static void
add_groups_for_each (Account *toadd, gpointer data)
{
struct add_group_data_struct *dadata = data;
Account *foundact;
foundact = gnc_account_lookup_by_name(dadata->to, xaccAccountGetName(toadd));
if (!foundact)
{
foundact = clone_account (toadd, dadata->com);
if (dadata->to)
gnc_account_append_child (dadata->to, foundact);
else if (dadata->parent)
gnc_account_append_child (dadata->parent, foundact);
else
{
g_warning ("add_groups_for_each: no valid parent");
}
}
{
if (gnc_account_n_children(toadd) > 0)
{
struct add_group_data_struct downdata;
downdata.to = foundact;
downdata.parent = foundact;
downdata.com = dadata->com;
gnc_account_foreach_child (toadd, add_groups_for_each, &downdata);
}
}
}
void
account_trees_merge(Account *existing_root, Account *new_accts_root)
{
GList *accounts, *node;
g_return_if_fail(new_accts_root != NULL);
g_return_if_fail(existing_root != NULL);
/* since we're have a chance of mutating the list (via
* gnc_account_add_child) while we're iterating over it, iterate
* over a copy. */
accounts = gnc_account_get_children(new_accts_root);
for (node = accounts; node; node = g_list_next(node))
{
Account *existing_named, *new_acct;
const char *name;
new_acct = (Account*)node->data;
name = xaccAccountGetName(new_acct);
existing_named = gnc_account_lookup_by_name(existing_root, name);
switch (determine_account_merge_disposition(existing_named, new_acct))
{
case GNC_ACCOUNT_MERGE_DISPOSITION_USE_EXISTING:
/* recurse */
account_trees_merge(existing_named, new_acct);
break;
case GNC_ACCOUNT_MERGE_DISPOSITION_CREATE_NEW:
/* merge this one in. */
gnc_account_append_child(existing_root, new_acct);
break;
}
}
g_list_free(accounts);
}
void SetUp() {
QofBook *book = qof_book_new();
Account *root = gnc_account_create_root(book);
t_asset_account1 = xaccMallocAccount(book);
xaccAccountSetName(t_asset_account1, "Asset");
gnc_account_append_child(root, t_asset_account1);
t_bank_account = xaccMallocAccount(book);
xaccAccountSetName(t_bank_account, "Bank");
gnc_account_append_child(t_asset_account1, t_bank_account);
t_asset_account2 = xaccMallocAccount(book);
xaccAccountSetName(t_asset_account2, "Asset-Bank");
gnc_account_append_child(root, t_asset_account2);
t_sav_account = xaccMallocAccount(book);
xaccAccountSetName(t_sav_account, "Bank");
gnc_account_append_child(t_asset_account2, t_sav_account);
t_expense_account = xaccMallocAccount(book);
xaccAccountSetName(t_expense_account, "Expense");
gnc_account_append_child(root, t_expense_account);
t_expense_account1 = xaccMallocAccount(book);
xaccAccountSetName(t_expense_account1, "Food");
gnc_account_append_child(t_expense_account, t_expense_account1);
t_expense_account2 = xaccMallocAccount(book);
xaccAccountSetName(t_expense_account2, "Drink");
gnc_account_append_child(t_expense_account, t_expense_account2);
}
static QofSession*
create_session(void)
{
QofSession* session = qof_session_new();
QofBook* book = qof_session_get_book( session );
Account* root = gnc_book_get_root_account( book );
Account* acct1;
Account* acct2;
KvpFrame* frame;
Transaction* tx;
Split* spl1;
Split* spl2;
Timespec ts;
struct timeval tv;
gnc_commodity_table* table;
gnc_commodity* currency;
table = gnc_commodity_table_get_table( book );
currency = gnc_commodity_table_lookup( table, GNC_COMMODITY_NS_CURRENCY, "CAD" );
acct1 = xaccMallocAccount( book );
xaccAccountSetType( acct1, ACCT_TYPE_BANK );
xaccAccountSetName( acct1, "Bank 1" );
xaccAccountSetCommodity( acct1, currency );
frame = qof_instance_get_slots( QOF_INSTANCE(acct1) );
kvp_frame_set_gint64( frame, "int64-val", 100 );
kvp_frame_set_double( frame, "double-val", 3.14159 );
kvp_frame_set_numeric( frame, "numeric-val", gnc_numeric_zero() );
time( &(tv.tv_sec) );
tv.tv_usec = 0;
ts.tv_sec = tv.tv_sec;
ts.tv_nsec = 1000 * tv.tv_usec;
kvp_frame_set_timespec( frame, "timespec-val", ts );
kvp_frame_set_string( frame, "string-val", "abcdefghijklmnop" );
kvp_frame_set_guid( frame, "guid-val", qof_instance_get_guid( QOF_INSTANCE(acct1) ) );
gnc_account_append_child( root, acct1 );
acct2 = xaccMallocAccount( book );
xaccAccountSetType( acct2, ACCT_TYPE_BANK );
xaccAccountSetName( acct2, "Bank 1" );
tx = xaccMallocTransaction( book );
xaccTransBeginEdit( tx );
xaccTransSetCurrency( tx, currency );
spl1 = xaccMallocSplit( book );
xaccTransAppendSplit( tx, spl1 );
spl2 = xaccMallocSplit( book );
xaccTransAppendSplit( tx, spl2 );
xaccTransCommitEdit( tx );
return session;
}
static gboolean
test_real_account (const char* tag, gpointer global_data, gpointer data)
{
char* msg;
Account* act = (Account*)data;
if (!gnc_account_get_parent (act))
{
gnc_account_append_child (gnc_book_get_root_account (sixbook), act);
}
msg = node_and_account_equal ((xmlNodePtr)global_data, act);
do_test_args (msg == NULL, "test_real_account",
__FILE__, __LINE__, msg);
g_free (msg);
return TRUE;
}
static void
set_parent (gpointer pObject, gpointer pValue)
{
Account* pAccount;
QofBook* pBook;
GncGUID* guid = (GncGUID*)pValue;
Account* pParent;
g_return_if_fail (pObject != NULL);
g_return_if_fail (GNC_IS_ACCOUNT (pObject));
pAccount = GNC_ACCOUNT (pObject);
pBook = qof_instance_get_book (QOF_INSTANCE (pAccount));
if (guid != NULL)
{
pParent = xaccAccountLookup (guid, pBook);
if (pParent != NULL)
{
gnc_account_append_child (pParent, pAccount);
}
}
}
Account *
xaccScrubUtilityGetOrMakeAccount (Account *root, gnc_commodity * currency,
const char *accname, GNCAccountType acctype,
gboolean placeholder)
{
Account * acc;
g_return_val_if_fail (root, NULL);
/* build the account name */
if (!currency)
{
PERR ("No currency specified!");
return NULL;
}
/* See if we've got one of these going already ... */
acc = gnc_account_lookup_by_name(root, accname);
if (acc == NULL)
{
/* Guess not. We'll have to build one. */
acc = xaccMallocAccount(gnc_account_get_book (root));
xaccAccountBeginEdit (acc);
xaccAccountSetName (acc, accname);
xaccAccountSetCommodity (acc, currency);
xaccAccountSetType (acc, acctype);
xaccAccountSetPlaceholder (acc, placeholder);
/* Hang the account off the root. */
gnc_account_append_child (root, acc);
xaccAccountCommitEdit (acc);
}
return acc;
}
static void
xaccSchedXactionInit(SchedXaction *sx, QofBook *book)
{
Account *ra;
const GncGUID *guid;
gchar guidstr[GUID_ENCODING_LENGTH+1];
qof_instance_init_data (&sx->inst, GNC_ID_SCHEDXACTION, book);
/* create a new template account for our splits */
sx->template_acct = xaccMallocAccount(book);
guid = qof_instance_get_guid( sx );
xaccAccountBeginEdit( sx->template_acct );
guid_to_string_buff( guid, guidstr );
xaccAccountSetName( sx->template_acct, guidstr);
xaccAccountSetCommodity
(sx->template_acct,
gnc_commodity_table_lookup( gnc_commodity_table_get_table(book),
"template", "template") );
xaccAccountSetType( sx->template_acct, ACCT_TYPE_BANK );
xaccAccountCommitEdit( sx->template_acct );
ra = gnc_book_get_template_root( book );
gnc_account_append_child( ra, sx->template_acct );
}
void
GncSqlAccountBackend::load_all (GncSqlBackend* sql_be)
{
QofBook* pBook;
ParentGuidVec l_accounts_needing_parents;
g_return_if_fail (sql_be != NULL);
ENTER ("");
pBook = sql_be->book();
std::stringstream sql;
sql << "SELECT * FROM " << TABLE_NAME;
auto stmt = sql_be->create_statement_from_sql(sql.str());
auto result = sql_be->execute_select_statement(stmt);
for (auto row : *result)
load_single_account (sql_be, row, l_accounts_needing_parents);
sql.str("");
sql << "SELECT DISTINCT guid FROM " << TABLE_NAME;
gnc_sql_slots_load_for_sql_subquery (sql_be, sql.str().c_str(),
(BookLookupFn)xaccAccountLookup);
/* While there are items on the list of accounts needing parents,
try to see if the parent has now been loaded. Theory says that if
items are removed from the front and added to the back if the
parent is still not available, then eventually, the list will
shrink to size 0. */
if (!l_accounts_needing_parents.empty())
{
auto progress_made = true;
std::reverse(l_accounts_needing_parents.begin(),
l_accounts_needing_parents.end());
auto end = l_accounts_needing_parents.end();
while (progress_made)
{
progress_made = false;
end = std::remove_if(l_accounts_needing_parents.begin(), end,
[&](ParentGuidPtr s)
{
auto pParent = xaccAccountLookup (&s->guid,
sql_be->book());
if (pParent != nullptr)
{
gnc_account_append_child (pParent,
s->pAccount);
progress_made = true;
delete s;
return true;
}
return false;
});
}
/* Any non-ROOT accounts left over must be parented by the root account */
auto root = gnc_book_get_root_account (pBook);
end = std::remove_if(l_accounts_needing_parents.begin(), end,
[&](ParentGuidPtr s)
{
if (xaccAccountGetType (s->pAccount) != ACCT_TYPE_ROOT)
gnc_account_append_child (root, s->pAccount);
delete s;
return true;
});
}
#if LOAD_TRANSACTIONS_AS_NEEDED
/* Load starting balances */
auto bal_slist = gnc_sql_get_account_balances_slist (sql_be);
for (auto bal = bal_slist; bal != NULL; bal = bal->next)
{
acct_balances_t* balances = (acct_balances_t*)bal->data;
qof_instance_increase_editlevel (balances->acct);
g_object_set (balances->acct,
"start-balance", &balances->balance,
"start-cleared-balance", &balances->cleared_balance,
"start-reconciled-balance", &balances->reconciled_balance,
NULL);
qof_instance_decrease_editlevel (balances->acct);
}
if (bal_slist != NULL)
{
g_slist_free (bal_slist);
}
#endif
LEAVE ("");
}
static void
load_all_accounts (GncSqlBackend* be)
{
GncSqlStatement* stmt = NULL;
GncSqlResult* result;
QofBook* pBook;
GList* l_accounts_needing_parents = NULL;
GSList* bal_slist;
GSList* bal;
g_return_if_fail (be != NULL);
ENTER ("");
pBook = be->book;
stmt = gnc_sql_create_select_statement (be, TABLE_NAME);
if (stmt == NULL)
{
LEAVE ("stmt == NULL");
return;
}
result = gnc_sql_execute_select_statement (be, stmt);
gnc_sql_statement_dispose (stmt);
if (result != NULL)
{
GncSqlRow* row = gnc_sql_result_get_first_row (result);
gchar* sql;
while (row != NULL)
{
load_single_account (be, row, &l_accounts_needing_parents);
row = gnc_sql_result_get_next_row (result);
}
gnc_sql_result_dispose (result);
sql = g_strdup_printf ("SELECT DISTINCT guid FROM %s", TABLE_NAME);
gnc_sql_slots_load_for_sql_subquery (be, sql, (BookLookupFn)xaccAccountLookup);
g_free (sql);
/* While there are items on the list of accounts needing parents,
try to see if the parent has now been loaded. Theory says that if
items are removed from the front and added to the back if the
parent is still not available, then eventually, the list will
shrink to size 0. */
if (l_accounts_needing_parents != NULL)
{
gboolean progress_made = TRUE;
Account* root;
Account* pParent;
GList* elem;
while (progress_made)
{
progress_made = FALSE;
for (elem = l_accounts_needing_parents; elem != NULL;)
{
account_parent_guid_struct* s = (account_parent_guid_struct*)elem->data;
pParent = xaccAccountLookup (&s->guid, be->book);
if (pParent != NULL)
{
GList* next_elem;
gnc_account_append_child (pParent, s->pAccount);
next_elem = g_list_next (elem);
l_accounts_needing_parents = g_list_delete_link (l_accounts_needing_parents,
elem);
g_free (s);
elem = next_elem;
progress_made = TRUE;
}
else
{
/* Can't be up in the for loop because the 'then' clause reads inside a node freed
by g_list_delete_link(). */
elem = g_list_next (elem);
}
}
}
/* Any non-ROOT accounts left over must be parented by the root account */
root = gnc_book_get_root_account (pBook);
while (l_accounts_needing_parents != NULL)
{
account_parent_guid_struct* s = (account_parent_guid_struct*)
l_accounts_needing_parents->data;
if (xaccAccountGetType (s->pAccount) != ACCT_TYPE_ROOT)
{
gnc_account_append_child (root, s->pAccount);
}
g_free (s);
l_accounts_needing_parents = g_list_delete_link (l_accounts_needing_parents,
l_accounts_needing_parents);
}
}
/* Load starting balances */
bal_slist = gnc_sql_get_account_balances_slist (be);
for (bal = bal_slist; bal != NULL; bal = bal->next)
{
acct_balances_t* balances = (acct_balances_t*)bal->data;
qof_instance_increase_editlevel (balances->acct);
g_object_set (balances->acct,
"start-balance", &balances->balance,
"start-cleared-balance", &balances->cleared_balance,
"start-reconciled-balance", &balances->reconciled_balance,
NULL);
qof_instance_decrease_editlevel (balances->acct);
}
if (bal_slist != NULL)
{
g_slist_free (bal_slist);
}
}
LEAVE ("");
}
static void
gnc_plugin_business_cmd_test_init_data (GtkAction *action,
GncMainWindowActionData *data)
{
QofBook *book = gnc_get_current_book();
GncCustomer *customer = gncCustomerCreate(book);
GncAddress *address = gncCustomerGetAddr(customer);
GncInvoice *invoice = gncInvoiceCreate(book);
GncOwner *owner = gncOwnerNew();
GncJob *job = gncJobCreate(book);
Account *root = gnc_book_get_root_account(book);
Account *inc_acct = xaccMallocAccount(book);
Account *bank_acct = xaccMallocAccount(book);
Account *tax_acct = xaccMallocAccount(book);
Account *ar_acct = xaccMallocAccount(book);
Timespec now;
// Create Customer
gncCustomerSetID(customer, "000001");
gncCustomerSetName(customer, "Test Customer");
gncCustomerSetCurrency(customer, gnc_default_currency());
gncAddressSetName(address, "Contact Person");
gncAddressSetAddr1(address, "20 Customer Lane");
gncAddressSetAddr2(address, "Customer M/S");
gncAddressSetAddr3(address, "Addr3, XXX 12345");
// Create the Owner
gncOwnerInitCustomer(owner, customer);
// Create the Invoice
timespecFromTime64(&now, time(NULL));
gncInvoiceSetID(invoice, "000012");
gncInvoiceSetOwner(invoice, owner);
gncInvoiceSetDateOpened(invoice, now);
gncInvoiceSetCurrency(invoice, gnc_default_currency());
// Create the Job
gncJobSetID(job, "000025");
gncJobSetName(job, "Test Job");
gncJobSetReference(job, "Customer's ref#");
gncJobSetOwner(job, owner);
// MODIFY THE OWNER
gncOwnerInitJob(owner, job);
// Create the A/R account
xaccAccountSetType(ar_acct, ACCT_TYPE_RECEIVABLE);
xaccAccountSetName(ar_acct, "A/R");
xaccAccountSetCommodity(ar_acct, gnc_default_currency());
gnc_account_append_child(root, ar_acct);
// Create the Income account
xaccAccountSetType(inc_acct, ACCT_TYPE_INCOME);
xaccAccountSetName(inc_acct, "Income");
xaccAccountSetCommodity(inc_acct, gnc_default_currency());
gnc_account_append_child(root, inc_acct);
// Create the Bank account
xaccAccountSetType(bank_acct, ACCT_TYPE_BANK);
xaccAccountSetName(bank_acct, "Bank");
xaccAccountSetCommodity(bank_acct, gnc_default_currency());
gnc_account_append_child(root, bank_acct);
// Create the Tax account
xaccAccountSetType(tax_acct, ACCT_TYPE_LIABILITY);
xaccAccountSetName(tax_acct, "Tax-Holding");
xaccAccountSetCommodity(tax_acct, gnc_default_currency());
gnc_account_append_child(root, tax_acct);
// Launch the invoice editor
gnc_ui_invoice_edit (GTK_WINDOW (data->window), invoice);
}