static GncEntry*
dom_tree_to_entry (xmlNodePtr node, QofBook *book)
{
struct entry_pdata entry_pdata;
gboolean successful;
entry_pdata.entry = gncEntryCreate(book);
entry_pdata.book = book;
entry_pdata.acc = NULL;
gncEntryBeginEdit (entry_pdata.entry);
successful = dom_tree_generic_parse (node, entry_handlers_v2,
&entry_pdata);
if (entry_pdata.acc != NULL)
{
if (gncEntryGetBill (entry_pdata.entry))
gncEntrySetBillAccount (entry_pdata.entry, entry_pdata.acc);
else
gncEntrySetInvAccount (entry_pdata.entry, entry_pdata.acc);
}
if (successful)
gncEntryCommitEdit (entry_pdata.entry);
else
{
PERR ("failed to parse entry tree");
gncEntryDestroy (entry_pdata.entry);
entry_pdata.entry = NULL;
}
return entry_pdata.entry;
}
Transaction *
dom_tree_to_transaction( xmlNodePtr node, QofBook *book )
{
Transaction *trn;
gboolean successful;
struct trans_pdata pdata;
g_return_val_if_fail(node, NULL);
g_return_val_if_fail(book, NULL);
trn = xaccMallocTransaction(book);
g_return_val_if_fail(trn, NULL);
xaccTransBeginEdit(trn);
pdata.trans = trn;
pdata.book = book;
successful = dom_tree_generic_parse(node, trn_dom_handlers, &pdata);
xaccTransCommitEdit(trn);
if ( !successful )
{
xmlElemDump(stdout, NULL, node);
xaccTransBeginEdit(trn);
xaccTransDestroy(trn);
xaccTransCommitEdit(trn);
trn = NULL;
}
return trn;
}
static GncBillTerm*
dom_tree_to_billterm (xmlNodePtr node, QofBook *book)
{
struct billterm_pdata billterm_pdata;
gboolean successful;
billterm_pdata.term = gncBillTermCreate (book);
billterm_pdata.book = book;
gncBillTermBeginEdit (billterm_pdata.term);
successful = dom_tree_generic_parse (node, billterm_handlers_v2,
&billterm_pdata);
if (successful)
{
gncBillTermCommitEdit (billterm_pdata.term);
}
else
{
PERR ("failed to parse billing term tree");
gncBillTermDestroy (billterm_pdata.term);
billterm_pdata.term = NULL;
}
return billterm_pdata.term;
}
GNCLot*
dom_tree_to_lot (xmlNodePtr node, QofBook *book)
{
struct lot_pdata pdata;
GNCLot *lot;
gboolean successful;
lot = gnc_lot_new(book);
ENTER("(lot=%p)", lot);
pdata.lot = lot;
pdata.book = book;
successful = dom_tree_generic_parse (node, lot_handlers_v2,
&pdata);
if (!successful)
{
PERR ("failed to parse lot");
gnc_lot_destroy (lot);
lot = NULL;
}
LEAVE("");
return lot;
}
static Split*
dom_tree_to_split(xmlNodePtr node, QofBook *book)
{
struct split_pdata pdata;
Split *ret;
g_return_val_if_fail (book, NULL);
ret = xaccMallocSplit(book);
g_return_val_if_fail(ret, NULL);
pdata.split = ret;
pdata.book = book;
/* this isn't going to work in a testing setup */
if (dom_tree_generic_parse(node, spl_dom_handlers, &pdata))
{
return ret;
}
else
{
xaccSplitDestroy(ret);
return NULL;
}
}
static
gboolean
sx_defer_inst_handler( xmlNodePtr node, gpointer sx_pdata )
{
struct sx_pdata *pdata = sx_pdata;
SchedXaction *sx = pdata->sx;
SXTmpStateData *tsd;
g_return_val_if_fail( node, FALSE );
tsd = g_new0( SXTmpStateData, 1 );
g_assert( sx_defer_dom_handlers != NULL );
if ( !dom_tree_generic_parse( node,
sx_defer_dom_handlers,
tsd ) )
{
xmlElemDump(stdout, NULL, node);
g_free( tsd );
tsd = NULL;
return FALSE;
}
/* We assume they were serialized in sorted order, here. */
sx->deferredList = g_list_append( sx->deferredList, tsd );
return TRUE;
}
static gboolean
dom_tree_to_prox_data (xmlNodePtr node, struct billterm_pdata *pdata)
{
gboolean successful;
successful = dom_tree_generic_parse (node, prox_data_handlers_v2, pdata);
if (!successful)
PERR ("failed to parse billing term prox data");
return successful;
}
GncBudget*
dom_tree_to_budget (xmlNodePtr node, QofBook* book)
{
GncBudget* bgt;
bgt = gnc_budget_new (book);
if (!dom_tree_generic_parse (node, budget_handlers, bgt))
{
PERR ("failed to parse budget tree");
gnc_budget_destroy (bgt);
bgt = NULL;
}
return bgt;
}
QofBook*
dom_tree_to_book (xmlNodePtr node, QofBook *book)
{
gboolean successful;
successful = dom_tree_generic_parse (node, book_handlers_v2,
book);
if (!successful)
{
PERR ("failed to parse book");
book = NULL;
}
return book;
}
gboolean
gnc_dom_tree_to_address (xmlNodePtr node, GncAddress *address)
{
struct address_pdata addr_pdata;
gboolean successful;
addr_pdata.address = address;
successful = dom_tree_generic_parse (node, address_handlers_v2,
&addr_pdata);
if (!successful)
{
PERR ("failed to parse address tree");
}
return successful;
}
gboolean
gnc_dom_tree_to_owner (xmlNodePtr node, GncOwner* owner, QofBook* book)
{
struct owner_pdata owner_pdata;
gboolean successful;
owner_pdata.owner = owner;
owner_pdata.book = book;
successful = dom_tree_generic_parse (node, owner_handlers_v2,
&owner_pdata);
if (!successful)
{
PERR ("failed to parse owner tree");
}
return successful;
}
static gboolean
sx_recurrence_handler(xmlNodePtr node, gpointer _pdata)
{
struct sx_pdata *parsing_data = _pdata;
GList *schedule = NULL;
gchar* debug_str;
g_return_val_if_fail(node, FALSE);
if (!dom_tree_generic_parse(node, sx_recurrence_list_handlers, &schedule))
return FALSE;
// g_return_val_if_fail(schedule, FALSE);
debug_str = recurrenceListToString(schedule);
g_debug("setting freshly-parsed schedule: [%s]", debug_str);
g_free(debug_str);
gnc_sx_set_schedule(parsing_data->sx, schedule);
parsing_data->saw_recurrence = TRUE;
return TRUE;
}
static GncTaxTableEntry*
dom_tree_to_ttentry (xmlNodePtr node, QofBook *book)
{
struct ttentry_pdata ttentry_pdata;
gboolean successful;
ttentry_pdata.ttentry = gncTaxTableEntryCreate ();
ttentry_pdata.book = book;
successful = dom_tree_generic_parse (node, ttentry_handlers_v2,
&ttentry_pdata);
if (!successful)
{
PERR ("failed to parse tax table entry tree");
gncTaxTableEntryDestroy (ttentry_pdata.ttentry);
ttentry_pdata.ttentry = NULL;
}
return ttentry_pdata.ttentry;
}
static GncEmployee*
dom_tree_to_employee (xmlNodePtr node, QofBook *book)
{
struct employee_pdata employee_pdata;
gboolean successful;
employee_pdata.employee = gncEmployeeCreate(book);
employee_pdata.book = book;
gncEmployeeBeginEdit (employee_pdata.employee);
successful = dom_tree_generic_parse (node, employee_handlers_v2,
&employee_pdata);
if (successful)
gncEmployeeCommitEdit (employee_pdata.employee);
else
{
PERR ("failed to parse employee tree");
gncEmployeeDestroy (employee_pdata.employee);
employee_pdata.employee = NULL;
}
return employee_pdata.employee;
}
static GncOrder*
dom_tree_to_order (xmlNodePtr node, QofBook *book)
{
struct order_pdata order_pdata;
gboolean successful;
order_pdata.order = gncOrderCreate(book);
order_pdata.book = book;
gncOrderBeginEdit (order_pdata.order);
successful = dom_tree_generic_parse (node, order_handlers_v2,
&order_pdata);
if (successful)
gncOrderCommitEdit (order_pdata.order);
else
{
PERR ("failed to parse order tree");
gncOrderDestroy (order_pdata.order);
order_pdata.order = NULL;
}
return order_pdata.order;
}
static GncJob*
dom_tree_to_job (xmlNodePtr node, QofBook *book)
{
struct job_pdata job_pdata;
gboolean successful;
job_pdata.job = gncJobCreate(book);
job_pdata.book = book;
gncJobBeginEdit (job_pdata.job);
successful = dom_tree_generic_parse (node, job_handlers_v2,
&job_pdata);
if (successful)
gncJobCommitEdit (job_pdata.job);
else
{
PERR ("failed to parse job tree");
gncJobDestroy (job_pdata.job);
job_pdata.job = NULL;
}
return job_pdata.job;
}
static GncVendor*
dom_tree_to_vendor (xmlNodePtr node, QofBook* book)
{
struct vendor_pdata vendor_pdata;
gboolean successful;
vendor_pdata.vendor = gncVendorCreate (book);
vendor_pdata.book = book;
gncVendorBeginEdit (vendor_pdata.vendor);
successful = dom_tree_generic_parse (node, vendor_handlers_v2,
&vendor_pdata);
if (successful)
gncVendorCommitEdit (vendor_pdata.vendor);
else
{
PERR ("failed to parse vendor tree");
gncVendorDestroy (vendor_pdata.vendor);
vendor_pdata.vendor = NULL;
}
return vendor_pdata.vendor;
}
static GncTaxTable*
dom_tree_to_taxtable (xmlNodePtr node, QofBook *book)
{
struct taxtable_pdata taxtable_pdata;
gboolean successful;
taxtable_pdata.table = gncTaxTableCreate (book);
taxtable_pdata.book = book;
gncTaxTableBeginEdit (taxtable_pdata.table);
successful = dom_tree_generic_parse (node, taxtable_handlers_v2,
&taxtable_pdata);
if (successful)
gncTaxTableCommitEdit (taxtable_pdata.table);
else
{
PERR ("failed to parse tax table tree");
gncTaxTableDestroy (taxtable_pdata.table);
taxtable_pdata.table = NULL;
}
return taxtable_pdata.table;
}
static GncInvoice*
dom_tree_to_invoice (xmlNodePtr node, QofBook* book)
{
struct invoice_pdata invoice_pdata;
gboolean successful;
invoice_pdata.invoice = gncInvoiceCreate (book);
invoice_pdata.book = book;
gncInvoiceBeginEdit (invoice_pdata.invoice);
successful = dom_tree_generic_parse (node, invoice_handlers_v2,
&invoice_pdata);
if (successful)
gncInvoiceCommitEdit (invoice_pdata.invoice);
else
{
PERR ("failed to parse invoice tree");
gncInvoiceDestroy (invoice_pdata.invoice);
invoice_pdata.invoice = NULL;
}
return invoice_pdata.invoice;
}
static GncCustomer*
dom_tree_to_customer (xmlNodePtr node, QofBook *book)
{
struct customer_pdata cust_pdata;
gboolean successful;
cust_pdata.customer = gncCustomerCreate(book);
cust_pdata.book = book;
gncCustomerBeginEdit (cust_pdata.customer);
successful = dom_tree_generic_parse (node, customer_handlers_v2,
&cust_pdata);
if (successful)
gncCustomerCommitEdit (cust_pdata.customer);
else
{
PERR ("failed to parse customer tree");
gncCustomerDestroy (cust_pdata.customer);
cust_pdata.customer = NULL;
}
return cust_pdata.customer;
}
static gboolean
gnc_schedXaction_end_handler(gpointer data_for_children,
GSList* data_from_children, GSList* sibling_data,
gpointer parent_data, gpointer global_data,
gpointer *result, const gchar *tag)
{
SchedXaction *sx;
gboolean successful = FALSE;
xmlNodePtr tree = (xmlNodePtr)data_for_children;
gxpf_data *gdata = (gxpf_data*)global_data;
struct sx_pdata sx_pdata;
if ( parent_data )
{
return TRUE;
}
if ( !tag )
{
return TRUE;
}
g_return_val_if_fail( tree, FALSE );
sx = xaccSchedXactionMalloc( gdata->bookdata );
memset(&sx_pdata, 0, sizeof(sx_pdata));
sx_pdata.sx = sx;
sx_pdata.book = gdata->bookdata;
g_assert( sx_dom_handlers != NULL );
successful = dom_tree_generic_parse( tree, sx_dom_handlers, &sx_pdata );
if (!successful)
{
g_critical("failed to parse scheduled xaction");
xmlElemDump( stdout, NULL, tree );
gnc_sx_begin_edit( sx );
xaccSchedXactionDestroy( sx );
goto done;
}
if (tree->properties)
{
gchar *sx_name = xaccSchedXactionGetName(sx);
xmlAttr *attr;
for (attr = tree->properties; attr != NULL; attr = attr->next)
{
xmlChar *attr_value = attr->children->content;
g_debug("sx attribute name[%s] value[%s]", attr->name, attr_value);
if (strcmp((const char *)attr->name, "version") != 0)
{
g_warning("unknown sx attribute [%s]", attr->name);
continue;
}
// if version == 1.0.0: ensure freqspec, no recurrence
// if version == 2.0.0: ensure recurrence, no freqspec.
if (strcmp((const char *)attr_value,
schedxaction_version_string) == 0)
{
if (!sx_pdata.saw_freqspec)
g_critical("did not see freqspec in version 1 sx [%s]", sx_name);
if (sx_pdata.saw_recurrence)
g_warning("saw recurrence in supposedly version 1 sx [%s]", sx_name);
}
if (strcmp((const char *)attr_value,
schedxaction_version2_string) == 0)
{
if (sx_pdata.saw_freqspec)
g_warning("saw freqspec in version 2 sx [%s]", sx_name);
if (!sx_pdata.saw_recurrence)
g_critical("did not find recurrence in version 2 sx [%s]", sx_name);
}
}
}
// generic_callback -> book_callback: insert the SX in the book
gdata->cb( tag, gdata->parsedata, sx );
/* FIXME: this should be removed somewhere near 1.8 release time. */
if ( sx->template_acct == NULL )
{
Account *ra = NULL;
const char *id = NULL;
Account *acct = NULL;
sixtp_gdv2 *sixdata = gdata->parsedata;
QofBook *book;
book = sixdata->book;
/* We're dealing with a pre-200107<near-end-of-month> rgmerk
change re: storing template accounts. */
/* Fix: get account with name of our GncGUID from the template
accounts. Make that our template_acct pointer. */
/* THREAD-UNSAFE */
id = guid_to_string( xaccSchedXactionGetGUID( sx ) );
ra = gnc_book_get_template_root(book);
if ( ra == NULL )
{
g_warning( "Error getting template root account from being-parsed Book." );
xmlFreeNode( tree );
return FALSE;
}
acct = gnc_account_lookup_by_name( ra, id );
if ( acct == NULL )
{
g_warning("no template account with name [%s]", id);
xmlFreeNode( tree );
return FALSE;
}
g_debug("template account name [%s] for SX with GncGUID [%s]",
xaccAccountGetName( acct ), id );
/* FIXME: free existing template account.
* HUH????? We only execute this if there isn't
* currently an existing template account, don't we?
* <rgmerk>
*/
sx->template_acct = acct;
}
done:
xmlFreeNode( tree );
return successful;
}
static gboolean
gnc_template_transaction_end_handler(gpointer data_for_children,
GSList* data_from_children,
GSList* sibling_data,
gpointer parent_data,
gpointer global_data,
gpointer *result,
const gchar *tag)
{
gboolean successful = FALSE;
xmlNodePtr tree = data_for_children;
gxpf_data *gdata = global_data;
QofBook *book = gdata->bookdata;
GList *n;
gnc_template_xaction_data txd;
txd.book = book;
txd.accts = NULL;
txd.transactions = NULL;
/* the DOM tree will have an account tree [the template
accounts] and a list of transactions [which will be members
of the template account].
we want to parse through the dom trees for each, placing
the null-parent account in the book's template-group slot,
the others under it, and the transactions as normal. */
if ( parent_data )
{
return TRUE;
}
if ( !tag )
{
return TRUE;
}
g_return_val_if_fail( tree, FALSE );
successful = dom_tree_generic_parse( tree, tt_dom_handlers, &txd );
if ( successful )
{
gdata->cb( tag, gdata->parsedata, &txd );
}
else
{
g_warning("failed to parse template transaction");
xmlElemDump( stdout, NULL, tree );
}
/* cleanup */
for ( n = txd.accts; n; n = n->next )
{
n->data = NULL;
}
for ( n = txd.transactions; n; n = n->next )
{
n->data = NULL;
}
g_list_free( txd.accts );
g_list_free( txd.transactions );
xmlFreeNode( tree );
return successful;
}
