gboolean
qof_commit_edit_part2(QofInstance *inst,
void (*on_error)(QofInstance *, QofBackendError),
void (*on_done)(QofInstance *),
void (*on_free)(QofInstance *))
{
QofInstancePrivate *priv;
QofBackend * be;
gboolean dirty;
priv = GET_PRIVATE(inst);
dirty = priv->dirty;
/* See if there's a backend. If there is, invoke it. */
be = qof_book_get_backend(priv->book);
if (be && qof_backend_commit_exists(be))
{
QofBackendError errcode;
/* clear errors */
do
{
errcode = qof_backend_get_error(be);
}
while (ERR_BACKEND_NO_ERR != errcode);
qof_backend_run_commit(be, inst);
errcode = qof_backend_get_error(be);
if (ERR_BACKEND_NO_ERR != errcode)
{
/* XXX Should perform a rollback here */
priv->do_free = FALSE;
/* Push error back onto the stack */
qof_backend_set_error (be, errcode);
if (on_error)
on_error(inst, errcode);
return FALSE;
}
/* XXX the backend commit code should clear dirty!! */
priv->dirty = FALSE;
}
// if (dirty && qof_get_alt_dirty_mode() &&
// !(priv->infant && priv->do_free)) {
// qof_collection_mark_dirty(priv->collection);
// qof_book_mark_dirty(priv->book);
// }
priv->infant = FALSE;
if (priv->do_free)
{
if (on_free)
on_free(inst);
return TRUE;
}
if (on_done)
on_done(inst);
return TRUE;
}
gboolean qof_commit_edit (QofInstance *inst)
{
QofInstancePrivate *priv;
if (!inst) return FALSE;
priv = GET_PRIVATE(inst);
priv->editlevel--;
if (0 < priv->editlevel) return FALSE;
#if 0
if ((0 == priv->editlevel) && priv->dirty)
{
QofBackend * be = qof_book_get_backend(priv->book);
if (be && qof_backend_commit_exists(be))
{
qof_backend_run_commit(be, inst);
}
}
#endif
if (0 > priv->editlevel)
{
PERR ("unbalanced call - resetting (was %d)", priv->editlevel);
priv->editlevel = 0;
}
return TRUE;
}
static void
compare_books( QofBook* book_1, QofBook* book_2 )
{
QofBackend *be = qof_book_get_backend( book_2 );
compare_account_trees( book_1, book_2 );
compare_pricedbs( book_1, book_2 );
compare_txs( book_1, book_2 );
compare_sxs( book_1, book_2 );
compare_lots( book_1, book_2 );
test_conn_get_index_list( be );
}
/* XXX This exports the list of accounts to a file. It does not
* export any transactions. It's a place-holder until full
* book-closing is implemented.
*/
gboolean
qof_session_export (QofSession *tmp_session,
QofSession *real_session,
QofPercentageFunc percentage_func)
{
QofBook *book, *book2;
QofBackend *be;
if ((!tmp_session) || (!real_session)) return FALSE;
book = qof_session_get_book (real_session);
ENTER ("tmp_session=%p real_session=%p book=%p book_id=%s",
tmp_session, real_session, book,
qof_session_get_url(tmp_session)
? qof_session_get_url(tmp_session) : "(null)");
/* There must be a backend or else. (It should always be the file
* backend too.)
*/
book2 = qof_session_get_book(tmp_session);
be = qof_book_get_backend(book2);
if (!be)
return FALSE;
be->percentage = percentage_func;
if (be->export_fn)
{
int err;
(be->export_fn)(be, book);
err = qof_backend_get_error(be);
if (ERR_BACKEND_NO_ERR != err)
{
return FALSE;
}
}
return TRUE;
}
gboolean
qof_begin_edit (QofInstance *inst)
{
QofInstancePrivate *priv;
QofBackend * be;
if (!inst) return FALSE;
priv = GET_PRIVATE(inst);
priv->editlevel++;
if (1 < priv->editlevel) return FALSE;
if (0 >= priv->editlevel)
priv->editlevel = 1;
be = qof_book_get_backend(priv->book);
if (be && qof_backend_begin_exists(be))
qof_backend_run_begin(be, inst);
else
priv->dirty = TRUE;
return TRUE;
}
static void
test_employee (void)
{
QofBackend *be;
QofBook *book;
QofSession *session;
GncEmployee *employee;
session = qof_session_new();
qof_session_begin(session, QOF_STDOUT, FALSE, FALSE);
book = qof_session_get_book(session);
/* The book *must* have a backend to pass the test of the 'dirty' flag */
/* See the README file for details */
be = qof_book_get_backend (book);
/* Test creation/destruction */
{
do_test (gncEmployeeCreate (NULL) == NULL, "employee create NULL");
employee = gncEmployeeCreate (book);
do_test (employee != NULL, "employee create");
do_test (qof_instance_get_book(QOF_INSTANCE(employee)) == book,
"getbook");
gncEmployeeBeginEdit (employee);
gncEmployeeDestroy (employee);
success ("create/destroy");
}
/* Test setting/getting routines; does the active flag get set right? */
{
GncGUID guid;
test_string_fcn (book, "Id", gncEmployeeSetID, gncEmployeeGetID);
test_string_fcn (book, "Username", gncEmployeeSetUsername, gncEmployeeGetUsername);
test_string_fcn (book, "Language", gncEmployeeSetLanguage, gncEmployeeGetLanguage);
test_string_fcn (book, "Acl", gncEmployeeSetAcl, gncEmployeeGetAcl);
test_numeric_fcn (book, "Workday", gncEmployeeSetWorkday, gncEmployeeGetWorkday);
test_numeric_fcn (book, "Rate", gncEmployeeSetRate, gncEmployeeGetRate);
test_bool_fcn (book, "Active", gncEmployeeSetActive, gncEmployeeGetActive);
do_test (gncEmployeeGetAddr (employee) != NULL, "Addr");
guid_new (&guid);
employee = gncEmployeeCreate (book);
count++;
gncEmployeeSetGUID (employee, &guid);
do_test (guid_equal (&guid, qof_instance_get_guid(QOF_INSTANCE(employee))), "guid compare");
}
#if 0
{
GList *list;
list = gncBusinessGetList (book, GNC_EMPLOYEE_MODULE_NAME, TRUE);
do_test (list != NULL, "getList all");
do_test (g_list_length (list) == count, "correct length: all");
g_list_free (list);
list = gncBusinessGetList (book, GNC_EMPLOYEE_MODULE_NAME, FALSE);
do_test (list != NULL, "getList active");
do_test (g_list_length (list) == 1, "correct length: active");
g_list_free (list);
}
#endif
{
const char *str = get_random_string();
const char *res;
GncAddress *addr;
addr = gncEmployeeGetAddr (employee);
gncAddressSetName (addr, str);
res = qof_object_printable (GNC_ID_EMPLOYEE, employee);
do_test (res != NULL, "Printable NULL?");
do_test (safe_strcmp (str, res) == 0, "Printable equals");
}
}
static gboolean
gxi_parse_file (GncXmlImportData *data)
{
QofSession *session = NULL;
QofBook *book;
QofBackend *backend;
QofBackendError io_err = ERR_BACKEND_NO_ERR;
gchar *message = NULL;
gboolean success = FALSE;
if (data->n_unassigned || data->n_impossible)
goto cleanup_parse_file;
/* fill subst hash table with byte sequence substitutions */
data->subst = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
g_hash_table_foreach (data->ambiguous_ht, (GHFunc) subst_insert_amb, data);
g_hash_table_foreach (data->unique, (GHFunc) subst_insert_unique, data);
if (!data->subst)
goto cleanup_parse_file;
/* create a temporary QofSession */
gxi_session_destroy (data);
session = qof_session_new ();
data->session = session;
qof_session_begin (session, data->filename, TRUE, FALSE, FALSE);
io_err = qof_session_get_error (session);
if (io_err != ERR_BACKEND_NO_ERR)
{
message = _("The file could not be reopened.");
goto cleanup_parse_file;
}
xaccLogDisable ();
gxi_update_progress_bar (_("Reading file..."), 0.0);
qof_session_load (session, gxi_update_progress_bar);
gxi_update_progress_bar (NULL, -1.0);
xaccLogEnable ();
io_err = qof_session_get_error (session);
if (io_err == ERR_BACKEND_NO_ERR)
{
/* loaded sucessfully now. strange, but ok */
success = TRUE;
goto cleanup_parse_file;
}
else if (io_err != ERR_FILEIO_NO_ENCODING)
{
/* another error, cannot handle this here */
message = _("The file could not be reopened.");
goto cleanup_parse_file;
}
qof_session_pop_error (session);
book = qof_session_get_book (session);
backend = qof_book_get_backend (book);
gxi_update_progress_bar (_("Parsing file..."), 0.0);
success = gnc_xml2_parse_with_subst (backend, book, data->subst);
gxi_update_progress_bar (NULL, -1.0);
if (success)
data->session = session;
else
message = _("There was an error parsing the file.");
cleanup_parse_file:
if (data->subst)
{
g_hash_table_destroy (data->subst);
data->subst = NULL;
}
if (message)
{
gnc_error_dialog (data->assistant, "%s", message);
}
if (!success)
gxi_session_destroy (data);
return success;
}
