gboolean
write_book_parts(FILE *out, QofBook *book)
{
xmlNodePtr domnode;
domnode = guid_to_dom_tree(book_id_string, qof_book_get_guid(book));
xmlElemDump(out, NULL, domnode);
xmlFreeNode (domnode);
if (ferror(out) || fprintf(out, "\n") < 0)
return FALSE;
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)
{
xmlElemDump(out, NULL, kvpnode);
xmlFreeNode(kvpnode);
if (ferror(out) || fprintf(out, "\n") < 0)
return FALSE;
}
}
return TRUE;
}
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;
}
gchar *
qof_book_increment_and_format_counter (QofBook *book, const char *counter_name)
{
KvpFrame *kvp;
KvpValue *value;
gint64 counter;
gchar* format;
gchar* result;
if (!book)
{
PWARN ("No book!!!");
return NULL;
}
if (!counter_name || *counter_name == '\0')
{
PWARN ("Invalid counter name.");
return NULL;
}
/* Get the current counter value from the KVP in the book. */
counter = qof_book_get_counter(book, counter_name);
/* Check if an error occurred */
if (counter < 0)
return NULL;
/* Increment the counter */
counter++;
/* Get the KVP from the current book */
kvp = qof_instance_get_slots (QOF_INSTANCE (book));
if (!kvp)
{
PWARN ("Book has no KVP_Frame");
return NULL;
}
/* Save off the new counter */
qof_book_begin_edit(book);
value = new KvpValue(counter);
delete kvp->set_path({"counters", counter_name}, value);
qof_instance_set_dirty (QOF_INSTANCE (book));
qof_book_commit_edit(book);
format = qof_book_get_counter_format(book, counter_name);
if (!format)
{
PWARN("Cannot get format for counter");
return NULL;
}
/* Generate a string version of the counter */
result = g_strdup_printf(format, counter);
g_free (format);
return result;
}
static gboolean
billterm_slots_handler (xmlNodePtr node, gpointer billterm_pdata)
{
struct billterm_pdata *pdata = billterm_pdata;
return dom_tree_to_kvp_frame_given (node,
qof_instance_get_slots (QOF_INSTANCE(pdata->term)));
}
static gboolean
customer_slots_handler (xmlNodePtr node, gpointer cust_pdata)
{
struct customer_pdata *pdata = cust_pdata;
return dom_tree_to_kvp_frame_given (node,
qof_instance_get_slots (QOF_INSTANCE(pdata->customer)));
}
static void
load_slot_for_list_item( GncSqlBackend* be, GncSqlRow* row, QofCollection* coll )
{
slot_info_t slot_info = { NULL, NULL, TRUE, NULL, 0, NULL, FRAME, NULL, NULL };
const GncGUID* guid;
QofInstance* inst;
g_return_if_fail( be != NULL );
g_return_if_fail( row != NULL );
g_return_if_fail( coll != NULL );
guid = load_obj_guid( be, row );
g_assert( guid != NULL );
inst = qof_collection_lookup_entity( coll, guid );
slot_info.be = be;
slot_info.pKvpFrame = qof_instance_get_slots( inst );
slot_info.context = NONE;
gnc_sql_load_object( be, row, TABLE_NAME, &slot_info, col_table );
if ( slot_info.path != NULL )
{
(void)g_string_free( slot_info.path, TRUE );
}
}
/** Returns pointer to default gain/loss policy for book, if one exists in the
* KVP, or NULL; does not validate contents nor determine if there is a valid
* book-currency, both of which are required, for the 'book-currency'
* currency accounting method to apply. Use instead
* 'gnc_book_get_default_gains_policy' which does these validations. */
const gchar *
qof_book_get_default_gains_policy (QofBook *book)
{
KvpFrame *kvp;
KvpValue *value;
if (!book)
{
PWARN ("No book!!!");
return NULL;
}
/* Get the KVP from the current book */
kvp = qof_instance_get_slots (QOF_INSTANCE (book));
if (!kvp)
{
PWARN ("Book has no KVP_Frame");
return NULL;
}
/* See if there is a default gain/loss policy */
value = kvp->get_slot({KVP_OPTION_PATH, OPTION_SECTION_ACCOUNTS,
OPTION_NAME_DEFAULT_GAINS_POLICY});
if (!value)
/* No default gain/loss policy, therefore not valid book-currency
accounting method */
return nullptr;
return g_strdup(value->get<const char*>());
}
xmlNodePtr
gnc_address_to_dom_tree (const char *tag, GncAddress *addr)
{
xmlNodePtr ret;
KvpFrame *kf;
ret = xmlNewNode(NULL, BAD_CAST tag);
xmlSetProp(ret, BAD_CAST "version", BAD_CAST address_version_string);
maybe_add_string (ret, addr_name_string, gncAddressGetName (addr));
maybe_add_string (ret, addr_addr1_string, gncAddressGetAddr1 (addr));
maybe_add_string (ret, addr_addr2_string, gncAddressGetAddr2 (addr));
maybe_add_string (ret, addr_addr3_string, gncAddressGetAddr3 (addr));
maybe_add_string (ret, addr_addr4_string, gncAddressGetAddr4 (addr));
maybe_add_string (ret, addr_phone_string, gncAddressGetPhone (addr));
maybe_add_string (ret, addr_fax_string, gncAddressGetFax (addr));
maybe_add_string (ret, addr_email_string, gncAddressGetEmail (addr));
kf = qof_instance_get_slots (QOF_INSTANCE(addr));
if (kf)
{
xmlNodePtr kvpnode = kvp_frame_to_dom_tree(addr_slots_string, kf);
if (kvpnode)
{
xmlAddChild(ret, kvpnode);
}
}
return ret;
}
static gboolean
employee_slots_handler (xmlNodePtr node, gpointer employee_pdata)
{
struct employee_pdata *pdata = employee_pdata;
return dom_tree_to_kvp_frame_given (
node, qof_instance_get_slots (QOF_INSTANCE(pdata->employee)));
}
/** Returns pointer to book-currency name for book, if one exists in the
* KVP, or NULL; does not validate contents nor determine if there is a valid
* default gain/loss policy, both of which are required, for the
* 'book-currency' currency accounting method to apply. Use instead
* 'gnc_book_get_book_currency' which does these validations. */
const gchar *
qof_book_get_book_currency (QofBook *book)
{
KvpFrame *kvp;
KvpValue *value;
if (!book)
{
PWARN ("No book!!!");
return NULL;
}
/* Get the KVP from the current book */
kvp = qof_instance_get_slots (QOF_INSTANCE (book));
if (!kvp)
{
PWARN ("Book has no KVP_Frame");
return NULL;
}
/* See if there is a book currency. */
value = kvp->get_slot({KVP_OPTION_PATH, OPTION_SECTION_ACCOUNTS,
OPTION_NAME_BOOK_CURRENCY});
if (!value) /* No book-currency */
return nullptr;
return value->get<const char*>();
}
TEST_F(ImapBayesTest, FindAccountBayes)
{
auto root = qof_instance_get_slots(QOF_INSTANCE(t_bank_account));
auto acct1_guid = guid_to_string (xaccAccountGetGUID(t_expense_account1));
auto acct2_guid = guid_to_string (xaccAccountGetGUID(t_expense_account2));
auto value = new KvpValue(INT64_C(42));
root->set_path({IMAP_FRAME_BAYES, foo, acct1_guid}, value);
root->set_path({IMAP_FRAME_BAYES, bar, acct1_guid}, value);
root->set_path({IMAP_FRAME_BAYES, baz, acct2_guid}, value);
root->set_path({IMAP_FRAME_BAYES, waldo, acct2_guid}, value);
root->set_path({IMAP_FRAME_BAYES, pepper, acct1_guid}, value);
root->set_path({IMAP_FRAME_BAYES, salt, acct2_guid}, value);
auto account = gnc_account_imap_find_account_bayes(t_imap, t_list1);
EXPECT_EQ(t_expense_account1, account);
account = gnc_account_imap_find_account_bayes(t_imap, t_list2);
EXPECT_EQ(t_expense_account2, account);
account = gnc_account_imap_find_account_bayes(t_imap, t_list3);
EXPECT_EQ(t_expense_account1, account);
account = gnc_account_imap_find_account_bayes(t_imap, t_list4);
EXPECT_EQ(t_expense_account2, account);
account = gnc_account_imap_find_account_bayes(t_imap, t_list5);
EXPECT_EQ(nullptr, account);
}
static void
load_slot_for_book_object( GncSqlBackend* be, GncSqlRow* row, BookLookupFn lookup_fn )
{
slot_info_t slot_info = { NULL, NULL, TRUE, NULL, 0, NULL, FRAME, NULL, NULL };
const GncGUID* guid;
QofInstance* inst;
g_return_if_fail( be != NULL );
g_return_if_fail( row != NULL );
g_return_if_fail( lookup_fn != NULL );
guid = load_obj_guid( be, row );
g_return_if_fail( guid != NULL );
inst = lookup_fn( guid, be->book );
g_return_if_fail( inst != NULL );
slot_info.be = be;
slot_info.pKvpFrame = qof_instance_get_slots( inst );
slot_info.path = NULL;
gnc_sql_load_object( be, row, TABLE_NAME, &slot_info, col_table );
if ( slot_info.path != NULL )
{
(void)g_string_free( slot_info.path, TRUE );
}
}
TEST_F(ImapPlainTest, AddAccount)
{
// prevent the embedded beginedit/commitedit from doing anything
qof_instance_increase_editlevel(QOF_INSTANCE(t_bank_account));
qof_instance_mark_clean(QOF_INSTANCE(t_bank_account));
gnc_account_imap_add_account(t_imap, "foo", "bar", t_expense_account1);
gnc_account_imap_add_account(t_imap, "baz", "waldo", t_expense_account2);
gnc_account_imap_add_account(t_imap, NULL, "pepper", t_expense_account1);
gnc_account_imap_add_account(t_imap, NULL, "salt", t_expense_account2);
EXPECT_EQ(1, qof_instance_get_editlevel(QOF_INSTANCE(t_bank_account)));
EXPECT_TRUE(qof_instance_get_dirty_flag(QOF_INSTANCE(t_bank_account)));
qof_instance_mark_clean(QOF_INSTANCE(t_bank_account));
gnc_account_imap_add_account(t_imap, NULL, NULL, t_expense_account2);
EXPECT_FALSE(qof_instance_get_dirty_flag(QOF_INSTANCE(t_bank_account)));
gnc_account_imap_add_account(t_imap, "pork", "sausage", NULL);
EXPECT_FALSE(qof_instance_get_dirty_flag(QOF_INSTANCE(t_bank_account)));
qof_instance_reset_editlevel(QOF_INSTANCE(t_bank_account));
auto root = qof_instance_get_slots(QOF_INSTANCE(t_bank_account));
auto value = root->get_slot({IMAP_FRAME, "foo", "bar"});
auto check_account = [this](KvpValue* v) {
return xaccAccountLookup(v->get<GncGUID*>(), this->t_imap->book); };
EXPECT_EQ(t_expense_account1, check_account(value));
value = root->get_slot({IMAP_FRAME, "baz", "waldo"});
EXPECT_EQ(t_expense_account2, check_account(value));
value = root->get_slot({IMAP_FRAME, "pepper"});
EXPECT_EQ(t_expense_account1, check_account(value));
value = root->get_slot({IMAP_FRAME, "salt"});
EXPECT_EQ(t_expense_account2, check_account(value));
value = root->get_slot({IMAP_FRAME, "pork", "sausage"});
EXPECT_EQ(nullptr, value);
}
static gboolean
address_slots_handler (xmlNodePtr node, gpointer addr_pdata)
{
struct address_pdata *pdata = addr_pdata;
return dom_tree_to_kvp_frame_given
(node, qof_instance_get_slots (QOF_INSTANCE (pdata->address)));
}
static gboolean
job_slots_handler (xmlNodePtr node, gpointer job_pdata)
{
struct job_pdata *pdata = job_pdata;
return dom_tree_to_kvp_frame_given
(node, qof_instance_get_slots (QOF_INSTANCE (pdata->job)));
}
const char*
qof_book_get_string_option(const QofBook* book, const char* opt_name)
{
auto slot = qof_instance_get_slots(QOF_INSTANCE (book))->get_slot(opt_name);
if (slot == nullptr)
return nullptr;
return slot->get<const char*>();
}
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;
}
KvpValue*
qof_book_get_option (QofBook *book, GSList *path)
{
KvpFrame *root = qof_instance_get_slots(QOF_INSTANCE (book));
Path path_v {KVP_OPTION_PATH};
for (auto item = path; item != nullptr; item = g_slist_next(item))
path_v.push_back(static_cast<const char*>(item->data));
return root->get_slot(path_v);
}
void
qof_book_set_feature (QofBook *book, const gchar *key, const gchar *descr)
{
KvpFrame *frame = qof_instance_get_slots (QOF_INSTANCE (book));
qof_book_begin_edit (book);
delete frame->set_path({GNC_FEATURES, key}, new KvpValue(descr));
qof_instance_set_dirty (QOF_INSTANCE (book));
qof_book_commit_edit (book);
}
void
qof_book_set_string_option(QofBook* book, const char* opt_name, const char* opt_val)
{
qof_book_begin_edit(book);
auto frame = qof_instance_get_slots(QOF_INSTANCE(book));
delete frame->set(opt_name, new KvpValue(opt_val));
qof_instance_set_dirty (QOF_INSTANCE (book));
qof_book_commit_edit(book);
}
static xmlNodePtr
billterm_dom_tree_create (GncBillTerm *term)
{
xmlNodePtr ret, data, kvpnode;
ret = xmlNewNode(NULL, BAD_CAST gnc_billterm_string);
xmlSetProp(ret, BAD_CAST "version", BAD_CAST billterm_version_string);
maybe_add_guid(ret, billterm_guid_string, QOF_INSTANCE(term));
xmlAddChild(ret, text_to_dom_tree (billterm_name_string,
gncBillTermGetName (term)));
xmlAddChild(ret, text_to_dom_tree (billterm_desc_string,
gncBillTermGetDescription (term)));
xmlAddChild(ret, int_to_dom_tree (billterm_refcount_string,
gncBillTermGetRefcount (term)));
xmlAddChild(ret, int_to_dom_tree (billterm_invisible_string,
gncBillTermGetInvisible (term)));
kvpnode = kvp_frame_to_dom_tree (billterm_slots_string,
qof_instance_get_slots (QOF_INSTANCE(term)));
if (kvpnode) xmlAddChild (ret, kvpnode);
/* We should not be our own child */
if (gncBillTermGetChild(term) != term)
maybe_add_guid(ret, billterm_child_string,
QOF_INSTANCE(gncBillTermGetChild (term)));
maybe_add_guid(ret, billterm_parent_string,
QOF_INSTANCE(gncBillTermGetParent (term)));
switch (gncBillTermGetType (term))
{
case GNC_TERM_TYPE_DAYS:
data = xmlNewChild (ret, NULL, BAD_CAST gnc_daystype_string, NULL);
maybe_add_int (data, days_duedays_string, gncBillTermGetDueDays (term));
maybe_add_int (data, days_discdays_string,
gncBillTermGetDiscountDays (term));
maybe_add_numeric (data, days_discount_string,
gncBillTermGetDiscount (term));
break;
case GNC_TERM_TYPE_PROXIMO:
data = xmlNewChild (ret, NULL, BAD_CAST gnc_proximotype_string, NULL);
maybe_add_int (data, prox_dueday_string, gncBillTermGetDueDays (term));
maybe_add_int (data, prox_discday_string,
gncBillTermGetDiscountDays (term));
maybe_add_numeric (data, prox_discount_string,
gncBillTermGetDiscount (term));
maybe_add_int (data, prox_cutoff_string, gncBillTermGetCutoff (term));
break;
}
return ret;
}
/* ================================================================= */
static gboolean
save_invoice( GncSqlBackend* be, QofInstance* inst )
{
const GncGUID* guid;
GncInvoice* invoice;
gint op;
gboolean is_infant;
gboolean is_ok = TRUE;
g_return_val_if_fail( inst != NULL, FALSE );
g_return_val_if_fail( GNC_IS_INVOICE(inst), FALSE );
g_return_val_if_fail( be != NULL, FALSE );
invoice = GNC_INVOICE(inst);
is_infant = qof_instance_get_infant( inst );
if ( qof_instance_get_destroying( inst ) )
{
op = OP_DB_DELETE;
}
else if ( be->is_pristine_db || is_infant )
{
op = OP_DB_INSERT;
}
else
{
op = OP_DB_UPDATE;
}
if ( op != OP_DB_DELETE )
{
// Ensure the commodity is in the db
is_ok = gnc_sql_save_commodity( be, gncInvoiceGetCurrency( invoice ) );
}
if ( is_ok )
{
is_ok = gnc_sql_do_db_operation( be, op, TABLE_NAME, GNC_ID_INVOICE, inst, col_table );
}
if ( is_ok )
{
// Now, commit or delete any slots
guid = qof_instance_get_guid( inst );
if ( !qof_instance_get_destroying(inst) )
{
is_ok = gnc_sql_slots_save( be, guid, is_infant, qof_instance_get_slots( inst ) );
}
else
{
is_ok = gnc_sql_slots_delete( be, guid );
}
}
return is_ok;
}
const gchar *
qof_book_get_counter_format(const QofBook *book, const char *counter_name)
{
KvpFrame *kvp;
const char *format;
KvpValue *value;
gchar *error;
if (!book)
{
PWARN ("No book!!!");
return NULL;
}
if (!counter_name || *counter_name == '\0')
{
PWARN ("Invalid counter name.");
return NULL;
}
/* Get the KVP from the current book */
kvp = qof_instance_get_slots (QOF_INSTANCE (book));
if (!kvp)
{
PWARN ("Book has no KVP_Frame");
return NULL;
}
format = NULL;
/* Get the format string */
value = kvp->get_slot({"counter_formats", counter_name});
if (value)
{
format = value->get<const char*>();
error = qof_book_validate_counter_format(format);
if (error != NULL)
{
PWARN("Invalid counter format string. Format string: '%s' Counter: '%s' Error: '%s')", format, counter_name, error);
/* Invalid format string */
format = NULL;
g_free(error);
}
}
/* If no (valid) format string was found, use the default format
* string */
if (!format)
{
/* Use the default format */
format = "%.6" G_GINT64_FORMAT;
}
return format;
}
static gboolean
save_taxtable( GncSqlBackend* be, QofInstance* inst )
{
GncTaxTable* tt;
const GncGUID* guid;
gint op;
gboolean is_infant;
gboolean is_ok;
g_return_val_if_fail( inst != NULL, FALSE );
g_return_val_if_fail( GNC_IS_TAXTABLE(inst), FALSE );
g_return_val_if_fail( be != NULL, FALSE );
tt = GNC_TAXTABLE(inst);
is_infant = qof_instance_get_infant( inst );
if ( qof_instance_get_destroying( inst ) )
{
op = OP_DB_DELETE;
}
else if ( be->is_pristine_db || is_infant )
{
op = OP_DB_INSERT;
}
else
{
op = OP_DB_UPDATE;
}
is_ok = gnc_sql_do_db_operation( be, op, TT_TABLE_NAME, GNC_ID_TAXTABLE, tt, tt_col_table );
if ( is_ok )
{
// Now, commit or delete any slots and tax table entries
guid = qof_instance_get_guid( inst );
if ( !qof_instance_get_destroying(inst) )
{
is_ok = gnc_sql_slots_save( be, guid, is_infant, qof_instance_get_slots( inst ) );
if ( is_ok )
{
is_ok = save_tt_entries( be, guid, gncTaxTableGetEntries( tt ) );
}
}
else
{
is_ok = gnc_sql_slots_delete( be, guid );
if ( is_ok )
{
is_ok = delete_all_tt_entries( be, guid );
}
}
}
return is_ok;
}
char *
qof_book_get_counter_format(const QofBook *book, const char *counter_name)
{
KvpFrame *kvp;
const char *user_format = NULL;
gchar *norm_format = NULL;
KvpValue *value;
gchar *error = NULL;
if (!book)
{
PWARN ("No book!!!");
return NULL;
}
if (!counter_name || *counter_name == '\0')
{
PWARN ("Invalid counter name.");
return NULL;
}
/* Get the KVP from the current book */
kvp = qof_instance_get_slots (QOF_INSTANCE (book));
if (!kvp)
{
PWARN ("Book has no KVP_Frame");
return NULL;
}
/* Get the format string */
value = kvp->get_slot({"counter_formats", counter_name});
if (value)
{
user_format = value->get<const char*>();
norm_format = qof_book_normalize_counter_format(user_format, &error);
if (!norm_format)
{
PWARN("Invalid counter format string. Format string: '%s' Counter: '%s' Error: '%s')", user_format, counter_name, error);
/* Invalid format string */
user_format = NULL;
g_free(error);
}
}
/* If no (valid) format string was found, use the default format
* string */
if (!norm_format)
{
/* Use the default format */
norm_format = g_strdup ("%.6" PRIi64);
}
return norm_format;
}
void
qof_book_set_string_option(QofBook* book, const char* opt_name, const char* opt_val)
{
qof_book_begin_edit(book);
auto frame = qof_instance_get_slots(QOF_INSTANCE(book));
if (opt_val && (*opt_val != '\0'))
delete frame->set(opt_name, new KvpValue(g_strdup(opt_val)));
else
delete frame->set(opt_name, nullptr);
qof_instance_set_dirty (QOF_INSTANCE (book));
qof_book_commit_edit(book);
}
void
qof_book_set_option (QofBook *book, KvpValue *value, GSList *path)
{
KvpFrame *root = qof_instance_get_slots (QOF_INSTANCE (book));
Path path_v {KVP_OPTION_PATH};
for (auto item = path; item != nullptr; item = g_slist_next(item))
path_v.push_back(static_cast<const char*>(item->data));
qof_book_begin_edit (book);
delete root->set_path(path_v, value);
qof_instance_set_dirty (QOF_INSTANCE (book));
qof_book_commit_edit (book);
}
static xmlNodePtr
employee_dom_tree_create (GncEmployee *employee)
{
xmlNodePtr ret, kvpnode;
gnc_numeric num;
Account* ccard_acc;
ret = xmlNewNode(NULL, BAD_CAST gnc_employee_string);
xmlSetProp(ret, BAD_CAST "version", BAD_CAST employee_version_string);
xmlAddChild(ret, guid_to_dom_tree(employee_guid_string,
qof_instance_get_guid(QOF_INSTANCE (employee))));
xmlAddChild(ret, text_to_dom_tree(employee_username_string,
gncEmployeeGetUsername (employee)));
xmlAddChild(ret, text_to_dom_tree(employee_id_string,
gncEmployeeGetID (employee)));
xmlAddChild(ret, gnc_address_to_dom_tree(employee_addr_string,
gncEmployeeGetAddr (employee)));
maybe_add_string (ret, employee_language_string,
gncEmployeeGetLanguage (employee));
maybe_add_string (ret, employee_acl_string, gncEmployeeGetAcl (employee));
xmlAddChild(ret, int_to_dom_tree(employee_active_string,
gncEmployeeGetActive (employee)));
num = gncEmployeeGetWorkday (employee);
xmlAddChild(ret, gnc_numeric_to_dom_tree (employee_workday_string, &num));
num = gncEmployeeGetRate (employee);
xmlAddChild(ret, gnc_numeric_to_dom_tree (employee_rate_string, &num));
xmlAddChild
(ret,
commodity_ref_to_dom_tree(employee_currency_string,
gncEmployeeGetCurrency (employee)));
ccard_acc = gncEmployeeGetCCard (employee);
if (ccard_acc)
xmlAddChild(ret, guid_to_dom_tree(employee_ccard_string,
qof_instance_get_guid(QOF_INSTANCE(ccard_acc))));
kvpnode = kvp_frame_to_dom_tree (employee_slots_string,
qof_instance_get_slots (QOF_INSTANCE(employee)));
if (kvpnode) xmlAddChild (ret, kvpnode);
return ret;
}
static gboolean
book_slots_handler (xmlNodePtr node, gpointer book_pdata)
{
QofBook *book = book_pdata;
gboolean success;
/* the below works only because the get is gaurenteed to return
* a frame, even if its empty */
success = dom_tree_to_kvp_frame_given (node, qof_instance_get_slots (QOF_INSTANCE (book)));
g_return_val_if_fail(success, FALSE);
return TRUE;
}
xmlNodePtr
qof_instance_slots_to_dom_tree(const char *tag, const QofInstance* inst)
{
xmlNodePtr ret;
const char ** keys;
unsigned int i;
KvpFrame *frame = qof_instance_get_slots(inst);
if (!frame)
return nullptr;
ret = xmlNewNode(nullptr, BAD_CAST tag);
frame->for_each_slot(add_kvp_slot, static_cast<void*>(ret));
return ret;
}
