static void
qof_instance_list_foreach(gpointer data, gpointer user_data)
{
QofInstanceCopyData *qecd;
QofInstance *original;
QofInstance *inst;
QofBook *book;
const GncGUID *g;
g_return_if_fail(data != NULL);
original = QOF_INSTANCE(data);
g_return_if_fail(user_data != NULL);
qecd = (QofInstanceCopyData*)user_data;
if (qof_instance_guid_match(qecd->new_session, original))
{
return;
}
qecd->from = original;
if (!qof_object_compliance(original->e_type, FALSE))
{
qecd->error = TRUE;
return;
}
book = qof_session_get_book(qecd->new_session);
inst = (QofInstance*)qof_object_new_instance(original->e_type, book);
if (!inst)
{
PERR (" failed to create new entity type=%s.", original->e_type);
qecd->error = TRUE;
return;
}
qecd->to = inst;
g = qof_instance_get_guid(original);
qof_instance_set_guid(qecd->to, g);
if (qecd->param_list != NULL)
{
g_slist_free(qecd->param_list);
qecd->param_list = NULL;
}
qof_class_param_foreach(original->e_type, qof_instance_param_cb, qecd);
qof_begin_edit(inst);
g_slist_foreach(qecd->param_list, qof_instance_foreach_copy, qecd);
qof_commit_edit(inst);
}
bool
GncSqlBackend::write_schedXactions()
{
GList* schedXactions;
SchedXaction* tmpSX;
bool is_ok = true;
schedXactions = gnc_book_get_schedxactions (m_book)->sx_list;
auto obe = m_backend_registry.get_object_backend(GNC_ID_SCHEDXACTION);
for (; schedXactions != NULL && is_ok; schedXactions = schedXactions->next)
{
tmpSX = static_cast<decltype (tmpSX)> (schedXactions->data);
is_ok = obe->commit (this, QOF_INSTANCE (tmpSX));
}
update_progress();
return is_ok;
}
static GncVendor*
load_single_vendor (GncSqlBackend* sql_be, GncSqlRow& row)
{
const GncGUID* guid;
GncVendor* pVendor;
g_return_val_if_fail (sql_be != NULL, NULL);
guid = gnc_sql_load_guid (sql_be, row);
pVendor = gncVendorLookup (sql_be->book(), guid);
if (pVendor == NULL)
{
pVendor = gncVendorCreate (sql_be->book());
}
gnc_sql_load_object (sql_be, row, GNC_ID_VENDOR, pVendor, col_table);
qof_instance_mark_clean (QOF_INSTANCE (pVendor));
return pVendor;
}
void
qof_instance_set_guid (gpointer ptr, const GncGUID *guid)
{
QofInstancePrivate *priv;
QofInstance *inst;
QofCollection *col;
g_return_if_fail(QOF_IS_INSTANCE(ptr));
inst = QOF_INSTANCE(ptr);
priv = GET_PRIVATE(inst);
if (guid_equal (guid, &priv->guid))
return;
col = priv->collection;
qof_collection_remove_entity(inst);
priv->guid = *guid;
qof_collection_insert_entity(col, inst);
}
static GncEmployee*
load_single_employee (GncSqlBackend* sql_be, GncSqlRow& row)
{
const GncGUID* guid;
GncEmployee* pEmployee;
g_return_val_if_fail (sql_be != NULL, NULL);
guid = gnc_sql_load_guid (sql_be, row);
pEmployee = gncEmployeeLookup (sql_be->book(), guid);
if (pEmployee == NULL)
{
pEmployee = gncEmployeeCreate (sql_be->book());
}
gnc_sql_load_object (sql_be, row, GNC_ID_EMPLOYEE, pEmployee, col_table);
qof_instance_mark_clean (QOF_INSTANCE (pEmployee));
return pEmployee;
}
static GncOrder*
load_single_order (GncSqlBackend* be, GncSqlRow& row)
{
const GncGUID* guid;
GncOrder* pOrder;
g_return_val_if_fail (be != NULL, NULL);
guid = gnc_sql_load_guid (be, row);
pOrder = gncOrderLookup (be->book(), guid);
if (pOrder == NULL)
{
pOrder = gncOrderCreate (be->book());
}
gnc_sql_load_object (be, row, GNC_ID_ORDER, pOrder, col_table);
qof_instance_mark_clean (QOF_INSTANCE (pOrder));
return pOrder;
}
static GncInvoice*
load_single_invoice (GncSqlBackend* be, GncSqlRow& row)
{
const GncGUID* guid;
GncInvoice* pInvoice;
g_return_val_if_fail (be != NULL, NULL);
guid = gnc_sql_load_guid (be, row);
pInvoice = gncInvoiceLookup (be->book(), guid);
if (pInvoice == NULL)
{
pInvoice = gncInvoiceCreate (be->book());
}
gnc_sql_load_object (be, row, GNC_ID_INVOICE, pInvoice, col_table);
qof_instance_mark_clean (QOF_INSTANCE (pInvoice));
return pInvoice;
}
static void
gnc_template_register_save_shares_cell (BasicCell * cell,
gpointer save_data,
gpointer user_data)
{
SRSaveData *sd = save_data;
char *sharesStr = "(x + y)/42";
g_return_if_fail (gnc_basic_cell_has_name (cell, SHRS_CELL));
/* FIXME: shares cells are numeric by definition. */
qof_instance_set (QOF_INSTANCE (sd->split),
"sx-shares", sharesStr,
NULL);
/* set the shares to an innocuous value */
/* Note that this marks the split dirty */
xaccSplitSetSharePriceAndAmount (sd->split,
gnc_numeric_create (0, 1),
gnc_numeric_create (0, 1));
}
void gnc_ofx_kvp_set_assoc_account(Account* investment_account,
const Account *income_account)
{
kvp_frame * acc_frame;
kvp_value * kvp_val;
const GncGUID * income_acc_guid;
g_assert(investment_account);
g_assert(income_account);
acc_frame = xaccAccountGetSlots(investment_account);
g_assert(acc_frame); // Must not be NULL, but the QofInstance doc is unclear about this
income_acc_guid = xaccAccountGetGUID(income_account);
kvp_val = kvp_value_new_guid(income_acc_guid);
xaccAccountBeginEdit(investment_account);
kvp_frame_set_slot_nc(acc_frame, KEY_ASSOC_INCOME_ACCOUNT,
kvp_val);
qof_instance_set_dirty(QOF_INSTANCE (investment_account));
xaccAccountCommitEdit(investment_account);
}
static GncJob*
load_single_job( GncSqlBackend* be, GncSqlRow* row )
{
const GncGUID* guid;
GncJob* pJob;
g_return_val_if_fail( be != NULL, NULL );
g_return_val_if_fail( row != NULL, NULL );
guid = gnc_sql_load_guid( be, row );
pJob = gncJobLookup( be->book, guid );
if ( pJob == NULL )
{
pJob = gncJobCreate( be->book );
}
gnc_sql_load_object( be, row, GNC_ID_JOB, pJob, col_table );
qof_instance_mark_clean( QOF_INSTANCE(pJob) );
return pJob;
}
static GncCustomer*
load_single_customer( GncSqlBackend* be, GncSqlRow* row )
{
const GncGUID* guid;
GncCustomer* pCustomer;
g_return_val_if_fail( be != NULL, NULL );
g_return_val_if_fail( row != NULL, NULL );
guid = gnc_sql_load_guid( be, row );
pCustomer = gncCustomerLookup( be->book, guid );
if ( pCustomer == NULL )
{
pCustomer = gncCustomerCreate( be->book );
}
gnc_sql_load_object( be, row, GNC_ID_CUSTOMER, pCustomer, col_table );
qof_instance_mark_clean( QOF_INSTANCE(pCustomer) );
return pCustomer;
}
void
GncSqlBudgetBackend::load_all (GncSqlBackend* sql_be)
{
InstanceVec instances;
g_return_if_fail (sql_be != NULL);
std::stringstream sql;
sql << "SELECT * FROM " << BUDGET_TABLE;
auto stmt = sql_be->create_statement_from_sql(sql.str());
auto result = sql_be->execute_select_statement(stmt);
for (auto row : *result)
{
auto b = load_single_budget (sql_be, row);
if (b != nullptr)
instances.push_back(QOF_INSTANCE(b));
}
if (!instances.empty())
gnc_sql_slots_load_for_instancevec (sql_be, instances);
}
static QofCollection*
grand_getDescend(mygrand *g)
{
QofCollection *col;
QofInstance *ent;
GList *list;
g_return_val_if_fail(g, NULL);
col = qof_collection_new(CHILD_MODULE_NAME);
for (list = g_list_copy(g->descend); list; list = list->next)
{
ent = QOF_INSTANCE(list->data);
if (!ent)
{
break;
}
do_test(0 == safe_strcmp(ent->e_type, CHILD_MODULE_NAME), "wrong entity");
qof_collection_add_entity(col, ent);
}
return col;
}
void
GncSqlOrderBackend::load_all (GncSqlBackend* be)
{
g_return_if_fail (be != NULL);
std::stringstream sql;
sql << "SELECT * FROM " << TABLE_NAME;
auto stmt = be->create_statement_from_sql(sql.str());
auto result = be->execute_select_statement(stmt);
InstanceVec instances;
for (auto row : *result)
{
GncOrder* pOrder = load_single_order (be, row);
if (pOrder != nullptr)
instances.push_back(QOF_INSTANCE(pOrder));
}
if (!instances.empty())
gnc_sql_slots_load_for_instancevec (be, instances);
}
/* Return the string entry for transfer column when template */
const char *
gnc_tree_util_split_reg_template_get_transfer_entry (Split *split)
{
static char *name = NULL;
Account *account;
GncGUID *guid = NULL;
/* Callers either g_strdup the return or use it as a temp for comparison,
so we keep our static ref and free it on every call. */
g_free (name);
if (!split)
return NULL;
qof_instance_get (QOF_INSTANCE (split),
"sx-account", &guid,
NULL);
account = xaccAccountLookup (guid, gnc_get_current_book ());
name = account ? gnc_get_account_name_for_register (account) : NULL;
return name;
}
static void
load_taxtable_entries (GncSqlBackend* sql_be, GncTaxTable* tt)
{
gchar guid_buf[GUID_ENCODING_LENGTH + 1];
GValue value;
gchar* buf;
g_return_if_fail (sql_be != NULL);
g_return_if_fail (tt != NULL);
guid_to_string_buff (qof_instance_get_guid (QOF_INSTANCE (tt)), guid_buf);
memset (&value, 0, sizeof (GValue));
g_value_init (&value, G_TYPE_STRING);
g_value_set_string (&value, guid_buf);
buf = g_strdup_printf ("SELECT * FROM %s WHERE taxtable='%s'",
TTENTRIES_TABLE_NAME, guid_buf);
auto stmt = sql_be->create_statement_from_sql (buf);
g_free (buf);
auto result = sql_be->execute_select_statement(stmt);
for (auto row : *result)
load_single_ttentry (sql_be, row, tt);
}
gint64
qof_book_get_counter (QofBook *book, const char *counter_name)
{
KvpFrame *kvp;
KvpValue *value;
if (!book)
{
PWARN ("No book!!!");
return -1;
}
if (!counter_name || *counter_name == '\0')
{
PWARN ("Invalid counter name.");
return -1;
}
/* Use the KVP in the book */
kvp = qof_instance_get_slots (QOF_INSTANCE (book));
if (!kvp)
{
PWARN ("Book has no KVP_Frame");
return -1;
}
value = kvp->get_slot({"counters", counter_name});
if (value)
{
/* found it */
return value->get<int64_t>();
}
else
{
/* New counter */
return 0;
}
}
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);
}
}
}
static void
set_root_template_guid( gpointer pObject, /*@ null @*/ gpointer pValue )
{
QofBook* book = QOF_BOOK(pObject);
GncGUID* guid = (GncGUID*)pValue;
Account* root;
g_return_if_fail( pObject != NULL );
g_return_if_fail( QOF_IS_BOOK(pObject) );
g_return_if_fail( pValue != NULL );
root = gnc_book_get_template_root( book );
if ( root == NULL )
{
root = xaccMallocAccount( book );
xaccAccountBeginEdit( root );
xaccAccountSetType( root, ACCT_TYPE_ROOT );
xaccAccountCommitEdit( root );
gnc_book_set_template_root( book, root );
}
qof_instance_set_guid( QOF_INSTANCE(root), guid );
}
static void
balance_cell_edited (GtkCellRendererText *cell,
gchar *path,
gchar *new_text,
gpointer user_data)
{
Account *account;
char *error_loc;
gnc_numeric amount;
hierarchy_data *data = (hierarchy_data *)user_data;
g_return_if_fail(data != NULL);
account = gnc_tree_view_account_get_selected_account(data->final_account_tree);
if (account == NULL)
{
g_critical("account is null");
return;
}
error_loc = NULL;
if (!gnc_exp_parser_parse (new_text, &amount, &error_loc))
{
amount = gnc_numeric_zero();
g_object_set (G_OBJECT(cell), "text", "", NULL);
}
/* Bug#348364: Emulating price-cell, we need to ensure the denominator of
* the amount is in the SCU of the account's commodity (so
* gnc-ui-util.c:is_decimal_fraction() on the remainder denom for
* fractional values will be a "decimal").
*/
{
int account_cmdty_fraction = xaccAccountGetCommoditySCU(account);
amount = gnc_numeric_convert(amount, account_cmdty_fraction, GNC_HOW_RND_ROUND_HALF_UP);
}
set_final_balance (data->balance_hash, account, amount);
qof_event_gen (QOF_INSTANCE(account), QOF_EVENT_MODIFY, NULL);
}
static void
billterm_scrub (QofBook *book)
{
GList *list = NULL;
GList *node;
GncBillTerm *parent, *term;
GHashTable *ht = g_hash_table_new(g_direct_hash, g_direct_equal);
DEBUG("scrubbing billterms...");
qof_object_foreach (GNC_ID_INVOICE, book, billterm_scrub_invoices, ht);
qof_object_foreach (GNC_ID_CUSTOMER, book, billterm_scrub_cust, ht);
qof_object_foreach (GNC_ID_VENDOR, book, billterm_scrub_vendor, ht);
qof_object_foreach (GNC_ID_BILLTERM, book, billterm_scrub_cb, &list);
/* destroy the list of "grandchildren" bill terms */
for (node = list; node; node = node->next)
{
gchar termstr[GUID_ENCODING_LENGTH+1];
term = node->data;
guid_to_string_buff(qof_instance_get_guid(QOF_INSTANCE(term)), termstr);
PWARN ("deleting grandchild billterm: %s\n", termstr);
/* Make sure the parent has no children */
parent = gncBillTermGetParent(term);
gncBillTermSetChild(parent, NULL);
/* Destroy this bill term */
gncBillTermBeginEdit(term);
gncBillTermDestroy(term);
}
/* reset the refcounts as necessary */
g_hash_table_foreach(ht, billterm_reset_refcount, NULL);
g_list_free(list);
g_hash_table_destroy(ht);
}
GList*
gnc_sx_get_sxes_referencing_account(QofBook *book, Account *acct)
{
GList *rtn = NULL;
const GncGUID *acct_guid = qof_entity_get_guid(QOF_INSTANCE(acct));
GList *sx_list = gnc_book_get_schedxactions(book)->sx_list;
for (; sx_list != NULL; sx_list = sx_list->next)
{
SchedXaction *sx = (SchedXaction*)sx_list->data;
GList *splits = xaccSchedXactionGetSplits(sx);
for (; splits != NULL; splits = splits->next)
{
Split *s = (Split*)splits->data;
KvpFrame *frame = kvp_frame_get_frame(xaccSplitGetSlots(s), GNC_SX_ID);
GncGUID *sx_split_acct_guid = kvp_frame_get_guid(frame, GNC_SX_ACCOUNT);
if (guid_equal(acct_guid, sx_split_acct_guid))
{
rtn = g_list_append(rtn, sx);
}
}
}
return rtn;
}
static void
bt_set_parent (gpointer data, gpointer value)
{
GncBillTerm* billterm;
GncBillTerm* parent;
QofBook* pBook;
GncGUID* guid = (GncGUID*)value;
g_return_if_fail (data != NULL);
g_return_if_fail (GNC_IS_BILLTERM (data));
billterm = GNC_BILLTERM (data);
pBook = qof_instance_get_book (QOF_INSTANCE (billterm));
if (guid != NULL)
{
parent = gncBillTermLookup (pBook, guid);
if (parent != NULL)
{
gncBillTermSetParent (billterm, parent);
gncBillTermSetChild (parent, billterm);
}
}
}
static gpointer
bt_get_parent (gpointer pObject)
{
const GncBillTerm* billterm;
const GncBillTerm* pParent;
const GncGUID* parent_guid;
g_return_val_if_fail (pObject != NULL, NULL);
g_return_val_if_fail (GNC_IS_BILLTERM (pObject), NULL);
billterm = GNC_BILLTERM (pObject);
pParent = gncBillTermGetParent (billterm);
if (pParent == NULL)
{
parent_guid = NULL;
}
else
{
parent_guid = qof_instance_get_guid (QOF_INSTANCE (pParent));
}
return (gpointer)parent_guid;
}
/**
* Loads all transactions for an account.
*
* @param be SQL backend
* @param account Account
*/
void gnc_sql_transaction_load_tx_for_account( GncSqlBackend* be, Account* account )
{
const GncGUID* guid;
gchar guid_buf[GUID_ENCODING_LENGTH+1];
gchar* query_sql;
GncSqlStatement* stmt;
g_return_if_fail( be != NULL );
g_return_if_fail( account != NULL );
guid = qof_instance_get_guid( QOF_INSTANCE(account) );
(void)guid_to_string_buff( guid, guid_buf );
query_sql = g_strdup_printf(
"SELECT DISTINCT t.* FROM %s AS t, %s AS s WHERE s.tx_guid=t.guid AND s.account_guid ='%s'",
TRANSACTION_TABLE, SPLIT_TABLE, guid_buf );
stmt = gnc_sql_create_statement_from_sql( be, query_sql );
g_free( query_sql );
if ( stmt != NULL )
{
query_transactions( be, stmt );
gnc_sql_statement_dispose( stmt );
}
}
/**
* Loads the budget amounts for a budget.
*
* @param sql_be SQL backend
* @param budget Budget
*/
static void
load_budget_amounts (GncSqlBackend* sql_be, GncBudget* budget)
{
gchar guid_buf[GUID_ENCODING_LENGTH + 1];
g_return_if_fail (sql_be != NULL);
g_return_if_fail (budget != NULL);
(void)guid_to_string_buff (qof_instance_get_guid (QOF_INSTANCE (budget)),
guid_buf);
auto sql = g_strdup_printf ("SELECT * FROM %s WHERE budget_guid='%s'",
AMOUNTS_TABLE, guid_buf);
auto stmt = sql_be->create_statement_from_sql(sql);
g_free (sql);
if (stmt != nullptr)
{
auto result = sql_be->execute_select_statement(stmt);
budget_amount_info_t info = { budget, NULL, 0 };
for (auto row : *result)
gnc_sql_load_object (sql_be, row, NULL, &info, budget_amounts_col_table);
}
}
static gpointer
get_parent (gpointer pObject)
{
const Account* pAccount;
const Account* pParent;
const GncGUID* parent_guid;
g_return_val_if_fail (pObject != NULL, NULL);
g_return_val_if_fail (GNC_IS_ACCOUNT (pObject), NULL);
pAccount = GNC_ACCOUNT (pObject);
pParent = gnc_account_get_parent (pAccount);
if (pParent == NULL)
{
parent_guid = NULL;
}
else
{
parent_guid = qof_instance_get_guid (QOF_INSTANCE (pParent));
}
return (gpointer)parent_guid;
}
static xmlNodePtr
ttentry_dom_tree_create (GncTaxTableEntry *entry)
{
xmlNodePtr ret;
Account *account;
gnc_numeric amount;
ret = xmlNewNode(NULL, BAD_CAST gnc_taxtableentry_string);
account = gncTaxTableEntryGetAccount (entry);
if (account)
xmlAddChild(ret, guid_to_dom_tree (ttentry_account_string,
qof_instance_get_guid (QOF_INSTANCE(account))));
amount = gncTaxTableEntryGetAmount (entry);
xmlAddChild (ret, gnc_numeric_to_dom_tree (ttentry_amount_string, &amount));
xmlAddChild(ret, text_to_dom_tree (ttentry_type_string,
gncAmountTypeToString (
gncTaxTableEntryGetType (entry))));
return ret;
}
static void
tt_set_parent( gpointer data, gpointer value )
{
GncTaxTable* tt;
GncTaxTable* parent;
QofBook* pBook;
GncGUID* guid = (GncGUID*)value;
g_return_if_fail( data != NULL );
g_return_if_fail( GNC_IS_TAXTABLE(data) );
tt = GNC_TAXTABLE(data);
pBook = qof_instance_get_book( QOF_INSTANCE(tt) );
if ( guid != NULL )
{
parent = gncTaxTableLookup( pBook, guid );
if ( parent != NULL )
{
gncTaxTableSetParent( tt, parent );
gncTaxTableSetChild( parent, tt );
}
}
}
static /*@ null @*//*@ dependent @*/ gpointer
bt_get_parent( gpointer pObject )
{
const GncTaxTable* tt;
const GncTaxTable* pParent;
const GncGUID* parent_guid;
g_return_val_if_fail( pObject != NULL, NULL );
g_return_val_if_fail( GNC_IS_TAXTABLE(pObject), NULL );
tt = GNC_TAXTABLE(pObject);
pParent = gncTaxTableGetParent( tt );
if ( pParent == NULL )
{
parent_guid = NULL;
}
else
{
parent_guid = qof_instance_get_guid( QOF_INSTANCE(pParent) );
}
return (gpointer)parent_guid;
}
