static xmlNodePtr
job_dom_tree_create (GncJob *job)
{
xmlNodePtr ret;
ret = xmlNewNode(NULL, BAD_CAST gnc_job_string);
xmlSetProp(ret, BAD_CAST "version", BAD_CAST job_version_string);
xmlAddChild(ret, guid_to_dom_tree(job_guid_string,
qof_instance_get_guid (QOF_INSTANCE (job))));
xmlAddChild(ret, text_to_dom_tree(job_id_string,
gncJobGetID (job)));
xmlAddChild(ret, text_to_dom_tree(job_name_string,
gncJobGetName (job)));
maybe_add_string (ret, job_reference_string, gncJobGetReference (job));
xmlAddChild(ret, gnc_owner_to_dom_tree (job_owner_string,
gncJobGetOwner (job)));
xmlAddChild(ret, int_to_dom_tree(job_active_string,
gncJobGetActive (job)));
/* xmlAddChild won't do anything with a NULL, so tests are superfluous. */
xmlAddChild(ret, qof_instance_slots_to_dom_tree(job_slots_string,
QOF_INSTANCE(job)));
return ret;
}
gboolean
write_book_parts (FILE* out, QofBook* book)
{
xmlNodePtr domnode, slotsnode;
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;
slotsnode = qof_instance_slots_to_dom_tree (book_slots_string,
QOF_INSTANCE (book));
if (slotsnode)
{
xmlElemDump (out, NULL, slotsnode);
xmlFreeNode (slotsnode);
if (ferror (out) || fprintf (out, "\n") < 0)
return FALSE;
}
return TRUE;
}
xmlNodePtr
gnc_budget_dom_tree_create (GncBudget* bgt)
{
xmlNodePtr ret;
ENTER ("(budget=%p)", bgt);
ret = xmlNewNode (NULL, BAD_CAST gnc_budget_string);
xmlSetProp (ret, BAD_CAST "version", BAD_CAST budget_version_string);
/* field: GncGUID */
xmlAddChild (ret, guid_to_dom_tree (bgt_id_string,
gnc_budget_get_guid (bgt)));
/* field: char* name */
xmlAddChild (ret, text_to_dom_tree (bgt_name_string,
gnc_budget_get_name (bgt)));
/* field: char* description */
xmlAddChild (ret, text_to_dom_tree (bgt_description_string,
gnc_budget_get_description (bgt)));
/* field: guint num_periods */
xmlAddChild (ret, guint_to_dom_tree (bgt_num_periods_string,
gnc_budget_get_num_periods (bgt)));
/* field: Recurrence* */
xmlAddChild (ret, recurrence_to_dom_tree (bgt_recurrence_string,
gnc_budget_get_recurrence (bgt)));
/* xmlAddChild won't do anything with a NULL, so tests are superfluous. */
xmlAddChild (ret, qof_instance_slots_to_dom_tree (bgt_slots_string,
QOF_INSTANCE (bgt)));
LEAVE (" ");
return ret;
}
xmlNodePtr
gnc_commodity_dom_tree_create(const gnc_commodity *com)
{
gnc_quote_source *source;
const char *string;
xmlNodePtr ret;
gboolean currency = gnc_commodity_is_iso(com);
xmlNodePtr slotsnode =
qof_instance_slots_to_dom_tree(cmdty_slots, QOF_INSTANCE(com));
if (currency && !gnc_commodity_get_quote_flag(com) && !slotsnode)
return NULL;
ret = xmlNewNode(NULL, BAD_CAST gnc_commodity_string);
xmlSetProp(ret, BAD_CAST "version", BAD_CAST commodity_version_string);
xmlAddChild(ret, text_to_dom_tree(cmdty_namespace,
gnc_commodity_get_namespace_compat(com)));
xmlAddChild(ret, text_to_dom_tree(cmdty_id,
gnc_commodity_get_mnemonic(com)));
if (!currency)
{
if (gnc_commodity_get_fullname(com))
{
xmlAddChild(ret, text_to_dom_tree(cmdty_name,
gnc_commodity_get_fullname(com)));
}
if (gnc_commodity_get_cusip(com) &&
strlen(gnc_commodity_get_cusip(com)) > 0)
{
xmlAddChild(ret, text_to_dom_tree(
cmdty_xcode,
gnc_commodity_get_cusip(com)));
}
xmlAddChild(ret, int_to_dom_tree(cmdty_fraction,
gnc_commodity_get_fraction(com)));
}
if (gnc_commodity_get_quote_flag(com))
{
xmlNewChild(ret, NULL, BAD_CAST cmdty_get_quotes, NULL);
source = gnc_commodity_get_quote_source(com);
if (source)
xmlAddChild(ret, text_to_dom_tree(cmdty_quote_source,
gnc_quote_source_get_internal_name(source)));
string = gnc_commodity_get_quote_tz(com);
if (string)
xmlAddChild(ret, text_to_dom_tree(cmdty_quote_tz, string));
}
if (slotsnode)
xmlAddChild(ret, slotsnode);
return ret;
}
static xmlNodePtr
billterm_dom_tree_create (GncBillTerm *term)
{
xmlNodePtr ret, data;
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)));
/* xmlAddChild won't do anything with a NULL, so tests are superfluous. */
xmlAddChild(ret, qof_instance_slots_to_dom_tree(billterm_slots_string,
QOF_INSTANCE(term)));
/* 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 xmlNodePtr
vendor_dom_tree_create (GncVendor* vendor)
{
xmlNodePtr ret;
GncBillTerm* term;
GncTaxTable* taxtable;
ret = xmlNewNode (NULL, BAD_CAST gnc_vendor_string);
xmlSetProp (ret, BAD_CAST "version", BAD_CAST vendor_version_string);
xmlAddChild (ret, guid_to_dom_tree (vendor_guid_string,
qof_instance_get_guid (QOF_INSTANCE (vendor))));
xmlAddChild (ret, text_to_dom_tree (vendor_name_string,
gncVendorGetName (vendor)));
xmlAddChild (ret, text_to_dom_tree (vendor_id_string,
gncVendorGetID (vendor)));
xmlAddChild (ret, gnc_address_to_dom_tree (vendor_addr_string,
gncVendorGetAddr (vendor)));
maybe_add_string (ret, vendor_notes_string, gncVendorGetNotes (vendor));
term = gncVendorGetTerms (vendor);
if (term)
xmlAddChild (ret, guid_to_dom_tree (vendor_terms_string,
qof_instance_get_guid (QOF_INSTANCE (term))));
xmlAddChild (ret, text_to_dom_tree (vendor_taxincluded_string,
gncTaxIncludedTypeToString (
gncVendorGetTaxIncluded (vendor))));
xmlAddChild (ret, int_to_dom_tree (vendor_active_string,
gncVendorGetActive (vendor)));
xmlAddChild
(ret,
commodity_ref_to_dom_tree (vendor_currency_string,
gncVendorGetCurrency (vendor)));
xmlAddChild (ret, int_to_dom_tree (vendor_taxtableoverride_string,
gncVendorGetTaxTableOverride (vendor)));
taxtable = gncVendorGetTaxTable (vendor);
if (taxtable)
xmlAddChild (ret, guid_to_dom_tree (vendor_taxtable_string,
qof_instance_get_guid (QOF_INSTANCE (taxtable))));
/* xmlAddChild won't do anything with a NULL, so tests are superfluous. */
xmlAddChild (ret, qof_instance_slots_to_dom_tree (vendor_slots_string,
QOF_INSTANCE (vendor)));
return ret;
}
static xmlNodePtr
employee_dom_tree_create (GncEmployee *employee)
{
xmlNodePtr ret;
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))));
/* xmlAddChild won't do anything with a NULL, so tests are superfluous. */
xmlAddChild(ret, qof_instance_slots_to_dom_tree(employee_slots_string,
QOF_INSTANCE(employee)));
return ret;
}
xmlNodePtr
gnc_lot_dom_tree_create(GNCLot *lot)
{
xmlNodePtr ret;
ENTER("(lot=%p)", lot);
ret = xmlNewNode(NULL, BAD_CAST gnc_lot_string);
xmlSetProp(ret, BAD_CAST "version", BAD_CAST lot_version_string);
xmlAddChild(ret, guid_to_dom_tree(lot_id_string, gnc_lot_get_guid(lot)));
/* xmlAddChild won't do anything with a NULL, so tests are superfluous. */
xmlAddChild(ret, qof_instance_slots_to_dom_tree(lot_slots_string,
QOF_INSTANCE(lot)));
LEAVE("");
return ret;
}
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)));
/* xmlAddChild won't do anything with a NULL, so tests are superfluous. */
xmlAddChild (ret, qof_instance_slots_to_dom_tree (book_slots_string,
QOF_INSTANCE (book)));
#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;
}
xmlNodePtr
gnc_transaction_dom_tree_create (Transaction* trn)
{
xmlNodePtr ret;
gchar* str = NULL;
ret = xmlNewNode (NULL, BAD_CAST "gnc:transaction");
xmlSetProp (ret, BAD_CAST "version",
BAD_CAST transaction_version_string);
xmlAddChild (ret, guid_to_dom_tree ("trn:id", xaccTransGetGUID (trn)));
xmlAddChild (ret, commodity_ref_to_dom_tree ("trn:currency",
xaccTransGetCurrency (trn)));
str = g_strdup (xaccTransGetNum (trn));
if (str && (g_strcmp0 (str, "") != 0))
{
xmlNewTextChild (ret, NULL, BAD_CAST "trn:num",
checked_char_cast (str));
}
g_free (str);
add_timespec (ret, "trn:date-posted", xaccTransRetDatePostedTS (trn), TRUE);
add_timespec (ret, "trn:date-entered",
xaccTransRetDateEnteredTS (trn), TRUE);
str = g_strdup (xaccTransGetDescription (trn));
if (str)
{
xmlNewTextChild (ret, NULL, BAD_CAST "trn:description",
checked_char_cast (str));
}
g_free (str);
/* xmlAddChild won't do anything with a NULL, so tests are superfluous. */
xmlAddChild (ret, qof_instance_slots_to_dom_tree ("trn:slots",
QOF_INSTANCE (trn)));
add_trans_splits (ret, trn);
return ret;
}
static xmlNodePtr
order_dom_tree_create (GncOrder* order)
{
xmlNodePtr ret;
time64 tt;
ret = xmlNewNode (NULL, BAD_CAST gnc_order_string);
xmlSetProp (ret, BAD_CAST "version", BAD_CAST order_version_string);
xmlAddChild (ret, guid_to_dom_tree (order_guid_string,
qof_instance_get_guid (QOF_INSTANCE (order))));
xmlAddChild (ret, text_to_dom_tree (order_id_string,
gncOrderGetID (order)));
xmlAddChild (ret, gnc_owner_to_dom_tree (order_owner_string,
gncOrderGetOwner (order)));
tt = gncOrderGetDateOpened (order);
xmlAddChild (ret, time64_to_dom_tree (order_opened_string, tt));
tt = gncOrderGetDateClosed (order);
if (tt != INT64_MAX)
xmlAddChild (ret, time64_to_dom_tree (order_closed_string, tt));
maybe_add_string (ret, order_notes_string, gncOrderGetNotes (order));
maybe_add_string (ret, order_reference_string, gncOrderGetReference (order));
xmlAddChild (ret, int_to_dom_tree (order_active_string,
gncOrderGetActive (order)));
/* xmlAddChild won't do anything with a NULL, so tests are superfluous. */
xmlAddChild (ret, qof_instance_slots_to_dom_tree (order_slots_string,
QOF_INSTANCE (order)));
return ret;
}
xmlNodePtr
gnc_address_to_dom_tree (const char* tag, GncAddress* addr)
{
xmlNodePtr ret;
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));
/* xmlAddChild won't do anything with a NULL, so tests are superfluous. */
xmlAddChild (ret, qof_instance_slots_to_dom_tree (addr_slots_string,
QOF_INSTANCE (addr)));
return ret;
}
static xmlNodePtr
taxtable_dom_tree_create (GncTaxTable *table)
{
xmlNodePtr ret, entries;
GList *list;
ret = xmlNewNode(NULL, BAD_CAST gnc_taxtable_string);
xmlSetProp(ret, BAD_CAST "version", BAD_CAST taxtable_version_string);
maybe_add_guid(ret, taxtable_guid_string, table);
xmlAddChild(ret, text_to_dom_tree (taxtable_name_string,
gncTaxTableGetName (table)));
xmlAddChild(ret, int_to_dom_tree (taxtable_refcount_string,
gncTaxTableGetRefcount (table)));
xmlAddChild(ret, int_to_dom_tree (taxtable_invisible_string,
gncTaxTableGetInvisible (table)));
/* We should not be our own child */
if (gncTaxTableGetChild(table) != table)
maybe_add_guid(ret, taxtable_child_string, gncTaxTableGetChild (table));
maybe_add_guid(ret, taxtable_parent_string, gncTaxTableGetParent (table));
entries = xmlNewChild (ret, NULL, BAD_CAST taxtable_entries_string, NULL);
for (list = gncTaxTableGetEntries (table); list; list = list->next)
{
GncTaxTableEntry *entry = static_cast<decltype(entry)>(list->data);
xmlAddChild(entries, ttentry_dom_tree_create (entry));
}
/* xmlAddChild won't do anything with a NULL, so tests are superfluous. */
xmlAddChild(ret, qof_instance_slots_to_dom_tree(taxtable_slots_string,
QOF_INSTANCE(table)));
return ret;
}
static xmlNodePtr
customer_dom_tree_create (GncCustomer* cust)
{
xmlNodePtr ret;
gnc_numeric num;
GncBillTerm* term;
GncTaxTable* taxtable;
ret = xmlNewNode (NULL, BAD_CAST gnc_customer_string);
xmlSetProp (ret, BAD_CAST "version", BAD_CAST customer_version_string);
xmlAddChild (ret, guid_to_dom_tree (cust_guid_string,
qof_instance_get_guid (QOF_INSTANCE (cust))));
xmlAddChild (ret, text_to_dom_tree (cust_name_string,
gncCustomerGetName (cust)));
xmlAddChild (ret, text_to_dom_tree (cust_id_string,
gncCustomerGetID (cust)));
xmlAddChild (ret, gnc_address_to_dom_tree (cust_addr_string,
gncCustomerGetAddr (cust)));
xmlAddChild (ret, gnc_address_to_dom_tree (cust_shipaddr_string,
gncCustomerGetShipAddr (cust)));
maybe_add_string (ret, cust_notes_string, gncCustomerGetNotes (cust));
term = gncCustomerGetTerms (cust);
if (term)
xmlAddChild (ret, guid_to_dom_tree (cust_terms_string,
qof_instance_get_guid (QOF_INSTANCE (term))));
xmlAddChild (ret, text_to_dom_tree (cust_taxincluded_string,
gncTaxIncludedTypeToString (
gncCustomerGetTaxIncluded (cust))));
xmlAddChild (ret, int_to_dom_tree (cust_active_string,
gncCustomerGetActive (cust)));
num = gncCustomerGetDiscount (cust);
xmlAddChild (ret, gnc_numeric_to_dom_tree (cust_discount_string, &num));
num = gncCustomerGetCredit (cust);
xmlAddChild (ret, gnc_numeric_to_dom_tree (cust_credit_string, &num));
xmlAddChild
(ret,
commodity_ref_to_dom_tree (cust_currency_string,
gncCustomerGetCurrency (cust)));
xmlAddChild (ret, int_to_dom_tree (cust_taxtableoverride_string,
gncCustomerGetTaxTableOverride (cust)));
taxtable = gncCustomerGetTaxTable (cust);
if (taxtable)
xmlAddChild (ret, guid_to_dom_tree (cust_taxtable_string,
qof_instance_get_guid (QOF_INSTANCE (taxtable))));
/* xmlAddChild won't do anything with a NULL, so tests are superfluous. */
xmlAddChild (ret, qof_instance_slots_to_dom_tree (cust_slots_string,
QOF_INSTANCE (cust)));
return ret;
}
static xmlNodePtr
invoice_dom_tree_create (GncInvoice* invoice)
{
xmlNodePtr ret;
Timespec ts;
Transaction* txn;
GNCLot* lot;
Account* acc;
GncBillTerm* term;
GncOwner* billto;
gnc_numeric amt;
ret = xmlNewNode (NULL, BAD_CAST gnc_invoice_string);
xmlSetProp (ret, BAD_CAST "version", BAD_CAST invoice_version_string);
xmlAddChild (ret, guid_to_dom_tree (invoice_guid_string,
qof_instance_get_guid (QOF_INSTANCE (invoice))));
xmlAddChild (ret, text_to_dom_tree (invoice_id_string,
gncInvoiceGetID (invoice)));
xmlAddChild (ret, gnc_owner_to_dom_tree (invoice_owner_string,
gncInvoiceGetOwner (invoice)));
ts = gncInvoiceGetDateOpened (invoice);
xmlAddChild (ret, timespec_to_dom_tree (invoice_opened_string, &ts));
maybe_add_timespec (ret, invoice_posted_string,
gncInvoiceGetDatePosted (invoice));
term = gncInvoiceGetTerms (invoice);
if (term)
xmlAddChild (ret, guid_to_dom_tree (invoice_terms_string,
qof_instance_get_guid (QOF_INSTANCE (term))));
maybe_add_string (ret, invoice_billing_id_string,
gncInvoiceGetBillingID (invoice));
maybe_add_string (ret, invoice_notes_string, gncInvoiceGetNotes (invoice));
xmlAddChild (ret, int_to_dom_tree (invoice_active_string,
gncInvoiceGetActive (invoice)));
txn = gncInvoiceGetPostedTxn (invoice);
if (txn)
xmlAddChild (ret, guid_to_dom_tree (invoice_posttxn_string,
xaccTransGetGUID (txn)));
lot = gncInvoiceGetPostedLot (invoice);
if (lot)
xmlAddChild (ret, guid_to_dom_tree (invoice_postlot_string,
gnc_lot_get_guid (lot)));
acc = gncInvoiceGetPostedAcc (invoice);
if (acc)
xmlAddChild (ret, guid_to_dom_tree (invoice_postacc_string,
qof_instance_get_guid (QOF_INSTANCE (acc))));
xmlAddChild
(ret,
commodity_ref_to_dom_tree (invoice_currency_string,
gncInvoiceGetCurrency (invoice)));
billto = gncInvoiceGetBillTo (invoice);
if (billto && billto->owner.undefined != NULL)
xmlAddChild (ret, gnc_owner_to_dom_tree (invoice_billto_string, billto));
amt = gncInvoiceGetToChargeAmount (invoice);
if (! gnc_numeric_zero_p (amt))
xmlAddChild (ret, gnc_numeric_to_dom_tree (invoice_tochargeamt_string, &amt));
/* xmlAddChild won't do anything with a NULL, so tests are superfluous. */
xmlAddChild (ret, qof_instance_slots_to_dom_tree (invoice_slots_string,
QOF_INSTANCE (invoice)));
return ret;
}
static xmlNodePtr
split_to_dom_tree (const gchar* tag, Split* spl)
{
xmlNodePtr ret;
ret = xmlNewNode (NULL, BAD_CAST tag);
xmlAddChild (ret, guid_to_dom_tree ("split:id", xaccSplitGetGUID (spl)));
{
char* memo = g_strdup (xaccSplitGetMemo (spl));
if (memo && g_strcmp0 (memo, "") != 0)
{
xmlNewTextChild (ret, NULL, BAD_CAST "split:memo",
checked_char_cast (memo));
}
g_free (memo);
}
{
char* action = g_strdup (xaccSplitGetAction (spl));
if (action && g_strcmp0 (action, "") != 0)
{
xmlNewTextChild (ret, NULL, BAD_CAST "split:action",
checked_char_cast (action));
}
g_free (action);
}
{
char tmp[2];
tmp[0] = xaccSplitGetReconcile (spl);
tmp[1] = '\0';
xmlNewTextChild (ret, NULL, BAD_CAST "split:reconciled-state",
BAD_CAST tmp);
}
add_timespec (ret, "split:reconcile-date",
xaccSplitRetDateReconciledTS (spl), FALSE);
add_gnc_num (ret, "split:value", xaccSplitGetValue (spl));
add_gnc_num (ret, "split:quantity", xaccSplitGetAmount (spl));
{
Account* account = xaccSplitGetAccount (spl);
xmlAddChild (ret, guid_to_dom_tree ("split:account",
xaccAccountGetGUID (account)));
}
{
GNCLot* lot = xaccSplitGetLot (spl);
if (lot)
{
xmlAddChild (ret, guid_to_dom_tree ("split:lot",
gnc_lot_get_guid (lot)));
}
}
/* xmlAddChild won't do anything with a NULL, so tests are superfluous. */
xmlAddChild (ret, qof_instance_slots_to_dom_tree ("split:slots",
QOF_INSTANCE (spl)));
return ret;
}
static xmlNodePtr
entry_dom_tree_create (GncEntry* entry)
{
xmlNodePtr ret;
Timespec ts;
Account* acc;
GncTaxTable* taxtable;
GncOrder* order;
GncInvoice* invoice;
ret = xmlNewNode (NULL, BAD_CAST gnc_entry_string);
xmlSetProp (ret, BAD_CAST "version", BAD_CAST entry_version_string);
xmlAddChild (ret, guid_to_dom_tree (entry_guid_string,
qof_instance_get_guid (QOF_INSTANCE (entry))));
ts = gncEntryGetDate (entry);
xmlAddChild (ret, timespec_to_dom_tree (entry_date_string, &ts));
ts = gncEntryGetDateEntered (entry);
xmlAddChild (ret, timespec_to_dom_tree (entry_dateentered_string, &ts));
maybe_add_string (ret, entry_description_string,
gncEntryGetDescription (entry));
maybe_add_string (ret, entry_action_string, gncEntryGetAction (entry));
maybe_add_string (ret, entry_notes_string, gncEntryGetNotes (entry));
maybe_add_numeric (ret, entry_qty_string, gncEntryGetQuantity (entry));
/* cust invoice */
acc = gncEntryGetInvAccount (entry);
if (acc)
xmlAddChild (ret, guid_to_dom_tree (entry_invacct_string,
qof_instance_get_guid (QOF_INSTANCE (acc))));
maybe_add_numeric (ret, entry_iprice_string, gncEntryGetInvPrice (entry));
maybe_add_numeric (ret, entry_idiscount_string,
gncEntryGetInvDiscount (entry));
invoice = gncEntryGetInvoice (entry);
if (invoice)
{
xmlAddChild (ret, guid_to_dom_tree (entry_invoice_string,
qof_instance_get_guid (QOF_INSTANCE (invoice))));
xmlAddChild (ret, text_to_dom_tree (entry_idisctype_string,
gncAmountTypeToString (
gncEntryGetInvDiscountType (entry))));
xmlAddChild (ret, text_to_dom_tree (entry_idischow_string,
gncEntryDiscountHowToString (
gncEntryGetInvDiscountHow (entry))));
xmlAddChild (ret, int_to_dom_tree (entry_itaxable_string,
gncEntryGetInvTaxable (entry)));
xmlAddChild (ret, int_to_dom_tree (entry_itaxincluded_string,
gncEntryGetInvTaxIncluded (entry)));
}
taxtable = gncEntryGetInvTaxTable (entry);
if (taxtable)
xmlAddChild (ret, guid_to_dom_tree (entry_itaxtable_string,
qof_instance_get_guid (QOF_INSTANCE (taxtable))));
/* vendor bills */
acc = gncEntryGetBillAccount (entry);
if (acc)
xmlAddChild (ret, guid_to_dom_tree (entry_billacct_string,
qof_instance_get_guid (QOF_INSTANCE (acc))));
maybe_add_numeric (ret, entry_bprice_string, gncEntryGetBillPrice (entry));
invoice = gncEntryGetBill (entry);
if (invoice)
{
GncOwner* owner;
xmlAddChild (ret, guid_to_dom_tree (entry_bill_string,
qof_instance_get_guid (QOF_INSTANCE (invoice))));
xmlAddChild (ret, int_to_dom_tree (entry_billable_string,
gncEntryGetBillable (entry)));
owner = gncEntryGetBillTo (entry);
if (owner && owner->owner.undefined != NULL)
xmlAddChild (ret, gnc_owner_to_dom_tree (entry_billto_string, owner));
xmlAddChild (ret, int_to_dom_tree (entry_btaxable_string,
gncEntryGetBillTaxable (entry)));
xmlAddChild (ret, int_to_dom_tree (entry_btaxincluded_string,
gncEntryGetBillTaxIncluded (entry)));
maybe_add_string (ret, entry_billpayment_string,
gncEntryPaymentTypeToString (gncEntryGetBillPayment (entry)));
}
taxtable = gncEntryGetBillTaxTable (entry);
if (taxtable)
xmlAddChild (ret, guid_to_dom_tree (entry_btaxtable_string,
qof_instance_get_guid (QOF_INSTANCE (taxtable))));
/* Other stuff */
order = gncEntryGetOrder (entry);
if (order)
xmlAddChild (ret, guid_to_dom_tree (entry_order_string,
qof_instance_get_guid (QOF_INSTANCE (order))));
/* xmlAddChild won't do anything with a NULL, so tests are superfluous. */
xmlAddChild (ret, qof_instance_slots_to_dom_tree (entry_slots_string,
QOF_INSTANCE (entry)));
return ret;
}
