Files
file	dialog-bi-import-gui.h
	GUI handling for bi-import plugin.

file	dialog-bi-import.h
	core import functions for invoice import plugin

file	gnc-plugin-bi-import.h
	Plugin registration of the bi-import module.

file	dialog-customer-import-gui.h
	GUI handling for customer import plugin.

file	dialog-customer-import.h
	core import functions for customer import plugin

file	gnc-plugin-customer-import.h
	Plugin registration of the customer_import module.

Data Structures
struct	bi_import_stats

struct	customer_import_stats

Macros
#define	GNC_TYPE_PLUGIN_example (gnc_plugin_example_get_type())

#define	GNC_PLUGIN_EXAMPLE_NAME "gnc-plugin-example"

#define	GNC_TYPE_PLUGIN_BI_IMPORT (gnc_plugin_bi_import_get_type())

#define	GNC_PLUGIN_BI_IMPORT_NAME "gnc-plugin-bi-import"

#define	GNC_TYPE_PLUGIN_CUSTOMER_IMPORT (gnc_plugin_customer_import_get_type())

#define	GNC_PLUGIN_CUSTOMER_IMPORT_NAME "gnc-plugin-customer-import"

Typedefs
typedef typedefG_BEGIN_DECLS struct _bi_import_gui	BillImportGui

typedef enum _bi_import_result	bi_import_result

typedef typedefG_BEGIN_DECLS struct _customer_import_gui	CustomerImportGui

typedef enum _customer_import_result	customer_import_result

Enumerations
enum	bi_import_model_columns { ID, DATE_OPENED, OWNER_ID, BILLING_ID, NOTES, DATE, DESC, ACTION, ACCOUNT, QUANTITY, PRICE, DISC_TYPE, DISC_HOW, DISCOUNT, TAXABLE, TAXINCLUDED, TAX_TABLE, DATE_POSTED, DUE_DATE, ACCOUNT_POSTED, MEMO_POSTED, ACCU_SPLITS, N_COLUMNS }

enum	_bi_import_result { RESULT_OK, RESULT_OPEN_FAILED, RESULT_ERROR_IN_REGEXP }

enum	customer_import_model_columns { CI_ID, CI_COMPANY, CI_NAME, CI_ADDR1, CI_ADDR2, CI_ADDR3, CI_ADDR4, CI_PHONE, CI_FAX, CI_EMAIL, CI_NOTES, CI_SHIPNAME, CI_SHIPADDR1, CI_SHIPADDR2, CI_SHIPADDR3, CI_SHIPADDR4, CI_SHIPPHONE, CI_SHIPFAX, CI_SHIPEMAIL, CI_N_COLUMNS }

enum	_customer_import_result { CI_RESULT_OK, CI_RESULT_OPEN_FAILED, CI_RESULT_ERROR_IN_REGEXP }

Functions
GncPlugin *	gnc_plugin_example_new (void)

void	gnc_plugin_example_create_plugin (void)
	Create a new GncPluginexample object and register it.

BillImportGui *	gnc_plugin_bi_import_showGUI (GtkWindow *parent)
	File chooser.

bi_import_result	gnc_bi_import_read_file (const gchar filename, const gchar parser_regexp, GtkListStore store, guint max_rows, bi_import_stats stats)
	Imports a csv file with invoice data into a GtkListStore. More...

void	gnc_bi_import_fix_bis (GtkListStore store, guint fixed, guint deleted, GString info, gchar *type)
	Adjusts and validates invoice import data. More...

void	gnc_bi_import_create_bis (GtkListStore store, QofBook book, guint n_invoices_created, guint n_invoices_updated, guint n_rows_ignored, gchar type, gchar open_mode, GString info, GtkWindow *parent)
	Creates and updates invoices from validated import data. More...

GncPlugin *	gnc_plugin_bi_import_new (void)

void	gnc_plugin_bi_import_create_plugin (void)
	Create a new GncPluginbi_import object and register it.

CustomerImportGui *	gnc_plugin_customer_import_showGUI (GtkWindow *parent)
	File chooser.

customer_import_result	gnc_customer_import_read_file (const gchar filename, const gchar parser_regexp, GtkListStore store, guint max_rows, customer_import_stats stats)

void	gnc_customer_import_fix_customers (GtkListStore store, guint fixed, guint deleted, gchar type)

void	gnc_customer_import_create_customers (GtkListStore store, QofBook book, guint n_customers_created, guint n_customers_updated, gchar *type)

GncPlugin *	gnc_plugin_customer_import_new (void)

void	gnc_plugin_customer_import_create_plugin (void)
	Create a new GncPlugincustomer_import object and register it.

Detailed Description

Function Documentation

◆ gnc_bi_import_create_bis()

void gnc_bi_import_create_bis	(	GtkListStore *	store,
		QofBook *	book,
		guint *	n_invoices_created,
		guint *	n_invoices_updated,
		guint *	n_rows_ignored,
		gchar *	type,
		gchar *	open_mode,
		GString *	info,
		GtkWindow *	parent
	)

Creates and updates invoices from validated import data.

Loops through the import data to create and update invoices. The first data row for an invoice is assumed to hold the header data.

If an invoice already exists, the user is asked, once per import, to confirm that invoices should be updated. If not confirmed, any rows for existing invoices are ignored. If confirmed, entries are added to existing invoices. Posted invoices, however, are never updated.

If the field date_posted is set, the system will attempt to also post the invoice. The system will not post the invoice if the entries of the invoice hold different currencies, or if the currency of the invoice differs from the currency of the account_posted.

As per user selection, the system displays tabs for either all affected invoices, all affected invoices not yet posted, or no invoices at all.

Definition at line 605 of file dialog-bi-import.c.

 {
     gboolean valid, on_first_row_of_invoice, invoice_posted;
     GtkTreeIter iter, first_row_of_invoice;
     gchar *id = NULL, *date_opened = NULL, *owner_id = NULL, *billing_id = NULL, *notes = NULL;
     gchar *date = NULL, *desc = NULL, *action = NULL, *account = NULL, *quantity = NULL,
           *price = NULL, *disc_type = NULL, *disc_how = NULL, *discount = NULL, *taxable = NULL,
           *taxincluded = NULL, *tax_table = NULL;
     gchar *date_posted = NULL, *due_date = NULL, *account_posted = NULL, *memo_posted = NULL,
           *accumulatesplits = NULL;
     guint dummy;
     GncInvoice *invoice;
     GncEntry *entry;
     gint day, month, year;
     gnc_numeric value;
     GncOwner *owner;
     Account *acc = NULL;
     enum update {YES = GTK_RESPONSE_YES, NO = GTK_RESPONSE_NO, NOT_ASKED = GTK_RESPONSE_NONE} update;
     GtkWidget *dialog;
     time64 today;
     InvoiceWindow *iw;
     GString *running_id;
 
     // these arguments are needed
     g_return_if_fail (store && book);
     // logic of this function only works for bills or invoices
     g_return_if_fail ((g_ascii_strcasecmp (type, "INVOICE") == 0) ||
             (g_ascii_strcasecmp (type, "BILL") == 0));
 
     // allow to call this function without statistics
     if (!n_invoices_created)
         n_invoices_created = &dummy;
     if (!n_invoices_updated)
         n_invoices_updated = &dummy;
     *n_invoices_created = 0;
     *n_invoices_updated = 0;
 
     invoice = NULL;
     update = NOT_ASKED;
     on_first_row_of_invoice = TRUE;
     running_id = g_string_new("");
 
     g_string_append_printf (info, "\n%s\n", _("Processing…") );
 
     valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter);
     while (valid)
     {
         // Walk through the list, reading each row
         gtk_tree_model_get (GTK_TREE_MODEL (store), &iter,
                             ID, &id,
                             DATE_OPENED, &date_opened,
                             DATE_POSTED, &date_posted,       // if autoposting requested
                             DUE_DATE, &due_date,             // if autoposting requested
                             ACCOUNT_POSTED, &account_posted, // if autoposting requested
                             MEMO_POSTED, &memo_posted,       // if autoposting requested
                             ACCU_SPLITS, &accumulatesplits,  // if autoposting requested
                             OWNER_ID, &owner_id,
                             BILLING_ID, &billing_id,
                             NOTES, &notes,
                             DATE, &date,
                             DESC, &desc,
                             ACTION, &action,
                             ACCOUNT, &account,
                             QUANTITY, &quantity,
                             PRICE, &price,
                             DISC_TYPE, &disc_type,
                             DISC_HOW, &disc_how,
                             DISCOUNT, &discount,
                             TAXABLE, &taxable,
                             TAXINCLUDED, &taxincluded,
                             TAX_TABLE, &tax_table, -1);
 
         if (on_first_row_of_invoice)
         {
             g_string_assign(running_id, id);
             first_row_of_invoice = iter;
 
             if (g_ascii_strcasecmp (type, "BILL") == 0)
                 invoice = gnc_search_bill_on_id (book, id);
             else if (g_ascii_strcasecmp (type, "INVOICE") == 0)
                 invoice = gnc_search_invoice_on_id (book, id);
             DEBUG( "Existing %s ID: %s\n", type, gncInvoiceGetID(invoice));
 
             // If the search is empty then there is no existing invoice so make a new one
             if (invoice == NULL)
             {
                  DEBUG( "Creating a new : %s\n", type );
                 // new invoice
                 invoice = gncInvoiceCreate (book);
                 /* Protect against thrashing the DB and trying to write the invoice
                  * record prematurely */
                 gncInvoiceBeginEdit (invoice);
                 gncInvoiceSetID (invoice, id);
                 owner = gncOwnerNew ();
                 if (g_ascii_strcasecmp (type, "BILL") == 0)
                     gncOwnerInitVendor (owner,
                                         gnc_search_vendor_on_id (book, owner_id));
                 else if (g_ascii_strcasecmp (type, "INVOICE") == 0)
                     gncOwnerInitCustomer (owner,
                                           gnc_search_customer_on_id (book, owner_id));
                 gncInvoiceSetOwner (invoice, owner);
                 gncInvoiceSetCurrency (invoice, gncOwnerGetCurrency (owner));   // Set the invoice currency based on the owner
                 qof_scan_date (date_opened, &day, &month, &year);
                 gncInvoiceSetDateOpened (invoice,
                                          gnc_dmy2time64 (day, month, year));
                 gncInvoiceSetBillingID (invoice, billing_id ? billing_id : "");
                 notes = un_escape(notes);
                 gncInvoiceSetNotes (invoice, notes ? notes : "");
                 gncInvoiceSetActive (invoice, TRUE);
                 //if (g_ascii_strcasecmp(type,"INVOICE"))gncInvoiceSetBillTo( invoice, billto );
                 (*n_invoices_created)++;
                 g_string_append_printf (info, _("Invoice %s created.\n"),id);
 
                 gncInvoiceCommitEdit (invoice);
             }
             else            // Dealing with an existing invoice.
             {
                 // For the first existing invoice in the import file,
                 // ask the user to confirm update of existing invoices.
                 if (update == NOT_ASKED)
                 {
                     dialog = gtk_message_dialog_new (parent,
                                                      GTK_DIALOG_MODAL,
                                                      GTK_MESSAGE_ERROR,
                                                      GTK_BUTTONS_YES_NO,
                                                      "%s",
                                                      _("Do you want to update existing bills/invoices?"));
                     update = gtk_dialog_run (GTK_DIALOG (dialog));
                     gtk_widget_destroy (dialog);
                 }
 
                 if (update == NO)
                 {
                     // If the user does not want to update existing invoices, ignore all rows of the invoice.
                     g_string_append_printf (info,_("Invoice %s not updated because it already exists.\n"),id);
                     while (valid && g_strcmp0 (id, running_id->str) == 0)
                     {
                         (*n_rows_ignored)++;
                         valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter);
                         if (valid)
                             gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, ID, &id, -1);
                     }
                     on_first_row_of_invoice = TRUE;
                     continue;
                 }
 
                 if (gncInvoiceIsPosted (invoice))
                 {
                     // If the invoice is already posted, ignore all rows of the invoice.
                     g_string_append_printf (info,_("Invoice %s not updated because it is already posted.\n"),id);
                     while (valid && g_strcmp0 (id, running_id->str) == 0)
                     {
                         (*n_rows_ignored)++;
                         valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter);
                         if (valid)
                             gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, ID, &id, -1);
                     }
                     on_first_row_of_invoice = TRUE;
                     continue;
                 }
 
                 (*n_invoices_updated)++;
                 g_string_append_printf (info, _("Invoice %s updated.\n"),id);
             }
         }
 
         // Add entry to invoice/bill
         entry = gncEntryCreate (book);
         gncEntryBeginEdit(entry);
         qof_scan_date (date, &day, &month, &year);
         {
             GDate *date = g_date_new_dmy(day, month, year);
             gncEntrySetDateGDate (entry, date);
             g_date_free (date);
         }
         today = gnc_time (NULL);
         gncEntrySetDateEntered(entry, today);
         // Remove escaped quotes
         desc = un_escape(desc);
         notes = un_escape(notes);
         gncEntrySetDescription (entry, desc);
         gncEntrySetAction (entry, action);
         value = gnc_numeric_zero();
         gnc_exp_parser_parse (quantity, &value, NULL);
         gncEntrySetQuantity (entry, value);
         acc = gnc_account_lookup_for_register (gnc_get_current_root_account (),
                                                account);
 
         if (g_ascii_strcasecmp (type, "BILL") == 0)
         {
             gncEntrySetBillAccount (entry, acc);
             value = gnc_numeric_zero();
             gnc_exp_parser_parse (price, &value, NULL);
             gncEntrySetBillPrice (entry, value);
             gncEntrySetBillTaxable (entry, text2bool (taxable));
             gncEntrySetBillTaxIncluded (entry, text2bool (taxincluded));
             gncEntrySetBillTaxTable (entry, gncTaxTableLookupByName (book, tax_table));
             gncBillAddEntry (invoice, entry);
         }
         else if (g_ascii_strcasecmp (type, "INVOICE") == 0)
         {
             gncEntrySetNotes (entry, notes);
             gncEntrySetInvAccount (entry, acc);
             value = gnc_numeric_zero();
             gnc_exp_parser_parse (price, &value, NULL);
             gncEntrySetInvPrice (entry, value);
             gncEntrySetInvTaxable (entry, text2bool (taxable));
             gncEntrySetInvTaxIncluded (entry, text2bool (taxincluded));
             gncEntrySetInvTaxTable (entry, gncTaxTableLookupByName (book, tax_table));
             value = gnc_numeric_zero();
             gnc_exp_parser_parse (discount, &value, NULL);
             gncEntrySetInvDiscount (entry, value);
             gncEntrySetInvDiscountType (entry, text2disc_type (disc_type));
             gncEntrySetInvDiscountHow (entry, text2disc_how (disc_how));
             gncInvoiceAddEntry (invoice, entry);
         }
         gncEntryCommitEdit(entry);
         valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter);
         // handle auto posting of invoices
 
         if (valid)
             gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, ID, &id, -1);
         else
             id = NULL;
 
         if (g_strcmp0 (id, running_id->str) == 0) // The next row is for the same invoice.
         {
             on_first_row_of_invoice = FALSE;
         }
         else // The next row is for a new invoice; try to post the invoice.
         {
             // Use posting values from the first row of this invoice.
             gtk_tree_model_get (GTK_TREE_MODEL (store), &first_row_of_invoice,
                                 ID, &id,
                                 DATE_POSTED, &date_posted,
                                 DUE_DATE, &due_date,
                                 ACCOUNT_POSTED, &account_posted,
                                 MEMO_POSTED, &memo_posted,
                                 ACCU_SPLITS, &accumulatesplits, -1);
             invoice_posted = FALSE;
 
             if (strlen(date_posted) != 0)
             {
                 // autopost this invoice
                 GHashTable *foreign_currs;
                 gboolean auto_pay;
                 time64 p_date, d_date;
                 guint curr_count;
                 gboolean scan_date_r;
                 scan_date_r = qof_scan_date (date_posted, &day, &month, &year);
                 DEBUG("Invoice %s is marked to be posted because...", id);
                 DEBUG("qof_scan_date = %d", scan_date_r);
                 if (g_ascii_strcasecmp (type, "INVOICE") == 0)
                     auto_pay = gnc_prefs_get_bool (GNC_PREFS_GROUP_INVOICE, GNC_PREF_AUTO_PAY);
                 else
                     auto_pay = gnc_prefs_get_bool (GNC_PREFS_GROUP_BILL, GNC_PREF_AUTO_PAY);
                 // Do we have any foreign currencies to deal with?
                 foreign_currs = gncInvoiceGetForeignCurrencies (invoice);
                 curr_count = g_hash_table_size (foreign_currs);
                 DEBUG("curr_count = %d",curr_count);
                 // Only auto-post if there's a single currency involved
                 if(curr_count == 0)
                 {
                     acc = gnc_account_lookup_for_register
                           (gnc_get_current_root_account (), account_posted);
                     // Check if the currencies match
                     if(gncInvoiceGetCurrency(invoice) == gnc_account_get_currency_or_parent(acc))
                     {
                         qof_scan_date (date_posted, &day, &month, &year);
                         p_date = gnc_dmy2time64 (day, month, year);
                         qof_scan_date (due_date, &day, &month, &year);
                         d_date = gnc_dmy2time64 (day, month, year);
                         gncInvoicePostToAccount (invoice, acc, p_date, d_date,
                                              memo_posted,
                                              text2bool (accumulatesplits),
                                              auto_pay);
                         PWARN("Invoice %s posted",id);
                         invoice_posted = TRUE;
                         g_string_append_printf (info, _("Invoice %s posted.\n"),id);
                     }
                     else // No match! Don't post it.
                     {
                         PWARN("Invoice %s NOT posted because currencies don't match", id);
                         g_string_append_printf (info,_("Invoice %s NOT posted because currencies don't match.\n"), id);
                     }
                 }
                 else
                 {
                     PWARN("Invoice %s NOT posted because it requires currency conversion.",id);
                     g_string_append_printf (info,_("Invoice %s NOT posted because it requires currency conversion.\n"),id);
                 }
                 g_hash_table_unref (foreign_currs);
             }
             else
             {
                 PWARN("Invoice %s is NOT marked for posting",id);
             }
 
             // open new bill / invoice in a tab, if requested
             if (g_ascii_strcasecmp(open_mode, "ALL") == 0
                     || (g_ascii_strcasecmp(open_mode, "NOT_POSTED") == 0
                         && !invoice_posted))
             {
                 iw =  gnc_ui_invoice_edit (parent, invoice);
                 gnc_plugin_page_invoice_new (iw);
             }
 
             // The next row will be for a new invoice.
             on_first_row_of_invoice = TRUE;
         }
     }
 
     if (*n_invoices_updated + *n_invoices_created == 0)
         g_string_append_printf (info, _("Nothing to process.\n"));
 
     // cleanup
     g_free (id);
     g_free (date_opened);
     g_free (owner_id);
     g_free (billing_id);
     g_free (notes);
     g_free (date);
     g_free (desc);
     g_free (action);
     g_free (account);
     g_free (quantity);
     g_free (price);
     g_free (disc_type);
     g_free (disc_how);
     g_free (discount);
     g_free (taxable);
     g_free (taxincluded);
     g_free (tax_table);
     g_free (date_posted);
     g_free (due_date);
     g_free (account_posted);
     g_free (memo_posted);
     g_free (accumulatesplits);
 
     g_string_free (running_id, TRUE);
 }

◆ gnc_bi_import_fix_bis()

void gnc_bi_import_fix_bis	(	GtkListStore *	store,
		guint *	n_rows_fixed,
		guint *	n_rows_ignored,
		GString *	info,
		gchar *	type
	)

Adjusts and validates invoice import data.

Replaces missing or invalid data with defaults:

if quantity is not set, default to 1
if date_opened is not set or invalid, default to today
if date is not set or invalid, default to date_opened
if due date is not set or invalid, default to date_posted

Validates the import data; any error causes all rows of the same invoice to be deleted from the import data:

id is not set, and there is no previous id
owner_id is not set, or customer/vendor does not exist
date_posted is not valid
account_posted does not exist
account posted is not the applicable type, A/P or A/R
price is not set
account does not exist

Adjustment and validation for header fields is only done for the first row of an invoice, which is assumed to hold the header data for all items of the same invoice. Currency related validation is done in subsqequent processing by gnc_bi_import_create_bis.

Parameters

store	Holds the rows of invoice import data
n_rows_fixed	Increased for every data row that is adjusted in this function
n_rows_ignored	Increased for every data row that is deleted in this function
info	Updated with the error messages from this function
type	The type of the import data, BILL or INVOICE

Definition at line 276 of file dialog-bi-import.c.

 {
     GtkTreeIter iter, first_row_of_invoice;
     gboolean valid, row_fixed, on_first_row_of_invoice, ignore_invoice;
     gchar *id = NULL, *date_opened = NULL, *date_posted = NULL, *due_date = NULL, *account_posted = NULL,
         *owner_id = NULL, *date = NULL, *account = NULL, *quantity = NULL, *price = NULL;
     GString *running_id;
     Account *acc = NULL;
     guint dummy;
     gint row = 1, fixed_for_invoice = 0, invoice_line = 0;
     const gchar* date_format_string = qof_date_format_get_string (qof_date_format_get()); // Get the user set date format string
 
     DEBUG("date_format_string: %s",date_format_string);
     // allow the call to this function with only GtkListeStore* specified
     if (!n_rows_fixed)
         n_rows_fixed = &dummy;
     if (!n_rows_ignored)
         n_rows_ignored = &dummy;
 
     *n_rows_fixed = 0;
     *n_rows_ignored = 0;
 
     // Init control variables
     running_id = g_string_new("");
     ignore_invoice = FALSE;
     on_first_row_of_invoice = TRUE;
     
     g_string_append_printf (info, _("Validation…\n") );
 
     // Walk through the list, reading each row.
     valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter);
     while (valid)
     {
         ++invoice_line;
         row_fixed = FALSE;
 
         //  If this is a row for a new invoice id, validate header values.
         if (on_first_row_of_invoice)
         {
             gtk_tree_model_get (GTK_TREE_MODEL (store), &iter,
                                 ID, &id,
                                 DATE_OPENED, &date_opened,
                                 DATE_POSTED, &date_posted,
                                 DUE_DATE, &due_date,
                                 ACCOUNT_POSTED, &account_posted,
                                 OWNER_ID, &owner_id, -1);
 
             g_string_assign (running_id, id);
             first_row_of_invoice = iter;
 
             // Validate the invoice id.
             if (strlen (id) == 0)
             {
                 // If there was an earlier valid id, then it replaces an empty id when the next row is read at the end of the loop.
                 // So an empty id error can only happen on the first row of an import file.
                 ignore_invoice = TRUE;
                 g_string_append_printf (info,
                                         _("Row %d: no invoice ID in first row of import file.\n"), row);
             }
 
             // Validate customer or vendor.
             if (strlen (owner_id) == 0)
             {
                 ignore_invoice = TRUE;
                 g_string_append_printf (info,
                                         _("Row %d, invoice %s/%u: owner not set.\n"),
                                         row, id, invoice_line);
             }
             // Verify that customer or vendor exists.
             if (g_ascii_strcasecmp (type, "BILL") == 0)
             {
                 if (!gnc_search_vendor_on_id
                     (gnc_get_current_book (), owner_id))
                 {
                     // Vendor not found.
                     ignore_invoice = TRUE;
                     g_string_append_printf (info,
                                             _("Row %d, invoice %s/%u: vendor %s does not exist.\n"),
                                             row, id, invoice_line, owner_id);
                 }
             }
             else if (g_ascii_strcasecmp (type, "INVOICE") == 0)
             {
                 if (!gnc_search_customer_on_id
                     (gnc_get_current_book (), owner_id))
                 {
                     // Customer not found.
                     ignore_invoice = TRUE;
                     g_string_append_printf (info,
                                             _("Row %d, invoice %s/%u: customer %s does not exist.\n"),
                                             row, id, invoice_line, owner_id);
                 }
             }
 
             if (strlen(date_posted) != 0)
             {
                 // Validate the date posted and due date.
                 if (!isDateValid(date_posted))
                 {
                     // Invalid date posted in first row of invoice, ignore the invoice
                     ignore_invoice = TRUE;
                     g_string_append_printf (info,
                                             _("Row %d, invoice %s/%u: %s is not a valid posting date.\n"),
                                             row, id, invoice_line, date_posted);
 
                     // Verify the due date.
                     if (!isDateValid(due_date))
                     {
                         // Invalid due date in first row of invoice, without valid posting date to substitute.
                         g_string_append_printf (info,
                                                 _("Row %d, invoice %s/%u: %s is not a valid due date.\n"),
                                                 row, id, invoice_line, due_date);
                     }
                 }
                 else
                 {
                     // Verify the due date.
                     if (!isDateValid(due_date))
                     {
                         // Fix this by using the date posted.
                         gtk_list_store_set (store, &iter, DUE_DATE,
                                             date_posted, -1);
                         row_fixed = TRUE;
                     }
                 }
 
             // Validate account posted.
             // Account should exists, and should be of type A/R for invoices, A/P for bills.
                  acc = gnc_account_lookup_for_register
                 (gnc_get_current_root_account (), account_posted);
                 if (acc == NULL)
                 {
                     ignore_invoice = TRUE;
                     g_string_append_printf (info,
                                             _("Row %d, invoice %s/%u: account %s does not exist.\n"),
                                             row, id, invoice_line, account_posted);
                 }
                 else
                 {
                     if (g_ascii_strcasecmp (type, "BILL") == 0)
                     {
 
                         if (xaccAccountGetType (acc) != ACCT_TYPE_PAYABLE)
                         {
                             ignore_invoice = TRUE;
                             g_string_append_printf (info,
                                                     _("Row %d, invoice %s/%u: account %s is not of type Accounts Payable.\n"),
                                                     row, id, invoice_line, account_posted);
                         }
                     }
                     else if (g_ascii_strcasecmp (type, "INVOICE") == 0)
                     {
                         if (xaccAccountGetType (acc) != ACCT_TYPE_RECEIVABLE)
                         {
                             ignore_invoice = TRUE;
                             g_string_append_printf (info,
                                                     _("Row %d, invoice %s/%u: account %s is not of type Accounts Receivable.\n"),
                                                     row, id, invoice_line, account_posted);
                         }
                     }
                 }
             }
 
             // Verify the date opened.
             if(!isDateValid(date_opened))
             {
                 // Fix this by using the current date.
                 gchar temp[20];
                 GDate date;
                 g_date_clear (&date, 1);
                 gnc_gdate_set_today (&date);
                 g_date_strftime (temp, 20, date_format_string, &date);    // Create a user specified date string.
                 gtk_list_store_set (store, &iter, DATE_OPENED,
                                     temp, -1);
                 row_fixed = TRUE;
             }
         }
 
         // Validate and fix item data for each row.
 
         // Get item data.
         gtk_tree_model_get (GTK_TREE_MODEL (store), &iter,
                             DATE, &date,
                             ACCOUNT, &account,
                             QUANTITY, &quantity,
                             PRICE, &price, -1);
 
 
         // Validate the price.
         if (strlen (price) == 0)
         {
             // No valid price, delete the row
             ignore_invoice = TRUE;
             g_string_append_printf (info,
                                     _("Row %d, invoice %s/%u: price not set.\n"),
                                     row, id, invoice_line);
         }
 
         // Validate the account
         acc = gnc_account_lookup_for_register (gnc_get_current_root_account (),
                                                account);
         if (acc == NULL)
         {
             ignore_invoice = TRUE;
             g_string_append_printf (info,
                                     _("Row %d, invoice %s/%u: account %s does not exist.\n"),
                                     row, id, invoice_line, account);
         }
 
         // Fix item data.
         if (!ignore_invoice)
         {
 
             // Verify the quantity.
             if (strlen (quantity) == 0)
             {
                 // The quantity is not set, default to 1.
                 gtk_list_store_set (store, &iter, QUANTITY, "1", -1);
                 row_fixed = TRUE;
             }
 
             // Verify the item date
             if(!isDateValid(date))
             {
                 // Invalid item date, replace with date opened
                 gtk_list_store_set (store, &iter, DATE,
                                     date_opened, -1);
                 row_fixed = TRUE;
             }
 
         }
         if (row_fixed) ++fixed_for_invoice;
 
         // Get the next row and its id.
         valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter);
         if (valid) gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, ID, &id, -1);
 
 
         // If the id of the next row is blank, it takes the id of the previous row.
         if (valid && strlen(id) == 0)
         {
             strcpy( id, running_id->str);
             gtk_list_store_set (store, &iter, ID, id, -1);
         }
 
         // If this row was the last row of the invoice...
         if (!valid || (valid && g_strcmp0 (id, running_id->str) != 0))
         {
             // If invoice should be ignored, remove all rows of this invoice.
             if (ignore_invoice)
             {
                 iter = first_row_of_invoice;
                 do
                 {
                     (*n_rows_ignored)++;
                     valid = gtk_list_store_remove (store, &iter);
                     if (valid) gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, ID, &id, -1);
                 }
                 while (valid && (g_strcmp0 (id, running_id->str) == 0));
 
                 if (running_id->len != 0)
                 {
                     g_string_append_printf (info,
                                             _("Error(s) in invoice %s, all rows of this invoice ignored.\n"),
                                             running_id->str);
                 }
                 else
                 {
                     g_string_append_printf (info,
                                             _("Error(s) in invoice without id, all rows of this invoice ignored.\n"));
                 }
 
                 // Fixes for ignored invoices don't count in the statistics.
                 fixed_for_invoice = 0;
 
                 ignore_invoice = FALSE;
             }
 
             on_first_row_of_invoice = TRUE;
             (*n_rows_fixed) += fixed_for_invoice;
             fixed_for_invoice = 0;
             invoice_line = 0;
 
             g_free (id);
             g_free (date_opened);
             g_free (date_posted);
             g_free (due_date);
             g_free (account_posted);
             g_free (owner_id);
         }
         else on_first_row_of_invoice = FALSE;
 
         g_free (date);
         g_free (account);
         g_free (quantity);
         g_free (price);
 
         row++;
     }
 
     // Deallocate strings.
     g_string_free (running_id, TRUE);
 
 }

◆ gnc_bi_import_read_file()

bi_import_result gnc_bi_import_read_file	(	const gchar *	filename,
		const gchar *	parser_regexp,
		GtkListStore *	store,
		guint	max_rows,
		bi_import_stats *	stats
	)

Imports a csv file with invoice data into a GtkListStore.

Opens the csv file and attempts to match each row with the regular expression provided in parser_regexp. This is a regular expression that matches each field of the import row and the user selected field separators (, or ;), optionally with the fields enclosed in quotes.

If the match is successful, the fields of the import row are transferred to a row in the GtkListStore store. If the match is not successful, the row is ignored. Maintains information about number of rows imported, the number of rows ignored, and the actual ignored rows.

Parameters

filename	The csv filename to read
parser_regexp	The regular expression with which to match the import rows
store	To store the matched data
max_rows	The maximum number of rows to import; use 0 for no maximum.
stats	Return information about matched and non-matched rows. Use NULL if the information is not required.

Definition at line 98 of file dialog-bi-import.c.

 {
     // some statistics
     bi_import_stats stats_fallback;
     FILE *f;
 
     // regexp
     char *line = NULL;
     gchar *line_utf8 = NULL;
     gchar *temp = NULL;
     GMatchInfo *match_info;
     GError *err;
     GRegex *regexpat;
 
     // model
     GtkTreeIter iter;
 
     f = g_fopen (filename, "rt");
     if (!f)
     {
         //gnc_error_dialog (NULL, _("File %s cannot be opened."), filename );
         return RESULT_OPEN_FAILED;
     }
 
     // set up statistics
     if (!stats)
         stats = &stats_fallback;
 
     // compile the regular expression and check for errors
     err = NULL;
     regexpat =
         g_regex_new (parser_regexp, G_REGEX_EXTENDED | G_REGEX_OPTIMIZE | G_REGEX_DUPNAMES, 0, &err);
     if (err != NULL)
     {
         GtkWidget *dialog;
         gchar *errmsg;
 
         errmsg = g_strdup_printf (_("Error in regular expression '%s':\n%s"),
                                   parser_regexp, err->message);
         g_error_free (err);
         err = NULL;
 
         dialog = gtk_message_dialog_new (NULL,
                                          GTK_DIALOG_MODAL,
                                          GTK_MESSAGE_ERROR,
                                          GTK_BUTTONS_OK, "%s", errmsg);
         gtk_dialog_run (GTK_DIALOG (dialog));
         gtk_widget_destroy (dialog);
         g_free (errmsg);
         errmsg = 0;
 
         fclose (f);
         return RESULT_ERROR_IN_REGEXP;
     }
 
     // start the import
     stats->n_imported = 0;
     stats->n_ignored = 0;
     stats->ignored_lines = g_string_new (NULL);
 #define buffer_size 1000
     line = g_malloc0 (buffer_size);
     while (!feof (f)
             && ((max_rows == 0)
                 || (stats->n_imported + stats->n_ignored < max_rows)))
     {
         int l;
         // read one line
         if (!fgets (line, buffer_size, f))
             break;          // eof
         // now strip the '\n' from the end of the line
         l = strlen (line);
         if ((l > 0) && (line[l - 1] == '\n'))
             line[l - 1] = 0;
 
         // if the line doesn't conform to UTF-8, try a default charcter set
         // conversion based on locale
         if (g_utf8_validate(line, -1, NULL))
             line_utf8 = line;
         else
             line_utf8 = g_locale_to_utf8 (line, -1, NULL, NULL, NULL);
 
         // Remove the potential XML-prohibited codepoints from the UTF-8 compliant string
         gnc_utf8_strip_invalid(line_utf8);
 
         // parse the line
         match_info = NULL;  // it seems, that in contrast to documentation, match_info is not always set -> g_match_info_free will segfault
         if (g_regex_match (regexpat, line_utf8, 0, &match_info))
         {
             // match found
             stats->n_imported++;
 
             // fill in the values
             gtk_list_store_append (store, &iter);
             FILL_IN_HELPER ("id", ID); /* FIXME: Should "id" be translated? I don't think so. */
             FILL_IN_HELPER ("date_opened", DATE_OPENED);
             FILL_IN_HELPER ("owner_id", OWNER_ID);
             FILL_IN_HELPER ("billing_id", BILLING_ID);
             FILL_IN_HELPER ("notes", NOTES);
 
             FILL_IN_HELPER ("date", DATE);
             FILL_IN_HELPER ("desc", DESC);
             FILL_IN_HELPER ("action", ACTION);
             FILL_IN_HELPER ("account", ACCOUNT);
             FILL_IN_HELPER ("quantity", QUANTITY);
             FILL_IN_HELPER ("price", PRICE);
             FILL_IN_HELPER ("disc_type", DISC_TYPE);
             FILL_IN_HELPER ("disc_how", DISC_HOW);
             FILL_IN_HELPER ("discount", DISCOUNT);
             FILL_IN_HELPER ("taxable", TAXABLE);
             FILL_IN_HELPER ("taxincluded", TAXINCLUDED);
             FILL_IN_HELPER ("tax_table", TAX_TABLE);
 
             FILL_IN_HELPER ("date_posted", DATE_POSTED);
             FILL_IN_HELPER ("due_date", DUE_DATE);
             FILL_IN_HELPER ("account_posted", ACCOUNT_POSTED);
             FILL_IN_HELPER ("memo_posted", MEMO_POSTED);
             FILL_IN_HELPER ("accu_splits", ACCU_SPLITS);
         }
         else
         {
             // ignore line
             stats->n_ignored++;
             g_string_append (stats->ignored_lines, line_utf8);
             g_string_append_c (stats->ignored_lines, '\n');
         }
 
         g_match_info_free (match_info);
         if (line_utf8 != line)
             g_free (line_utf8);
     }
     g_free (line);
     line = 0;
 
     g_regex_unref (regexpat);
     regexpat = 0;
     fclose (f);
 
     if (stats == &stats_fallback)
         // stats are not requested -> free the string
         g_string_free (stats->ignored_lines, TRUE);
 
     return RESULT_OK;
 }

◆ gnc_plugin_bi_import_new()

GncPlugin* gnc_plugin_bi_import_new ( void )

Returns: A new GncPluginbi_import object

Definition at line 80 of file gnc-plugin-bi-import.c.

 {
     return GNC_PLUGIN (g_object_new (GNC_TYPE_PLUGIN_BI_IMPORT, (gchar*) NULL));
 }

◆ gnc_plugin_customer_import_new()

GncPlugin* gnc_plugin_customer_import_new ( void )

Returns: A new GncPlugincustomer_import object

Definition at line 78 of file gnc-plugin-customer-import.c.

 {
     return GNC_PLUGIN (g_object_new (GNC_TYPE_PLUGIN_CUSTOMER_IMPORT, (gchar*) NULL));
 }

◆ gnc_plugin_example_new()

GncPlugin* gnc_plugin_example_new ( void )

Returns: A new GncPluginexample object

Definition at line 66 of file gnc-plugin.example.c.

 {
     return GNC_PLUGIN (g_object_new (GNC_TYPE_PLUGIN_EXAMPLE, (gchar*) NULL));
 }

Files

Data Structures

Macros

Typedefs

Enumerations

Functions