GnuCash  4.11-11-ge9df8d41d2+
Files | Macros | Typedefs | Enumerations | Functions

An invoice holds a list of entries, a pointer to the customer, and the job, the dates entered and posted, as well as the account, transaction and lot for the posted invoice. More...

Files

file  gncInvoice.h
 Business Invoice Interface.
 

Macros

#define GNC_ID_INVOICE   "gncInvoice"
 
#define GNC_TYPE_INVOICE   (gnc_invoice_get_type ())
 
#define GNC_INVOICE(o)   (G_TYPE_CHECK_INSTANCE_CAST ((o), GNC_TYPE_INVOICE, GncInvoice))
 
#define GNC_INVOICE_CLASS(k)   (G_TYPE_CHECK_CLASS_CAST((k), GNC_TYPE_INVOICE, GncInvoiceClass))
 
#define GNC_IS_INVOICE(o)   (G_TYPE_CHECK_INSTANCE_TYPE ((o), GNC_TYPE_INVOICE))
 
#define GNC_IS_INVOICE_CLASS(k)   (G_TYPE_CHECK_CLASS_TYPE ((k), GNC_TYPE_INVOICE))
 
#define GNC_INVOICE_GET_CLASS(o)   (G_TYPE_INSTANCE_GET_CLASS ((o), GNC_TYPE_INVOICE, GncInvoiceClass))
 
#define INVOICE_ID   "id"
 
#define INVOICE_OWNER   "owner"
 
#define INVOICE_OPENED   "date_opened"
 
#define INVOICE_POSTED   "date_posted"
 
#define INVOICE_DUE   "date_due"
 
#define INVOICE_IS_POSTED   "is_posted?"
 
#define INVOICE_IS_PAID   "is_paid?"
 
#define INVOICE_TERMS   "terms"
 
#define INVOICE_BILLINGID   "billing_id"
 
#define INVOICE_NOTES   "notes"
 
#define INVOICE_DOCLINK   "doclink"
 
#define INVOICE_ACC   "account"
 
#define INVOICE_POST_TXN   "posted_txn"
 
#define INVOICE_POST_LOT   "posted_lot"
 
#define INVOICE_IS_CN   "credit_note"
 
#define INVOICE_TYPE   "type"
 
#define INVOICE_TYPE_STRING   "type_string"
 
#define INVOICE_BILLTO   "bill-to"
 
#define INVOICE_ENTRIES   "list_of_entries"
 
#define INVOICE_JOB   "invoice_job"
 
#define INVOICE_FROM_LOT   "invoice-from-lot"
 
#define INVOICE_FROM_TXN   "invoice-from-txn"
 
#define gncInvoiceGetGUID(x)   qof_instance_get_guid (QOF_INSTANCE(x))
 deprecated functions
 
#define gncInvoiceRetGUID(x)   (x ? *(qof_instance_get_guid (QOF_INSTANCE(x))) : *(guid_null()))
 

Typedefs

typedef GList GncInvoiceList
 
typedef GList EntryList
 

Enumerations

enum  GncInvoiceType {
  GNC_INVOICE_UNDEFINED, GNC_INVOICE_CUST_INVOICE, GNC_INVOICE_VEND_INVOICE, GNC_INVOICE_EMPL_INVOICE,
  GNC_INVOICE_CUST_CREDIT_NOTE, GNC_INVOICE_VEND_CREDIT_NOTE, GNC_INVOICE_EMPL_CREDIT_NOTE, GNC_INVOICE_NUM_TYPES
}
 

Functions

GType gnc_invoice_get_type (void)
 
void gncInvoiceAddEntry (GncInvoice *invoice, GncEntry *entry)
 
void gncInvoiceRemoveEntry (GncInvoice *invoice, GncEntry *entry)
 
void gncInvoiceAddPrice (GncInvoice *invoice, GNCPrice *price)
 
void gncBillAddEntry (GncInvoice *bill, GncEntry *entry)
 Call this function when adding an entry to a bill instead of an invoice.
 
void gncBillRemoveEntry (GncInvoice *bill, GncEntry *entry)
 
void gncInvoiceSortEntries (GncInvoice *invoice)
 Call this function when an Entry is changed and you want to re-sort the list of entries.
 
void gncInvoiceRemoveEntries (GncInvoice *invoice)
 Remove all entries from an invoice. More...
 
gnc_numeric gncInvoiceGetTotal (GncInvoice *invoice)
 Return the "total" amount of the invoice as seen on the document (and shown to the user in the reports and invoice ledger). More...
 
gnc_numeric gncInvoiceGetTotalOf (GncInvoice *invoice, GncEntryPaymentType type)
 
gnc_numeric gncInvoiceGetTotalSubtotal (GncInvoice *invoice)
 
gnc_numeric gncInvoiceGetTotalTax (GncInvoice *invoice)
 
AccountValueList * gncInvoiceGetTotalTaxList (GncInvoice *invoice)
 Return a list of tax totals accumulated per tax account.
 
EntryList * gncInvoiceGetEntries (GncInvoice *invoice)
 
GNCPrice * gncInvoiceGetPrice (GncInvoice *invoice, gnc_commodity *commodity)
 
gboolean gncInvoiceAmountPositive (const GncInvoice *invoice)
 Depending on the invoice type, invoices have a different effect on the balance. More...
 
GHashTable * gncInvoiceGetForeignCurrencies (const GncInvoice *invoice)
 Return an overview of amounts on this invoice that will be posted to accounts in currencies that are different from the invoice currency. More...
 
Transaction * gncInvoicePostToAccount (GncInvoice *invoice, Account *acc, time64 posted_date, time64 due_date, const char *memo, gboolean accumulatesplits, gboolean autopay)
 Post this invoice to an account. More...
 
gboolean gncInvoiceUnpost (GncInvoice *invoice, gboolean reset_tax_tables)
 Unpost this invoice. More...
 
void gncInvoiceAutoApplyPayments (GncInvoice *invoice)
 Attempt to pay the invoice using open payment lots and lots for documents of the opposite sign (credit notes versus invoices).
 
void gncInvoiceApplyPayment (const GncInvoice *invoice, Transaction *txn, Account *xfer_acc, gnc_numeric amount, gnc_numeric exch, time64 date, const char *memo, const char *num)
 A convenience function to apply a payment to an invoice. More...
 
GncInvoice * gncInvoiceGetInvoiceFromTxn (const Transaction *txn)
 Given a transaction, find and return the Invoice.
 
GncInvoice * gncInvoiceGetInvoiceFromLot (GNCLot *lot)
 Given a LOT, find and return the Invoice attached to the lot.
 
void gncInvoiceBeginEdit (GncInvoice *invoice)
 
void gncInvoiceCommitEdit (GncInvoice *invoice)
 
int gncInvoiceCompare (const GncInvoice *a, const GncInvoice *b)
 
gboolean gncInvoiceIsPosted (const GncInvoice *invoice)
 
gboolean gncInvoiceIsPaid (const GncInvoice *invoice)
 
QofBook * gncInvoiceGetBook (GncInvoice *x)
 
gboolean gncInvoiceEqual (const GncInvoice *a, const GncInvoice *b)
 Test support function used by test-dbi-business-stuff.c.
 

Create/Destroy Functions

GncInvoice * gncInvoiceCreate (QofBook *book)
 
void gncInvoiceDestroy (GncInvoice *invoice)
 
GncInvoice * gncInvoiceCopy (const GncInvoice *other_invoice)
 Create a new GncInvoice object as a deep copy of the given other invoice. More...
 

Set Functions

void gncInvoiceSetID (GncInvoice *invoice, const char *id)
 
void gncInvoiceSetOwner (GncInvoice *invoice, GncOwner *owner)
 
void gncInvoiceSetDateOpenedGDate (GncInvoice *invoice, const GDate *date)
 Set the DateOpened using a GDate argument. More...
 
void gncInvoiceSetDateOpened (GncInvoice *invoice, time64 date)
 
void gncInvoiceSetDatePosted (GncInvoice *invoice, time64 date)
 
void gncInvoiceSetTerms (GncInvoice *invoice, GncBillTerm *terms)
 
void gncInvoiceSetBillingID (GncInvoice *invoice, const char *billing_id)
 
void gncInvoiceSetNotes (GncInvoice *invoice, const char *notes)
 
void gncInvoiceSetDocLink (GncInvoice *invoice, const char *doclink)
 
void gncInvoiceSetCurrency (GncInvoice *invoice, gnc_commodity *currency)
 
void gncInvoiceSetActive (GncInvoice *invoice, gboolean active)
 
void gncInvoiceSetIsCreditNote (GncInvoice *invoice, gboolean credit_note)
 
void gncInvoiceSetBillTo (GncInvoice *invoice, GncOwner *billto)
 
void gncInvoiceSetToChargeAmount (GncInvoice *invoice, gnc_numeric amount)
 

Get Functions

const char * gncInvoiceGetID (const GncInvoice *invoice)
 
const GncOwnergncInvoiceGetOwner (const GncInvoice *invoice)
 
time64 gncInvoiceGetDateOpened (const GncInvoice *invoice)
 
time64 gncInvoiceGetDatePosted (const GncInvoice *invoice)
 
time64 gncInvoiceGetDateDue (const GncInvoice *invoice)
 
GncBillTerm * gncInvoiceGetTerms (const GncInvoice *invoice)
 
const char * gncInvoiceGetBillingID (const GncInvoice *invoice)
 
const char * gncInvoiceGetNotes (const GncInvoice *invoice)
 
const char * gncInvoiceGetDocLink (const GncInvoice *invoice)
 
GncOwnerType gncInvoiceGetOwnerType (const GncInvoice *invoice)
 
GList * gncInvoiceGetTypeListForOwnerType (const GncOwnerType type)
 
GncInvoiceType gncInvoiceGetType (const GncInvoice *invoice)
 
const char * gncInvoiceGetTypeString (const GncInvoice *invoice)
 
gnc_commodity * gncInvoiceGetCurrency (const GncInvoice *invoice)
 
GncOwnergncInvoiceGetBillTo (GncInvoice *invoice)
 
gnc_numeric gncInvoiceGetToChargeAmount (const GncInvoice *invoice)
 
gboolean gncInvoiceGetActive (const GncInvoice *invoice)
 
gboolean gncInvoiceGetIsCreditNote (const GncInvoice *invoice)
 
GNCLot * gncInvoiceGetPostedLot (const GncInvoice *invoice)
 
Transaction * gncInvoiceGetPostedTxn (const GncInvoice *invoice)
 
AccountgncInvoiceGetPostedAcc (const GncInvoice *invoice)
 

Detailed Description

An invoice holds a list of entries, a pointer to the customer, and the job, the dates entered and posted, as well as the account, transaction and lot for the posted invoice.

Function Documentation

◆ gncInvoiceAmountPositive()

gboolean gncInvoiceAmountPositive ( const GncInvoice *  invoice)

Depending on the invoice type, invoices have a different effect on the balance.

Customer invoices increase the balance, while vendor bills decrease the balance. Credit notes have the opposite effect.

Returns TRUE if the invoice will increase the balance or FALSE otherwise.

Definition at line 1360 of file gncInvoice.c.

1361 {
1362  switch (gncInvoiceGetType (invoice))
1363  {
1364  case GNC_INVOICE_CUST_INVOICE:
1365  case GNC_INVOICE_VEND_CREDIT_NOTE:
1366  case GNC_INVOICE_EMPL_CREDIT_NOTE:
1367  return TRUE;
1368  case GNC_INVOICE_CUST_CREDIT_NOTE:
1369  case GNC_INVOICE_VEND_INVOICE:
1370  case GNC_INVOICE_EMPL_INVOICE:
1371  return FALSE;
1372  case GNC_INVOICE_UNDEFINED:
1373  default:
1374  /* Should never be reached.
1375  * If it is, perhaps a new value is added to GncInvoiceType ? */
1376  g_assert_not_reached ();
1377  return FALSE;
1378  }
1379 }

◆ gncInvoiceApplyPayment()

void gncInvoiceApplyPayment ( const GncInvoice *  invoice,
Transaction *  txn,
Account xfer_acc,
gnc_numeric  amount,
gnc_numeric  exch,
time64  date,
const char *  memo,
const char *  num 
)

A convenience function to apply a payment to an invoice.

It creates a lot for a payment optionally based on an existing transaction and then tries to balance it with the given invoice. Contrary to gncOwnerApplyPayment, no other open documents or payments for the owner will be considered to balance the payment.

This code is actually a convenience wrapper around gncOwnerCreatePaymentLotSecs and gncOwnerAutoApplyPaymentsWithLots. See their descriptions for more details on what happens exactly.

Definition at line 2024 of file gncInvoice.c.

2028 {
2029  GNCLot *payment_lot;
2030  GList *selected_lots = NULL;
2031  const GncOwner *owner;
2032 
2033  /* Verify our arguments */
2034  if (!invoice || !gncInvoiceIsPosted (invoice) || !xfer_acc) return;
2035 
2036  owner = gncOwnerGetEndOwner (gncInvoiceGetOwner (invoice));
2037  g_return_if_fail (owner->owner.undefined);
2038 
2039  /* Create a lot for this payment */
2040  payment_lot = gncOwnerCreatePaymentLotSecs (owner, &txn,
2041  invoice->posted_acc,
2042  xfer_acc, amount, exch,
2043  date, memo, num);
2044 
2045  /* Select the invoice as only payment candidate */
2046  selected_lots = g_list_prepend (selected_lots, invoice->posted_lot);
2047 
2048  /* And link the invoice lot and the payment lot together as well as possible. */
2049  if (payment_lot)
2050  selected_lots = g_list_prepend (selected_lots, payment_lot);
2051  gncOwnerAutoApplyPaymentsWithLots (owner, selected_lots);
2052 }
void gncOwnerAutoApplyPaymentsWithLots(const GncOwner *owner, GList *lots)
Given a list of lots, try to balance as many of them as possible by creating balancing transactions b...
Definition: gncOwner.c:1259
GNCLot * gncOwnerCreatePaymentLotSecs(const GncOwner *owner, Transaction **preset_txn, Account *posted_acc, Account *xfer_acc, gnc_numeric amount, gnc_numeric exch, time64 date, const char *memo, const char *num)
Create a lot for a payment to the owner using the other parameters passed in.
Definition: gncOwner.c:751
const GncOwner * gncOwnerGetEndOwner(const GncOwner *owner)
Get the "parent" Owner or GncGUID thereof.
Definition: gncOwner.c:573

◆ gncInvoiceCopy()

GncInvoice* gncInvoiceCopy ( const GncInvoice *  other_invoice)

Create a new GncInvoice object as a deep copy of the given other invoice.

The returned new invoice has everything copied from the other invoice, including the ID string field. All GncEntries are newly allocated copies of the original invoice's entries.

Definition at line 343 of file gncInvoice.c.

344 {
345  GncInvoice *invoice;
346  QofBook* book;
347  GList *node;
348  GValue v = G_VALUE_INIT;
349 
350  g_assert (from);
351  book = qof_instance_get_book (from);
352  g_assert (book);
353 
354  invoice = g_object_new (GNC_TYPE_INVOICE, NULL);
355  qof_instance_init_data (&invoice->inst, _GNC_MOD_NAME, book);
356 
357  gncInvoiceBeginEdit (invoice);
358 
359  invoice->id = CACHE_INSERT (from->id);
360  invoice->notes = CACHE_INSERT (from->notes);
361  invoice->billing_id = CACHE_INSERT (from->billing_id);
362  invoice->active = from->active;
363 
364  qof_instance_get_kvp (QOF_INSTANCE (from), &v, 1, GNC_INVOICE_IS_CN);
365  if (G_VALUE_HOLDS_INT64 (&v))
366  qof_instance_set_kvp (QOF_INSTANCE (invoice), &v, 1, GNC_INVOICE_IS_CN);
367  g_value_unset (&v);
368 
369  invoice->terms = from->terms;
370  gncBillTermIncRef (invoice->terms);
371 
372  gncOwnerCopy (&from->billto, &invoice->billto);
373  gncOwnerCopy (&from->owner, &invoice->owner);
374  invoice->job = from->job; // FIXME: Need IncRef or similar here?!?
375 
376  invoice->to_charge_amount = from->to_charge_amount;
377  invoice->date_opened = from->date_opened;
378 
379  // Oops. Do not forget to copy the pointer to the correct currency here.
380  invoice->currency = from->currency;
381 
382  invoice->doclink = from->doclink;
383 
384  // Copy all invoice->entries
385  for (node = from->entries; node; node = node->next)
386  {
387  GncEntry *from_entry = node->data;
388  GncEntry *to_entry = gncEntryCreate (book);
389  gncEntryCopy (from_entry, to_entry, FALSE);
390 
391  switch (gncInvoiceGetOwnerType (invoice))
392  {
393  case GNC_OWNER_VENDOR:
394  case GNC_OWNER_EMPLOYEE:
395  // this is a vendor bill, or an expense voucher
396  gncBillAddEntry (invoice, to_entry);
397  break;
398  case GNC_OWNER_CUSTOMER:
399  default:
400  // this is an invoice
401  gncInvoiceAddEntry (invoice, to_entry);
402  break;
403  }
404  }
405 
406  // FIXME: The prices are not (yet) copied; is this a problem?
407 
408  // Posted-date and the posted Txn is intentionally not copied; the
409  // copy isn't "posted" but needs to be posted by the user.
410  mark_invoice (invoice);
411  gncInvoiceCommitEdit (invoice);
412 
413  return invoice;
414 }
void qof_instance_set_kvp(QofInstance *, GValue const *value, unsigned count,...)
Sets a KVP slot to a value from a GValue.
QofBook * qof_instance_get_book(gconstpointer inst)
Return the book pointer.
void qof_instance_get_kvp(QofInstance *, GValue *value, unsigned count,...)
Retrieves the contents of a KVP slot into a provided GValue.
void qof_instance_init_data(QofInstance *inst, QofIdType type, QofBook *book)
Initialise the settings associated with an instance.
void gncBillAddEntry(GncInvoice *bill, GncEntry *entry)
Call this function when adding an entry to a bill instead of an invoice.
Definition: gncInvoice.c:735

◆ gncInvoiceGetForeignCurrencies()

GHashTable* gncInvoiceGetForeignCurrencies ( const GncInvoice *  invoice)

Return an overview of amounts on this invoice that will be posted to accounts in currencies that are different from the invoice currency.

These accounts can be the accounts referred to in invoice entries or tax tables. This information is returned in the from of a hash table. The keys in the hash table are the foreign currencies, the values are the accumulated amounts in that currency. Drop the reference to the hash table with g_hash_table_unref when no longer needed.

Definition at line 1381 of file gncInvoice.c.

1382 {
1383  EntryList *entries_iter;
1384  gboolean is_cust_doc = (gncInvoiceGetOwnerType (invoice) == GNC_OWNER_CUSTOMER);
1385  gboolean is_cn = gncInvoiceGetIsCreditNote (invoice);
1386  GHashTable *amt_hash = g_hash_table_new_full (g_direct_hash, g_direct_equal,
1387  NULL, g_free);
1388  ENTER ("");
1389 
1390  for (entries_iter = invoice->entries; entries_iter != NULL; entries_iter = g_list_next(entries_iter))
1391  {
1392  GncEntry *entry = (GncEntry*)entries_iter->data;
1393  Account *this_acc;
1394  gnc_commodity *account_currency;
1395  AccountValueList *tt_amts = NULL, *tt_iter;
1396 
1397  /* Check entry's account currency */
1398  this_acc = (is_cust_doc ? gncEntryGetInvAccount (entry) :
1399  gncEntryGetBillAccount (entry));
1400  account_currency = xaccAccountGetCommodity (this_acc);
1401 
1402  if (this_acc &&
1403  !gnc_commodity_equal (gncInvoiceGetCurrency (invoice), account_currency))
1404  {
1405  gnc_numeric *curr_amt = (gnc_numeric*) g_hash_table_lookup (amt_hash, account_currency);
1406  gnc_numeric *entry_amt = (gnc_numeric*) g_new0 (gnc_numeric, 1);
1407  *entry_amt = gncEntryGetDocValue (entry, FALSE, is_cust_doc, is_cn);
1408  if (curr_amt)
1409  *entry_amt = gnc_numeric_add (*entry_amt, *curr_amt, GNC_DENOM_AUTO, GNC_HOW_RND_ROUND_HALF_UP);
1410  g_hash_table_insert (amt_hash, account_currency, entry_amt);
1411  }
1412 
1413  /* Check currencies of each account in the tax table linked
1414  * to the current entry */
1415  tt_amts = gncEntryGetDocTaxValues (entry, is_cust_doc, is_cn);
1416 
1417  if (!tt_amts)
1418  continue;
1419 
1420  for (tt_iter = tt_amts; tt_iter != NULL; tt_iter = g_list_next(tt_iter))
1421  {
1422  GncAccountValue *tt_amt_val = (GncAccountValue*)tt_iter->data;
1423  Account *tt_acc = tt_amt_val->account;
1424  gnc_commodity *tt_acc_currency = xaccAccountGetCommodity (tt_acc);
1425 
1426  if (tt_acc &&
1427  !gnc_commodity_equal (gncInvoiceGetCurrency (invoice), tt_acc_currency))
1428  {
1429  gnc_numeric *curr_amt = (gnc_numeric*) g_hash_table_lookup (amt_hash, tt_acc_currency);
1430  gnc_numeric *tt_acc_amt = (gnc_numeric*) g_new0 (gnc_numeric, 1);
1431  *tt_acc_amt = tt_amt_val->value;
1432  if (curr_amt)
1433  *tt_acc_amt = gnc_numeric_add (*tt_acc_amt, *curr_amt, GNC_DENOM_AUTO, GNC_HOW_RND_ROUND_HALF_UP);
1434  g_hash_table_insert (amt_hash, tt_acc_currency, tt_acc_amt);
1435  }
1436  }
1437  gncAccountValueDestroy (tt_amts);
1438  }
1439 
1440  LEAVE ("");
1441  return amt_hash;
1442 }
AccountValueList * gncEntryGetDocTaxValues(GncEntry *entry, gboolean is_cust_doc, gboolean is_cn)
Careful: the returned list is NOT owned by the entry and should be freed by the caller.
Definition: gncEntry.c:1544
gboolean gnc_commodity_equal(const gnc_commodity *a, const gnc_commodity *b)
This routine returns TRUE if the two commodities are equal.
gnc_numeric gnc_numeric_add(gnc_numeric a, gnc_numeric b, gint64 denom, gint how)
Return a+b.
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
Round to the nearest integer, rounding away from zero when there are two equidistant nearest integers...
Definition: gnc-numeric.h:166
void gncAccountValueDestroy(GList *list)
Destroy a list of accountvalues.
Definition: gncTaxTable.c:997
gnc_commodity * xaccAccountGetCommodity(const Account *acc)
Get the account's commodity.
Definition: Account.cpp:3448
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282
#define GNC_DENOM_AUTO
Values that can be passed as the 'denom' argument.
Definition: gnc-numeric.h:246

◆ gncInvoiceGetTotal()

gnc_numeric gncInvoiceGetTotal ( GncInvoice *  invoice)

Return the "total" amount of the invoice as seen on the document (and shown to the user in the reports and invoice ledger).

Definition at line 1026 of file gncInvoice.c.

1027 {
1028  if (!invoice) return gnc_numeric_zero ();
1029  return gncInvoiceGetTotalInternal (invoice, TRUE, TRUE, FALSE, 0);
1030 }

◆ gncInvoicePostToAccount()

Transaction* gncInvoicePostToAccount ( GncInvoice *  invoice,
Account acc,
time64  posted_date,
time64  due_date,
const char *  memo,
gboolean  accumulatesplits,
gboolean  autopay 
)

Post this invoice to an account.

Returns the new Transaction that is tied to this invoice. The transaction is set with the supplied posted date, due date, and memo. The Transaction description is set to the name of the company.

If accumulate splits is TRUE, entries in the same account will be merged into one single split in that account. Otherwise each entry will be posted as a separate split, possibly resulting in multiple splits in one account.

If autopay is TRUE, the code will try to find pre-payments, invoices or credit notes that can reduce the amount due for this invoice, marking the invoice as fully or partially paid, depending on the amounts on all documents involved. If autopay is FALSE, it's the user's responsibility to explicitly pay the invoice.

Definition at line 1515 of file gncInvoice.c.

1519 {
1520  Transaction *txn;
1521  QofBook *book;
1522  GNCLot *lot = NULL;
1523  GList *iter;
1524  GList *splitinfo = NULL;
1525  gnc_numeric total;
1526  gboolean is_cust_doc;
1527  gboolean is_cn;
1528  const char *name, *type;
1529  char *lot_title;
1530  Account *ccard_acct = NULL;
1531  const GncOwner *owner;
1532  int denom = xaccAccountGetCommoditySCU (acc);
1533  AccountValueList *taxes;
1534 
1535  if (!invoice || !acc) return NULL;
1536  if (gncInvoiceIsPosted (invoice)) return NULL;
1537 
1538  ENTER ("");
1539  gncInvoiceBeginEdit (invoice);
1540  book = qof_instance_get_book (invoice);
1541 
1542  /* Stabilize the Billing Terms of this invoice */
1543  if (invoice->terms)
1544  gncInvoiceSetTerms (invoice,
1545  gncBillTermReturnChild (invoice->terms, TRUE));
1546 
1547  /* GncEntry functions need to know if the invoice/credit note is for a customer or a vendor/employee. */
1548  is_cust_doc = (gncInvoiceGetOwnerType (invoice) == GNC_OWNER_CUSTOMER);
1549  is_cn = gncInvoiceGetIsCreditNote (invoice);
1550 
1551  /* Figure out if we need to separate out "credit-card" items */
1552  owner = gncOwnerGetEndOwner (gncInvoiceGetOwner (invoice));
1553  if (gncInvoiceGetOwnerType (invoice) == GNC_OWNER_EMPLOYEE)
1554  ccard_acct = gncEmployeeGetCCard (gncOwnerGetEmployee (owner));
1555 
1556  /* Create a new lot for this invoice */
1557  lot = gnc_lot_new (book);
1558  gncInvoiceAttachToLot (invoice, lot);
1559  gnc_lot_begin_edit (lot);
1560 
1561  type = gncInvoiceGetTypeString (invoice);
1562 
1563  /* Set the lot title */
1564  lot_title = g_strdup_printf ("%s %s", type, gncInvoiceGetID (invoice));
1565  gnc_lot_set_title (lot, lot_title);
1566  g_free (lot_title);
1567 
1568  /* Create a new transaction */
1569  txn = xaccMallocTransaction (book);
1570  xaccTransBeginEdit (txn);
1571 
1572  name = gncOwnerGetName (gncOwnerGetEndOwner (gncInvoiceGetOwner (invoice)));
1573 
1574  /* Set Transaction Description (Owner Name) , Num (invoice ID or type, based
1575  * on book option), Currency */
1576  xaccTransSetDescription (txn, name ? name : "");
1577  gnc_set_num_action (txn, NULL, gncInvoiceGetID (invoice), type);
1578  xaccTransSetCurrency (txn, invoice->currency);
1579 
1580  /* Entered and Posted at date */
1581  xaccTransSetDateEnteredSecs (txn, gnc_time (NULL));
1582  xaccTransSetDatePostedSecsNormalized (txn, post_date);
1583  gncInvoiceSetDatePosted (invoice, xaccTransRetDatePosted(txn));
1584 
1585  xaccTransSetDateDue (txn, due_date);
1586 
1587  /* Get invoice total and taxes. */
1588  total = gncInvoiceGetTotal (invoice);
1589  taxes = gncInvoiceGetTotalTaxList (invoice);
1590  /* The two functions above return signs relative to the document
1591  * We need to convert them to balance values before we can use them here
1592  * Note the odd construct comparing two booleans is to xor them
1593  * that is, only evaluate true if both are different.
1594  */
1595  if (is_cust_doc != is_cn)
1596  {
1597  GList *node;
1598  total = gnc_numeric_neg (total);
1599  for (node = taxes; node; node = node->next)
1600  {
1601  GncAccountValue *acc_val = node->data;
1602  acc_val->value = gnc_numeric_neg (acc_val->value);
1603  }
1604  }
1605 
1606  /* Iterate through the entries; sum up everything for each account.
1607  * then create the appropriate splits in this txn.
1608  */
1609 
1610  for (iter = gncInvoiceGetEntries (invoice); iter; iter = iter->next)
1611  {
1612  gnc_numeric value, tax;
1613  GncEntry * entry = iter->data;
1614  Account *this_acc;
1615 
1616  /* Stabilize the TaxTable in this entry */
1617  gncEntryBeginEdit (entry);
1618  if (is_cust_doc)
1619  gncEntrySetInvTaxTable
1620  (entry, gncTaxTableReturnChild (gncEntryGetInvTaxTable (entry), TRUE));
1621  else
1622  {
1623  gncEntrySetBillTaxTable
1624  (entry, gncTaxTableReturnChild (gncEntryGetBillTaxTable (entry), TRUE));
1625 
1626  /* If this is a bill, and the entry came from an invoice originally, copy the price */
1627  if (gncEntryGetBillable (entry))
1628  {
1629  /* We need to set the net price since it may be another tax rate for invoices than bills */
1630  gncEntrySetInvPrice (entry, gncEntryGetPrice (entry, FALSE, TRUE));
1631  gncEntrySetInvTaxIncluded (entry, FALSE);
1632  }
1633  }
1634  gncEntryCommitEdit (entry);
1635 
1636  /* Obtain the Entry's Value and TaxValues
1637  Note we use rounded values here and below to prevent creating an imbalanced transaction */
1638  value = gncEntryGetBalValue (entry, TRUE, is_cust_doc);
1639  tax = gncEntryGetBalTaxValue (entry, TRUE, is_cust_doc);
1640 
1641  DEBUG ("Tax %" PRId64 "/%" PRId64 " on entry value %" PRId64 "/%" PRId64,
1642  tax.num, tax.denom, value.num, value.denom);
1643  /* add the value for the account split */
1644  this_acc = (is_cust_doc ? gncEntryGetInvAccount (entry) :
1645  gncEntryGetBillAccount (entry));
1646  if (this_acc)
1647  {
1648  if (gnc_numeric_check (value) == GNC_ERROR_OK)
1649  {
1650  if (accumulatesplits)
1651  splitinfo = gncAccountValueAdd (splitinfo, this_acc, value);
1652  /* Adding to total in case of accumulatesplits will be deferred to later when each split is effectively added */
1653  else if (!gncInvoicePostAddSplit (book, this_acc, txn, value,
1654  gncEntryGetDescription (entry),
1655  type, invoice))
1656  {
1657  /*This is an error, which shouldn't even be able to happen.
1658  We can't really do anything sensible about it, and this is
1659  a user-interface free zone so we can't try asking the user
1660  again either, have to return NULL*/
1661  PERR("Failed to add split %s", gncEntryGetDescription (entry));
1662  LEAVE ("NULL");
1663  return NULL;
1664  }
1665 
1666  /* If there is a credit-card account, and this is a CCard
1667  * payment type, subtract it from the total, and instead
1668  * create a split to the CC Acct with a memo of the entry
1669  * description instead of the provided memo. Note that the
1670  * value reversal is the same as the post account.
1671  *
1672  * Note: we don't have to worry about the tax values --
1673  * expense vouchers don't have them.
1674  */
1675  if (ccard_acct && gncEntryGetBillPayment (entry) == GNC_PAYMENT_CARD)
1676  {
1677  Split *split;
1678 
1679  total = gnc_numeric_sub (total, value, denom,
1681 
1682  split = xaccMallocSplit (book);
1683  xaccSplitSetMemo (split, gncEntryGetDescription (entry));
1684  /* set action based on book option */
1685  gnc_set_num_action (NULL, split, gncInvoiceGetID (invoice), type);
1686  xaccAccountBeginEdit (ccard_acct);
1687  xaccAccountInsertSplit (ccard_acct, split);
1688  xaccAccountCommitEdit (ccard_acct);
1689  xaccTransAppendSplit (txn, split);
1690  xaccSplitSetBaseValue (split, gnc_numeric_neg (value),
1691  invoice->currency);
1692 
1693  }
1694 
1695  }
1696  else
1697  PWARN ("bad value in our entry");
1698  }
1699 
1700  /* check the taxes */
1701  if (gnc_numeric_check (tax) != GNC_ERROR_OK)
1702  PWARN ("bad tax in our entry");
1703 
1704  } /* for */
1705 
1706 
1707  /* now merge in the TaxValues */
1708  splitinfo = gncAccountValueAddList (splitinfo, taxes);
1709  gncAccountValueDestroy (taxes);
1710 
1711  /* Iterate through the splitinfo list and generate the splits */
1712  if (splitinfo)
1713  PINFO ("Processing Split List");
1714  for (iter = splitinfo; iter; iter = iter->next)
1715  {
1716  GncAccountValue *acc_val = iter->data;
1717 
1718  //gnc_numeric amt_rounded = gnc_numeric_convert(acc_val->value,
1719  // denom, GNC_HOW_DENOM_EXACT | GNC_HOW_RND_ROUND_HALF_UP);
1720  if (!gncInvoicePostAddSplit (book, acc_val->account, txn, acc_val->value,
1721  memo, type, invoice))
1722  {
1723  /*This is an error, which shouldn't even be able to happen.
1724  We can't really do anything sensible about it, and this is
1725  a user-interface free zone so we can't try asking the user
1726  again either, have to return NULL*/
1727  PERR("Failed to add split %s, aborting accumulated splits.", memo);
1728  return NULL;
1729  }
1730  }
1731 
1732  /* If there is a ccard account, we may have an additional "to_card" payment.
1733  * we should make that now.
1734  */
1735  if (ccard_acct && !gnc_numeric_zero_p (invoice->to_charge_amount))
1736  {
1737  Split *split = xaccMallocSplit (book);
1738 
1739  /* To charge amount is stored in document value. We need balance value here
1740  * so convert if necessary. */
1741  gnc_numeric to_charge_bal_amount = (is_cn ? gnc_numeric_neg (invoice->to_charge_amount)
1742  : invoice->to_charge_amount);
1743 
1744  PINFO ("Process to_card payment split");
1745  /* Set memo. */
1746  xaccSplitSetMemo (split, _("Extra to Charge Card"));
1747  /* Set action based on book option */
1748  gnc_set_num_action (NULL, split, gncInvoiceGetID (invoice), type);
1749 
1750  xaccAccountBeginEdit (ccard_acct);
1751  xaccAccountInsertSplit (ccard_acct, split);
1752  xaccAccountCommitEdit (ccard_acct);
1753  xaccTransAppendSplit (txn, split);
1754  xaccSplitSetBaseValue (split, gnc_numeric_neg (to_charge_bal_amount),
1755  invoice->currency);
1756 
1757  total = gnc_numeric_sub (total, to_charge_bal_amount, denom,
1759  }
1760 
1761  /* Now create the Posted split (which is the opposite sign of the above splits) */
1762  {
1763  Split *split = xaccMallocSplit (book);
1764 
1765  PINFO ("Process to_card balancing split");
1766  /* Set memo */
1767  xaccSplitSetMemo (split, memo);
1768  /* Set action based on book option */
1769  gnc_set_num_action (NULL, split, gncInvoiceGetID (invoice), type);
1770 
1771  xaccAccountBeginEdit (acc);
1772  xaccAccountInsertSplit (acc, split);
1773  xaccAccountCommitEdit (acc);
1774  xaccTransAppendSplit (txn, split);
1775  xaccSplitSetBaseValue (split, gnc_numeric_neg (total),
1776  invoice->currency);
1777 
1778  /* add this split to the lot */
1779  gnc_lot_add_split (lot, split);
1780  }
1781 
1782  /* Now attach this invoice to the txn and account */
1783  gncInvoiceAttachToTxn (invoice, txn);
1784  gncInvoiceSetPostedAcc (invoice, acc);
1785 
1786  xaccTransSetReadOnly (txn, _("Generated from an invoice. Try unposting the invoice."));
1787  xaccTransCommitEdit (txn);
1788 
1789  gncAccountValueDestroy (splitinfo);
1790 
1791  gnc_lot_commit_edit (lot);
1792  /* Not strictly necessary, since it was done by the Set calls
1793  * above, but good insurance. */
1794  DEBUG("Committing Invoice %s", invoice->id);
1795  mark_invoice (invoice);
1796  gncInvoiceCommitEdit (invoice);
1797 
1798  /* If requested, attempt to automatically apply open payments
1799  * and reverse documents to this lot to close it (or at least
1800  * reduce its balance) */
1801  if (autopay)
1802  gncInvoiceAutoApplyPayments (invoice);
1803 
1804  LEAVE ("");
1805  return txn;
1806 }
#define xaccTransAppendSplit(t, s)
Add a split to the transaction.
Definition: Transaction.h:362
Transaction * xaccMallocTransaction(QofBook *book)
The xaccMallocTransaction() will malloc memory and initialize it.
Definition: Transaction.c:510
void xaccSplitSetBaseValue(Split *s, gnc_numeric value, const gnc_commodity *base_currency)
Depending on the base_currency, set either the value or the amount of this split or both: If the base...
Definition: Split.c:1323
void xaccTransSetDatePostedSecsNormalized(Transaction *trans, time64 time)
This function sets the posted date of the transaction, specified by a time64 (see ctime(3))...
QofBook * qof_instance_get_book(gconstpointer inst)
Return the book pointer.
#define PINFO(format, args...)
Print an informational note.
Definition: qoflog.h:256
int xaccAccountGetCommoditySCU(const Account *acc)
Return the SCU for the account.
Definition: Account.cpp:2701
gnc_numeric gnc_numeric_neg(gnc_numeric a)
Returns a newly created gnc_numeric that is the negative of the given gnc_numeric value...
#define DEBUG(format, args...)
Print a debugging message.
Definition: qoflog.h:264
void gnc_lot_add_split(GNCLot *lot, Split *split)
The gnc_lot_add_split() routine adds a split to this lot.
Definition: gnc-lot.c:622
void xaccTransSetDescription(Transaction *trans, const char *desc)
Sets the transaction Description.
gboolean gnc_numeric_zero_p(gnc_numeric a)
Returns 1 if the given gnc_numeric is 0 (zero), else returns 0.
Use any denominator which gives an exactly correct ratio of numerator to denominator.
Definition: gnc-numeric.h:189
#define PERR(format, args...)
Log a serious error.
Definition: qoflog.h:244
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
Round to the nearest integer, rounding away from zero when there are two equidistant nearest integers...
Definition: gnc-numeric.h:166
gnc_numeric gncInvoiceGetTotal(GncInvoice *invoice)
Return the "total" amount of the invoice as seen on the document (and shown to the user in the report...
Definition: gncInvoice.c:1026
void gncInvoiceAutoApplyPayments(GncInvoice *invoice)
Attempt to pay the invoice using open payment lots and lots for documents of the opposite sign (credi...
Definition: gncInvoice.c:1980
void xaccTransSetCurrency(Transaction *trans, gnc_commodity *curr)
Set a new currency on a transaction.
Definition: Transaction.c:1425
#define PWARN(format, args...)
Log a warning.
Definition: qoflog.h:250
void xaccTransSetReadOnly(Transaction *trans, const char *reason)
Set the transaction to be ReadOnly by setting a non-NULL value as "reason".
Definition: Transaction.c:2139
void xaccSplitSetMemo(Split *split, const char *memo)
The memo is an arbitrary string associated with a split.
Definition: Split.c:1732
time64 xaccTransRetDatePosted(const Transaction *trans)
Retrieve the posted date of the transaction.
Definition: Transaction.c:2484
void xaccTransSetDateDue(Transaction *trans, time64 time)
Dates and txn-type for A/R and A/P "invoice" postings.
Definition: Transaction.c:2095
void xaccTransCommitEdit(Transaction *trans)
The xaccTransCommitEdit() method indicates that the changes to the transaction and its splits are com...
void gncAccountValueDestroy(GList *list)
Destroy a list of accountvalues.
Definition: gncTaxTable.c:997
void xaccTransBeginEdit(Transaction *trans)
The xaccTransBeginEdit() method must be called before any changes are made to a transaction or any of...
Split * xaccMallocSplit(QofBook *book)
Constructor.
Definition: gmock-Split.cpp:37
gnc_numeric gnc_numeric_sub(gnc_numeric a, gnc_numeric b, gint64 denom, gint how)
Return a-b.
const GncOwner * gncOwnerGetEndOwner(const GncOwner *owner)
Get the "parent" Owner or GncGUID thereof.
Definition: gncOwner.c:573
void xaccAccountBeginEdit(Account *acc)
The xaccAccountBeginEdit() subroutine is the first phase of a two-phase-commit wrapper for account up...
Definition: Account.cpp:1449
#define xaccAccountInsertSplit(acc, s)
The xaccAccountInsertSplit() method will insert the indicated split into the indicated account...
Definition: Account.h:1038
GList * gncAccountValueAddList(GList *l1, GList *l2)
Merge l2 into l1.
Definition: gncTaxTable.c:970
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282
time64 gnc_time(time64 *tbuf)
get the current local time
Definition: gnc-date.cpp:273
GNCNumericErrorCode gnc_numeric_check(gnc_numeric in)
Check for error signal in value.
GList * gncAccountValueAdd(GList *list, Account *acc, gnc_numeric value)
This will add value to the account-value for acc, creating a new list object if necessary.
Definition: gncTaxTable.c:942
void xaccTransSetDateEnteredSecs(Transaction *trans, time64 secs)
Modify the date of when the transaction was entered.
Definition: Transaction.c:2052
GncEmployee * gncOwnerGetEmployee(const GncOwner *owner)
If the given owner is of type GNC_OWNER_EMPLOYEE, returns the pointer to the employee object...
Definition: gncOwner.c:391
No error.
Definition: gnc-numeric.h:224
AccountValueList * gncInvoiceGetTotalTaxList(GncInvoice *invoice)
Return a list of tax totals accumulated per tax account.
Definition: gncInvoice.c:1050
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.cpp:1490

◆ gncInvoiceRemoveEntries()

void gncInvoiceRemoveEntries ( GncInvoice *  invoice)

Remove all entries from an invoice.

To be called before destroying an invoice.

Definition at line 776 of file gncInvoice.c.

777 {
778  GList *node;
779 
780  if (!invoice) return;
781 
782  for (node = invoice->entries; node; node = node->next)
783  {
784  GncEntry *entry = node->data;
785 
786  switch (gncInvoiceGetOwnerType (invoice))
787  {
788  case GNC_OWNER_VENDOR:
789  case GNC_OWNER_EMPLOYEE:
790  // this is a vendor bill, or an expense voucher
791  gncBillRemoveEntry (invoice, entry);
792  break;
793  case GNC_OWNER_CUSTOMER:
794  default:
795  // this is an invoice
796  gncInvoiceRemoveEntry (invoice, entry);
797  break;
798  }
799 
800  /* If the entry is no longer referenced by any document,
801  * remove it.
802  */
803  if (!(gncEntryGetInvoice (entry) ||
804  gncEntryGetBill (entry) ||
805  gncEntryGetOrder (entry)))
806  {
807  gncEntryBeginEdit (entry);
808  gncEntryDestroy (entry);
809  }
810  }
811 }

◆ gncInvoiceSetDateOpenedGDate()

void gncInvoiceSetDateOpenedGDate ( GncInvoice *  invoice,
const GDate *  date 
)

Set the DateOpened using a GDate argument.

(Note: Internally this stores the date in a time64 as created through time64CanonicalDayTime()).

Definition at line 494 of file gncInvoice.c.

495 {
496  g_assert (date);
497  gncInvoiceSetDateOpened(invoice, time64CanonicalDayTime (gdate_to_time64 (*date)));
498 }
time64 gdate_to_time64(GDate d)
Turns a GDate into a time64, returning the first second of the day.
Definition: gnc-date.cpp:1256
time64 time64CanonicalDayTime(time64 t)
convert a time64 on a certain day (localtime) to the time64 representing midday on that day...
Definition: gnc-date.cpp:413

◆ gncInvoiceUnpost()

gboolean gncInvoiceUnpost ( GncInvoice *  invoice,
gboolean  reset_tax_tables 
)

Unpost this invoice.

This will destroy the posted transaction and return the invoice to its unposted state. It may leave empty lots out there. If reset_tax_tables is TRUE, then it will also revert all the Tax Tables to the parent, which will potentially change the total value of the invoice. It may also leave some orphaned Tax Table children.

Returns TRUE if successful, FALSE if there is a problem.

Definition at line 1809 of file gncInvoice.c.

1810 {
1811  Transaction *txn;
1812  GNCLot *lot;
1813  GList *lot_split_list, *lot_split_iter;
1814 
1815  if (!invoice) return FALSE;
1816  if (!gncInvoiceIsPosted (invoice)) return FALSE;
1817 
1818  txn = gncInvoiceGetPostedTxn (invoice);
1819  g_return_val_if_fail (txn, FALSE);
1820 
1821  lot = gncInvoiceGetPostedLot (invoice);
1822  g_return_val_if_fail (lot, FALSE);
1823 
1824  ENTER ("");
1825  /* Destroy the Posted Transaction */
1826  xaccTransClearReadOnly (txn);
1827  xaccTransBeginEdit (txn);
1828  xaccTransDestroy (txn);
1829  xaccTransCommitEdit (txn);
1830 
1831  /* Disconnect the lot from the invoice; re-attach to the invoice owner */
1832  gncInvoiceDetachFromLot (lot);
1833  gncOwnerAttachToLot (&invoice->owner, lot);
1834 
1835  /* Check if this invoice was linked to other lots (payments/inverse signed
1836  * invoices).
1837  * If this is the case, recreate the link transaction between all the remaining lots.
1838  *
1839  * Note that before GnuCash 2.6 payments were not stored in separate lots, but
1840  * always ended up in invoice lots when matched to an invoice. Over-payments
1841  * were copied to a new lot, to which later an invoice was added again and so on.
1842  * These over-payments were handled with automatic payment forward transactions.
1843  * You could consider these transactions to be links between lots as well, but
1844  * to avoid some unexpected behavior, these will not be altered here.
1845  */
1846 
1847  // Note: make a copy of the lot list here, when splits are deleted from the lot,
1848  // the original list may be destroyed by the lot code.
1849  lot_split_list = g_list_copy (gnc_lot_get_split_list (lot));
1850  if (lot_split_list)
1851  PINFO ("Recreating link transactions for remaining lots");
1852  for (lot_split_iter = lot_split_list; lot_split_iter; lot_split_iter = lot_split_iter->next)
1853  {
1854  Split *split = lot_split_iter->data;
1855  GList *other_split_list, *list_iter;
1856  Transaction *other_txn = xaccSplitGetParent (split);
1857  GList *lot_list = NULL;
1858 
1859  /* Only work with transactions that link invoices and payments.
1860  * Note: this check also catches the possible case of NULL splits. */
1861  if (xaccTransGetTxnType (other_txn) != TXN_TYPE_LINK)
1862  continue;
1863 
1864  /* Save a list of lots this linking transaction linked to */
1865  other_split_list = xaccTransGetSplitList (other_txn);
1866  for (list_iter = other_split_list; list_iter; list_iter = list_iter->next)
1867  {
1868  Split *other_split = list_iter->data;
1869  GNCLot *other_lot = xaccSplitGetLot (other_split);
1870 
1871  /* Omit the lot we are about to delete */
1872  if (other_lot == lot)
1873  continue;
1874 
1875  lot_list = g_list_prepend (lot_list, other_lot);
1876  }
1877  /* Maintain original split order */
1878  lot_list = g_list_reverse (lot_list);
1879 
1880  /* Now remove this link transaction. */
1881  xaccTransClearReadOnly (other_txn);
1882  xaccTransBeginEdit (other_txn);
1883  xaccTransDestroy (other_txn);
1884  xaccTransCommitEdit (other_txn);
1885 
1886  /* Re-balance the saved lots as well as is possible */
1887  gncOwnerAutoApplyPaymentsWithLots (&invoice->owner, lot_list);
1888 
1889  /* If any of the saved lots has no more splits, then destroy it.
1890  * Otherwise if any has an invoice associated with it,
1891  * send it a modified event to reset its paid status */
1892  for (list_iter = lot_list; list_iter; list_iter = list_iter->next)
1893  {
1894  GNCLot *other_lot = list_iter->data;
1895  GncInvoice *other_invoice = gncInvoiceGetInvoiceFromLot (other_lot);
1896 
1897  if (!gnc_lot_count_splits (other_lot))
1898  gnc_lot_destroy (other_lot);
1899  else if (other_invoice)
1900  qof_event_gen (QOF_INSTANCE(other_invoice), QOF_EVENT_MODIFY, NULL);
1901  }
1902  g_list_free (lot_list);
1903  }
1904  g_list_free (lot_split_list);
1905 
1906  /* If the lot has no splits, then destroy it */
1907  if (!gnc_lot_count_splits (lot))
1908  gnc_lot_destroy (lot);
1909 
1910  /* Clear out the invoice posted information */
1911  gncInvoiceBeginEdit (invoice);
1912 
1913  invoice->posted_acc = NULL;
1914  invoice->posted_txn = NULL;
1915  invoice->posted_lot = NULL;
1916  invoice->date_posted = INT64_MAX;
1917 
1918  /* if we've been asked to reset the tax tables, then do so */
1919  if (reset_tax_tables)
1920  {
1921  gboolean is_cust_doc = (gncInvoiceGetOwnerType (invoice) == GNC_OWNER_CUSTOMER);
1922  GList *iter;
1923 
1924  for (iter = gncInvoiceGetEntries (invoice); iter; iter = iter->next)
1925  {
1926  GncEntry *entry = iter->data;
1927 
1928  gncEntryBeginEdit (entry);
1929  if (is_cust_doc)
1930  gncEntrySetInvTaxTable (entry,
1931  gncTaxTableGetParent (gncEntryGetInvTaxTable( entry)));
1932  else
1933  gncEntrySetBillTaxTable (entry,
1934  gncTaxTableGetParent (gncEntryGetBillTaxTable (entry)));
1935  gncEntryCommitEdit (entry);
1936  }
1937  }
1938 
1939  mark_invoice (invoice);
1940  gncInvoiceCommitEdit (invoice);
1941 
1942  LEAVE ("TRUE");
1943 
1944  return TRUE;
1945 }
char xaccTransGetTxnType(const Transaction *trans)
Returns the Transaction Type.
Definition: Transaction.c:2548
#define PINFO(format, args...)
Print an informational note.
Definition: qoflog.h:256
Transaction * xaccSplitGetParent(const Split *split)
Returns the parent transaction of the split.
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
void gncOwnerAutoApplyPaymentsWithLots(const GncOwner *owner, GList *lots)
Given a list of lots, try to balance as many of them as possible by creating balancing transactions b...
Definition: gncOwner.c:1259
void xaccTransDestroy(Transaction *trans)
Destroys a transaction.
SplitList * gnc_lot_get_split_list(const GNCLot *lot)
The gnc_lot_get_split_list() routine returns a GList of all the splits in this lot.
Definition: gnc-lot.c:436
void gncOwnerAttachToLot(const GncOwner *owner, GNCLot *lot)
Attach an owner to a lot.
Definition: gncOwner.c:623
void xaccTransCommitEdit(Transaction *trans)
The xaccTransCommitEdit() method indicates that the changes to the transaction and its splits are com...
#define TXN_TYPE_LINK
Transaction is a link between (invoice and payment) lots.
Definition: Transaction.h:127
void xaccTransBeginEdit(Transaction *trans)
The xaccTransBeginEdit() method must be called before any changes are made to a transaction or any of...
GncInvoice * gncInvoiceGetInvoiceFromLot(GNCLot *lot)
Given a LOT, find and return the Invoice attached to the lot.
Definition: gncInvoice.c:1307
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282
void qof_event_gen(QofInstance *entity, QofEventId event_id, gpointer event_data)
Invoke all registered event handlers using the given arguments.
Definition: qofevent.cpp:231
SplitList * xaccTransGetSplitList(const Transaction *trans)
The xaccTransGetSplitList() method returns a GList of the splits in a transaction.
GNCLot * xaccSplitGetLot(const Split *split)
Returns the pointer to the debited/credited Lot where this split belongs to, or NULL if it doesn't be...
Definition: Split.c:1885