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; }