static GtkWidget *
create_owner_widget (GNCOption *option, GncOwnerType type, GtkWidget *hbox)
{
GtkWidget *widget;
GncOwner owner;
switch (type)
{
case GNC_OWNER_CUSTOMER:
gncOwnerInitCustomer (&owner, NULL);
break;
case GNC_OWNER_VENDOR:
gncOwnerInitVendor (&owner, NULL);
break;
case GNC_OWNER_EMPLOYEE:
gncOwnerInitEmployee (&owner, NULL);
break;
case GNC_OWNER_JOB:
gncOwnerInitJob (&owner, NULL);
break;
default:
return NULL;
}
widget = gnc_owner_select_create (NULL, hbox,
gnc_get_current_book (), &owner);
gnc_option_set_widget (option, widget);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (gnc_option_changed_option_cb), option);
return widget;
}
static gboolean
owner_type_handler (xmlNodePtr node, gpointer owner_pdata)
{
struct owner_pdata* pdata = static_cast<decltype (pdata)> (owner_pdata);
char* txt = dom_tree_to_text (node);
g_return_val_if_fail (txt, FALSE);
if (!g_strcmp0 (txt, GNC_ID_CUSTOMER))
gncOwnerInitCustomer (pdata->owner, NULL);
else if (!g_strcmp0 (txt, GNC_ID_JOB))
gncOwnerInitJob (pdata->owner, NULL);
else if (!g_strcmp0 (txt, GNC_ID_VENDOR))
gncOwnerInitVendor (pdata->owner, NULL);
else if (!g_strcmp0 (txt, GNC_ID_EMPLOYEE))
gncOwnerInitEmployee (pdata->owner, NULL);
else
{
PWARN ("Unknown owner type: %s", txt);
g_free (txt);
return FALSE;
}
g_free (txt);
return TRUE;
}
gboolean gncOwnerGetOwnerFromLot (GNCLot *lot, GncOwner *owner)
{
GncGUID *guid = NULL;
QofBook *book;
GncOwnerType type = GNC_OWNER_NONE;
if (!lot || !owner) return FALSE;
book = gnc_lot_get_book (lot);
qof_instance_get (QOF_INSTANCE (lot),
"owner-type", &type,
"owner-guid", &guid,
NULL);
switch (type)
{
case GNC_OWNER_CUSTOMER:
gncOwnerInitCustomer (owner, gncCustomerLookup (book, guid));
break;
case GNC_OWNER_VENDOR:
gncOwnerInitVendor (owner, gncVendorLookup (book, guid));
break;
case GNC_OWNER_EMPLOYEE:
gncOwnerInitEmployee (owner, gncEmployeeLookup (book, guid));
break;
case GNC_OWNER_JOB:
gncOwnerInitJob (owner, gncJobLookup (book, guid));
break;
default:
return FALSE;
}
return (owner->owner.undefined != NULL);
}
void
qofOwnerSetEntity (GncOwner *owner, QofInstance *ent)
{
if (!owner || !ent)
{
return;
}
if (0 == g_strcmp0(ent->e_type, GNC_ID_CUSTOMER))
{
owner->type = GNC_OWNER_CUSTOMER;
gncOwnerInitCustomer(owner, (GncCustomer*)ent);
}
else if (0 == g_strcmp0(ent->e_type, GNC_ID_JOB))
{
owner->type = GNC_OWNER_JOB;
gncOwnerInitJob(owner, (GncJob*)ent);
}
else if (0 == g_strcmp0(ent->e_type, GNC_ID_VENDOR))
{
owner->type = GNC_OWNER_VENDOR;
gncOwnerInitVendor(owner, (GncVendor*)ent);
}
else if (0 == g_strcmp0(ent->e_type, GNC_ID_EMPLOYEE))
{
owner->type = GNC_OWNER_EMPLOYEE;
gncOwnerInitEmployee(owner, (GncEmployee*)ent);
}
else
{
owner->type = GNC_OWNER_NONE;
owner->owner.undefined = NULL;
}
}
gboolean gncOwnerGetOwnerFromTypeGuid (QofBook *book, GncOwner *owner, QofIdType type, GncGUID *guid)
{
if (!book || !owner || !type || !guid) return FALSE;
if (0 == g_strcmp0(type, GNC_ID_CUSTOMER))
{
GncCustomer *customer = gncCustomerLookup(book, guid);
gncOwnerInitCustomer(owner, customer);
return (NULL != customer);
}
else if (0 == g_strcmp0(type, GNC_ID_JOB))
{
GncJob *job = gncJobLookup(book, guid);
gncOwnerInitJob(owner, job);
return (NULL != job);
}
else if (0 == g_strcmp0(type, GNC_ID_VENDOR))
{
GncVendor *vendor = gncVendorLookup(book, guid);
gncOwnerInitVendor(owner, vendor);
return (NULL != vendor);
}
else if (0 == g_strcmp0(type, GNC_ID_EMPLOYEE))
{
GncEmployee *employee = gncEmployeeLookup(book, guid);
gncOwnerInitEmployee(owner, employee);
return (NULL != employee);
}
return 0;
}
static void
gnc_plugin_business_init (GncPluginBusiness *plugin)
{
GncPluginBusinessPrivate *priv;
priv = GNC_PLUGIN_BUSINESS_GET_PRIVATE (plugin);
priv->last_customer = gncOwnerNew ();
gncOwnerInitCustomer (priv->last_customer, NULL);
priv->last_vendor = gncOwnerNew ();
gncOwnerInitVendor (priv->last_vendor, NULL);
priv->last_employee = gncOwnerNew ();
gncOwnerInitEmployee (priv->last_employee, NULL);
}
static void
gnc_plugin_page_owner_tree_cmd_new_invoice (GtkAction *action,
GncPluginPageOwnerTree *page)
{
GncPluginPageOwnerTreePrivate *priv;
GncOwner current_owner;
ENTER("action %p, page %p", action, page);
priv = GNC_PLUGIN_PAGE_OWNER_TREE_GET_PRIVATE(page);
switch (priv->owner_type)
{
case GNC_OWNER_NONE :
case GNC_OWNER_UNDEFINED :
gncOwnerInitUndefined(¤t_owner, NULL);
break;
case GNC_OWNER_CUSTOMER :
{
gncOwnerInitCustomer(¤t_owner,
gncOwnerGetCustomer(gnc_plugin_page_owner_tree_get_current_owner (page)) );
break;
}
case GNC_OWNER_JOB :
{
gncOwnerInitJob(¤t_owner,
gncOwnerGetJob(gnc_plugin_page_owner_tree_get_current_owner (page)) );
break;
}
case GNC_OWNER_VENDOR :
{
gncOwnerInitVendor(¤t_owner,
gncOwnerGetVendor(gnc_plugin_page_owner_tree_get_current_owner (page)) );
break;
}
case GNC_OWNER_EMPLOYEE :
{
gncOwnerInitEmployee(¤t_owner,
gncOwnerGetEmployee(gnc_plugin_page_owner_tree_get_current_owner (page)) );
break;
}
}
if (gncOwnerGetType(¤t_owner) != GNC_OWNER_UNDEFINED)
gnc_ui_invoice_new (¤t_owner, gnc_get_current_book());
LEAVE(" ");
}
/* Function to set the UI Value for a particular option */
static gboolean
vendor_set_value (GNCOption *option, gboolean use_default,
GtkWidget *widget, SCM value)
{
GncOwner owner;
GncVendor *vendor;
if (!SWIG_IsPointer (value))
scm_misc_error("business_options:vendor_set_value",
"SCM is not a wrapped pointer.", value);
vendor = SWIG_MustGetPtr(value, SWIG_TypeQuery("_p__gncVendor"), 1, 0);
gncOwnerInitVendor (&owner, vendor);
widget = gnc_option_get_gtk_widget (option);
gnc_owner_set_owner (widget, &owner);
return FALSE;
}
/***********************************************************************
* @todo Maybe invoice checking should be done in gnc_bi_import_fix_bis (...)
* rather than in here? But that is more concerned with ensuring the csv is consistent.
* @param GtkListStore *store
* @param guint *n_invoices_created
* @param guint *n_invoices_updated
* @return void
***********************************************************************/
void
gnc_bi_import_create_bis (GtkListStore * store, QofBook * book,
guint * n_invoices_created,
guint * n_invoices_updated,
gchar * type, gchar * open_mode, GString * info)
{
gboolean valid;
GtkTreeIter iter;
gchar *id, *date_opened, *owner_id, *billing_id, *notes;
gchar *date, *desc, *action, *account, *quantity, *price, *disc_type,
*disc_how, *discount, *taxable, *taxincluded, *tax_table;
gchar *date_posted, *due_date, *account_posted, *memo_posted,
*accumulatesplits;
guint dummy;
GncInvoice *invoice;
GncEntry *entry;
gint day, month, year;
gnc_numeric value;
GncOwner *owner;
Account *acc;
enum update {YES = GTK_RESPONSE_YES, NO = GTK_RESPONSE_NO} update;
GtkWidget *dialog;
Timespec today;
InvoiceWindow *iw;
gchar *new_id = NULL;
gint64 denom = 0;
gnc_commodity *currency;
// 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 = NO;
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, ¬es,
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);
// TODO: Assign a new invoice number if one is absent. BUT we don't want to assign a new invoice for every line!!
// so we'd have to flag this up somehow or add an option in the import GUI. The former implies that we make
// an assumption about what the importer (person) wants to do. It seems reasonable that a CSV file full of items with
// If an invoice exists then we add to it in this current schema.
// no predefined invoice number is a new invoice that's in need of a new number.
// This was not designed to satisfy the need for repeat invoices however, so maybe we need a another method for this, after all
// It should be easier to copy an invoice with a new ID than to go through all this malarky.
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
if (strlen (date_opened) != 0) // If a date is specified in CSV
{
// FIXME: Must check for the return value of qof_scan_date!
qof_scan_date (date_opened, &day, &month, &year);
gncInvoiceSetDateOpened (invoice,
gnc_dmy2timespec (day, month, year));
}
else // If no date in CSV
{
time64 now = gnc_time (NULL);
Timespec now_timespec;
timespecFromTime64 (&now_timespec, now);
gncInvoiceSetDateOpened (invoice, now_timespec);
}
gncInvoiceSetBillingID (invoice, billing_id ? billing_id : "");
gncInvoiceSetNotes (invoice, notes ? notes : "");
gncInvoiceSetActive (invoice, TRUE);
//if (g_ascii_strcasecmp(type,"INVOICE"))gncInvoiceSetBillTo( invoice, billto );
(*n_invoices_created)++;
update = YES;
// 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
&& strlen(date_posted) == 0))
{
iw = gnc_ui_invoice_edit (invoice);
gnc_plugin_page_invoice_new (iw);
}
gncInvoiceCommitEdit (invoice);
}
// I want to warn the user that an existing billvoice exists, but not every
// time.
// An import can contain many lines usually referring to the same invoice.
// NB: Posted invoices are NEVER updated.
else // if invoice exists
{
if (gncInvoiceIsPosted (invoice)) // Is it already posted?
{
valid =
gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter);
continue; // If already posted then never import
}
if (update != YES) // Pop up a dialog to ask if updates are the expected action
{
dialog = gtk_message_dialog_new (NULL,
GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_YES_NO,
"%s",
_("Are you sure you have bills/invoices to update?"));
update = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
if (update == NO)
{
// Cleanup and leave
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);
return;
}
}
(*n_invoices_updated)++;
}
// add entry to invoice/bill
entry = gncEntryCreate (book);
gncEntryBeginEdit(entry);
currency = gncInvoiceGetCurrency(invoice);
if (currency) denom = gnc_commodity_get_fraction(currency);
// FIXME: Must check for the return value of qof_scan_date!
qof_scan_date (date, &day, &month, &year);
{
GDate *date = g_date_new_dmy(day, month, year);
gncEntrySetDateGDate (entry, date);
g_date_free (date);
}
timespecFromTime64 (&today, gnc_time (NULL)); // set today to the current date
gncEntrySetDateEntered (entry, today);
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));
gncEntryCommitEdit(entry);
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));
gncEntryCommitEdit(entry);
gncInvoiceAddEntry (invoice, 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, &new_id, -1);
if (g_strcmp0 (id, new_id) != 0)
{
// the next invoice id is different => try to autopost this invoice
if (qof_scan_date (date_posted, &day, &month, &year))
{
// autopost this invoice
gboolean auto_pay;
Timespec d1, d2;
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);
d1 = gnc_dmy2timespec (day, month, year);
// FIXME: Must check for the return value of qof_scan_date!
qof_scan_date (due_date, &day, &month, &year); // obtains the due date, or leaves it at date_posted
d2 = gnc_dmy2timespec (day, month, year);
acc = gnc_account_lookup_for_register
(gnc_get_current_root_account (), account_posted);
gncInvoicePostToAccount (invoice, acc, &d1, &d2,
memo_posted,
text2bool (accumulatesplits),
auto_pay);
}
}
}
// cleanup
g_free (new_id);
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);
}
static void
load_owner( const GncSqlBackend* be, GncSqlRow* row,
QofSetterFunc setter, gpointer pObject,
const GncSqlColumnTableEntry* table_row )
{
const GValue* val;
gchar* buf;
GncOwnerType type;
GncGUID guid;
QofBook* book;
GncOwner owner;
GncGUID* pGuid = NULL;
g_return_if_fail( be != NULL );
g_return_if_fail( row != NULL );
g_return_if_fail( pObject != NULL );
g_return_if_fail( table_row != NULL );
book = be->primary_book;
buf = g_strdup_printf( "%s_type", table_row->col_name );
val = gnc_sql_row_get_value_at_col_name( row, buf );
type = (GncOwnerType)gnc_sql_get_integer_value( val );
g_free( buf );
buf = g_strdup_printf( "%s_guid", table_row->col_name );
val = gnc_sql_row_get_value_at_col_name( row, buf );
g_free( buf );
if ( val != NULL && G_VALUE_HOLDS_STRING( val ) && g_value_get_string( val ) != NULL )
{
string_to_guid( g_value_get_string( val ), &guid );
pGuid = &guid;
}
switch ( type )
{
case GNC_OWNER_CUSTOMER:
{
GncCustomer *cust = NULL;
if ( pGuid != NULL )
{
cust = gncCustomerLookup( book, pGuid );
if ( cust == NULL )
{
cust = gncCustomerCreate( book );
gncCustomerSetGUID( cust, &guid );
}
}
gncOwnerInitCustomer( &owner, cust );
break;
}
case GNC_OWNER_JOB:
{
GncJob *job = NULL;
if ( pGuid != NULL )
{
job = gncJobLookup( book, pGuid );
if ( job == NULL )
{
job = gncJobCreate( book );
gncJobSetGUID( job, &guid );
}
}
gncOwnerInitJob( &owner, job );
break;
}
case GNC_OWNER_VENDOR:
{
GncVendor *vendor = NULL;
if ( pGuid != NULL )
{
vendor = gncVendorLookup( book, pGuid );
if ( vendor == NULL )
{
vendor = gncVendorCreate( book );
gncVendorSetGUID( vendor, &guid );
}
}
gncOwnerInitVendor( &owner, vendor );
break;
}
case GNC_OWNER_EMPLOYEE:
{
GncEmployee *employee = NULL;
if ( pGuid != NULL )
{
employee = gncEmployeeLookup( book, pGuid );
if ( employee == NULL )
{
employee = gncEmployeeCreate( book );
gncEmployeeSetGUID( employee, &guid );
}
}
gncOwnerInitEmployee( &owner, employee );
break;
}
default:
PWARN("Invalid owner type: %d\n", type );
}
if ( table_row->gobj_param_name != NULL )
{
g_object_set( pObject, table_row->gobj_param_name, &owner, NULL );
}
else
{
(*setter)( pObject, &owner );
}
}
static gboolean
owner_id_handler (xmlNodePtr node, gpointer owner_pdata)
{
struct owner_pdata* pdata = static_cast<decltype (pdata)> (owner_pdata);
GncGUID* guid;
guid = dom_tree_to_guid (node);
g_return_val_if_fail (guid, FALSE);
switch (gncOwnerGetType (pdata->owner))
{
case GNC_OWNER_CUSTOMER:
{
GncCustomer* cust = gncCustomerLookup (pdata->book, guid);
if (!cust)
{
cust = gncCustomerCreate (pdata->book);
gncCustomerSetGUID (cust, guid);
}
gncOwnerInitCustomer (pdata->owner, cust);
break;
}
case GNC_OWNER_JOB:
{
GncJob* job = gncJobLookup (pdata->book, guid);
if (!job)
{
job = gncJobCreate (pdata->book);
gncJobSetGUID (job, guid);
}
gncOwnerInitJob (pdata->owner, job);
break;
}
case GNC_OWNER_VENDOR:
{
GncVendor* vendor = gncVendorLookup (pdata->book, guid);
if (!vendor)
{
vendor = gncVendorCreate (pdata->book);
gncVendorSetGUID (vendor, guid);
}
gncOwnerInitVendor (pdata->owner, vendor);
break;
}
case GNC_OWNER_EMPLOYEE:
{
GncEmployee* employee = gncEmployeeLookup (pdata->book, guid);
if (!employee)
{
employee = gncEmployeeCreate (pdata->book);
gncEmployeeSetGUID (employee, guid);
}
gncOwnerInitEmployee (pdata->owner, employee);
break;
}
default:
PWARN ("Invalid owner type: %d\n", gncOwnerGetType (pdata->owner));
g_free (guid);
return FALSE;
}
g_free (guid);
return TRUE;
}
