static void
_show_created_transactions(GncSxSinceLastRunDialog *app_dialog, GList *created_txn_guids)
{
GNCLedgerDisplay *ledger;
GncPluginPage *page;
Query *book_query, *guid_query, *query;
GList *guid_iter;
book_query = qof_query_create_for(GNC_ID_SPLIT);
guid_query = qof_query_create_for(GNC_ID_SPLIT);
qof_query_set_book(book_query, gnc_get_current_book());
for (guid_iter = created_txn_guids; guid_iter != NULL; guid_iter = guid_iter->next)
{
xaccQueryAddGUIDMatch(guid_query, (GncGUID*)guid_iter->data, GNC_ID_TRANS, QOF_QUERY_OR);
}
query = qof_query_merge(book_query, guid_query, QOF_QUERY_AND);
// inspired by dialog-find-transactions:do_find_cb:
ledger = gnc_ledger_display_query(query, SEARCH_LEDGER, REG_STYLE_JOURNAL);
gnc_ledger_display_refresh(ledger);
page = gnc_plugin_page_register_new_ledger(ledger);
g_object_set(G_OBJECT(page), "page-name", _("Created Transactions"), NULL);
gnc_main_window_open_page(NULL, page);
qof_query_destroy(query);
qof_query_destroy(book_query);
qof_query_destroy(guid_query);
}
static void
search_new_item_cb (GtkButton *button, GNCSearchWindow *sw)
{
gpointer res;
g_return_if_fail (sw->new_item_cb);
res = (sw->new_item_cb)(sw->user_data);
if (res)
{
const GncGUID *guid = (const GncGUID *) ((sw->get_guid->param_getfcn)(res, sw->get_guid));
QofQueryOp op = QOF_QUERY_OR;
if (!sw->q)
{
if (!sw->start_q)
{
sw->start_q = qof_query_create_for (sw->search_for);
qof_query_set_book (sw->start_q, gnc_get_current_book ());
}
sw->q = qof_query_copy (sw->start_q);
op = QOF_QUERY_AND;
}
qof_query_add_guid_match (sw->q, g_slist_prepend (NULL, QOF_PARAM_GUID),
guid, op);
/* Watch this entity so we'll refresh once it's actually changed */
gnc_gui_component_watch_entity (sw->component_id, guid, QOF_EVENT_MODIFY);
}
}
static int
get_num_xactions_before_date(QofBook *book, time64 close_date)
{
QofQuery *q;
GSList *param;
QofQueryPredData *pred;
GList *res, *n;
int cnt = 0;
q = qof_query_create_for(GNC_ID_TRANS);
qof_query_set_max_results(q, -1);
qof_query_set_book (q, book);
/* Look for transactions earlier than the closing date */
param = g_slist_prepend (NULL, TRANS_DATE_POSTED);
pred = qof_query_date_predicate (QOF_COMPARE_LTE, QOF_DATE_MATCH_NORMAL, close_date);
qof_query_add_term (q, param, pred, QOF_QUERY_FIRST_TERM);
/* Run the query, find how many transactions there are */
res = qof_query_run (q);
cnt = 0;
for (n = res; n; n = n->next) cnt ++;
qof_query_destroy (q);
return cnt;
}
/** Creates a new query that searches for all GncAddress items in the
* current book. */
static QofQuery *new_query_for_addresss(QofBook *book)
{
GSList *primary_sort_params = NULL;
QofQuery *query = qof_query_create_for (GNC_ID_ADDRESS);
g_assert(book);
qof_query_set_book (query, book);
/* No particular sort order here. */
return query;
}
static void
gnc_ledger_display_make_query (GNCLedgerDisplay *ld,
gint limit,
SplitRegisterType type)
{
Account *leader;
GList *accounts;
if (!ld)
return;
switch (ld->ld_type)
{
case LD_SINGLE:
case LD_SUBACCOUNT:
break;
case LD_GL:
return;
default:
PERR ("unknown ledger type: %d", ld->ld_type);
return;
}
qof_query_destroy (ld->query);
ld->query = qof_query_create_for(GNC_ID_SPLIT);
/* This is a bit of a hack. The number of splits should be
* configurable, or maybe we should go back a time range instead
* of picking a number, or maybe we should be able to exclude
* based on reconciled status. Anyway, this works for now. */
if ((limit != 0) && (type != SEARCH_LEDGER))
qof_query_set_max_results (ld->query, limit);
qof_query_set_book (ld->query, gnc_get_current_book());
leader = gnc_ledger_display_leader (ld);
if (ld->ld_type == LD_SUBACCOUNT)
accounts = gnc_account_get_descendants (leader);
else
accounts = NULL;
accounts = g_list_prepend (accounts, leader);
xaccQueryAddAccountMatch (ld->query, accounts,
QOF_GUID_MATCH_ANY, QOF_QUERY_AND);
g_list_free (accounts);
}
/* Opens up a general journal window. */
GNCLedgerDisplay *
gnc_ledger_display_gl (void)
{
Query *query;
time64 start;
struct tm tm;
GNCLedgerDisplay *ld;
ENTER(" ");
query = qof_query_create_for(GNC_ID_SPLIT);
qof_query_set_book (query, gnc_get_current_book());
/* In lieu of not "mis-using" some portion of the infrastructure by writing
* a bunch of new code, we just filter out the accounts of the template
* transactions. While these are in a seperate Account trees just for this
* reason, the query engine makes no distinction between Account trees.
* See Gnome Bug 86302.
* -- jsled */
{
Account *tRoot;
GList *al;
tRoot = gnc_book_get_template_root( gnc_get_current_book() );
al = gnc_account_get_descendants( tRoot );
if (g_list_length(al) != 0)
xaccQueryAddAccountMatch( query, al, QOF_GUID_MATCH_NONE, QOF_QUERY_AND );
g_list_free (al);
al = NULL;
tRoot = NULL;
}
gnc_tm_get_today_start(&tm);
tm.tm_mon--; /* Default the register to the last month's worth of transactions. */
start = gnc_mktime (&tm);
xaccQueryAddDateMatchTT (query,
TRUE, start,
FALSE, 0,
QOF_QUERY_AND);
ld = gnc_ledger_display_internal (NULL, query, LD_GL, GENERAL_JOURNAL,
REG_STYLE_JOURNAL, FALSE, FALSE);
LEAVE("%p", ld);
return ld;
}
/**
* @param id: The string version of the GncGUID of the context of template
* transaction being edited in this template GL. As used by scheduled
* transactions, this is the GncGUID of the SX itself which is magically the
* *name* of the (template) account which contains the transactions for this
* scheduled transaction. That's right. The stringified GncGUID of the SX is
* the name of the SX'es template account.
**/
GNCLedgerDisplay2 *
gnc_ledger_display2_template_gl (char *id)
{
QofBook *book;
Query *q;
GNCLedgerDisplay2 *ld;
GncTreeModelSplitReg *model;
Account *root, *acct;
gboolean isTemplateModeTrue;
ENTER("id=%s", id ? id : "(null)");
acct = NULL;
isTemplateModeTrue = TRUE;
q = qof_query_create_for(GNC_ID_SPLIT);
book = gnc_get_current_book ();
qof_query_set_book (q, book);
if ( id != NULL )
{
root = gnc_book_get_template_root (book);
acct = gnc_account_lookup_by_name(root, id);
g_assert( acct );
xaccQueryAddSingleAccountMatch (q, acct, QOF_QUERY_AND);
}
ld = gnc_ledger_display2_internal (NULL, q, LD2_GL,
SEARCH_LEDGER2,
REG2_STYLE_JOURNAL,
FALSE,
isTemplateModeTrue);
model = gnc_ledger_display2_get_split_model_register (ld);
if ( acct )
{
gnc_tree_model_split_reg_set_template_account (model, acct);
}
LEAVE("%p", ld);
return ld;
}
static void
run_tests (void)
{
QofQuery *q;
int i;
test_query (NULL);
q = qof_query_create_for(GNC_ID_SPLIT);
test_query (q);
qof_query_destroy (q);
for (i = 0; i < 50; i++)
{
q = get_random_query ();
test_query (q);
qof_query_destroy (q);
}
}
/** Creates a new query that searches for an GncEntry item with
* description string equal to the given "desc" argument. The query
* will find the single GncEntry with the latest (=newest)
* DATE_ENTERED. */
static QofQuery *new_query_for_entry_desc(GncEntryLedger *reg, const char* desc, gboolean use_invoice)
{
QofQuery *query = NULL;
QofQueryPredData *predData = NULL;
GSList *param_list = NULL;
GSList *primary_sort_params = NULL;
const char* should_be_null = (use_invoice ? ENTRY_BILL : ENTRY_INVOICE);
g_assert(reg);
g_assert(desc);
/* The query itself and its book */
query = qof_query_create_for (GNC_ID_ENTRY);
qof_query_set_book (query, reg->book);
/* Predicate data: We want to compare one string, namely the given
* argument */
predData =
qof_query_string_predicate (QOF_COMPARE_EQUAL, desc,
QOF_STRING_MATCH_CASEINSENSITIVE, FALSE);
/* Search Parameter: We want to query on the ENTRY_DESC column */
param_list = qof_query_build_param_list (ENTRY_DESC, NULL);
/* Register this in the query */
qof_query_add_term (query, param_list, predData, QOF_QUERY_FIRST_TERM);
/* For invoice entries, Entry->Bill must be NULL, and vice versa */
qof_query_add_guid_match (query,
qof_query_build_param_list (should_be_null,
QOF_PARAM_GUID, NULL),
NULL, QOF_QUERY_AND);
/* Set the sort order: By DATE_ENTERED, increasing, and returning
* only one single resulting item. */
primary_sort_params = qof_query_build_param_list(ENTRY_DATE_ENTERED, NULL);
qof_query_set_sort_order (query, primary_sort_params, NULL, NULL);
qof_query_set_sort_increasing (query, TRUE, TRUE, TRUE);
qof_query_set_max_results(query, 1);
return query;
}
/*******************************************************************
* get_earliest_in_book
*
* Find the earliest date occuring in the book. Do this by making
* a query and sorting by date. Since the truncated sort returns
* only the *last* search results, sort in decreasing order.
*******************************************************************/
static time64
get_earliest_in_book (QofBook *book)
{
QofQuery *q;
GSList *p1, *p2;
GList *res;
time64 earliest;
q = qof_query_create_for (GNC_ID_SPLIT);
qof_query_set_max_results (q, 1);
qof_query_set_book (q, book);
/* Sort by transaction date */
p1 = g_slist_prepend (NULL, TRANS_DATE_POSTED);
p1 = g_slist_prepend (p1, SPLIT_TRANS);
p2 = g_slist_prepend (NULL, QUERY_DEFAULT_SORT);
qof_query_set_sort_order (q, p1, p2, NULL);
/* Reverse the sort order */
qof_query_set_sort_increasing (q, FALSE, FALSE, FALSE);
/* Run the query, find the earliest transaction date */
res = qof_query_run (q);
if (res)
{
earliest = xaccQueryGetEarliestDateFound (q);
}
else
{
/* If no results, we don't want to bomb totally */
earliest = gnc_time (0);
}
qof_query_destroy (q);
return earliest;
}
static void
create_children (GNCGeneralSearch *gsl,
const char *label,
gboolean text_editable,
QofIdTypeConst type,
QofBook *book)
{
GtkListStore * list_store;
QofQuery * q;
GtkTreeIter iter;
GList * list, * it;
GtkEntryCompletion *completion;
/* Add a text entry box */
gsl->entry = gtk_entry_new ();
if (!text_editable)
gtk_editable_set_editable (GTK_EDITABLE (gsl->entry), FALSE);
gtk_box_pack_start (GTK_BOX (gsl), gsl->entry, TRUE, TRUE, 0);
/* Setup a GtkEntryCompletion auxiliary widget for our Entry box
* This requires an internal table ("model") with the possible
* auto-completion text entries */
/* Query for the requested object type */
q = qof_query_create_for (type);
qof_query_add_boolean_match(q, g_slist_prepend
(NULL, QOF_PARAM_ACTIVE), TRUE, QOF_QUERY_AND);
qof_query_set_book (q, book);
list = qof_query_run(q);
/* Setup the internal model */
list_store = gtk_list_store_new (GSL_N_COLUMNS, G_TYPE_STRING, G_TYPE_OBJECT);
for (it = list; it != NULL ; it = it->next)
{
char * name;
name = g_strdup(qof_object_printable(type, it->data));
/* Add a new row to the model */
if (name)
{
gtk_list_store_append (list_store, &iter);
gtk_list_store_set (list_store, &iter,
GSL_COLUMN_TEXT, name,
GSL_COLUMN_QOFOBJECT, G_OBJECT(it->data),
-1);
g_free(name);
}
}
qof_query_destroy(q);
/* Add the GtkEntryCompletion widget */
completion = gtk_entry_completion_new();
gtk_entry_completion_set_model(completion, GTK_TREE_MODEL(list_store));
gtk_entry_completion_set_text_column(completion, 0);
gtk_entry_completion_set_inline_completion(completion, TRUE);
gtk_entry_set_completion(GTK_ENTRY(gsl->entry), completion);
g_signal_connect (G_OBJECT (completion), "match_selected",
G_CALLBACK (gnc_gsl_match_selected_cb), gsl);
g_signal_connect (G_OBJECT (gsl->entry), "focus-out-event",
G_CALLBACK (gnc_gsl_focus_out_cb), gsl);
g_object_unref(completion);
gtk_widget_show (gsl->entry);
/* Add the search button */
gsl->button = gtk_button_new_with_label (label);
gtk_box_pack_start (GTK_BOX (gsl), gsl->button, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (gsl->button), "clicked",
G_CALLBACK (search_cb), gsl);
gtk_widget_show (gsl->button);
}
for(int i = 0; i < numOfAccounts; i++)
{
if(xaccAccountGetType(accountsList.at(i)) == 8)
{
expenseAccountsList.append(accountsList.at(i));
}
}
SplitQList splitsList = buildSplitListDateSort(expenseAccountsList);
buildMiniJournalStruct(splitsList);
}
#if 0
/* get all transactions earlier than the specified date */
QofQuery *qr = qof_query_create_for (GNC_ID_SPLIT);
qof_query_set_book(qr, ::gnc_account_get_book(selectedAccount));
// To look for dates, you need to create a "PredData" object
Timespec calve_date;
//calve_date = gdate_to_timespec(trans.getGDatePosted());
QofQueryPredData *pred_data = qof_query_date_predicate (QOF_COMPARE_LTE,
QOF_DATE_MATCH_NORMAL,
calve_date);
// and additionally a "query parameter" object
GSList *param_list = qof_query_build_param_list (TRANS_DATE_POSTED, NULL);
// The "PredData" and the "query parameter" object are added to this query
qof_query_add_term (qr, param_list, pred_data,
QOF_QUERY_FIRST_TERM);
// Query is run; result is returned
GtkWidget *
gnc_reconcile_view_new (Account *account, GNCReconcileViewType type,
time64 statement_date)
{
GNCReconcileView *view;
GtkListStore *liststore;
gboolean include_children, auto_check;
GList *accounts = NULL;
GList *splits;
Query *query;
g_return_val_if_fail (account, NULL);
g_return_val_if_fail ((type == RECLIST_DEBIT) ||
(type == RECLIST_CREDIT), NULL);
view = g_object_new (GNC_TYPE_RECONCILE_VIEW, NULL);
/* Create the list store with 6 columns and add to treeview,
column 0 will be a pointer to the entry */
liststore = gtk_list_store_new (6, G_TYPE_POINTER, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN );
gtk_tree_view_set_model (GTK_TREE_VIEW (view), GTK_TREE_MODEL (liststore));
g_object_unref (liststore);
view->account = account;
view->view_type = type;
view->statement_date = statement_date;
query = qof_query_create_for (GNC_ID_SPLIT);
qof_query_set_book (query, gnc_get_current_book ());
include_children = xaccAccountGetReconcileChildrenStatus (account);
if (include_children)
accounts = gnc_account_get_descendants (account);
/* match the account */
accounts = g_list_prepend (accounts, account);
xaccQueryAddAccountMatch (query, accounts, QOF_GUID_MATCH_ANY, QOF_QUERY_AND);
g_list_free (accounts);
/* limit the matches to CREDITs and DEBITs only, depending on the type */
if (type == RECLIST_CREDIT)
xaccQueryAddValueMatch(query, gnc_numeric_zero (),
QOF_NUMERIC_MATCH_CREDIT,
QOF_COMPARE_GTE, QOF_QUERY_AND);
else
xaccQueryAddValueMatch(query, gnc_numeric_zero (),
QOF_NUMERIC_MATCH_DEBIT,
QOF_COMPARE_GTE, QOF_QUERY_AND);
/* limit the matches only to Cleared and Non-reconciled splits */
xaccQueryAddClearedMatch (query, CLEARED_NO | CLEARED_CLEARED, QOF_QUERY_AND);
/* Initialize the QueryList */
gnc_reconcile_view_construct (view, query);
/* find the list of splits to auto-reconcile */
auto_check = gnc_prefs_get_bool (GNC_PREFS_GROUP_RECONCILE, GNC_PREF_CHECK_CLEARED);
if (auto_check)
{
time64 statement_date_day_end = gnc_time64_get_day_end(statement_date);
for (splits = qof_query_run (query); splits; splits = splits->next)
{
Split *split = splits->data;
char recn = xaccSplitGetReconcile (split);
time64 trans_date = xaccTransGetDate (xaccSplitGetParent (split));
/* Just an extra verification that our query is correct ;) */
g_assert (recn == NREC || recn == CREC);
if (recn == CREC &&
gnc_difftime (trans_date, statement_date_day_end) <= 0)
g_hash_table_insert (view->reconciled, split, split);
}
}
/* Free the query -- we don't need it anymore */
qof_query_destroy (query);
return GTK_WIDGET (view);
}
GNCSearchWindow *
gnc_employee_search (GncEmployee *start, QofBook *book)
{
QofIdType type = GNC_EMPLOYEE_MODULE_NAME;
struct _employee_select_window *sw;
QofQuery *q, *q2 = NULL;
static GList *params = NULL;
static GList *columns = NULL;
static GNCSearchCallbackButton buttons[] =
{
{ N_("View/Edit Employee"), edit_employee_cb, NULL, TRUE},
{ N_("Expense Vouchers"), invoice_employee_cb, NULL, TRUE},
{ N_("Process Payment"), payment_employee_cb, NULL, FALSE},
{ NULL },
};
g_return_val_if_fail (book, NULL);
/* Build parameter list in reverse order */
if (params == NULL)
{
params = gnc_search_param_prepend (params, _("Employee ID"), NULL, type,
EMPLOYEE_ID, NULL);
params = gnc_search_param_prepend (params, _("Employee Username"), NULL,
type, EMPLOYEE_USERNAME, NULL);
params = gnc_search_param_prepend (params, _("Employee Name"), NULL,
type, EMPLOYEE_ADDR, ADDRESS_NAME, NULL);
}
/* Build the column list in reverse order */
if (columns == NULL)
{
columns = gnc_search_param_prepend (columns, _("Username"), NULL, type,
EMPLOYEE_USERNAME, NULL);
columns = gnc_search_param_prepend (columns, _("ID #"), NULL, type,
EMPLOYEE_ID, NULL);
columns = gnc_search_param_prepend (columns, _("Name"), NULL, type,
EMPLOYEE_ADDR, ADDRESS_NAME, NULL);
}
/* Build the queries */
q = qof_query_create_for (type);
qof_query_set_book (q, book);
#if 0
if (start)
{
q2 = qof_query_copy (q);
qof_query_add_guid_match (q2, g_slist_prepend (NULL, QOF_PARAM_GUID),
gncEmployeeGetGUID (start), QOF_QUERY_AND);
}
#endif
/* launch select dialog and return the result */
sw = g_new0 (struct _employee_select_window, 1);
sw->book = book;
sw->q = q;
return gnc_search_dialog_create (type, _("Find Employee"),
params, columns, q, q2,
buttons, NULL, new_employee_cb,
sw, free_employee_cb,
GNC_PREFS_GROUP_SEARCH, NULL);
}
/*******************************************************
* account_splits
*
* gather the splits / transactions for an account and
* send them to a file
*******************************************************/
static
void account_splits (CsvExportInfo *info, Account *acc, FILE *fh )
{
Query *q;
GSList *p1, *p2;
GList *splits;
QofBook *book;
q = qof_query_create_for (GNC_ID_SPLIT);
book = gnc_get_current_book();
qof_query_set_book (q, book);
/* Sort by transaction date */
p1 = g_slist_prepend (NULL, TRANS_DATE_POSTED);
p1 = g_slist_prepend (p1, SPLIT_TRANS);
p2 = g_slist_prepend (NULL, QUERY_DEFAULT_SORT);
qof_query_set_sort_order (q, p1, p2, NULL);
xaccQueryAddSingleAccountMatch (q, acc, QOF_QUERY_AND);
xaccQueryAddDateMatchTT (q, TRUE, info->csvd.start_time, TRUE, info->csvd.end_time, QOF_QUERY_AND);
/* Run the query */
for (splits = qof_query_run (q); splits; splits = splits->next)
{
Split *split;
Transaction *trans;
SplitList *s_list;
GList *node;
Split *t_split;
int nSplits;
int cnt;
gchar *line;
split = splits->data;
trans = xaccSplitGetParent (split);
nSplits = xaccTransCountSplits (trans);
s_list = xaccTransGetSplitList (trans);
// Look for trans already exported in trans_list
if (g_list_find (info->trans_list, trans) != NULL)
continue;
// Simple Layout
if (info->simple_layout)
{
line = make_simple_trans_line (acc, trans, split, info);
/* Write to file */
if (!write_line_to_file (fh, line))
{
info->failed = TRUE;
break;
}
g_free (line);
continue;
}
// Complex Transaction Line.
line = make_complex_trans_line (acc, trans, split, info);
/* Write to file */
if (!write_line_to_file (fh, line))
{
info->failed = TRUE;
break;
}
g_free (line);
/* Loop through the list of splits for the Transaction */
node = s_list;
cnt = 0;
while ((cnt < nSplits) && (info->failed == FALSE))
{
t_split = node->data;
// Complex Split Line.
line = make_complex_split_line (trans, t_split, info);
if (!write_line_to_file (fh, line))
info->failed = TRUE;
g_free (line);
cnt++;
node = node->next;
}
info->trans_list = g_list_prepend (info->trans_list, trans); // add trans to trans_list
}
qof_query_destroy (q);
g_list_free (splits);
}
/*******************************************************
* account_splits
*
* gather the splits / transactions for an account and
* send them to a file
*******************************************************/
static
void account_splits (CsvExportInfo *info, Account *acc, FILE *fh )
{
Query *q;
GSList *p1, *p2;
GList *splits;
QofBook *book;
gchar *end_sep;
gchar *mid_sep;
q = qof_query_create_for(GNC_ID_SPLIT);
book = gnc_get_current_book();
qof_query_set_book (q, book);
/* Set up separators */
if (info->use_quotes)
{
end_sep = "\"";
mid_sep = g_strconcat ( "\"", info->separator_str, "\"", NULL);
}
else
{
end_sep = "";
mid_sep = g_strconcat ( info->separator_str, NULL);
}
/* Sort by transaction date */
p1 = g_slist_prepend (NULL, TRANS_DATE_POSTED);
p1 = g_slist_prepend (p1, SPLIT_TRANS);
p2 = g_slist_prepend (NULL, QUERY_DEFAULT_SORT);
qof_query_set_sort_order (q, p1, p2, NULL);
xaccQueryAddSingleAccountMatch (q, acc, QOF_QUERY_AND);
xaccQueryAddDateMatchTT (q, TRUE, info->csvd.start_time, TRUE, info->csvd.end_time, QOF_QUERY_AND);
/* Run the query */
for (splits = qof_query_run(q); splits; splits = splits->next)
{
Split *split;
Transaction *trans;
SplitList *s_list;
GList *node;
Split *t_split;
int nSplits;
int cnt;
gchar *part1;
gchar *part2;
gchar *date;
const gchar *currentSel;
const gchar *split_amount;
split = splits->data;
trans = xaccSplitGetParent(split);
nSplits = xaccTransCountSplits(trans);
s_list = xaccTransGetSplitList(trans);
/* Date */
date = qof_print_date ( xaccTransGetDate(trans));
part1 = g_strconcat ( end_sep, date, mid_sep, NULL);
g_free(date);
/* Name */
currentSel = xaccAccountGetName(acc);
part2 = g_strconcat ( part1, currentSel, mid_sep, NULL);
g_free(part1);
/* Number */
currentSel = gnc_get_num_action(trans, NULL);
part1 = g_strconcat ( part2, currentSel, mid_sep, NULL);
g_free(part2);
/* Description */
currentSel = xaccTransGetDescription(trans);
part2 = g_strconcat ( part1, currentSel, mid_sep, NULL);
g_free(part1);
/* Notes */
currentSel = xaccTransGetNotes(trans);
if (currentSel == NULL)
part1 = g_strconcat ( part2, mid_sep, NULL);
else
part1 = g_strconcat ( part2, currentSel, mid_sep, NULL);
g_free(part2);
/* Memo */
currentSel = xaccSplitGetMemo(split);
part2 = g_strconcat ( part1, currentSel, mid_sep, NULL);
g_free(part1);
/* Category */
currentSel = xaccSplitGetCorrAccountName(split);
part1 = g_strconcat ( part2, currentSel, mid_sep, "T", mid_sep, NULL);
g_free(part2);
/* Action */
currentSel = gnc_get_num_action(NULL, split);
part2 = g_strconcat ( part1, currentSel, mid_sep, NULL);
g_free(part1);
/* Reconcile */
switch (xaccSplitGetReconcile (split))
{
case NREC:
currentSel = "N";
break;
case CREC:
currentSel = "C";
break;
case YREC:
currentSel = "Y";
break;
case FREC:
currentSel = "F";
break;
case VREC:
currentSel = "V";
break;
default:
currentSel = "N";
}
part1 = g_strconcat ( part2, currentSel, mid_sep, NULL);
g_free(part2);
/* To with Symbol */
split_amount = xaccPrintAmount(xaccSplitGetAmount(split), gnc_split_amount_print_info(split, TRUE));
part2 = g_strconcat ( part1, split_amount, mid_sep, NULL);
g_free(part1);
/* From with Symbol */
part1 = g_strconcat ( part2, "", mid_sep, NULL);
g_free(part2);
/* To Number Only */
split_amount = xaccPrintAmount(xaccSplitGetAmount(split), gnc_split_amount_print_info(split, FALSE));
part2 = g_strconcat ( part1, split_amount, mid_sep, NULL);
g_free(part1);
/* From Number Only */
part1 = g_strconcat ( part2, "", mid_sep, "", mid_sep, "", end_sep, "\n", NULL);
g_free(part2);
/* Write to file */
if (!write_line_to_file(fh, part1))
{
info->failed = TRUE;
break;
}
g_free(part1);
/* Loop through the list of splits for the Transcation */
node = s_list;
cnt = 0;
while ( (cnt < nSplits) && (info->failed == FALSE))
{
t_split = node->data;
/* Start of line */
part1 = g_strconcat ( end_sep, mid_sep, mid_sep, mid_sep, mid_sep, mid_sep, NULL);
/* Memo */
currentSel = xaccSplitGetMemo(t_split);
part2 = g_strconcat ( part1, currentSel, mid_sep, NULL);
g_free(part1);
/* Account */
currentSel = xaccAccountGetName( xaccSplitGetAccount(t_split));
part1 = g_strconcat ( part2, currentSel, mid_sep, "S", mid_sep, NULL);
g_free(part2);
/* Action */
currentSel = gnc_get_num_action(NULL, t_split);
part2 = g_strconcat ( part1, currentSel, mid_sep, NULL);
g_free(part1);
/* Reconcile */
switch (xaccSplitGetReconcile (split))
{
case NREC:
currentSel = "N";
break;
case CREC:
currentSel = "C";
break;
case YREC:
currentSel = "Y";
break;
case FREC:
currentSel = "F";
break;
case VREC:
currentSel = "V";
break;
default:
currentSel = "N";
}
part1 = g_strconcat ( part2, currentSel, mid_sep, NULL);
g_free(part2);
/* From / To with Symbol */
split_amount = xaccPrintAmount(xaccSplitGetAmount(t_split), gnc_split_amount_print_info(t_split, TRUE));
if (xaccSplitGetAccount(t_split) == acc)
part2 = g_strconcat ( part1, split_amount, mid_sep, mid_sep, NULL);
else
part2 = g_strconcat ( part1, mid_sep, split_amount, mid_sep, NULL);
g_free(part1);
/* From / To Numbers only */
split_amount = xaccPrintAmount(xaccSplitGetAmount(t_split), gnc_split_amount_print_info(t_split, FALSE));
if (xaccSplitGetAccount(t_split) == acc)
part1 = g_strconcat ( part2, split_amount, mid_sep, mid_sep, NULL);
else
part1 = g_strconcat ( part2, mid_sep, split_amount, mid_sep, NULL);
g_free(part2);
/* From / To - Share Price / Conversion factor */
split_amount = xaccPrintAmount(xaccSplitGetSharePrice(t_split), gnc_split_amount_print_info(t_split, FALSE));
if (xaccSplitGetAccount(t_split) == acc)
part2 = g_strconcat ( part1, split_amount, mid_sep, end_sep, "\n", NULL);
else
part2 = g_strconcat ( part1, mid_sep, split_amount, end_sep, "\n", NULL);
g_free(part1);
if (!write_line_to_file(fh, part2))
info->failed = TRUE;
g_free(part2);
cnt++;
node = node->next;
}
}
g_free(mid_sep);
qof_query_destroy (q);
g_list_free( splits );
}
static void
search_update_query (GNCSearchWindow *sw)
{
static GSList *active_params = NULL;
QofQuery *q, *q2, *new_q;
GList *node;
QofQueryOp op;
QofQueryPredData* pdata;
if (sw->grouping == GNC_SEARCH_MATCH_ANY)
op = QOF_QUERY_OR;
else
op = QOF_QUERY_AND;
if (active_params == NULL)
active_params = g_slist_prepend (NULL, QOF_PARAM_ACTIVE);
/* Make sure we supply a book! */
if (sw->start_q == NULL)
{
sw->start_q = qof_query_create_for (sw->search_for);
qof_query_set_book (sw->start_q, gnc_get_current_book ());
}
else
{
/* We've got a query -- purge it of any "active" parameters */
qof_query_purge_terms (sw->start_q, active_params);
}
/* Now create a new query to work from */
q = qof_query_create_for (sw->search_for);
/* Walk the list of criteria */
for (node = sw->crit_list; node; node = node->next)
{
struct _crit_data *data = node->data;
pdata = gnc_search_core_type_get_predicate (data->element);
if (pdata)
qof_query_add_term (q, gnc_search_param_get_param_path (data->param),
pdata, op);
}
/* Now combine this query with the existing query, depending on
* what we want to do... We can assume that cases 1, 2, and 3
* already have sw->q being valid!
*/
switch (sw->search_type)
{
case 0: /* New */
new_q = qof_query_merge (sw->start_q, q, QOF_QUERY_AND);
qof_query_destroy (q);
break;
case 1: /* Refine */
new_q = qof_query_merge (sw->q, q, QOF_QUERY_AND);
qof_query_destroy (q);
break;
case 2: /* Add */
new_q = qof_query_merge (sw->q, q, QOF_QUERY_OR);
qof_query_destroy (q);
break;
case 3: /* Delete */
q2 = qof_query_invert (q);
new_q = qof_query_merge (sw->q, q2, QOF_QUERY_AND);
qof_query_destroy (q2);
qof_query_destroy (q);
break;
default:
g_warning ("bad search type: %d", sw->search_type);
new_q = q;
break;
}
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (sw->active_only_check)))
{
qof_query_add_boolean_match (new_q, active_params, TRUE, QOF_QUERY_AND);
active_params = NULL;
}
/* Destroy the old query */
if (sw->q)
qof_query_destroy (sw->q);
/* And save the new one */
sw->q = new_q;
}
GNCSearchWindow *
gnc_job_search (GncJob *start, GncOwner *owner, QofBook *book)
{
QofQuery *q, *q2 = NULL;
QofIdType type = GNC_JOB_MODULE_NAME;
struct _job_select_window *sw;
static GList *params = NULL;
static GList *columns = NULL;
static GNCSearchCallbackButton buttons[] =
{
{ N_("View/Edit Job"), edit_job_cb, NULL, TRUE},
{ N_("View Invoices"), invoice_job_cb, NULL, TRUE},
{ N_("Process Payment"), payment_job_cb, NULL, FALSE},
{ NULL },
};
g_return_val_if_fail (book, NULL);
/* Build parameter list in reverse order */
if (params == NULL)
{
params = gnc_search_param_prepend (params, _("Owner's Name"), NULL, type,
JOB_OWNER, OWNER_NAME, NULL);
params = gnc_search_param_prepend (params, _("Only Active?"), NULL, type,
JOB_ACTIVE, NULL);
params = gnc_search_param_prepend (params, _("Billing ID"), NULL, type,
JOB_REFERENCE, NULL);
params = gnc_search_param_prepend (params, _("Job Number"), NULL, type,
JOB_ID, NULL);
params = gnc_search_param_prepend (params, _("Job Name"), NULL, type,
JOB_NAME, NULL);
}
/* Build the column list in reverse order */
if (columns == NULL)
{
columns = gnc_search_param_prepend (columns, _("Billing ID"), NULL, type,
JOB_REFERENCE, NULL);
columns = gnc_search_param_prepend (columns, _("Company"), NULL, type,
JOB_OWNER, OWNER_NAME, NULL);
columns = gnc_search_param_prepend (columns, _("Job Name"), NULL, type,
JOB_NAME, NULL);
columns = gnc_search_param_prepend (columns, _("ID #"), NULL, type,
JOB_ID, NULL);
}
/* Build the queries */
q = qof_query_create_for (type);
qof_query_set_book (q, book);
/* If we have a start job but, for some reason, not an owner -- grab
* the owner from the starting job.
*/
if ((!owner || !gncOwnerGetGUID (owner)) && start)
owner = gncJobGetOwner (start);
/* If owner is supplied, limit all searches to invoices who's owner
* is the supplied owner! Show all invoices by this owner.
*/
if (owner && gncOwnerGetGUID (owner))
{
qof_query_add_guid_match (q, g_slist_prepend
(g_slist_prepend (NULL, QOF_PARAM_GUID),
JOB_OWNER),
gncOwnerGetGUID (owner), QOF_QUERY_AND);
q2 = qof_query_copy (q);
}
#if 0
if (start)
{
if (q2 == NULL)
q2 = qof_query_copy (q);
qof_query_add_guid_match (q2, g_slist_prepend (NULL, QOF_PARAM_GUID),
gncJobGetGUID (start), QOF_QUERY_AND);
}
#endif
/* launch select dialog and return the result */
sw = g_new0 (struct _job_select_window, 1);
if (owner)
{
gncOwnerCopy (owner, &(sw->owner_def));
sw->owner = &(sw->owner_def);
}
sw->book = book;
sw->q = q;
return gnc_search_dialog_create (type, _("Find Job"),
params, columns, q, q2, buttons, NULL,
new_job_cb, sw, free_userdata_cb,
GCONF_SECTION_SEARCH, NULL);
}
GNCSearchWindow *
gnc_customer_search (GncCustomer *start, QofBook *book)
{
QofQuery *q, *q2 = NULL;
QofIdType type = GNC_CUSTOMER_MODULE_NAME;
struct _customer_select_window *sw;
static GList *params = NULL;
static GList *columns = NULL;
static GNCSearchCallbackButton buttons[] =
{
{ N_("View/Edit Customer"), edit_customer_cb, NULL, TRUE},
{ N_("Customer's Jobs"), jobs_customer_cb, NULL, TRUE},
// { N_("Customer's Orders"), order_customer_cb, NULL, TRUE},
{ N_("Customer's Invoices"), invoice_customer_cb, NULL, TRUE},
{ N_("Process Payment"), payment_customer_cb, NULL, FALSE},
{ NULL },
};
(void)order_customer_cb;
g_return_val_if_fail (book, NULL);
/* Build parameter list in reverse order */
if (params == NULL)
{
params = gnc_search_param_prepend (params, _("Shipping Contact"), NULL, type,
CUSTOMER_SHIPADDR, ADDRESS_NAME, NULL);
params = gnc_search_param_prepend (params, _("Billing Contact"), NULL, type,
CUSTOMER_ADDR, ADDRESS_NAME, NULL);
params = gnc_search_param_prepend (params, _("Customer ID"), NULL, type,
CUSTOMER_ID, NULL);
params = gnc_search_param_prepend (params, _("Company Name"), NULL, type,
CUSTOMER_NAME, NULL);
}
/* Build the column list in reverse order */
if (columns == NULL)
{
columns = gnc_search_param_prepend (columns, _("Contact"), NULL, type,
CUSTOMER_ADDR, ADDRESS_NAME, NULL);
columns = gnc_search_param_prepend (columns, _("Company"), NULL, type,
CUSTOMER_NAME, NULL);
columns = gnc_search_param_prepend (columns, _("ID #"), NULL, type,
CUSTOMER_ID, NULL);
}
/* Build the queries */
q = qof_query_create_for (type);
qof_query_set_book (q, book);
#if 0
if (start)
{
q2 = qof_query_copy (q);
qof_query_add_guid_match (q2, g_slist_prepend (NULL, QOF_PARAM_GUID),
gncCustomerGetGUID (start), QOF_QUERY_AND);
}
#endif
/* launch select dialog and return the result */
sw = g_new0 (struct _customer_select_window, 1);
sw->book = book;
sw->q = q;
return gnc_search_dialog_create (type, _("Find Customer"),
params, columns, q, q2, buttons, NULL,
new_customer_cb, sw, free_userdata_cb,
GCONF_SECTION_SEARCH, NULL);
}