void
xaccAccountScrubColorNotSet (QofBook *book)
{
GValue value_s = G_VALUE_INIT;
// get the run-once value
qof_instance_get_kvp (QOF_INSTANCE (book), &value_s, 1, "remove-color-not-set-slots");
if (G_VALUE_HOLDS_STRING (&value_s) && (strcmp(g_value_get_string (&value_s), "true") == 0))
return;
else
{
GValue value_b = G_VALUE_INIT;
Account *root = gnc_book_get_root_account (book);
GList *accts = gnc_account_get_descendants_sorted (root);
GList *ptr;
for (ptr = accts; ptr; ptr = g_list_next (ptr))
{
const gchar *color = xaccAccountGetColor (ptr->data);
if (g_strcmp0 (color, "Not Set") == 0)
xaccAccountSetColor (ptr->data, "");
}
g_list_free (accts);
g_value_init (&value_b, G_TYPE_BOOLEAN);
g_value_set_boolean (&value_b, TRUE);
// set the run-once value
qof_instance_set_kvp (QOF_INSTANCE (book), &value_b, 1, "remove-color-not-set-slots");
}
}
static void
test_load_file(const char *filename)
{
QofSession *session;
QofBook *book;
Account *root;
gboolean ignore_lock;
gchar *logdomain = "GConf";
guint loglevel = G_LOG_LEVEL_WARNING;
TestErrorStruct check = { loglevel, logdomain, NULL };
g_log_set_handler (logdomain, loglevel,
(GLogFunc)test_checked_handler, &check);
session = qof_session_new();
remove_locks(filename);
ignore_lock = (safe_strcmp(g_getenv("SRCDIR"), ".") != 0);
qof_session_begin(session, filename, ignore_lock, FALSE, TRUE);
qof_session_load(session, NULL);
book = qof_session_get_book (session);
root = gnc_book_get_root_account(book);
do_test (gnc_account_get_book (root) == book,
"book and root account don't match");
do_test_args(qof_session_get_error(session) == ERR_BACKEND_NO_ERR,
"session load xml2", __FILE__, __LINE__,
"qof error=%d for file [%s]",
qof_session_get_error(session), filename);
/* Uncomment the line below to generate corrected files */
qof_session_save( session, NULL );
qof_session_end(session);
}
static void
show_book_details (AcctPeriodInfo *info)
{
QofBook *currbook;
char close_date_str[MAX_DATE_LENGTH];
char prev_close_date_str[MAX_DATE_LENGTH];
const char *period_text;
char *str;
const char *cstr;
int ntrans, nacc;
ENTER ("info=%p", info);
/* Tell user about how the previous book closing went. */
cstr = get_close_status_str (info);
gtk_label_set_text (info->close_results, cstr);
info->close_status = -1;
/* Pull info from widget, push into freq spec */
//gnc_frequency_save_state (info->period_menu, info->period, &info->closing_date);
recurrenceListFree(&info->period);
gnc_frequency_save_to_recurrence(info->period_menu, &info->period, &info->closing_date);
qof_print_date_dmy_buff (close_date_str, MAX_DATE_LENGTH,
g_date_get_day(&info->closing_date),
g_date_get_month(&info->closing_date),
g_date_get_year(&info->closing_date));
currbook = gnc_get_current_book();
ntrans = get_num_xactions_before_date(currbook,
gnc_timet_get_day_end_gdate (&info->closing_date));
nacc = gnc_account_n_descendants (gnc_book_get_root_account (currbook));
/* Display the book info */
period_text =
_("You have asked for a book to be created. This book "
"will contain all transactions up to midnight %s "
"(for a total of %d transactions spread over %d accounts). "
"Click on 'Forward' to create this book. "
"Click on 'Back' to adjust the dates.");
str = g_strdup_printf (period_text, close_date_str, ntrans, nacc);
gtk_label_set_text (info->book_details, str);
g_free (str);
/* Weird bug fix ! */
gtk_widget_show (GTK_WIDGET (info->book_details));
/* Create default settings for the title, notes fields */
qof_print_date_dmy_buff (prev_close_date_str, MAX_DATE_LENGTH,
g_date_get_day(&info->prev_closing_date),
g_date_get_month(&info->prev_closing_date),
g_date_get_year(&info->prev_closing_date));
str = g_strdup_printf (_("Period %s - %s"), prev_close_date_str, close_date_str);
gtk_entry_set_text (info->book_title, str);
xxxgtk_textview_set_text (info->book_notes, str);
g_free (str);
}
static void
use_existing_account_data_func(GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell,
GtkTreeModel *tree_model,
GtkTreeIter *iter,
gpointer user_data)
{
Account *new_acct;
Account *real_root;
GncAccountMergeDisposition disposition;
char *to_user = "******";
g_return_if_fail (GTK_TREE_MODEL (tree_model));
new_acct = gnc_tree_view_account_get_account_from_iter(tree_model, iter);
if (new_acct == NULL)
{
g_object_set (G_OBJECT(cell), "text", "(null account)", NULL);
return;
}
real_root = gnc_book_get_root_account(gnc_get_current_book());
disposition = determine_merge_disposition(real_root, new_acct);
switch (disposition)
{
case GNC_ACCOUNT_MERGE_DISPOSITION_USE_EXISTING:
to_user = _("Yes");
break;
case GNC_ACCOUNT_MERGE_DISPOSITION_CREATE_NEW:
to_user = _("No");
break;
}
g_object_set(G_OBJECT(cell), "text", to_user, NULL);
}
static void
run_test (void)
{
QofSession *sess;
QofBook *book;
Account *root;
/* --------------------------------------------------------- */
/* In the first test, we will merely try to see if we can run
* without crashing. We don't check to see if data is good. */
sess = get_random_session ();
book = qof_session_get_book (sess);
do_test ((NULL != book), "create random data");
add_random_transactions_to_book (book, transaction_num);
root = gnc_book_get_root_account (book);
xaccAccountTreeScrubLots (root);
/* --------------------------------------------------------- */
/* In the second test, we create an account with unrealized gains,
* and see if that gets fixed correctly, with the correct balances,
* and etc.
* XXX not implemented
*/
success ("automatic lot scrubbing lightly tested and seem to work");
qof_session_end (sess);
}
/**************************************************
* gnc_csv_account_map_search
*
* search the existing mappings for the account
* linked to the import string.
**************************************************/
Account * gnc_csv_account_map_search (gchar *map_string)
{
Account *root, *account = NULL;
GList *accts, *ptr;
/* Get list of Accounts */
root = gnc_book_get_root_account (gnc_get_current_book());
accts = gnc_account_get_descendants_sorted (root);
/* Go through list of accounts */
for (ptr = accts; ptr; ptr = g_list_next (ptr))
{
GncImportMatchMap *tmp_imap;
tmp_imap = gnc_account_imap_create_imap (ptr->data);
if (gnc_account_imap_find_account (tmp_imap, CSV_CATEGORY, map_string) != NULL)
{
account = ptr->data;
account_imap_destroy (tmp_imap);
break;
}
account_imap_destroy (tmp_imap);
}
g_list_free (accts);
return account;
}
void
xaccTransScrubOrphans (Transaction *trans)
{
SplitList *node;
QofBook *book = NULL;
Account *root = NULL;
if (!trans) return;
for (node = trans->splits; node; node = node->next)
{
Split *split = node->data;
if (split->acc)
{
TransScrubOrphansFast (trans, gnc_account_get_root(split->acc));
return;
}
}
/* If we got to here, then *none* of the splits belonged to an
* account. Not a happy situation. We should dig an account
* out of the book the transaction belongs to.
* XXX we should probably *always* to this, instead of the above loop!
*/
PINFO ("Free Floating Transaction!");
book = xaccTransGetBook (trans);
root = gnc_book_get_root_account (book);
TransScrubOrphansFast (trans, root);
}
static void
placeholder_cell_data_func (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell,
GtkTreeModel *model,
GtkTreeIter *iter,
gpointer user_data)
{
Account *account, *root;
gboolean willbe_placeholder = FALSE;
GncAccountMergeDisposition disp;
g_return_if_fail (GTK_TREE_MODEL (model));
account = gnc_tree_view_account_get_account_from_iter (model, iter);
root = gnc_book_get_root_account(gnc_get_current_book());
disp = determine_merge_disposition(root, account);
switch (disp)
{
case GNC_ACCOUNT_MERGE_DISPOSITION_USE_EXISTING:
{
/* find the existing account, do whatever it is. */
gchar *full_name;
Account *existing_acct;
full_name = gnc_account_get_full_name(account);
existing_acct = gnc_account_lookup_by_full_name(root, full_name);
willbe_placeholder = xaccAccountGetPlaceholder(existing_acct);
g_free(full_name);
}
break;
case GNC_ACCOUNT_MERGE_DISPOSITION_CREATE_NEW:
willbe_placeholder = xaccAccountGetPlaceholder(account);
break;
}
gtk_cell_renderer_toggle_set_active(GTK_CELL_RENDERER_TOGGLE(cell), willbe_placeholder);
}
static void
load_xfer_type_cells (GncEntryLedger *ledger)
{
Account *root;
ComboCell *cell;
QuickFill *qf = NULL;
GtkListStore *store = NULL;
root = gnc_book_get_root_account (ledger->book);
if (root == NULL) return;
/* Use a common, shared quickfill. For the ORDER or INVOICE,
* ledgers, we don't want expense-type accounts in the menu.
* For BILL, etc. then leave out the income types.
*/
switch (ledger->type)
{
case GNCENTRY_ORDER_ENTRY:
case GNCENTRY_ORDER_VIEWER:
case GNCENTRY_INVOICE_ENTRY:
case GNCENTRY_INVOICE_VIEWER:
case GNCENTRY_CUST_CREDIT_NOTE_ENTRY:
case GNCENTRY_CUST_CREDIT_NOTE_VIEWER:
qf = gnc_get_shared_account_name_quickfill (root, IKEY,
skip_expense_acct_cb, NULL);
store = gnc_get_shared_account_name_list_store (root, IKEY,
skip_expense_acct_cb, NULL);
break;
case GNCENTRY_BILL_ENTRY:
case GNCENTRY_BILL_VIEWER:
case GNCENTRY_EXPVOUCHER_ENTRY:
case GNCENTRY_EXPVOUCHER_VIEWER:
case GNCENTRY_VEND_CREDIT_NOTE_ENTRY:
case GNCENTRY_VEND_CREDIT_NOTE_VIEWER:
case GNCENTRY_EMPL_CREDIT_NOTE_ENTRY:
case GNCENTRY_EMPL_CREDIT_NOTE_VIEWER:
case GNCENTRY_NUM_REGISTER_TYPES:
qf = gnc_get_shared_account_name_quickfill (root, EKEY,
skip_income_acct_cb, NULL);
store = gnc_get_shared_account_name_list_store (root, EKEY,
skip_income_acct_cb, NULL);
break;
default:
PWARN ("Bad GncEntryLedgerType");
break;
}
cell = (ComboCell *)
gnc_table_layout_get_cell (ledger->table->layout, ENTRY_IACCT_CELL);
gnc_combo_cell_use_quickfill_cache (cell, qf);
gnc_combo_cell_use_list_store_cache (cell, store);
cell = (ComboCell *)
gnc_table_layout_get_cell (ledger->table->layout, ENTRY_BACCT_CELL);
gnc_combo_cell_use_quickfill_cache (cell, qf);
gnc_combo_cell_use_list_store_cache (cell, store);
}
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;
}
/*
* Given an owner, extract the open balance from the owner and then
* convert it to the desired currency.
*/
gnc_numeric
gncOwnerGetBalanceInCurrency (const GncOwner *owner,
const gnc_commodity *report_currency)
{
gnc_numeric balance = gnc_numeric_zero ();
GList *acct_list, *acct_node, *acct_types, *lot_list = NULL, *lot_node;
QofBook *book;
gnc_commodity *owner_currency;
GNCPriceDB *pdb;
g_return_val_if_fail (owner, gnc_numeric_zero ());
/* Get account list */
book = qof_instance_get_book (qofOwnerGetOwner (owner));
acct_list = gnc_account_get_descendants (gnc_book_get_root_account (book));
acct_types = gncOwnerGetAccountTypesList (owner);
owner_currency = gncOwnerGetCurrency (owner);
/* For each account */
for (acct_node = acct_list; acct_node; acct_node = acct_node->next)
{
Account *account = acct_node->data;
/* Check if this account can have lots for the owner, otherwise skip to next */
if (g_list_index (acct_types, (gpointer)xaccAccountGetType (account))
== -1)
continue;
if (!gnc_commodity_equal (owner_currency, xaccAccountGetCommodity (account)))
continue;
/* Get a list of open lots for this owner and account */
lot_list = xaccAccountFindOpenLots (account, gncOwnerLotMatchOwnerFunc,
(gpointer)owner, NULL);
/* For each lot */
for (lot_node = lot_list; lot_node; lot_node = lot_node->next)
{
GNCLot *lot = lot_node->data;
gnc_numeric lot_balance = gnc_lot_get_balance (lot);
GncInvoice *invoice = gncInvoiceGetInvoiceFromLot(lot);
if (invoice)
balance = gnc_numeric_add (balance, lot_balance,
gnc_commodity_get_fraction (owner_currency), GNC_HOW_RND_ROUND_HALF_UP);
}
}
pdb = gnc_pricedb_get_db (book);
if (report_currency)
balance = gnc_pricedb_convert_balance_latest_price (
pdb, balance, owner_currency, report_currency);
return balance;
}
static void
balance_cell_data_func (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell,
GtkTreeModel *model,
GtkTreeIter *iter,
gpointer user_data)
{
Account *account;
gnc_numeric balance;
const gchar *string;
GNCPrintAmountInfo print_info;
hierarchy_data *data = (hierarchy_data *)user_data;
gboolean allow_value;
g_return_if_fail (GTK_TREE_MODEL (model));
account = gnc_tree_view_account_get_account_from_iter (model, iter);
balance = get_final_balance (data->balance_hash, account);
if (gnc_numeric_zero_p (balance))
{
string = "";
}
else
{
print_info = gnc_account_print_info (account, FALSE);
string = xaccPrintAmount (balance, print_info);
}
if (xaccAccountGetType(account) == ACCT_TYPE_EQUITY ||
xaccAccountGetType(account) == ACCT_TYPE_TRADING)
{
allow_value = FALSE;
string = _("zero");
}
else
{
GncAccountMergeDisposition disp;
disp = determine_merge_disposition(gnc_book_get_root_account(gnc_get_current_book()), account);
if (disp == GNC_ACCOUNT_MERGE_DISPOSITION_CREATE_NEW)
{
allow_value = !xaccAccountGetPlaceholder(account);
}
else
{
allow_value = FALSE;
string = _("existing account");
}
}
g_object_set (G_OBJECT (cell),
"text", string,
"editable", allow_value,
"sensitive", allow_value,
NULL);
}
bool
GncSqlBackend::write_transactions()
{
auto obe = m_backend_registry.get_object_backend(GNC_ID_TRANS);
write_objects_t data{this, TRUE, obe.get()};
(void)xaccAccountTreeForEachTransaction (
gnc_book_get_root_account (m_book), write_tx, &data);
update_progress();
return data.is_ok;
}
/* ================================================================= */
static /*@ dependent @*//*@ null @*/ gpointer
get_root_account_guid( gpointer pObject )
{
QofBook* book = QOF_BOOK(pObject);
const Account* root;
g_return_val_if_fail( pObject != NULL, NULL );
g_return_val_if_fail( QOF_IS_BOOK(pObject), NULL );
root = gnc_book_get_root_account( book );
return (gpointer)qof_instance_get_guid( QOF_INSTANCE(root) );
}
bool
GncSqlBackend::write_accounts()
{
update_progress();
auto is_ok = write_account_tree (gnc_book_get_root_account (m_book));
if (is_ok)
{
update_progress();
is_ok = write_account_tree (gnc_book_get_template_root(m_book));
}
return is_ok;
}
static void
set_root_account_guid( gpointer pObject, /*@ null @*/ gpointer pValue )
{
QofBook* book = QOF_BOOK(pObject);
const Account* root;
GncGUID* guid = (GncGUID*)pValue;
g_return_if_fail( pObject != NULL );
g_return_if_fail( QOF_IS_BOOK(pObject) );
g_return_if_fail( pValue != NULL );
root = gnc_book_get_root_account( book );
qof_instance_set_guid( QOF_INSTANCE(root), guid );
}
xmlNodePtr
gnc_book_dom_tree_create(QofBook *book)
{
xmlNodePtr ret;
G_GNUC_UNUSED gboolean allow_incompat = TRUE;
ret = xmlNewNode(NULL, BAD_CAST gnc_book_string);
xmlSetProp(ret, BAD_CAST "version", BAD_CAST gnc_v2_book_version_string);
xmlAddChild(ret, guid_to_dom_tree(book_id_string,
qof_book_get_guid(book)));
if (qof_instance_get_slots (QOF_INSTANCE (book)))
{
xmlNodePtr kvpnode = kvp_frame_to_dom_tree(book_slots_string,
qof_instance_get_slots (QOF_INSTANCE (book)));
if (kvpnode)
xmlAddChild(ret, kvpnode);
}
#ifdef IMPLEMENT_BOOK_DOM_TREES_LATER
/* theoretically, we should be adding all the below to the book
* but in fact, there's enough brain damage in the code already
* that we are only going to hand-edit the file at a higher layer.
* And that's OK, since its probably a performance boost anyway.
*/
xmlAddChild(ret, gnc_commodity_dom_tree_create(
gnc_commodity_table_get_table(book)));
xmlAddChild(ret, gnc_pricedb_dom_tree_create(gnc_pricedb_get_db(book)));
if (allow_incompat)
{
accnode = gnc_account_dom_tree_create(account, FALSE);
xmlAddChild (ret, rootAccNode);
}
append_account_tree (ret, gnc_book_get_root(book));
xaccAccountTreeForEachTransaction (gnc_book_get_root_account(book),
traverse_txns, ret);
/* xxx FIXME hack alert how are we going to handle
* gnc_book_get_template_group handled ??? */
xmlAddChild(ret, gnc_schedXaction_dom_tree_create(
gnc_book_get_schedxactions(book)));
#endif
return ret;
}
void
dai_finish_cb(GnomeDruidPage *druid_page, GtkWidget *widget,
gpointer user_data)
{
ABInitialInfo *info = user_data;
Account *root;
g_return_if_fail(info && info->gnc_hash);
/* Commit the changes */
root = gnc_book_get_root_account(gnc_get_current_book());
gnc_account_foreach_descendant(root, (AccountCb) clear_kvp_acc_cb, NULL);
g_hash_table_foreach(info->gnc_hash, (GHFunc) save_kvp_acc_cb, NULL);
gtk_widget_destroy(info->window);
}
static Split *
get_balance_split (Transaction *trans, Account *root, Account *account,
gnc_commodity *commodity)
{
Split *balance_split;
gchar *accname;
if (!account ||
!gnc_commodity_equiv (commodity, xaccAccountGetCommodity(account)))
{
if (!root)
{
root = gnc_book_get_root_account (xaccTransGetBook (trans));
if (NULL == root)
{
/* This can't occur, things should be in books */
PERR ("Bad data corruption, no root account in book");
return NULL;
}
}
accname = g_strconcat (_("Imbalance"), "-",
gnc_commodity_get_mnemonic (commodity), NULL);
account = xaccScrubUtilityGetOrMakeAccount (root, commodity,
accname, ACCT_TYPE_BANK, FALSE);
g_free (accname);
if (!account)
{
PERR ("Can't get balancing account");
return NULL;
}
}
balance_split = xaccTransFindSplitByAccount(trans, account);
/* Put split into account before setting split value */
if (!balance_split)
{
balance_split = xaccMallocSplit (qof_instance_get_book(trans));
xaccTransBeginEdit (trans);
xaccSplitSetParent(balance_split, trans);
xaccSplitSetAccount(balance_split, account);
xaccTransCommitEdit (trans);
}
return balance_split;
}
static void
run_test (void)
{
QofSession *session;
Account *root;
QofBook *book;
session = get_random_session ();
book = qof_session_get_book (session);
root = gnc_book_get_root_account (book);
add_random_transactions_to_book (book, 20);
xaccAccountTreeForEachTransaction (root, test_trans_query, book);
qof_session_end (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;
}
Account *
gnc_account_select_combo_get_active (GtkWidget *combo)
{
const gchar *text;
QofBook *book;
if (!combo || !GTK_IS_COMBO_BOX(combo))
return NULL;
book = g_object_get_data (G_OBJECT(combo), "book");
if (!book)
return NULL;
text = gtk_entry_get_text( GTK_ENTRY( gtk_bin_get_child( GTK_BIN( GTK_COMBO_BOX(combo)))));
if (!text || g_strcmp0 (text, "") == 0)
return NULL;
return gnc_account_lookup_by_full_name (gnc_book_get_root_account (book), text);
}
/* Find the trading split for a commodity, but don't create any splits
or accounts if they don't already exist. */
static Split *
find_trading_split (Transaction *trans, Account *root,
gnc_commodity *commodity)
{
Account *trading_account;
Account *ns_account;
Account *account;
if (!root)
{
root = gnc_book_get_root_account (xaccTransGetBook (trans));
if (NULL == root)
{
/* This can't occur, things should be in books */
PERR ("Bad data corruption, no root account in book");
return NULL;
}
}
trading_account = gnc_account_lookup_by_name (root, _("Trading"));
if (!trading_account)
{
return NULL;
}
ns_account = gnc_account_lookup_by_name (trading_account,
gnc_commodity_get_namespace(commodity));
if (!ns_account)
{
return NULL;
}
account = gnc_account_lookup_by_name (ns_account,
gnc_commodity_get_mnemonic(commodity));
if (!account)
{
return NULL;
}
return xaccTransFindSplitByAccount(trans, account);
}
static void
get_account_info (FindAccountDialog *facc_dialog)
{
Account *root;
GList *accts;
GList *ptr;
gchar *filter_text;
gboolean radio_root;
/* Get the state of the root radio button */
radio_root = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(facc_dialog->radio_root));
/* Get list of Accounts */
if ((facc_dialog->account == NULL) || (radio_root == TRUE))
root = gnc_book_get_root_account (gnc_get_current_book());
else
root = facc_dialog->account;
accts = gnc_account_get_descendants_sorted (root);
filter_text = g_ascii_strdown (gtk_entry_get_text (GTK_ENTRY(facc_dialog->filter_text_entry)), -1);
/* Go through list of accounts */
for (ptr = accts; ptr; ptr = g_list_next (ptr))
{
Account *acc = ptr->data;
gchar *full_name = gnc_account_get_full_name (acc);
gchar *match_string = g_ascii_strdown (full_name, -1);
if ((g_strcmp0 (filter_text, "") == 0) || (g_strrstr (match_string, filter_text) != NULL))
fill_model (facc_dialog, acc);
g_free (match_string);
g_free (full_name);
}
g_free (filter_text);
g_list_free (accts);
gtk_tree_view_columns_autosize (GTK_TREE_VIEW(facc_dialog->view));
}
static Account*
load_single_account (GncSqlBackend* be, GncSqlRow* row,
GList** l_accounts_needing_parents)
{
const GncGUID* guid;
Account* pAccount = NULL;
g_return_val_if_fail (be != NULL, NULL);
g_return_val_if_fail (row != NULL, NULL);
g_return_val_if_fail (l_accounts_needing_parents != NULL, NULL);
guid = gnc_sql_load_guid (be, row);
if (guid != NULL)
{
pAccount = xaccAccountLookup (guid, be->book);
}
if (pAccount == NULL)
{
pAccount = xaccMallocAccount (be->book);
}
xaccAccountBeginEdit (pAccount);
gnc_sql_load_object (be, row, GNC_ID_ACCOUNT, pAccount, col_table);
xaccAccountCommitEdit (pAccount);
/* If we don't have a parent and this isn't the root account, it might be because the parent
account hasn't been loaded yet. Remember the account and its parent guid for later. */
if (gnc_account_get_parent (pAccount) == NULL
&& pAccount != gnc_book_get_root_account (be->book))
{
account_parent_guid_struct* s = static_cast<decltype (s)> (
g_malloc (sizeof (account_parent_guid_struct)));
g_assert (s != NULL);
s->pAccount = pAccount;
gnc_sql_load_object (be, row, GNC_ID_ACCOUNT, s, parent_col_table);
*l_accounts_needing_parents = g_list_prepend (*l_accounts_needing_parents, s);
}
return pAccount;
}
/**
* Saves the budget amounts for a budget.
*
* @param sql_be SQL backend
* @param budget Budget
*/
static gboolean
save_budget_amounts (GncSqlBackend* sql_be, GncBudget* budget)
{
GList* descendants;
GList* node;
budget_amount_info_t info;
guint num_periods;
gboolean is_ok = TRUE;;
g_return_val_if_fail (sql_be != NULL, FALSE);
g_return_val_if_fail (budget != NULL, FALSE);
// Delete the amounts, then save
delete_budget_amounts (sql_be, budget);
info.budget = budget;
num_periods = gnc_budget_get_num_periods (budget);
descendants = gnc_account_get_descendants (gnc_book_get_root_account (
sql_be->book()));
for (node = descendants; node != NULL && is_ok; node = g_list_next (node))
{
guint i;
info.account = GNC_ACCOUNT (node->data);
for (i = 0; i < num_periods && is_ok; i++)
{
if (gnc_budget_is_account_period_value_set (budget, info.account, i))
{
info.period_num = i;
is_ok = sql_be->do_db_operation(OP_DB_INSERT, AMOUNTS_TABLE,
"", &info,
budget_amounts_col_table);
}
}
}
g_list_free (descendants);
return is_ok;
}
void
dai_match_page_prepare_cb(GnomeDruidPage *druid_page, GtkWidget *widget,
gpointer user_data)
{
ABInitialInfo *info = user_data;
Account *root;
AccCbData data;
g_return_if_fail(info && info->api);
/* No way back */
gnome_druid_set_buttons_sensitive(GNOME_DRUID(info->druid),
FALSE, TRUE, TRUE, TRUE);
/* Do not run this twice */
if (info->match_page_prepared)
return;
else
info->match_page_prepared = TRUE;
/* Load aqbanking accounts */
#ifdef AQBANKING_VERSION_4_PLUS
AB_Banking_OnlineInit(info->api, 0);
#else
AB_Banking_OnlineInit(info->api);
#endif
/* Determine current mapping */
root = gnc_book_get_root_account(gnc_get_current_book());
info->gnc_hash = g_hash_table_new(&g_direct_hash, &g_direct_equal);
data.api = info->api;
data.hash = info->gnc_hash;
gnc_account_foreach_descendant(
root, (AccountCb) hash_from_kvp_acc_cb, &data);
/* Update the graphical representation */
update_account_list(info);
}
static Account*
load_single_account (GncSqlBackend* sql_be, GncSqlRow& row,
ParentGuidVec& l_accounts_needing_parents)
{
const GncGUID* guid;
Account* pAccount = NULL;
g_return_val_if_fail (sql_be != NULL, NULL);
guid = gnc_sql_load_guid (sql_be, row);
if (guid != NULL)
{
pAccount = xaccAccountLookup (guid, sql_be->book());
}
if (pAccount == NULL)
{
pAccount = xaccMallocAccount (sql_be->book());
}
xaccAccountBeginEdit (pAccount);
gnc_sql_load_object (sql_be, row, GNC_ID_ACCOUNT, pAccount, col_table);
xaccAccountCommitEdit (pAccount);
/* If we don't have a parent and this isn't the root account, it might be
because the parent account hasn't been loaded yet. Remember the account
and its parent guid for later. */
if (gnc_account_get_parent (pAccount) == NULL
&& pAccount != gnc_book_get_root_account (sql_be->book()))
{
auto s = new ParentGuid;
s->pAccount = pAccount;
gnc_sql_load_object (sql_be, row, GNC_ID_ACCOUNT, s, parent_col_table);
l_accounts_needing_parents.push_back(s);
}
return pAccount;
}
void
ViewletModel::rightVGenerate(::Account *selectedAccount)
{
::QofBook *book = gnc_account_get_book(selectedAccount);
::Account *rootAccount = gnc_book_get_root_account(book);
GList *accountsGList = gnc_account_get_descendants(rootAccount);
AccountQList accountsList = accountFromGList(accountsGList);
int numOfAccounts = accountsList.count();
qDebug()<<"Total num of accounts: "<<numOfAccounts;
AccountQList expenseAccountsList;
for(int i = 0; i < numOfAccounts; i++)
{
if(xaccAccountGetType(accountsList.at(i)) == 8)
{
expenseAccountsList.append(accountsList.at(i));
}
}
SplitQList splitsList = buildSplitListDateSort(expenseAccountsList);
buildMiniJournalStruct(splitsList);
}
/* Get the trading split for a given commodity, creating it (and the
necessary accounts) if it doesn't exist. */
static Split *
get_trading_split (Transaction *trans, Account *root,
gnc_commodity *commodity)
{
Split *balance_split;
Account *trading_account;
Account *ns_account;
Account *account;
gnc_commodity *default_currency = NULL;
if (!root)
{
root = gnc_book_get_root_account (xaccTransGetBook (trans));
if (NULL == root)
{
/* This can't occur, things should be in books */
PERR ("Bad data corruption, no root account in book");
return NULL;
}
}
/* Get the default currency. This is harder than it seems. It's not
possible to call gnc_default_currency() since it's a UI function. One
might think that the currency of the root account would do, but the root
account has no currency. Instead look for the Income placeholder account
and use its currency. */
default_currency = xaccAccountGetCommodity(gnc_account_lookup_by_name(root,
_("Income")));
if (! default_currency)
{
default_currency = commodity;
}
trading_account = xaccScrubUtilityGetOrMakeAccount (root,
default_currency,
_("Trading"),
ACCT_TYPE_TRADING, TRUE);
if (!trading_account)
{
PERR ("Can't get trading account");
return NULL;
}
ns_account = xaccScrubUtilityGetOrMakeAccount (trading_account,
default_currency,
gnc_commodity_get_namespace(commodity),
ACCT_TYPE_TRADING, TRUE);
if (!ns_account)
{
PERR ("Can't get namespace account");
return NULL;
}
account = xaccScrubUtilityGetOrMakeAccount (ns_account, commodity,
gnc_commodity_get_mnemonic(commodity),
ACCT_TYPE_TRADING, FALSE);
if (!account)
{
PERR ("Can't get commodity account");
return NULL;
}
balance_split = xaccTransFindSplitByAccount(trans, account);
/* Put split into account before setting split value */
if (!balance_split)
{
balance_split = xaccMallocSplit (qof_instance_get_book(trans));
xaccTransBeginEdit (trans);
xaccSplitSetParent(balance_split, trans);
xaccSplitSetAccount(balance_split, account);
xaccTransCommitEdit (trans);
}
return balance_split;
}
