GnuCash  4.8a-132-gcdaeb421d+
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 1354 of file gncInvoice.c.

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

◆ 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 1995 of file gncInvoice.c.

1999 {
2000  GNCLot *payment_lot;
2001  GList *selected_lots = NULL;
2002  const GncOwner *owner;
2003 
2004  /* Verify our arguments */
2005  if (!invoice || !gncInvoiceIsPosted (invoice) || !xfer_acc) return;
2006 
2007  owner = gncOwnerGetEndOwner (gncInvoiceGetOwner (invoice));
2008  g_return_if_fail (owner->owner.undefined);
2009 
2010  /* Create a lot for this payment */
2011  payment_lot = gncOwnerCreatePaymentLotSecs (owner, &txn,
2012  invoice->posted_acc,
2013  xfer_acc, amount, exch,
2014  date, memo, num);
2015 
2016  /* Select the invoice as only payment candidate */
2017  selected_lots = g_list_prepend (selected_lots, invoice->posted_lot);
2018 
2019  /* And link the invoice lot and the payment lot together as well as possible. */
2020  if (payment_lot)
2021  selected_lots = g_list_prepend (selected_lots, payment_lot);
2022  gncOwnerAutoApplyPaymentsWithLots (owner, selected_lots);
2023 }
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 342 of file gncInvoice.c.

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

◆ 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 1375 of file gncInvoice.c.

1376 {
1377  EntryList *entries_iter;
1378  gboolean is_cust_doc = (gncInvoiceGetOwnerType (invoice) == GNC_OWNER_CUSTOMER);
1379  gboolean is_cn = gncInvoiceGetIsCreditNote (invoice);
1380  GHashTable *amt_hash = g_hash_table_new_full (g_direct_hash, g_direct_equal,
1381  NULL, g_free);
1382 
1383  for (entries_iter = invoice->entries; entries_iter != NULL; entries_iter = g_list_next(entries_iter))
1384  {
1385  GncEntry *entry = (GncEntry*)entries_iter->data;
1386  Account *this_acc;
1387  gnc_commodity *account_currency;
1388  AccountValueList *tt_amts = NULL, *tt_iter;
1389 
1390  /* Check entry's account currency */
1391  this_acc = (is_cust_doc ? gncEntryGetInvAccount (entry) :
1392  gncEntryGetBillAccount (entry));
1393  account_currency = xaccAccountGetCommodity (this_acc);
1394 
1395  if (this_acc &&
1396  !gnc_commodity_equal (gncInvoiceGetCurrency (invoice), account_currency))
1397  {
1398  gnc_numeric *curr_amt = (gnc_numeric*) g_hash_table_lookup (amt_hash, account_currency);
1399  gnc_numeric *entry_amt = (gnc_numeric*) g_new0 (gnc_numeric, 1);
1400  *entry_amt = gncEntryGetDocValue (entry, FALSE, is_cust_doc, is_cn);
1401  if (curr_amt)
1402  *entry_amt = gnc_numeric_add (*entry_amt, *curr_amt, GNC_DENOM_AUTO, GNC_HOW_RND_ROUND_HALF_UP);
1403  g_hash_table_insert (amt_hash, account_currency, entry_amt);
1404  }
1405 
1406  /* Check currencies of each account in the tax table linked
1407  * to the current entry */
1408  tt_amts = gncEntryGetDocTaxValues (entry, is_cust_doc, is_cn);
1409 
1410  if (!tt_amts)
1411  continue;
1412 
1413  for (tt_iter = tt_amts; tt_iter != NULL; tt_iter = g_list_next(tt_iter))
1414  {
1415  GncAccountValue *tt_amt_val = (GncAccountValue*)tt_iter->data;
1416  Account *tt_acc = tt_amt_val->account;
1417  gnc_commodity *tt_acc_currency = xaccAccountGetCommodity (tt_acc);
1418 
1419  if (tt_acc &&
1420  !gnc_commodity_equal (gncInvoiceGetCurrency (invoice), tt_acc_currency))
1421  {
1422  gnc_numeric *curr_amt = (gnc_numeric*) g_hash_table_lookup (amt_hash, tt_acc_currency);
1423  gnc_numeric *tt_acc_amt = (gnc_numeric*) g_new0 (gnc_numeric, 1);
1424  *tt_acc_amt = tt_amt_val->value;
1425  if (curr_amt)
1426  *tt_acc_amt = gnc_numeric_add (*tt_acc_amt, *curr_amt, GNC_DENOM_AUTO, GNC_HOW_RND_ROUND_HALF_UP);
1427  g_hash_table_insert (amt_hash, tt_acc_currency, tt_acc_amt);
1428  }
1429  }
1430  gncAccountValueDestroy (tt_amts);
1431  }
1432  return amt_hash;
1433 }
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:1492
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.
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:3405
#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 1021 of file gncInvoice.c.

1022 {
1023  if (!invoice) return gnc_numeric_zero ();
1024  return gncInvoiceGetTotalInternal (invoice, TRUE, TRUE, FALSE, 0);
1025 }

◆ 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 1502 of file gncInvoice.c.

1506 {
1507  Transaction *txn;
1508  QofBook *book;
1509  GNCLot *lot = NULL;
1510  GList *iter;
1511  GList *splitinfo = NULL;
1512  gnc_numeric total;
1513  gboolean is_cust_doc;
1514  gboolean is_cn;
1515  const char *name, *type;
1516  char *lot_title;
1517  Account *ccard_acct = NULL;
1518  const GncOwner *owner;
1519  int denom = xaccAccountGetCommoditySCU (acc);
1520  AccountValueList *taxes;
1521 
1522  if (!invoice || !acc) return NULL;
1523  if (gncInvoiceIsPosted (invoice)) return NULL;
1524 
1525  gncInvoiceBeginEdit (invoice);
1526  book = qof_instance_get_book (invoice);
1527 
1528  /* Stabilize the Billing Terms of this invoice */
1529  if (invoice->terms)
1530  gncInvoiceSetTerms (invoice,
1531  gncBillTermReturnChild (invoice->terms, TRUE));
1532 
1533  /* GncEntry functions need to know if the invoice/credit note is for a customer or a vendor/employee. */
1534  is_cust_doc = (gncInvoiceGetOwnerType (invoice) == GNC_OWNER_CUSTOMER);
1535  is_cn = gncInvoiceGetIsCreditNote (invoice);
1536 
1537  /* Figure out if we need to separate out "credit-card" items */
1538  owner = gncOwnerGetEndOwner (gncInvoiceGetOwner (invoice));
1539  if (gncInvoiceGetOwnerType (invoice) == GNC_OWNER_EMPLOYEE)
1540  ccard_acct = gncEmployeeGetCCard (gncOwnerGetEmployee (owner));
1541 
1542  /* Create a new lot for this invoice */
1543  lot = gnc_lot_new (book);
1544  gncInvoiceAttachToLot (invoice, lot);
1545  gnc_lot_begin_edit (lot);
1546 
1547  type = gncInvoiceGetTypeString (invoice);
1548 
1549  /* Set the lot title */
1550  lot_title = g_strdup_printf ("%s %s", type, gncInvoiceGetID (invoice));
1551  gnc_lot_set_title (lot, lot_title);
1552  g_free (lot_title);
1553 
1554  /* Create a new transaction */
1555  txn = xaccMallocTransaction (book);
1556  xaccTransBeginEdit (txn);
1557 
1558  name = gncOwnerGetName (gncOwnerGetEndOwner (gncInvoiceGetOwner (invoice)));
1559 
1560  /* Set Transaction Description (Owner Name) , Num (invoice ID or type, based
1561  * on book option), Currency */
1562  xaccTransSetDescription (txn, name ? name : "");
1563  gnc_set_num_action (txn, NULL, gncInvoiceGetID (invoice), type);
1564  xaccTransSetCurrency (txn, invoice->currency);
1565 
1566  /* Entered and Posted at date */
1567  xaccTransSetDateEnteredSecs (txn, gnc_time (NULL));
1568  xaccTransSetDatePostedSecsNormalized (txn, post_date);
1569  gncInvoiceSetDatePosted (invoice, xaccTransRetDatePosted(txn));
1570 
1571  xaccTransSetDateDue (txn, due_date);
1572 
1573  /* Get invoice total and taxes. */
1574  total = gncInvoiceGetTotal (invoice);
1575  taxes = gncInvoiceGetTotalTaxList (invoice);
1576  /* The two functions above return signs relative to the document
1577  * We need to convert them to balance values before we can use them here
1578  * Note the odd construct comparing two booleans is to xor them
1579  * that is, only evaluate true if both are different.
1580  */
1581  if (is_cust_doc != is_cn)
1582  {
1583  GList *node;
1584  total = gnc_numeric_neg (total);
1585  for (node = taxes; node; node = node->next)
1586  {
1587  GncAccountValue *acc_val = node->data;
1588  acc_val->value = gnc_numeric_neg (acc_val->value);
1589  }
1590  }
1591 
1592  /* Iterate through the entries; sum up everything for each account.
1593  * then create the appropriate splits in this txn.
1594  */
1595 
1596  for (iter = gncInvoiceGetEntries (invoice); iter; iter = iter->next)
1597  {
1598  gnc_numeric value, tax;
1599  GncEntry * entry = iter->data;
1600  Account *this_acc;
1601 
1602  /* Stabilize the TaxTable in this entry */
1603  gncEntryBeginEdit (entry);
1604  if (is_cust_doc)
1605  gncEntrySetInvTaxTable
1606  (entry, gncTaxTableReturnChild (gncEntryGetInvTaxTable (entry), TRUE));
1607  else
1608  {
1609  gncEntrySetBillTaxTable
1610  (entry, gncTaxTableReturnChild (gncEntryGetBillTaxTable (entry), TRUE));
1611 
1612  /* If this is a bill, and the entry came from an invoice originally, copy the price */
1613  if (gncEntryGetBillable (entry))
1614  {
1615  /* We need to set the net price since it may be another tax rate for invoices than bills */
1616  gncEntrySetInvPrice (entry, gncEntryGetPrice (entry, FALSE, TRUE));
1617  gncEntrySetInvTaxIncluded (entry, FALSE);
1618  }
1619  }
1620  gncEntryCommitEdit (entry);
1621 
1622  /* Obtain the Entry's Value and TaxValues
1623  Note we use rounded values here and below to prevent creating an imbalanced transaction */
1624  value = gncEntryGetBalValue (entry, TRUE, is_cust_doc);
1625  tax = gncEntryGetBalTaxValue (entry, TRUE, is_cust_doc);
1626 
1627  /* add the value for the account split */
1628  this_acc = (is_cust_doc ? gncEntryGetInvAccount (entry) :
1629  gncEntryGetBillAccount (entry));
1630  if (this_acc)
1631  {
1632  if (gnc_numeric_check (value) == GNC_ERROR_OK)
1633  {
1634  if (accumulatesplits)
1635  splitinfo = gncAccountValueAdd (splitinfo, this_acc, value);
1636  /* Adding to total in case of accumulatesplits will be deferred to later when each split is effectively added */
1637  else if (!gncInvoicePostAddSplit (book, this_acc, txn, value,
1638  gncEntryGetDescription (entry),
1639  type, invoice))
1640  {
1641  /*This is an error, which shouldn't even be able to happen.
1642  We can't really do anything sensible about it, and this is
1643  a user-interface free zone so we can't try asking the user
1644  again either, have to return NULL*/
1645  return NULL;
1646  }
1647 
1648  /* If there is a credit-card account, and this is a CCard
1649  * payment type, subtract it from the total, and instead
1650  * create a split to the CC Acct with a memo of the entry
1651  * description instead of the provided memo. Note that the
1652  * value reversal is the same as the post account.
1653  *
1654  * Note: we don't have to worry about the tax values --
1655  * expense vouchers don't have them.
1656  */
1657  if (ccard_acct && gncEntryGetBillPayment (entry) == GNC_PAYMENT_CARD)
1658  {
1659  Split *split;
1660 
1661  total = gnc_numeric_sub (total, value, denom,
1663 
1664  split = xaccMallocSplit (book);
1665  xaccSplitSetMemo (split, gncEntryGetDescription (entry));
1666  /* set action based on book option */
1667  gnc_set_num_action (NULL, split, gncInvoiceGetID (invoice), type);
1668  xaccAccountBeginEdit (ccard_acct);
1669  xaccAccountInsertSplit (ccard_acct, split);
1670  xaccAccountCommitEdit (ccard_acct);
1671  xaccTransAppendSplit (txn, split);
1672  xaccSplitSetBaseValue (split, gnc_numeric_neg (value),
1673  invoice->currency);
1674 
1675  }
1676 
1677  }
1678  else
1679  g_warning ("bad value in our entry");
1680  }
1681 
1682  /* check the taxes */
1683  if (gnc_numeric_check (tax) != GNC_ERROR_OK)
1684  g_warning ("bad tax in our entry");
1685 
1686  } /* for */
1687 
1688 
1689  /* now merge in the TaxValues */
1690  splitinfo = gncAccountValueAddList (splitinfo, taxes);
1691  gncAccountValueDestroy (taxes);
1692 
1693  /* Iterate through the splitinfo list and generate the splits */
1694  for (iter = splitinfo; iter; iter = iter->next)
1695  {
1696  GncAccountValue *acc_val = iter->data;
1697 
1698  //gnc_numeric amt_rounded = gnc_numeric_convert(acc_val->value,
1699  // denom, GNC_HOW_DENOM_EXACT | GNC_HOW_RND_ROUND_HALF_UP);
1700  if (!gncInvoicePostAddSplit (book, acc_val->account, txn, acc_val->value,
1701  memo, type, invoice))
1702  {
1703  /*This is an error, which shouldn't even be able to happen.
1704  We can't really do anything sensible about it, and this is
1705  a user-interface free zone so we can't try asking the user
1706  again either, have to return NULL*/
1707  return NULL;
1708  }
1709  }
1710 
1711  /* If there is a ccard account, we may have an additional "to_card" payment.
1712  * we should make that now.
1713  */
1714  if (ccard_acct && !gnc_numeric_zero_p (invoice->to_charge_amount))
1715  {
1716  Split *split = xaccMallocSplit (book);
1717 
1718  /* To charge amount is stored in document value. We need balance value here
1719  * so convert if necessary. */
1720  gnc_numeric to_charge_bal_amount = (is_cn ? gnc_numeric_neg (invoice->to_charge_amount)
1721  : invoice->to_charge_amount);
1722 
1723  /* Set memo. */
1724  xaccSplitSetMemo (split, _("Extra to Charge Card"));
1725  /* Set action based on book option */
1726  gnc_set_num_action (NULL, split, gncInvoiceGetID (invoice), type);
1727 
1728  xaccAccountBeginEdit (ccard_acct);
1729  xaccAccountInsertSplit (ccard_acct, split);
1730  xaccAccountCommitEdit (ccard_acct);
1731  xaccTransAppendSplit (txn, split);
1732  xaccSplitSetBaseValue (split, gnc_numeric_neg (to_charge_bal_amount),
1733  invoice->currency);
1734 
1735  total = gnc_numeric_sub (total, to_charge_bal_amount, denom,
1737  }
1738 
1739  /* Now create the Posted split (which is the opposite sign of the above splits) */
1740  {
1741  Split *split = xaccMallocSplit (book);
1742 
1743  /* Set memo */
1744  xaccSplitSetMemo (split, memo);
1745  /* Set action based on book option */
1746  gnc_set_num_action (NULL, split, gncInvoiceGetID (invoice), type);
1747 
1748  xaccAccountBeginEdit (acc);
1749  xaccAccountInsertSplit (acc, split);
1750  xaccAccountCommitEdit (acc);
1751  xaccTransAppendSplit (txn, split);
1752  xaccSplitSetBaseValue (split, gnc_numeric_neg (total),
1753  invoice->currency);
1754 
1755  /* add this split to the lot */
1756  gnc_lot_add_split (lot, split);
1757  }
1758 
1759  /* Now attach this invoice to the txn and account */
1760  gncInvoiceAttachToTxn (invoice, txn);
1761  gncInvoiceSetPostedAcc (invoice, acc);
1762 
1763  xaccTransSetReadOnly (txn, _("Generated from an invoice. Try unposting the invoice."));
1764  xaccTransCommitEdit (txn);
1765 
1766  gncAccountValueDestroy (splitinfo);
1767 
1768  gnc_lot_commit_edit (lot);
1769  /* Not strictly necessary, since it was done by the Set calls
1770  * above, but good insurance. */
1771  DEBUG("Committing Invoice %s", invoice->id);
1772  mark_invoice (invoice);
1773  gncInvoiceCommitEdit (invoice);
1774 
1775  /* If requested, attempt to automatically apply open payments
1776  * and reverse documents to this lot to close it (or at least
1777  * reduce its balance) */
1778  if (autopay)
1779  gncInvoiceAutoApplyPayments (invoice);
1780 
1781  return txn;
1782 }
#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:1319
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.
int xaccAccountGetCommoditySCU(const Account *acc)
Return the SCU for the account.
Definition: Account.cpp:2682
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
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:1021
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:1951
void xaccTransSetCurrency(Transaction *trans, gnc_commodity *curr)
Set a new currency on a transaction.
Definition: Transaction.c:1425
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:1728
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:1430
#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
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:1045
void xaccAccountCommitEdit(Account *acc)
ThexaccAccountCommitEdit() subroutine is the second phase of a two-phase-commit wrapper for account u...
Definition: Account.cpp:1471

◆ gncInvoiceRemoveEntries()

void gncInvoiceRemoveEntries ( GncInvoice *  invoice)

Remove all entries from an invoice.

To be called before destroying an invoice.

Definition at line 775 of file gncInvoice.c.

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

◆ 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 493 of file gncInvoice.c.

494 {
495  g_assert (date);
496  gncInvoiceSetDateOpened(invoice, time64CanonicalDayTime (gdate_to_time64 (*date)));
497 }
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 1785 of file gncInvoice.c.

1786 {
1787  Transaction *txn;
1788  GNCLot *lot;
1789  GList *lot_split_list, *lot_split_iter;
1790 
1791  if (!invoice) return FALSE;
1792  if (!gncInvoiceIsPosted (invoice)) return FALSE;
1793 
1794  txn = gncInvoiceGetPostedTxn (invoice);
1795  g_return_val_if_fail (txn, FALSE);
1796 
1797  lot = gncInvoiceGetPostedLot (invoice);
1798  g_return_val_if_fail (lot, FALSE);
1799 
1800  /* Destroy the Posted Transaction */
1801  xaccTransClearReadOnly (txn);
1802  xaccTransBeginEdit (txn);
1803  xaccTransDestroy (txn);
1804  xaccTransCommitEdit (txn);
1805 
1806  /* Disconnect the lot from the invoice; re-attach to the invoice owner */
1807  gncInvoiceDetachFromLot (lot);
1808  gncOwnerAttachToLot (&invoice->owner, lot);
1809 
1810  /* Check if this invoice was linked to other lots (payments/inverse signed
1811  * invoices).
1812  * If this is the case, recreate the link transaction between all the remaining lots.
1813  *
1814  * Note that before GnuCash 2.6 payments were not stored in separate lots, but
1815  * always ended up in invoice lots when matched to an invoice. Over-payments
1816  * were copied to a new lot, to which later an invoice was added again and so on.
1817  * These over-payments were handled with automatic payment forward transactions.
1818  * You could consider these transactions to be links between lots as well, but
1819  * to avoid some unexpected behavior, these will not be altered here.
1820  */
1821 
1822  // Note: make a copy of the lot list here, when splits are deleted from the lot,
1823  // the original list may be destroyed by the lot code.
1824  lot_split_list = g_list_copy (gnc_lot_get_split_list (lot));
1825  for (lot_split_iter = lot_split_list; lot_split_iter; lot_split_iter = lot_split_iter->next)
1826  {
1827  Split *split = lot_split_iter->data;
1828  GList *other_split_list, *list_iter;
1829  Transaction *other_txn = xaccSplitGetParent (split);
1830  GList *lot_list = NULL;
1831 
1832  /* Only work with transactions that link invoices and payments.
1833  * Note: this check also catches the possible case of NULL splits. */
1834  if (xaccTransGetTxnType (other_txn) != TXN_TYPE_LINK)
1835  continue;
1836 
1837  /* Save a list of lots this linking transaction linked to */
1838  other_split_list = xaccTransGetSplitList (other_txn);
1839  for (list_iter = other_split_list; list_iter; list_iter = list_iter->next)
1840  {
1841  Split *other_split = list_iter->data;
1842  GNCLot *other_lot = xaccSplitGetLot (other_split);
1843 
1844  /* Omit the lot we are about to delete */
1845  if (other_lot == lot)
1846  continue;
1847 
1848  lot_list = g_list_prepend (lot_list, other_lot);
1849  }
1850  /* Maintain original split order */
1851  lot_list = g_list_reverse (lot_list);
1852 
1853  /* Now remove this link transaction. */
1854  xaccTransClearReadOnly (other_txn);
1855  xaccTransBeginEdit (other_txn);
1856  xaccTransDestroy (other_txn);
1857  xaccTransCommitEdit (other_txn);
1858 
1859  /* Re-balance the saved lots as well as is possible */
1860  gncOwnerAutoApplyPaymentsWithLots (&invoice->owner, lot_list);
1861 
1862  /* If any of the saved lots has no more splits, then destroy it.
1863  * Otherwise if any has an invoice associated with it,
1864  * send it a modified event to reset its paid status */
1865  for (list_iter = lot_list; list_iter; list_iter = list_iter->next)
1866  {
1867  GNCLot *other_lot = list_iter->data;
1868  GncInvoice *other_invoice = gncInvoiceGetInvoiceFromLot (other_lot);
1869 
1870  if (!gnc_lot_count_splits (other_lot))
1871  gnc_lot_destroy (other_lot);
1872  else if (other_invoice)
1873  qof_event_gen (QOF_INSTANCE(other_invoice), QOF_EVENT_MODIFY, NULL);
1874  }
1875  g_list_free (lot_list);
1876  }
1877  g_list_free (lot_split_list);
1878 
1879  /* If the lot has no splits, then destroy it */
1880  if (!gnc_lot_count_splits (lot))
1881  gnc_lot_destroy (lot);
1882 
1883  /* Clear out the invoice posted information */
1884  gncInvoiceBeginEdit (invoice);
1885 
1886  invoice->posted_acc = NULL;
1887  invoice->posted_txn = NULL;
1888  invoice->posted_lot = NULL;
1889  invoice->date_posted = INT64_MAX;
1890 
1891  /* if we've been asked to reset the tax tables, then do so */
1892  if (reset_tax_tables)
1893  {
1894  gboolean is_cust_doc = (gncInvoiceGetOwnerType (invoice) == GNC_OWNER_CUSTOMER);
1895  GList *iter;
1896 
1897  for (iter = gncInvoiceGetEntries (invoice); iter; iter = iter->next)
1898  {
1899  GncEntry *entry = iter->data;
1900 
1901  gncEntryBeginEdit (entry);
1902  if (is_cust_doc)
1903  gncEntrySetInvTaxTable (entry,
1904  gncTaxTableGetParent (gncEntryGetInvTaxTable( entry)));
1905  else
1906  gncEntrySetBillTaxTable (entry,
1907  gncTaxTableGetParent (gncEntryGetBillTaxTable (entry)));
1908  gncEntryCommitEdit (entry);
1909  }
1910  }
1911 
1912  mark_invoice (invoice);
1913  gncInvoiceCommitEdit (invoice);
1914 
1915  return TRUE;
1916 }
char xaccTransGetTxnType(const Transaction *trans)
Returns the Transaction Type.
Definition: Transaction.c:2548
Transaction * xaccSplitGetParent(const Split *split)
Returns the parent transaction of the split.
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:1301
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:1881