示例#1
0
/* for each entry, check the tax tables.  If the tax tables are
 * grandchildren, then fix them to point to the most senior child
 */
static void
taxtable_scrub_entries (QofInstance * entry_p, gpointer ht_p)
{
    GHashTable *ht = static_cast<decltype(ht)>(ht_p);
    GncEntry *entry = GNC_ENTRY(entry_p);
    GncTaxTable *table, *new_tt;
    gint32 count;

    table = gncEntryGetInvTaxTable(entry);
    if (table)
    {
        if (taxtable_is_grandchild(table))
        {
            gchar guidstr[GUID_ENCODING_LENGTH+1];
            guid_to_string_buff(qof_instance_get_guid(QOF_INSTANCE(entry)),guidstr);
            PINFO("Fixing i-taxtable on entry %s\n",guidstr);
            new_tt = taxtable_find_senior(table);
            gncEntryBeginEdit(entry);
            gncEntrySetInvTaxTable(entry, new_tt);
            gncEntryCommitEdit(entry);
            table = new_tt;
        }
        if (table)
        {
            count = GPOINTER_TO_INT(g_hash_table_lookup(ht, table));
            count++;
            g_hash_table_insert(ht, table, GINT_TO_POINTER(count));
        }
    }

    table = gncEntryGetBillTaxTable(entry);
    if (table)
    {
        if (taxtable_is_grandchild(table))
        {
            gchar guidstr[GUID_ENCODING_LENGTH+1];
            guid_to_string_buff(qof_instance_get_guid(QOF_INSTANCE(entry)),guidstr);
            PINFO("Fixing b-taxtable on entry %s\n",guidstr);
            new_tt = taxtable_find_senior(table);
            gncEntryBeginEdit(entry);
            gncEntrySetBillTaxTable(entry, new_tt);
            gncEntryCommitEdit(entry);
            table = new_tt;
        }
        if (table)
        {
            count = GPOINTER_TO_INT(g_hash_table_lookup(ht, table));
            count++;
            g_hash_table_insert(ht, table, GINT_TO_POINTER(count));
        }
    }
}
示例#2
0
/* for each invoice, check the bill terms.  If the bill terms are
 * grandchildren, then fix them to point to the most senior child
 */
static void
billterm_scrub_invoices (QofInstance * invoice_p, gpointer ht_p)
{
    GHashTable *ht = ht_p;
    GncInvoice *invoice = GNC_INVOICE(invoice_p);
    GncBillTerm *term, *new_bt;
    gint32 count;

    term = gncInvoiceGetTerms(invoice);
    if (term)
    {
        if (billterm_is_grandchild(term))
        {
            gchar guidstr[GUID_ENCODING_LENGTH+1];
            guid_to_string_buff(qof_instance_get_guid(QOF_INSTANCE(invoice)),guidstr);
            PWARN("Fixing i-billterm on invoice %s\n", guidstr);
            new_bt = billterm_find_senior(term);
            gncInvoiceBeginEdit(invoice);
            gncInvoiceSetTerms(invoice, new_bt);
            gncInvoiceCommitEdit(invoice);
            term = new_bt;
        }
        if (term)
        {
            count = GPOINTER_TO_INT(g_hash_table_lookup(ht, term));
            count++;
            g_hash_table_insert(ht, term, GINT_TO_POINTER(count));
        }
    }
}
/********************************************************************
 * get_custom_report_selection
 *
 * this helper function is called to get the selection when the user
 * clicks on "Run" or "Delete". Includes calling a dialog when there
 * is no selection.
 *
 * const gchar* message -- the message to provide user if there is no
 * actual selection found.
 *********************************************************************/
static SCM
get_custom_report_selection(CustomReportDialog *crd,
                            const gchar* message)
{
    GtkTreeSelection *sel;
    GtkTreeModel *model;
    GtkTreeIter iter;
    GncGUID *guid = guid_malloc ();
    gchar *guid_str;

    sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(crd->reportview));

    if (gtk_tree_selection_get_selected(sel, &model, &iter))
    {
        gtk_tree_model_get(model, &iter, COL_NUM, &guid, -1);
        guid_str = g_new0 (gchar, GUID_ENCODING_LENGTH+1 );
        guid_to_string_buff (guid, guid_str);
    }
    else
    {
        /* no selection, notify user */
        gnc_error_dialog (GTK_WINDOW (crd->dialog), "%s", message);
        return SCM_EOL;

    }
    return scm_from_utf8_string (guid_str);
}
/**************************************************************
 * custom_report_list_view_row_activated_cb
 *
 * this is the double-click signal. No need to call
 * get_custom_report_selection as the double-click implies the
 * selection.
 **************************************************************/
void
custom_report_list_view_row_activated_cb(GtkTreeView *view, GtkTreePath *path,
        GtkTreeViewColumn *column, gpointer data)
{
    CustomReportDialog *crd = data;
    GtkTreeModel *model;
    GtkTreeIter iter;

    model = gtk_tree_view_get_model(view);

    if (gtk_tree_model_get_iter(model, &iter, path))
    {
        if (column == crd->namecol)
        {
            GncGUID *guid = guid_malloc ();
            gchar *guid_str;

            gtk_tree_model_get(model, &iter, COL_NUM, &guid, -1);
            guid_str = g_new0 (gchar, GUID_ENCODING_LENGTH+1 );
            guid_to_string_buff (guid, guid_str);

            custom_report_run_report(scm_from_utf8_string (guid_str), crd);
        }
    }
}
示例#5
0
static void
gnc_cm_event_handler (QofInstance *entity,
                      QofEventId event_type,
                      gpointer user_data,
                      gpointer event_data)
{
    const GncGUID *guid = qof_entity_get_guid(entity);
#if CM_DEBUG
    gchar guidstr[GUID_ENCODING_LENGTH+1];
    guid_to_string_buff (guid, guidstr);
    fprintf (stderr, "event_handler: event %d, entity %p, guid %s\n", event_type,
             entity, guidstr);
#endif
    add_event (&changes, guid, event_type, TRUE);

    if (QOF_CHECK_TYPE(entity, GNC_ID_SPLIT))
    {
        /* split events are never generated by the engine, but might
         * be generated by a backend (viz. the postgres backend.)
         * Handle them like a transaction modify event. */
        add_event_type (&changes, GNC_ID_TRANS, QOF_EVENT_MODIFY, TRUE);
    }
    else
        add_event_type (&changes, entity->e_type, event_type, TRUE);

    got_events = TRUE;

    if (suspend_counter == 0)
        gnc_gui_refresh_internal (FALSE);
}
示例#6
0
static void
load_taxtable_entries( GncSqlBackend* be, GncTaxTable* tt )
{
    GncSqlResult* result;
    gchar guid_buf[GUID_ENCODING_LENGTH+1];
    GValue value;
    gchar* buf;
    GncSqlStatement* stmt;
    GError* error = NULL;

    g_return_if_fail( be != NULL );
    g_return_if_fail( tt != NULL );

    guid_to_string_buff( qof_instance_get_guid( QOF_INSTANCE(tt) ), guid_buf );
    memset( &value, 0, sizeof( GValue ) );
    g_value_init( &value, G_TYPE_STRING );
    g_value_set_string( &value, guid_buf );
    buf = g_strdup_printf( "SELECT * FROM %s WHERE taxtable='%s'", TTENTRIES_TABLE_NAME, guid_buf );
    stmt = gnc_sql_connection_create_statement_from_sql( be->conn, buf );
    g_free( buf );
    result = gnc_sql_execute_select_statement( be, stmt );
    gnc_sql_statement_dispose( stmt );
    if ( result != NULL )
    {
        GncSqlRow* row;

        row = gnc_sql_result_get_first_row( result );
        while ( row != NULL )
        {
            load_single_ttentry( be, row, tt );
            row = gnc_sql_result_get_next_row( result );
        }
        gnc_sql_result_dispose( result );
    }
}
static const char*
equals_node_val_vs_splits (xmlNodePtr node, const Transaction* trn)
{
    xmlNodePtr spl_node;
    Split* spl_mark;
    int i;

    g_return_val_if_fail (node, FALSE);
    g_return_val_if_fail (node->xmlChildrenNode, FALSE);

    for (i = 0, spl_mark = xaccTransGetSplit ((Transaction*)trn, i);
         spl_mark;
         i++, spl_mark = xaccTransGetSplit ((Transaction*)trn, i))
    {
        spl_node = find_appropriate_node (node, spl_mark);

        if (!spl_node)
        {
            gchar guidstr[GUID_ENCODING_LENGTH + 1];
            guid_to_string_buff (xaccSplitGetGUID (spl_mark), guidstr);
            g_print ("Split GUID %s", guidstr);
            return "no matching split found";
        }

        const char* msg = equals_node_val_vs_split_internal (spl_node, spl_mark);
        if (msg != NULL)
        {
            return msg;
        }
    }

    return NULL;
}
示例#8
0
static void
col_ref_cb (QofInstance* ref_ent, gpointer user_data)
{
    QofInstanceReference *ref;
    QofInstanceCopyData  *qecd;
    QofInstance *ent;
    const GncGUID   *cm_guid;
    char         cm_sa[GUID_ENCODING_LENGTH + 1];
    gchar        *cm_string;

    g_return_if_fail(user_data);
    qecd = (QofInstanceCopyData*)user_data;
    ent = qecd->from;
    g_return_if_fail(ent);
    ref = g_new0(QofInstanceReference, 1);
    ref->type = ent->e_type;
    ref->ref_guid = g_new(GncGUID, 1);
    ref->ent_guid = qof_instance_get_guid(ent);
    ref->param = qof_class_get_parameter(ent->e_type,
                                         qecd->param->param_name);
    cm_guid = qof_entity_get_guid(ref_ent);
    guid_to_string_buff(cm_guid, cm_sa);
    cm_string = g_strdup(cm_sa);
    if (TRUE == string_to_guid(cm_string, ref->ref_guid))
    {
        g_free(cm_string);
        qof_session_update_reference_list(qecd->new_session, ref);
    }
}
示例#9
0
void gncBillTermDestroy (GncBillTerm *term)
{
    gchar guidstr[GUID_ENCODING_LENGTH+1];
    if (!term) return;
    guid_to_string_buff(qof_instance_get_guid(&term->inst),guidstr);
    DEBUG("destroying bill term %s (%p)", guidstr, term);
    qof_instance_set_destroying(term, TRUE);
    qof_instance_set_dirty (&term->inst);
    gncBillTermCommitEdit (term);
}
示例#10
0
Account*
gnc_sx_get_template_transaction_account(SchedXaction *sx)
{
    Account *template_root, *sx_template_acct;
    char sx_guid_str[GUID_ENCODING_LENGTH+1];

    template_root = gnc_book_get_template_root(gnc_get_current_book());
    guid_to_string_buff(xaccSchedXactionGetGUID(sx), sx_guid_str);
    sx_template_acct = gnc_account_lookup_by_name(template_root, sx_guid_str);
    return sx_template_acct;
}
示例#11
0
void
qof_instance_print_dirty (const QofInstance *inst, gpointer dummy)
{
    QofInstancePrivate *priv;

    priv = GET_PRIVATE(inst);
    if (priv->dirty)
    {
        gchar guidstr[GUID_ENCODING_LENGTH+1];
        guid_to_string_buff(&priv->guid, guidstr);
        printf("%s instance %s is dirty.\n", inst->e_type, guidstr);
    }
}
示例#12
0
gboolean
gnc_sql_slots_delete( GncSqlBackend* be, const GncGUID* guid )
{
    gchar* buf;
    GncSqlResult* result;
    gchar guid_buf[GUID_ENCODING_LENGTH + 1];
    GncSqlStatement* stmt;
    slot_info_t slot_info = { NULL, NULL, TRUE, NULL, 0, NULL, FRAME, NULL, g_string_new('\0') };

    g_return_val_if_fail( be != NULL, FALSE );
    g_return_val_if_fail( guid != NULL, FALSE );

    (void)guid_to_string_buff( guid, guid_buf );

    buf = g_strdup_printf( "SELECT * FROM %s WHERE obj_guid='%s' and slot_type in ('%d', '%d') and not guid_val is null",
                           TABLE_NAME, guid_buf, KVP_TYPE_FRAME, KVP_TYPE_GLIST );
    stmt = gnc_sql_create_statement_from_sql( be, buf );
    g_free( buf );
    if ( stmt != NULL )
    {
        result = gnc_sql_execute_select_statement( be, stmt );
        gnc_sql_statement_dispose( stmt );
        if ( result != NULL )
        {
            GncSqlRow* row = gnc_sql_result_get_first_row( result );

            while ( row != NULL )
            {
                GncSqlColumnTableEntry table_row = col_table[guid_val_col];
                GncGUID child_guid;
                const GValue* val =
                    gnc_sql_row_get_value_at_col_name( row, table_row.col_name);
                if ( val == NULL )
                    continue;

                (void)string_to_guid( g_value_get_string( val ), &child_guid );
                gnc_sql_slots_delete( be, &child_guid );
                row = gnc_sql_result_get_next_row( result );
            }
            gnc_sql_result_dispose( result );
        }
    }

    slot_info.be = be;
    slot_info.guid = guid;
    slot_info.is_ok = TRUE;
    slot_info.is_ok = gnc_sql_do_db_operation( be, OP_DB_DELETE, TABLE_NAME,
                      TABLE_NAME, &slot_info, obj_guid_col_table );

    return slot_info.is_ok;
}
示例#13
0
/** Save all persistent program state to disk.  This function finds the
 *  name of the "new" state file associated with a specific book guid.
 *  It saves some top level data, then iterates through the list of
 *  open windows calling a helper function to save each window.
 *
 *  @note The name of the state file is based on the name of the data
 *  file, not the path name of the data file.  If there are multiple
 *  data files with the same name, the state files will be suffixed
 *  with a number.  E.G. test_account, test_account_2, test_account_3,
 *  etc.
 *
 *  @param session The QofSession whose state should be saved.
 *
 *  @param unused */
static void
gnc_save_all_state (gpointer session, gpointer unused)
{
    QofBook *book;
    gchar guid_string[GUID_ENCODING_LENGTH+1];
    const GncGUID *guid;
    GKeyFile *keyfile = NULL;

    keyfile = gnc_state_get_current ();
    if (keyfile)
    {
        /* Remove existing Window and Page groups from the keyfile
         * They will be regenerated.
         */
        gsize num_groups, curr;
        gchar **groups = g_key_file_get_groups (keyfile, &num_groups);
        for (curr=0; curr < num_groups; curr++)
        {
            if (g_str_has_prefix (groups[curr], "Window ") ||
                    g_str_has_prefix (groups[curr], "Page "))
            {
                DEBUG ("Removing state group %s", groups[curr]);
                g_key_file_remove_group (keyfile, groups[curr], NULL);
            }
        }
        g_strfreev (groups);
    }

    /* Store the book's GncGUID in the top level group */
    book = qof_session_get_book(session);
    guid = qof_entity_get_guid(QOF_INSTANCE(book));
    guid_to_string_buff(guid, guid_string);
    g_key_file_set_string(keyfile, STATE_FILE_TOP, STATE_FILE_BOOK_GUID,
                          guid_string);

    gnc_main_window_save_all_windows(keyfile);

#ifdef DEBUG
    /*  Debugging: dump a copy to the trace log */
    {
        gchar *file_data;
        gsize file_length;
        file_data = g_key_file_to_data(keyfile, &file_length, NULL);
        DEBUG("=== File Data Written===\n%s\n=== File End ===\n", file_data);
        g_free(file_data);
    }
#endif
    LEAVE("");
}
示例#14
0
static void
billterm_scrub_cust (QofInstance * cust_p, gpointer ht_p)
{
    GHashTable *ht = ht_p;
    GncCustomer *cust = GNC_CUSTOMER(cust_p);
    GncBillTerm *term;
    gint32 count;

    term = gncCustomerGetTerms(cust);
    if (term)
    {
        count = GPOINTER_TO_INT(g_hash_table_lookup(ht, term));
        count++;
        g_hash_table_insert(ht, term, GINT_TO_POINTER(count));
        if (billterm_is_grandchild(term))
        {
            gchar custstr[GUID_ENCODING_LENGTH+1];
            gchar termstr[GUID_ENCODING_LENGTH+1];
            guid_to_string_buff(qof_instance_get_guid(QOF_INSTANCE(cust)),custstr);
            guid_to_string_buff(qof_instance_get_guid(QOF_INSTANCE(term)),termstr);
            PWARN("customer %s has grandchild billterm %s\n", custstr,termstr);
        }
    }
}
示例#15
0
static void
billterm_scrub_vendor (QofInstance * vendor_p, gpointer ht_p)
{
    GHashTable *ht = ht_p;
    GncVendor *vendor = GNC_VENDOR(vendor_p);
    GncBillTerm *term;
    gint32 count;

    term = gncVendorGetTerms(vendor);
    if (term)
    {
        count = GPOINTER_TO_INT(g_hash_table_lookup(ht, term));
        count++;
        g_hash_table_insert(ht, term, GINT_TO_POINTER(count));
        if (billterm_is_grandchild(term))
        {
            gchar vendstr[GUID_ENCODING_LENGTH+1];
            gchar termstr[GUID_ENCODING_LENGTH+1];
            guid_to_string_buff(qof_instance_get_guid(QOF_INSTANCE(vendor)),vendstr);
            guid_to_string_buff(qof_instance_get_guid(QOF_INSTANCE(term)),termstr);
            PWARN("vendor %s has grandchild billterm %s\n", vendstr, termstr);
        }
    }
}
示例#16
0
static void
billterm_reset_refcount (gpointer key, gpointer value, gpointer notused)
{
    GncBillTerm *term = key;
    gint32 count = GPOINTER_TO_INT(value);

    if (count != gncBillTermGetRefcount(term) && !gncBillTermGetInvisible(term))
    {
        gchar termstr[GUID_ENCODING_LENGTH+1];
        guid_to_string_buff(qof_instance_get_guid(QOF_INSTANCE(term)),termstr);
        PWARN("Fixing refcount on billterm %s (%" G_GINT64_FORMAT " -> %d)\n",
                termstr, gncBillTermGetRefcount(term), count);
        gncBillTermSetRefcount(term, count);
    }
}
示例#17
0
static void
taxtable_reset_refcount (gpointer key, gpointer value, gpointer notused)
{
    GncTaxTable *table = static_cast<decltype(table)>(key);
    gint32 count = GPOINTER_TO_INT(value);

    if (count != gncTaxTableGetRefcount(table) && !gncTaxTableGetInvisible(table))
    {
        gchar guidstr[GUID_ENCODING_LENGTH+1];
        guid_to_string_buff(qof_instance_get_guid(QOF_INSTANCE(table)),guidstr);
        PWARN("Fixing refcount on taxtable %s (%" G_GINT64_FORMAT " -> %d)\n",
              guidstr,gncTaxTableGetRefcount(table), count);
        gncTaxTableSetRefcount(table, count);
    }
}
示例#18
0
gboolean
gnc_sql_slots_delete (GncSqlBackend* sql_be, const GncGUID* guid)
{
    gchar* buf;
    gchar guid_buf[GUID_ENCODING_LENGTH + 1];
    slot_info_t slot_info = { NULL, NULL, TRUE, NULL, KvpValue::Type::INVALID,
                              NULL, FRAME, NULL, "" };

    g_return_val_if_fail (sql_be != NULL, FALSE);
    g_return_val_if_fail (guid != NULL, FALSE);

    (void)guid_to_string_buff (guid, guid_buf);

    buf = g_strdup_printf ("SELECT * FROM %s WHERE obj_guid='%s' and slot_type in ('%d', '%d') and not guid_val is null",
                           TABLE_NAME, guid_buf, KvpValue::Type::FRAME, KvpValue::Type::GLIST);
    auto stmt = sql_be->create_statement_from_sql(buf);
    g_free (buf);
    if (stmt != nullptr)
    {
        auto result = sql_be->execute_select_statement(stmt);
        for (auto row : *result)
        {
            try
            {
                const GncSqlColumnTableEntryPtr table_row =
                    col_table[guid_val_col];
                GncGUID child_guid;
                auto val = row.get_string_at_col (table_row->name());
                (void)string_to_guid (val.c_str(), &child_guid);
                gnc_sql_slots_delete (sql_be, &child_guid);
            }
            catch (std::invalid_argument)
            {
                continue;
            }
        }
    }

    slot_info.be = sql_be;
    slot_info.guid = guid;
    slot_info.is_ok = TRUE;
    slot_info.is_ok = sql_be->do_db_operation(OP_DB_DELETE, TABLE_NAME,
                                              TABLE_NAME, &slot_info,
                                              obj_guid_col_table);

    return slot_info.is_ok;
}
示例#19
0
static /*@ null @*/ Split*
load_single_split( GncSqlBackend* be, GncSqlRow* row )
{
    const GncGUID* guid;
    GncGUID split_guid;
    Split* pSplit = NULL;
    gboolean bad_guid = FALSE;

    g_return_val_if_fail( be != NULL, NULL );
    g_return_val_if_fail( row != NULL, NULL );

    guid = gnc_sql_load_guid( be, row );
    if ( guid == NULL ) return NULL;
    if (guid_equal(guid, guid_null()))
    {
	PWARN("Bad GUID, creating new");
	bad_guid = TRUE;
	split_guid = guid_new_return();
    }
    else
    {
	split_guid = *guid;
	pSplit = xaccSplitLookup( &split_guid, be->book );
    }

    if ( pSplit == NULL )
    {
	pSplit = xaccMallocSplit( be->book );
    }

    /* If the split is dirty, don't overwrite it */
    if ( !qof_instance_is_dirty( QOF_INSTANCE(pSplit) ) )
    {
        gnc_sql_load_object( be, row, GNC_ID_SPLIT, pSplit, split_col_table );
    }

    /*# -ifempty */
    if (pSplit != xaccSplitLookup( &split_guid, be->book ))
    {
        gchar guidstr[GUID_ENCODING_LENGTH+1];
        guid_to_string_buff(qof_instance_get_guid(pSplit), guidstr);
        PERR("A malformed split with id %s was found in the dataset.", guidstr);
        qof_backend_set_error( &be->be, ERR_BACKEND_DATA_CORRUPT);
        pSplit = NULL;
    }
    return pSplit;
}
示例#20
0
static  GncSqlResultPtr
gnc_sql_set_recurrences_from_db (GncSqlBackend* sql_be, const GncGUID* guid)
{
    gchar* buf;
    gchar guid_buf[GUID_ENCODING_LENGTH + 1];

    g_return_val_if_fail (sql_be != NULL, NULL);
    g_return_val_if_fail (guid != NULL, NULL);

    (void)guid_to_string_buff (guid, guid_buf);
    buf = g_strdup_printf ("SELECT * FROM %s WHERE obj_guid='%s'", TABLE_NAME,
                           guid_buf);
    auto stmt = sql_be->create_statement_from_sql (buf);
    g_free (buf);
    auto result = sql_be->execute_select_statement(stmt);
    return result;
}
示例#21
0
static gboolean
_get_template_split_account(GncSxInstance *instance, Split *template_split, Account **split_acct, GList **creation_errors)
{
    GncGUID *acct_guid;
    kvp_frame *split_kvpf;
    kvp_value *kvp_val;

    split_kvpf = xaccSplitGetSlots(template_split);
    /* contains the guid of the split's actual account. */
    kvp_val = kvp_frame_get_slot_path(split_kvpf,
                                      GNC_SX_ID,
                                      GNC_SX_ACCOUNT,
                                      NULL);
    if (kvp_val == NULL)
    {
        GString *err = g_string_new("");
        g_string_printf(err, "Null account kvp value for SX [%s], cancelling creation.",
                        xaccSchedXactionGetName(instance->parent->sx));
        g_critical("%s", err->str);
        if (creation_errors != NULL)
            *creation_errors = g_list_append(*creation_errors, err);
        else
            g_string_free(err, TRUE);
        return FALSE;
    }
    acct_guid = kvp_value_get_guid( kvp_val );
    *split_acct = xaccAccountLookup(acct_guid, gnc_get_current_book());
    if (*split_acct == NULL)
    {
        char guid_str[GUID_ENCODING_LENGTH+1];
        GString *err;
        guid_to_string_buff((const GncGUID*)acct_guid, guid_str);
        err = g_string_new("");
        g_string_printf(err, "Unknown account for guid [%s], cancelling SX [%s] creation.",
                        guid_str, xaccSchedXactionGetName(instance->parent->sx));
        g_critical("%s", err->str);
        if (creation_errors != NULL)
            *creation_errors = g_list_append(*creation_errors, err);
        else
            g_string_free(err, TRUE);
        return FALSE;
    }

    return TRUE;
}
示例#22
0
/**
 * Deletes the budget amounts for a budget.
 *
 * @param sql_be SQL backend
 * @param budget Budget
 */
static gboolean
delete_budget_amounts (GncSqlBackend* sql_be, GncBudget* budget)
{
    gchar guid_buf[GUID_ENCODING_LENGTH + 1];

    g_return_val_if_fail (sql_be != NULL, FALSE);
    g_return_val_if_fail (budget != NULL, FALSE);

    (void)guid_to_string_buff (qof_instance_get_guid (QOF_INSTANCE (budget)),
                               guid_buf);
    std::stringstream sql;
    sql << "DELETE FROM " << AMOUNTS_TABLE << " WHERE budget_guid='"<<
        guid_buf << "'";
    auto stmt = sql_be->create_statement_from_sql(sql.str());
    sql_be->execute_nonselect_statement(stmt);

    return true;
}
示例#23
0
static /*@ null @*/ GncSqlResult*
gnc_sql_set_recurrences_from_db( GncSqlBackend* be, const GncGUID* guid )
{
    gchar* buf;
    gchar guid_buf[GUID_ENCODING_LENGTH+1];
    GncSqlStatement* stmt;
    GncSqlResult* result;

    g_return_val_if_fail( be != NULL, NULL );
    g_return_val_if_fail( guid != NULL, NULL );

    (void)guid_to_string_buff( guid, guid_buf );
    buf = g_strdup_printf( "SELECT * FROM %s WHERE obj_guid='%s'", TABLE_NAME, guid_buf );
    stmt = gnc_sql_connection_create_statement_from_sql( be->conn, buf );
    g_free( buf );
    result = gnc_sql_execute_select_statement( be, stmt );
    gnc_sql_statement_dispose( stmt );
    return result;
}
示例#24
0
xmlNodePtr
guid_to_dom_tree(const char *tag, const GncGUID* gid)
{
    char guid_str[GUID_ENCODING_LENGTH + 1];
    xmlNodePtr ret;

    ret = xmlNewNode(NULL, BAD_CAST tag);

    xmlSetProp(ret, BAD_CAST "type", BAD_CAST "guid");

    if (!guid_to_string_buff(gid, guid_str))
    {
        PERR("guid_to_string_buff failed\n");
        return NULL;
    }

    xmlNodeAddContent(ret, BAD_CAST guid_str);

    return ret;
}
示例#25
0
/********************************************************************\
 * gnc_split_scm_set_account                                        *
 *   set the account of a scheme representation of a split.         *
 *                                                                  *
 * Args: split_scm - the scheme split                               *
 *       account   - the account to set                             *
 * Returns: Nothing                                                 *
\********************************************************************/
void
gnc_split_scm_set_account(SCM split_scm, Account *account)
{
    gchar guid_string[GUID_ENCODING_LENGTH+1];
    SCM arg;

    initialize_scm_functions();

    if (!gnc_is_split_scm(split_scm))
        return;
    if (account == NULL)
        return;

    guid_to_string_buff(xaccAccountGetGUID(account), guid_string);
    if (strlen(guid_string) == 0)
        return;

    arg = scm_from_utf8_string(guid_string);

    scm_call_2(setters.split_scm_account_guid, split_scm, arg);
}
示例#26
0
static void
load_taxtable_entries (GncSqlBackend* sql_be, GncTaxTable* tt)
{
    gchar guid_buf[GUID_ENCODING_LENGTH + 1];
    GValue value;
    gchar* buf;

    g_return_if_fail (sql_be != NULL);
    g_return_if_fail (tt != NULL);

    guid_to_string_buff (qof_instance_get_guid (QOF_INSTANCE (tt)), guid_buf);
    memset (&value, 0, sizeof (GValue));
    g_value_init (&value, G_TYPE_STRING);
    g_value_set_string (&value, guid_buf);
    buf = g_strdup_printf ("SELECT * FROM %s WHERE taxtable='%s'",
                           TTENTRIES_TABLE_NAME, guid_buf);
    auto stmt = sql_be->create_statement_from_sql (buf);
    g_free (buf);
    auto result = sql_be->execute_select_statement(stmt);
    for (auto row : *result)
        load_single_ttentry (sql_be, row, tt);
}
示例#27
0
static void
billterm_scrub (QofBook *book)
{
    GList *list = NULL;
    GList *node;
    GncBillTerm *parent, *term;
    GHashTable *ht = g_hash_table_new(g_direct_hash, g_direct_equal);

    DEBUG("scrubbing billterms...");
    qof_object_foreach (GNC_ID_INVOICE,  book, billterm_scrub_invoices, ht);
    qof_object_foreach (GNC_ID_CUSTOMER, book, billterm_scrub_cust, ht);
    qof_object_foreach (GNC_ID_VENDOR,   book, billterm_scrub_vendor, ht);
    qof_object_foreach (GNC_ID_BILLTERM, book, billterm_scrub_cb, &list);

    /* destroy the list of "grandchildren" bill terms */
    for (node = list; node; node = node->next)
    {
        gchar termstr[GUID_ENCODING_LENGTH+1];
        term = node->data;

        guid_to_string_buff(qof_instance_get_guid(QOF_INSTANCE(term)), termstr);
        PWARN ("deleting grandchild billterm: %s\n", termstr);

        /* Make sure the parent has no children */
        parent = gncBillTermGetParent(term);
        gncBillTermSetChild(parent, NULL);

        /* Destroy this bill term */
        gncBillTermBeginEdit(term);
        gncBillTermDestroy(term);
    }

    /* reset the refcounts as necessary */
    g_hash_table_foreach(ht, billterm_reset_refcount, NULL);

    g_list_free(list);
    g_hash_table_destroy(ht);
}
示例#28
0
/**
 * Loads the budget amounts for a budget.
 *
 * @param sql_be SQL backend
 * @param budget Budget
 */
static void
load_budget_amounts (GncSqlBackend* sql_be, GncBudget* budget)
{
    gchar guid_buf[GUID_ENCODING_LENGTH + 1];

    g_return_if_fail (sql_be != NULL);
    g_return_if_fail (budget != NULL);

    (void)guid_to_string_buff (qof_instance_get_guid (QOF_INSTANCE (budget)),
                               guid_buf);
    auto sql = g_strdup_printf ("SELECT * FROM %s WHERE budget_guid='%s'",
                                AMOUNTS_TABLE, guid_buf);
    auto stmt = sql_be->create_statement_from_sql(sql);
    g_free (sql);
    if (stmt != nullptr)
    {
        auto result = sql_be->execute_select_statement(stmt);
        budget_amount_info_t info = { budget, NULL, 0 };

        for (auto row : *result)
            gnc_sql_load_object (sql_be, row, NULL, &info, budget_amounts_col_table);
    }
}
示例#29
0
/**
 * Loads all transactions for an account.
 *
 * @param be SQL backend
 * @param account Account
 */
void gnc_sql_transaction_load_tx_for_account( GncSqlBackend* be, Account* account )
{
    const GncGUID* guid;
    gchar guid_buf[GUID_ENCODING_LENGTH+1];
    gchar* query_sql;
    GncSqlStatement* stmt;

    g_return_if_fail( be != NULL );
    g_return_if_fail( account != NULL );

    guid = qof_instance_get_guid( QOF_INSTANCE(account) );
    (void)guid_to_string_buff( guid, guid_buf );
    query_sql = g_strdup_printf(
                    "SELECT DISTINCT t.* FROM %s AS t, %s AS s WHERE s.tx_guid=t.guid AND s.account_guid ='%s'",
                    TRANSACTION_TABLE, SPLIT_TABLE, guid_buf );
    stmt = gnc_sql_create_statement_from_sql( be, query_sql );
    g_free( query_sql );
    if ( stmt != NULL )
    {
        query_transactions( be, stmt );
        gnc_sql_statement_dispose( stmt );
    }
}
示例#30
0
static void
slots_load_info (slot_info_t* pInfo)
{
    gchar guid_buf[GUID_ENCODING_LENGTH + 1];

    g_return_if_fail (pInfo != NULL);
    g_return_if_fail (pInfo->be != NULL);
    g_return_if_fail (pInfo->guid != NULL);
    g_return_if_fail (pInfo->pKvpFrame != NULL);

    (void)guid_to_string_buff (pInfo->guid, guid_buf);

    std::stringstream buf;
    buf << "SELECT * FROM " << TABLE_NAME <<
        " WHERE obj_guid='" << guid_buf << "'";
    auto stmt = pInfo->be->create_statement_from_sql (buf.str());
    if (stmt != nullptr)
    {
        auto result = pInfo->be->execute_select_statement (stmt);
        for (auto row : *result)
            load_slot (pInfo, row);
    }
}