static gboolean
taxtable_guid_handler (xmlNodePtr node, gpointer taxtable_pdata)
{
struct taxtable_pdata *pdata = taxtable_pdata;
GncGUID *guid;
GncTaxTable *table;
guid = dom_tree_to_guid(node);
g_return_val_if_fail (guid, FALSE);
table = gncTaxTableLookup (pdata->book, guid);
if (table)
{
gncTaxTableDestroy (pdata->table);
pdata->table = table;
gncTaxTableBeginEdit (table);
}
else
{
gncTaxTableSetGUID(pdata->table, guid);
}
g_free(guid);
return TRUE;
}
static gboolean
invoice_guid_handler (xmlNodePtr node, gpointer invoice_pdata)
{
struct invoice_pdata* pdata = static_cast<decltype (pdata)> (invoice_pdata);
GncGUID* guid;
GncInvoice* invoice;
guid = dom_tree_to_guid (node);
g_return_val_if_fail (guid, FALSE);
invoice = gncInvoiceLookup (pdata->book, guid);
if (invoice)
{
gncInvoiceDestroy (pdata->invoice);
pdata->invoice = invoice;
gncInvoiceBeginEdit (invoice);
}
else
{
gncInvoiceSetGUID (pdata->invoice, guid);
}
g_free (guid);
return TRUE;
}
static gboolean
employee_guid_handler (xmlNodePtr node, gpointer employee_pdata)
{
struct employee_pdata *pdata = employee_pdata;
GncGUID *guid;
GncEmployee *employee;
guid = dom_tree_to_guid(node);
g_return_val_if_fail(guid, FALSE);
/* See if we've already created this one */
employee = gncEmployeeLookup (pdata->book, guid);
if (employee)
{
gncEmployeeDestroy (pdata->employee);
pdata->employee = employee;
gncEmployeeBeginEdit (employee);
}
else
{
gncEmployeeSetGUID(pdata->employee, guid);
}
g_free(guid);
return TRUE;
}
static gboolean
customer_guid_handler (xmlNodePtr node, gpointer cust_pdata)
{
struct customer_pdata *pdata = cust_pdata;
GncGUID *guid;
GncCustomer *cust;
guid = dom_tree_to_guid(node);
g_return_val_if_fail(guid, FALSE);
cust = gncCustomerLookup (pdata->book, guid);
if (cust)
{
gncCustomerDestroy (pdata->customer);
pdata->customer = cust;
gncCustomerBeginEdit (cust);
}
else
{
gncCustomerSetGUID(pdata->customer, guid);
}
g_free(guid);
return TRUE;
}
static gboolean
billterm_guid_handler (xmlNodePtr node, gpointer billterm_pdata)
{
struct billterm_pdata *pdata = billterm_pdata;
GncGUID *guid;
GncBillTerm *term;
guid = dom_tree_to_guid(node);
g_return_val_if_fail (guid, FALSE);
term = gncBillTermLookup (pdata->book, guid);
if (term)
{
gncBillTermDestroy (pdata->term);
pdata->term = term;
gncBillTermBeginEdit (term);
}
else
{
gncBillTermSetGUID(pdata->term, guid);
}
g_free(guid);
return TRUE;
}
static gboolean
entry_guid_handler (xmlNodePtr node, gpointer entry_pdata)
{
struct entry_pdata *pdata = entry_pdata;
GncGUID *guid;
GncEntry *entry;
guid = dom_tree_to_guid(node);
g_return_val_if_fail (guid, FALSE);
entry = gncEntryLookup (pdata->book, guid);
if (entry)
{
gncEntryDestroy (pdata->entry);
pdata->entry = entry;
gncEntryBeginEdit (entry);
}
else
{
gncEntrySetGUID(pdata->entry, guid);
}
g_free(guid);
return TRUE;
}
static gboolean
job_guid_handler (xmlNodePtr node, gpointer job_pdata)
{
struct job_pdata *pdata = job_pdata;
GncGUID *guid;
GncJob *job;
guid = dom_tree_to_guid(node);
g_return_val_if_fail(guid, FALSE);
job = gncJobLookup (pdata->book, guid);
if (job)
{
gncJobDestroy (pdata->job);
pdata->job = job;
gncJobBeginEdit (job);
}
else
{
gncJobSetGUID(pdata->job, guid);
}
g_free(guid);
return TRUE;
}
static gboolean
spl_account_handler(xmlNodePtr node, gpointer data)
{
struct split_pdata *pdata = data;
GncGUID *id = dom_tree_to_guid(node);
Account *account;
g_return_val_if_fail(id, FALSE);
account = xaccAccountLookup (id, pdata->book);
if (!account && gnc_transaction_xml_v2_testing &&
!guid_equal (id, guid_null ()))
{
account = xaccMallocAccount (pdata->book);
xaccAccountSetGUID (account, id);
xaccAccountSetCommoditySCU (account,
xaccSplitGetAmount (pdata->split).denom);
}
xaccAccountInsertSplit (account, pdata->split);
g_free(id);
return TRUE;
}
static gboolean
order_guid_handler (xmlNodePtr node, gpointer order_pdata)
{
struct order_pdata *pdata = order_pdata;
GncGUID *guid;
GncOrder *order;
guid = dom_tree_to_guid(node);
g_return_val_if_fail (guid, FALSE);
order = gncOrderLookup (pdata->book, guid);
if (order)
{
gncOrderDestroy (pdata->order);
pdata->order = order;
gncOrderBeginEdit (order);
}
else
{
gncOrderSetGUID(pdata->order, guid);
}
g_free(guid);
return TRUE;
}
static gboolean
vendor_guid_handler (xmlNodePtr node, gpointer vendor_pdata)
{
struct vendor_pdata* pdata = static_cast<decltype (pdata)> (vendor_pdata);
GncGUID* guid;
GncVendor* vendor;
guid = dom_tree_to_guid (node);
g_return_val_if_fail (guid, FALSE);
vendor = gncVendorLookup (pdata->book, guid);
if (vendor)
{
gncVendorDestroy (pdata->vendor);
pdata->vendor = vendor;
gncVendorBeginEdit (vendor);
}
else
{
gncVendorSetGUID (pdata->vendor, guid);
}
g_free (guid);
return TRUE;
}
static gboolean
set_parent_child (xmlNodePtr node, struct taxtable_pdata *pdata,
void (*func)(GncTaxTable *, GncTaxTable *))
{
GncGUID *guid;
GncTaxTable *table;
guid = dom_tree_to_guid(node);
g_return_val_if_fail (guid, FALSE);
table = gncTaxTableLookup (pdata->book, guid);
/* Ignore pointers to self */
if (table == pdata->table)
{
PINFO ("found a self-referential parent/child; ignoring.\n");
return TRUE;
}
if (!table)
{
table = gncTaxTableCreate (pdata->book);
gncTaxTableBeginEdit (table);
gncTaxTableSetGUID (table, guid);
gncTaxTableCommitEdit (table);
}
g_free (guid);
g_return_val_if_fail (table, FALSE);
func (pdata->table, table);
return TRUE;
}
static void
test_dom_tree_to_guid(void)
{
int i;
for (i = 0; i < 20; i++)
{
GncGUID *test_guid1;
GncGUID *test_guid2;
xmlNodePtr test_node;
test_guid1 = get_random_guid();
if (!(test_node = guid_to_dom_tree("test-guid", test_guid1)))
{
failure_args("guid_to_dom_tree", __FILE__, __LINE__,
"conversion to dom tree failed");
}
test_guid2 = dom_tree_to_guid(test_node);
do_test(guid_equal(test_guid1, test_guid2),
"dom_tree_to_guid" );
xmlFreeNode(test_node);
g_free(test_guid1);
g_free(test_guid2);
}
}
static gboolean
price_parse_xml_sub_node(GNCPrice *p, xmlNodePtr sub_node, QofBook *book)
{
if (!p || !sub_node) return FALSE;
gnc_price_begin_edit (p);
if (g_strcmp0("price:id", (char*)sub_node->name) == 0)
{
GncGUID *c = dom_tree_to_guid(sub_node);
if (!c) return FALSE;
gnc_price_set_guid(p, c);
g_free(c);
}
else if (g_strcmp0("price:commodity", (char*)sub_node->name) == 0)
{
gnc_commodity *c = dom_tree_to_commodity_ref(sub_node, book);
if (!c) return FALSE;
gnc_price_set_commodity(p, c);
}
else if (g_strcmp0("price:currency", (char*)sub_node->name) == 0)
{
gnc_commodity *c = dom_tree_to_commodity_ref(sub_node, book);
if (!c) return FALSE;
gnc_price_set_currency(p, c);
}
else if (g_strcmp0("price:time", (char*)sub_node->name) == 0)
{
Timespec t = dom_tree_to_timespec(sub_node);
if (!dom_tree_valid_timespec(&t, sub_node->name)) return FALSE;
gnc_price_set_time(p, t);
}
else if (g_strcmp0("price:source", (char*)sub_node->name) == 0)
{
char *text = dom_tree_to_text(sub_node);
if (!text) return FALSE;
gnc_price_set_source(p, text);
g_free(text);
}
else if (g_strcmp0("price:type", (char*)sub_node->name) == 0)
{
char *text = dom_tree_to_text(sub_node);
if (!text) return FALSE;
gnc_price_set_typestr(p, text);
g_free(text);
}
else if (g_strcmp0("price:value", (char*)sub_node->name) == 0)
{
gnc_numeric *value = dom_tree_to_gnc_numeric(sub_node);
if (!value) return FALSE;
gnc_price_set_value(p, *value);
g_free(value);
}
gnc_price_commit_edit (p);
return TRUE;
}
static gboolean
budget_id_handler (xmlNodePtr node, gpointer bgt)
{
GncGUID* guid;
guid = dom_tree_to_guid (node);
g_return_val_if_fail (guid, FALSE);
qof_instance_set_guid (QOF_INSTANCE (bgt), guid);
g_free (guid);
return TRUE;
}
static gboolean
book_id_handler(xmlNodePtr node, gpointer book_pdata)
{
QofBook *book = book_pdata;
GncGUID *guid;
guid = dom_tree_to_guid(node);
qof_instance_set_guid(QOF_INSTANCE(book), guid);
g_free(guid);
return TRUE;
}
static gboolean
spl_id_handler(xmlNodePtr node, gpointer data)
{
struct split_pdata *pdata = data;
GncGUID *tmp = dom_tree_to_guid(node);
g_return_val_if_fail(tmp, FALSE);
xaccSplitSetGUID(pdata->split, tmp);
g_free(tmp);
return TRUE;
}
static
gboolean
sx_id_handler( xmlNodePtr node, gpointer sx_pdata )
{
struct sx_pdata *pdata = sx_pdata;
SchedXaction *sx = pdata->sx;
GncGUID *tmp = dom_tree_to_guid( node );
g_return_val_if_fail( tmp, FALSE );
xaccSchedXactionSetGUID(sx, tmp);
g_free( tmp );
return TRUE;
}
static gboolean
trn_id_handler(xmlNodePtr node, gpointer trans_pdata)
{
struct trans_pdata *pdata = trans_pdata;
Transaction *trn = pdata->trans;
GncGUID *tmp = dom_tree_to_guid(node);
g_return_val_if_fail(tmp, FALSE);
xaccTransSetGUID((Transaction*)trn, tmp);
g_free(tmp);
return TRUE;
}
static gboolean
lot_id_handler (xmlNodePtr node, gpointer p)
{
struct lot_pdata *pdata = static_cast<decltype(pdata)>(p);
GncGUID *guid;
ENTER("(lot=%p)", pdata->lot);
guid = dom_tree_to_guid(node);
gnc_lot_set_guid(pdata->lot, *guid);
g_free(guid);
LEAVE("");
return TRUE;
}
static gboolean
invoice_posttxn_handler (xmlNodePtr node, gpointer invoice_pdata)
{
struct invoice_pdata* pdata = static_cast<decltype (pdata)> (invoice_pdata);
GncGUID* guid;
Transaction* txn;
guid = dom_tree_to_guid (node);
g_return_val_if_fail (guid, FALSE);
txn = xaccTransLookup (guid, pdata->book);
g_free (guid);
g_return_val_if_fail (txn, FALSE);
gncInvoiceSetPostedTxn (pdata->invoice, txn);
return TRUE;
}
static gboolean
customer_terms_handler (xmlNodePtr node, gpointer cust_pdata)
{
struct customer_pdata *pdata = cust_pdata;
GncGUID *guid;
GncBillTerm *term;
guid = dom_tree_to_guid(node);
g_return_val_if_fail (guid, FALSE);
term = gnc_billterm_xml_find_or_create(pdata->book, guid);
g_assert(term);
g_free (guid);
gncCustomerSetTerms (pdata->customer, term);
return TRUE;
}
static gboolean
invoice_terms_handler (xmlNodePtr node, gpointer invoice_pdata)
{
struct invoice_pdata* pdata = static_cast<decltype (pdata)> (invoice_pdata);
GncGUID* guid;
GncBillTerm* term;
guid = dom_tree_to_guid (node);
g_return_val_if_fail (guid, FALSE);
term = gnc_billterm_xml_find_or_create (pdata->book, guid);
g_assert (term);
g_free (guid);
gncInvoiceSetTerms (pdata->invoice, term);
return TRUE;
}
static gboolean
invoice_postlot_handler (xmlNodePtr node, gpointer invoice_pdata)
{
struct invoice_pdata* pdata = static_cast<decltype (pdata)> (invoice_pdata);
GncGUID* guid;
GNCLot* lot;
guid = dom_tree_to_guid (node);
g_return_val_if_fail (guid, FALSE);
lot = gnc_lot_lookup (guid, pdata->book);
g_free (guid);
g_return_val_if_fail (lot, FALSE);
gncInvoiceSetPostedLot (pdata->invoice, lot);
return TRUE;
}
static gboolean
ttentry_acct_handler (xmlNodePtr node, gpointer ttentry_pdata)
{
struct ttentry_pdata *pdata = ttentry_pdata;
GncGUID *guid;
Account * acc;
guid = dom_tree_to_guid (node);
g_return_val_if_fail (guid, FALSE);
acc = xaccAccountLookup (guid, pdata->book);
g_free (guid);
g_return_val_if_fail (acc, FALSE);
gncTaxTableEntrySetAccount (pdata->ttentry, acc);
return TRUE;
}
static gboolean
invoice_postacc_handler (xmlNodePtr node, gpointer invoice_pdata)
{
struct invoice_pdata* pdata = static_cast<decltype (pdata)> (invoice_pdata);
GncGUID* guid;
Account* acc;
guid = dom_tree_to_guid (node);
g_return_val_if_fail (guid, FALSE);
acc = xaccAccountLookup (guid, pdata->book);
g_free (guid);
g_return_val_if_fail (acc, FALSE);
gncInvoiceSetPostedAcc (pdata->invoice, acc);
return TRUE;
}
static xmlNodePtr
find_appropriate_node (xmlNodePtr node, Split* spl)
{
xmlNodePtr mark;
for (mark = node->xmlChildrenNode; mark; mark = mark->next)
{
gboolean account_guid_good = FALSE;
gboolean amount_good = FALSE;
xmlNodePtr mark2;
for (mark2 = mark->xmlChildrenNode; mark2; mark2 = mark2->next)
{
if (g_strcmp0 ((char*)mark2->name, "split:value") == 0)
{
gnc_numeric* num = dom_tree_to_gnc_numeric (mark2);
if (gnc_numeric_equal (*num, xaccSplitGetValue (spl)))
{
amount_good = TRUE;
}
g_free (num);
}
else if (g_strcmp0 ((char*)mark2->name, "split:account") == 0)
{
GncGUID* accid = dom_tree_to_guid (mark2);
Account* account = xaccSplitGetAccount (spl);
if (guid_equal (accid, xaccAccountGetGUID (account)))
{
account_guid_good = TRUE;
}
g_free (accid);
}
if (account_guid_good && amount_good)
{
return mark;
}
}
}
return NULL;
}
static gboolean
employee_ccard_handler (xmlNodePtr node, gpointer employee_pdata)
{
struct employee_pdata *pdata = employee_pdata;
GncGUID *guid;
Account *ccard_acc;
guid = dom_tree_to_guid(node);
g_return_val_if_fail(guid, FALSE);
ccard_acc = xaccAccountLookup (guid, pdata->book);
g_free(guid);
g_return_val_if_fail (ccard_acc, FALSE);
gncEmployeeSetCCard (pdata->employee, ccard_acc);
return TRUE;
}
static inline gboolean
set_account(xmlNodePtr node, struct entry_pdata *pdata,
void (*func)(GncEntry *entry, Account *acc))
{
GncGUID *guid;
Account * acc;
guid = dom_tree_to_guid (node);
g_return_val_if_fail (guid, FALSE);
acc = xaccAccountLookup (guid, pdata->book);
g_free (guid);
g_return_val_if_fail (acc, FALSE);
if (func)
func (pdata->entry, acc);
else
pdata->acc = acc;
return TRUE;
}
static
gboolean
sx_templ_acct_handler( xmlNodePtr node, gpointer sx_pdata)
{
struct sx_pdata *pdata = sx_pdata;
SchedXaction *sx = pdata->sx;
GncGUID *templ_acct_guid = dom_tree_to_guid(node);
Account *account;
if (!templ_acct_guid)
{
return FALSE;
}
account = xaccAccountLookup(templ_acct_guid, pdata->book);
sx_set_template_account(sx, account);
g_free(templ_acct_guid);
return TRUE;
}
gboolean
equals_node_val_vs_guid(xmlNodePtr node, const GncGUID *id)
{
GncGUID *cmpid;
g_return_val_if_fail(node, FALSE);
g_return_val_if_fail(id, FALSE);
cmpid = dom_tree_to_guid(node);
g_return_val_if_fail(cmpid, FALSE);
if (guid_compare(cmpid, id) == 0)
{
g_free(cmpid);
return TRUE;
}
else
{
g_free(cmpid);
return FALSE;
}
}
