Invoice

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_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.
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).
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.
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.
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.
gboolean	gncInvoiceUnpost (GncInvoice *invoice, gboolean reset_tax_tables)
	Unpost this invoice.
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.
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.

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.
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 GncOwner *	gncInvoiceGetOwner (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)
GncOwner *	gncInvoiceGetBillTo (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)
Account *	gncInvoiceGetPostedAcc (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.

Macro Definition Documentation

GNC_ID_INVOICE

#define GNC_ID_INVOICE   "gncInvoice"

Definition at line 57 of file gncInvoice.h.

GNC_INVOICE

#define GNC_INVOICE

(

o

)

(G_TYPE_CHECK_INSTANCE_CAST ((o), GNC_TYPE_INVOICE, GncInvoice))

Definition at line 76 of file gncInvoice.h.

{
    if (book == NULL || guid == NULL) return NULL;
    QOF_BOOK_RETURN_ENTITY(book, guid, GNC_ID_INVOICE, GncInvoice);
}
 
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);
 
#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_JOB         "invoice_job"
 
#define INVOICE_FROM_LOT    "invoice-from-lot"
#define INVOICE_FROM_TXN    "invoice-from-txn"
 
QofBook *gncInvoiceGetBook (GncInvoice *x);
 
#define gncInvoiceGetGUID(x) qof_instance_get_guid (QOF_INSTANCE(x))
#define gncInvoiceRetGUID(x) (x ? *(qof_instance_get_guid (QOF_INSTANCE(x))) : *(guid_null()))
 
gboolean gncInvoiceEqual (const GncInvoice *a, const GncInvoice *b);
 
#ifdef __cplusplus
}
#endif
 
#endif /* GNC_INVOICE_H_ */

GNC_INVOICE_CLASS

#define GNC_INVOICE_CLASS

(

k

)

(G_TYPE_CHECK_CLASS_CAST((k), GNC_TYPE_INVOICE, GncInvoiceClass))

Definition at line 78 of file gncInvoice.h.

GNC_INVOICE_GET_CLASS

#define GNC_INVOICE_GET_CLASS

(

o

)

(G_TYPE_INSTANCE_GET_CLASS ((o), GNC_TYPE_INVOICE, GncInvoiceClass))

Definition at line 84 of file gncInvoice.h.

GNC_IS_INVOICE

#define GNC_IS_INVOICE

(

o

)

(G_TYPE_CHECK_INSTANCE_TYPE ((o), GNC_TYPE_INVOICE))

Definition at line 80 of file gncInvoice.h.

GNC_IS_INVOICE_CLASS

#define GNC_IS_INVOICE_CLASS

(

k

)

(G_TYPE_CHECK_CLASS_TYPE ((k), GNC_TYPE_INVOICE))

Definition at line 82 of file gncInvoice.h.

GNC_TYPE_INVOICE

#define GNC_TYPE_INVOICE   (gnc_invoice_get_type ())

Definition at line 75 of file gncInvoice.h.

gncInvoiceGetGUID

#define gncInvoiceGetGUID

(

x

)

qof_instance_get_guid (QOF_INSTANCE(x))

deprecated functions

Definition at line 314 of file gncInvoice.h.

gncInvoiceRetGUID

#define gncInvoiceRetGUID

(

x

)

(x ? *(qof_instance_get_guid (QOF_INSTANCE(x))) : *(guid_null()))

Definition at line 315 of file gncInvoice.h.

INVOICE_ACC

#define INVOICE_ACC   "account"

Definition at line 299 of file gncInvoice.h.

INVOICE_BILLINGID

#define INVOICE_BILLINGID   "billing_id"

Definition at line 296 of file gncInvoice.h.

INVOICE_BILLTO

#define INVOICE_BILLTO   "bill-to"

Definition at line 305 of file gncInvoice.h.

INVOICE_DOCLINK

#define INVOICE_DOCLINK   "doclink"

Definition at line 298 of file gncInvoice.h.

INVOICE_DUE

#define INVOICE_DUE   "date_due"

Definition at line 292 of file gncInvoice.h.

INVOICE_FROM_LOT

#define INVOICE_FROM_LOT   "invoice-from-lot"

Definition at line 308 of file gncInvoice.h.

INVOICE_FROM_TXN

#define INVOICE_FROM_TXN   "invoice-from-txn"

Definition at line 309 of file gncInvoice.h.

INVOICE_ID

#define INVOICE_ID   "id"

Definition at line 288 of file gncInvoice.h.

INVOICE_IS_CN

#define INVOICE_IS_CN   "credit_note"

Definition at line 302 of file gncInvoice.h.

INVOICE_IS_PAID

#define INVOICE_IS_PAID   "is_paid?"

Definition at line 294 of file gncInvoice.h.

INVOICE_IS_POSTED

#define INVOICE_IS_POSTED   "is_posted?"

Definition at line 293 of file gncInvoice.h.

INVOICE_JOB

#define INVOICE_JOB   "invoice_job"

Definition at line 306 of file gncInvoice.h.

INVOICE_NOTES

#define INVOICE_NOTES   "notes"

Definition at line 297 of file gncInvoice.h.

INVOICE_OPENED

#define INVOICE_OPENED   "date_opened"

Definition at line 290 of file gncInvoice.h.

INVOICE_OWNER

#define INVOICE_OWNER   "owner"

Definition at line 289 of file gncInvoice.h.

INVOICE_POST_LOT

#define INVOICE_POST_LOT   "posted_lot"

Definition at line 301 of file gncInvoice.h.

INVOICE_POST_TXN

#define INVOICE_POST_TXN   "posted_txn"

Definition at line 300 of file gncInvoice.h.

INVOICE_POSTED

#define INVOICE_POSTED   "date_posted"

Definition at line 291 of file gncInvoice.h.

INVOICE_TERMS

#define INVOICE_TERMS   "terms"

Definition at line 295 of file gncInvoice.h.

INVOICE_TYPE

#define INVOICE_TYPE   "type"

Definition at line 303 of file gncInvoice.h.

INVOICE_TYPE_STRING

#define INVOICE_TYPE_STRING   "type_string"

Definition at line 304 of file gncInvoice.h.

Typedef Documentation

EntryList

typedef GList EntryList

Definition at line 177 of file gncInvoice.h.

GncInvoiceList

typedef GList GncInvoiceList

Definition at line 42 of file gncInvoice.h.

Enumeration Type Documentation

GncInvoiceType

enum GncInvoiceType

Definition at line 59 of file gncInvoice.h.

{
    GNC_INVOICE_UNDEFINED ,
    GNC_INVOICE_CUST_INVOICE ,       /* Invoice */
    GNC_INVOICE_VEND_INVOICE ,       /* Bill */
    GNC_INVOICE_EMPL_INVOICE ,       /* Voucher */
    GNC_INVOICE_CUST_CREDIT_NOTE ,   /* Credit Note for a customer */
    GNC_INVOICE_VEND_CREDIT_NOTE ,   /* Credit Note from a vendor */
    GNC_INVOICE_EMPL_CREDIT_NOTE ,   /* Credit Note from an employee,
                                        not sure this makes sense,
                                        but all code is symmetrical
                                        so I've added it to prevent unexpected errors */
    GNC_INVOICE_NUM_TYPES
} GncInvoiceType;

Function Documentation

gncBillAddEntry()

void gncBillAddEntry	(	GncInvoice *	bill,
		GncEntry *	entry
	)

Call this function when adding an entry to a bill instead of an invoice.

Definition at line 719 of file gncInvoice.c.

{
    GncInvoice *old;
 
    g_assert (bill);
    g_assert (entry);
    if (!bill || !entry) return;
 
    old = gncEntryGetBill (entry);
    if (old == bill) return;    /* I already own this one */
    if (old) gncBillRemoveEntry (old, entry);
 
    gncInvoiceBeginEdit (bill);
    gncEntrySetBill (entry, bill);
    bill->entries = g_list_insert_sorted (bill->entries, entry,
                                          (GCompareFunc)gncEntryCompare);
    mark_invoice (bill);
    gncInvoiceCommitEdit (bill);
}

gncBillRemoveEntry()

void gncBillRemoveEntry	(	GncInvoice *	bill,
		GncEntry *	entry
	)

Definition at line 739 of file gncInvoice.c.

{
    if (!bill || !entry) return;
 
    gncInvoiceBeginEdit (bill);
    gncEntrySetBill (entry, NULL);
    bill->entries = g_list_remove (bill->entries, entry);
    mark_invoice (bill);
    gncInvoiceCommitEdit (bill);
}

gncInvoiceAddEntry()

void gncInvoiceAddEntry	(	GncInvoice *	invoice,
		GncEntry *	entry
	)

Definition at line 661 of file gncInvoice.c.

{
    GncInvoice *old;
 
    g_assert (invoice);
    g_assert (entry);
    if (!invoice || !entry) return;
 
    old = gncEntryGetInvoice (entry);
    if (old == invoice) return; /* I already own this one */
    if (old) gncInvoiceRemoveEntry (old, entry);
 
    gncInvoiceBeginEdit (invoice);
    gncEntrySetInvoice (entry, invoice);
    invoice->entries = g_list_insert_sorted (invoice->entries, entry,
                       (GCompareFunc)gncEntryCompare);
    mark_invoice (invoice);
    gncInvoiceCommitEdit (invoice);
}

gncInvoiceAddPrice()

void gncInvoiceAddPrice	(	GncInvoice *	invoice,
		GNCPrice *	price
	)

Definition at line 692 of file gncInvoice.c.

{
    GList *node;
    gnc_commodity *commodity;
 
    if (!invoice || !price) return;
 
    /* Keep only one price per commodity per invoice
     * So if a price was set previously remove it first */
    node = g_list_first (invoice->prices);
    commodity = gnc_price_get_commodity (price);
    while (node != NULL)
    {
        GNCPrice *curr = (GNCPrice*)node->data;
        if (gnc_commodity_equal (commodity, gnc_price_get_commodity (curr)))
            break;
        node = g_list_next (node);
    }
 
    gncInvoiceBeginEdit (invoice);
    if (node)
        invoice->prices = g_list_delete_link (invoice->prices, node);
    invoice->prices = g_list_prepend (invoice->prices, price);
    mark_invoice (invoice);
    gncInvoiceCommitEdit (invoice);
}

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

{
    switch (gncInvoiceGetType (invoice))
    {
    case GNC_INVOICE_CUST_INVOICE:
    case GNC_INVOICE_VEND_CREDIT_NOTE:
    case GNC_INVOICE_EMPL_CREDIT_NOTE:
        return TRUE;
    case GNC_INVOICE_CUST_CREDIT_NOTE:
    case GNC_INVOICE_VEND_INVOICE:
    case GNC_INVOICE_EMPL_INVOICE:
        return FALSE;
    case GNC_INVOICE_UNDEFINED:
    default:
        /* Should never be reached.
         * If it is, perhaps a new value is added to GncInvoiceType ? */
        g_assert_not_reached ();
        return FALSE;
    }
}

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

{
    GNCLot *payment_lot;
    GList *selected_lots = NULL;
    const GncOwner *owner;
 
    /* Verify our arguments */
    if (!invoice || !gncInvoiceIsPosted (invoice) || !xfer_acc) return;
 
    owner = gncOwnerGetEndOwner (gncInvoiceGetOwner (invoice));
    g_return_if_fail (owner->owner.undefined);
 
    /* Create a lot for this payment */
    payment_lot = gncOwnerCreatePaymentLotSecs (owner, &txn,
                                                invoice->posted_acc,
                                                xfer_acc, amount, exch,
                                                date, memo, num);
 
    /* Select the invoice as only payment candidate */
    selected_lots = g_list_prepend (selected_lots, invoice->posted_lot);
 
    /* And link the invoice lot and the payment lot together as well as possible. */
    if (payment_lot)
        selected_lots = g_list_prepend (selected_lots, payment_lot);
    gncOwnerAutoApplyPaymentsWithLots (owner, selected_lots);
}

gncInvoiceAutoApplyPayments()

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).

Definition at line 1907 of file gncInvoice.c.

{
    GNCLot *inv_lot;
    Account *acct;
    const GncOwner *owner;
    GList *lot_list;
    struct lotmatch lm;
 
    /* General note: "paying" in this context means balancing
     * a lot, by linking opposite signed lots together. So below the term
     * "payment" can both mean a true payment or it can mean a document of
     * the opposite sign (invoice vs credit note). It just
     * depends on what type of document was given as parameter
     * to this function. */
 
    /* Payments can only be applied to posted invoices */
    g_return_if_fail (invoice);
    g_return_if_fail (invoice->posted_lot);
 
    inv_lot = invoice->posted_lot;
    acct = invoice->posted_acc;
    owner = gncOwnerGetEndOwner (gncInvoiceGetOwner (invoice));
 
    /* Find all lots whose balance (or part of their balance) could be
     * used to close this lot.
     * To be eligible, the lots have to have an opposite signed balance
     * and be for the same owner.
     * For example, for an invoice lot, payment lots and credit note lots
     * could be used. */
    lm.positive_balance =  gnc_numeric_positive_p (gnc_lot_get_balance (inv_lot));
    lm.owner = owner;
    lot_list = xaccAccountFindOpenLots (acct, gnc_lot_match_owner_balancing,
                                        &lm, NULL);
 
    lot_list = g_list_prepend (lot_list, inv_lot);
    gncOwnerAutoApplyPaymentsWithLots (owner, lot_list);
    g_list_free (lot_list);
}

gncInvoiceBeginEdit()

void gncInvoiceBeginEdit

(

GncInvoice *

invoice

)

Definition at line 1996 of file gncInvoice.c.

{
    qof_begin_edit (&invoice->inst);
}

gncInvoiceCommitEdit()

void gncInvoiceCommitEdit

(

GncInvoice *

invoice

)

Definition at line 2015 of file gncInvoice.c.

{
    if (!qof_commit_edit (QOF_INSTANCE(invoice))) return;
    qof_commit_edit_part2 (&invoice->inst, gncInvoiceOnError,
                           gncInvoiceOnDone, invoice_free);
}

gncInvoiceCompare()

int gncInvoiceCompare	(	const GncInvoice *	a,
		const GncInvoice *	b
	)

Definition at line 2022 of file gncInvoice.c.

{
    int compare;
 
    if (a == b) return 0;
    if (!a) return -1;
    if (!b) return 1;
 
    compare = g_strcmp0 (a->id, b->id);
    if (compare) return compare;
    if (a->date_opened != b->date_opened) return a->date_opened - b->date_opened;
    if (a->date_posted != b->date_posted) return a->date_posted - b->date_posted;
    return qof_instance_guid_compare(a, b);
}

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

{
    GncInvoice *invoice;
    QofBook* book;
    GList *node;
    GValue v = G_VALUE_INIT;
 
    g_assert (from);
    book = qof_instance_get_book (from);
    g_assert (book);
 
    invoice = g_object_new (GNC_TYPE_INVOICE, NULL);
    qof_instance_init_data (&invoice->inst, _GNC_MOD_NAME, book);
 
    gncInvoiceBeginEdit (invoice);
 
    invoice->id = CACHE_INSERT (from->id);
    invoice->notes = CACHE_INSERT (from->notes);
    invoice->billing_id = CACHE_INSERT (from->billing_id);
    invoice->active = from->active;
 
    qof_instance_get_kvp (QOF_INSTANCE (from), &v, 1, GNC_INVOICE_IS_CN);
    if (G_VALUE_HOLDS_INT64 (&v))
         qof_instance_set_kvp (QOF_INSTANCE (invoice), &v, 1, GNC_INVOICE_IS_CN);
    g_value_unset (&v);
 
    invoice->terms = from->terms;
    gncBillTermIncRef (invoice->terms);
 
    gncOwnerCopy (&from->billto, &invoice->billto);
    gncOwnerCopy (&from->owner, &invoice->owner);
    invoice->job = from->job; // FIXME: Need IncRef or similar here?!?
 
    invoice->to_charge_amount = from->to_charge_amount;
    invoice->date_opened = from->date_opened;
 
    // Oops. Do not forget to copy the pointer to the correct currency here.
    invoice->currency = from->currency;
 
    gncInvoiceSetDocLink (invoice, gncInvoiceGetDocLink (from));
 
    // Copy all invoice->entries
    for (node = from->entries; node; node = node->next)
    {
        GncEntry *from_entry = node->data;
        GncEntry *to_entry = gncEntryCreate (book);
        gncEntryCopy (from_entry, to_entry, FALSE);
 
        switch (gncInvoiceGetOwnerType (invoice))
        {
        case GNC_OWNER_VENDOR:
        case GNC_OWNER_EMPLOYEE:
            // this is a vendor bill, or an expense voucher
            gncBillAddEntry (invoice, to_entry);
            break;
        case GNC_OWNER_CUSTOMER:
        default:
            // this is an invoice
            gncInvoiceAddEntry (invoice, to_entry);
            break;
        }
    }
 
    // FIXME: The prices are not (yet) copied; is this a problem?
 
    // Posted-date and the posted Txn is intentionally not copied; the
    // copy isn't "posted" but needs to be posted by the user.
    mark_invoice (invoice);
    gncInvoiceCommitEdit (invoice);
 
    return invoice;
}

gncInvoiceCreate()

GncInvoice * gncInvoiceCreate

(

QofBook *

book

)

Definition at line 313 of file gncInvoice.c.

{
    GncInvoice *invoice;
 
    if (!book) return NULL;
 
    invoice = g_object_new (GNC_TYPE_INVOICE, NULL);
    qof_instance_init_data (&invoice->inst, _GNC_MOD_NAME, book);
 
    invoice->id = CACHE_INSERT ("");
    invoice->notes = CACHE_INSERT ("");
    invoice->billing_id = CACHE_INSERT ("");
 
    invoice->billto.type = GNC_OWNER_CUSTOMER;
    invoice->active = TRUE;
 
    invoice->to_charge_amount = gnc_numeric_zero ();
 
    qof_event_gen (&invoice->inst, QOF_EVENT_CREATE, NULL);
 
    return invoice;
}

gncInvoiceDestroy()

void gncInvoiceDestroy

(

GncInvoice *

invoice

)

Definition at line 409 of file gncInvoice.c.

{
    if (!invoice) return;
    qof_instance_set_destroying (invoice, TRUE);
    gncInvoiceCommitEdit (invoice);
}

gncInvoiceEqual()

gboolean gncInvoiceEqual	(	const GncInvoice *	a,
		const GncInvoice *	b
	)

Test support function used by test-dbi-business-stuff.c.

Definition at line 2037 of file gncInvoice.c.

{
    if (a == NULL && b == NULL) return TRUE;
    if (a == NULL || b == NULL) return FALSE;
 
    g_return_val_if_fail (GNC_IS_INVOICE(a), FALSE);
    g_return_val_if_fail (GNC_IS_INVOICE(b), FALSE);
 
    if (g_strcmp0 (a->id, b->id) != 0)
    {
        PWARN("IDs differ: %s vs %s", a->id, b->id);
        return FALSE;
    }
 
    if (g_strcmp0 (a->notes, b->notes) != 0)
    {
        PWARN("Notes differ: %s vs %s", a->notes, b->notes);
        return FALSE;
    }
 
    if (g_strcmp0 (a->billing_id, b->billing_id) != 0)
    {
        PWARN("Billing IDs differ: %s vs %s", a->billing_id, b->billing_id);
        return FALSE;
    }
 
    if (g_strcmp0 (a->printname, b->printname) != 0)
    {
        PWARN("Printnames differ: %s vs %s", a->printname, b->printname);
        return FALSE;
    }
 
    if (a->active != b->active)
    {
        PWARN("Active flags differ");
        return FALSE;
    }
 
    if (!gncBillTermEqual (a->terms, b->terms))
    {
        PWARN("Billterms differ");
        return FALSE;
    }
 
    if (!gncJobEqual (a->job, b->job))
    {
        PWARN("Jobs differ");
        return FALSE;
    }
 
    if (!gnc_commodity_equal (a->currency, b->currency))
    {
        PWARN("Currencies differ");
        return FALSE;
    }
 
    if (!xaccAccountEqual (a->posted_acc, b->posted_acc, TRUE))
    {
        PWARN("Posted accounts differ");
        return FALSE;
    }
 
    if (!xaccTransEqual (a->posted_txn, b->posted_txn, TRUE, TRUE, TRUE, FALSE))
    {
        PWARN("Posted tx differ");
        return FALSE;
    }
 
#if 0
    if (!gncLotEqual (a->posted_lot, b->posted_lot))
    {
        PWARN("Posted lots differ");
        return FALSE;
    }
#endif
 
    /* FIXME: Need real checks */
#if 0
    GList       *entries;
    GList       *prices;
    GncOwner    owner;
    GncOwner    billto;
    time64      date_opened;
    time64      date_posted;
 
    gnc_numeric to_charge_amount;
#endif
 
    return TRUE;
}

gncInvoiceGetActive()

gboolean gncInvoiceGetActive

(

const GncInvoice *

invoice

)

Definition at line 1140 of file gncInvoice.c.

{
    if (!invoice) return FALSE;
    return invoice->active;
}

gncInvoiceGetBillingID()

const char * gncInvoiceGetBillingID

(

const GncInvoice *

invoice

)

Definition at line 864 of file gncInvoice.c.

{
    if (!invoice) return NULL;
    return invoice->billing_id;
}

gncInvoiceGetBillTo()

GncOwner * gncInvoiceGetBillTo

(

GncInvoice *

invoice

)

Definition at line 1116 of file gncInvoice.c.

{
    if (!invoice) return NULL;
    return &invoice->billto;
}

gncInvoiceGetBook()

QofBook * gncInvoiceGetBook

(

GncInvoice *

x

)

Definition at line 103 of file gncInvoice.c.

{
    return qof_instance_get_book (QOF_INSTANCE(x));
}

gncInvoiceGetCurrency()

gnc_commodity * gncInvoiceGetCurrency

(

const GncInvoice *

invoice

)

Definition at line 1110 of file gncInvoice.c.

{
    if (!invoice) return NULL;
    return invoice->currency;
}

gncInvoiceGetDateDue()

time64 gncInvoiceGetDateDue

(

const GncInvoice *

invoice

)

Definition at line 849 of file gncInvoice.c.

{
    Transaction *txn;
    if (!invoice) return INT64_MAX;
    txn = gncInvoiceGetPostedTxn (invoice);
    if (!txn) return INT64_MAX;
    return xaccTransRetDateDue (txn);
}

gncInvoiceGetDateOpened()

time64 gncInvoiceGetDateOpened

(

const GncInvoice *

invoice

)

Definition at line 837 of file gncInvoice.c.

{
    if (!invoice) return INT64_MAX;
    return invoice->date_opened;
}

gncInvoiceGetDatePosted()

time64 gncInvoiceGetDatePosted

(

const GncInvoice *

invoice

)

Definition at line 843 of file gncInvoice.c.

{
    if (!invoice) return INT64_MAX;
    return invoice->date_posted;
}

gncInvoiceGetDocLink()

const char * gncInvoiceGetDocLink

(

const GncInvoice *

invoice

)

Definition at line 876 of file gncInvoice.c.

{
    if (!invoice) return NULL;
 
    GValue v = G_VALUE_INIT;
    qof_instance_get_kvp (QOF_INSTANCE(invoice), &v, 1, GNC_INVOICE_DOCLINK);
    const char *rv = G_VALUE_HOLDS_STRING(&v) ? g_value_get_string (&v) : NULL;
    g_value_unset (&v);
 
    return rv;
}

gncInvoiceGetEntries()

EntryList * gncInvoiceGetEntries

(

GncInvoice *

invoice

)

Definition at line 1164 of file gncInvoice.c.

{
    if (!invoice) return NULL;
    return invoice->entries;
}

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

{
    EntryList *entries_iter;
    gboolean is_cust_doc = (gncInvoiceGetOwnerType (invoice) == GNC_OWNER_CUSTOMER);
    gboolean is_cn = gncInvoiceGetIsCreditNote (invoice);
    GHashTable *amt_hash = g_hash_table_new_full (g_direct_hash, g_direct_equal,
                                                  NULL, g_free);
    ENTER ("");
 
    for (entries_iter = invoice->entries; entries_iter != NULL; entries_iter = g_list_next(entries_iter))
    {
        GncEntry *entry = (GncEntry*)entries_iter->data;
        Account *this_acc;
        gnc_commodity *account_currency;
        AccountValueList *tt_amts = NULL, *tt_iter;
 
        /* Check entry's account currency */
        this_acc = (is_cust_doc ? gncEntryGetInvAccount (entry) :
                    gncEntryGetBillAccount (entry));
        account_currency = xaccAccountGetCommodity (this_acc);
 
        if (this_acc &&
                !gnc_commodity_equal (gncInvoiceGetCurrency (invoice), account_currency))
        {
            gnc_numeric *curr_amt = (gnc_numeric*) g_hash_table_lookup (amt_hash, account_currency);
            gnc_numeric *entry_amt = (gnc_numeric*) g_new0 (gnc_numeric, 1);
            *entry_amt = gncEntryGetDocValue (entry, FALSE, is_cust_doc, is_cn);
            if (curr_amt)
                *entry_amt = gnc_numeric_add (*entry_amt, *curr_amt, GNC_DENOM_AUTO, GNC_HOW_RND_ROUND_HALF_UP);
            g_hash_table_insert (amt_hash, account_currency, entry_amt);
        }
 
        /* Check currencies of each account in the tax table linked
         * to the current entry */
        tt_amts = gncEntryGetDocTaxValues (entry, is_cust_doc, is_cn);
 
        if (!tt_amts)
            continue;
 
        for (tt_iter = tt_amts; tt_iter != NULL; tt_iter = g_list_next(tt_iter))
        {
            GncAccountValue *tt_amt_val = (GncAccountValue*)tt_iter->data;
            Account *tt_acc = tt_amt_val->account;
            gnc_commodity *tt_acc_currency = xaccAccountGetCommodity (tt_acc);
 
            if (tt_acc &&
                    !gnc_commodity_equal (gncInvoiceGetCurrency (invoice), tt_acc_currency))
            {
                gnc_numeric *curr_amt = (gnc_numeric*) g_hash_table_lookup (amt_hash, tt_acc_currency);
                gnc_numeric *tt_acc_amt = (gnc_numeric*) g_new0 (gnc_numeric, 1);
                *tt_acc_amt = tt_amt_val->value;
                if (curr_amt)
                    *tt_acc_amt = gnc_numeric_add (*tt_acc_amt, *curr_amt, GNC_DENOM_AUTO, GNC_HOW_RND_ROUND_HALF_UP);
                g_hash_table_insert (amt_hash, tt_acc_currency, tt_acc_amt);
            }
        }
        gncAccountValueDestroy (tt_amts);
    }
 
    LEAVE ("");
    return amt_hash;
}

gncInvoiceGetID()

const char * gncInvoiceGetID

(

const GncInvoice *

invoice

)

Definition at line 801 of file gncInvoice.c.

{
    if (!invoice) return NULL;
    return invoice->id;
}

gncInvoiceGetInvoiceFromLot()

GncInvoice * gncInvoiceGetInvoiceFromLot

(

GNCLot *

lot

)

Given a LOT, find and return the Invoice attached to the lot.

Definition at line 1234 of file gncInvoice.c.

{
    GncGUID *guid = NULL;
    QofBook *book;
    GncInvoice *invoice = NULL;
 
    if (!lot) return NULL;
 
    invoice = gnc_lot_get_cached_invoice (lot);
    if (!invoice)
    {
        book = gnc_lot_get_book (lot);
        qof_instance_get (QOF_INSTANCE(lot), "invoice", &guid, NULL);
        invoice = gncInvoiceLookup (book, guid);
        guid_free (guid);
        gnc_lot_set_cached_invoice (lot, invoice);
    }
 
    return invoice;
}

gncInvoiceGetInvoiceFromTxn()

GncInvoice * gncInvoiceGetInvoiceFromTxn

(

const Transaction *

txn

)

Given a transaction, find and return the Invoice.

Definition at line 1272 of file gncInvoice.c.

{
    GncGUID *guid = NULL;
    QofBook *book;
    GncInvoice *invoice = NULL;
 
    if (!txn) return NULL;
 
    book = xaccTransGetBook (txn);
    qof_instance_get (QOF_INSTANCE (txn), "invoice", &guid, NULL);
    invoice = gncInvoiceLookup (book, guid);
    guid_free (guid);
    return invoice;
}

gncInvoiceGetIsCreditNote()

gboolean gncInvoiceGetIsCreditNote

(

const GncInvoice *

invoice

)

Definition at line 1146 of file gncInvoice.c.

{
    GValue v = G_VALUE_INIT;
    gboolean retval;
    if (!invoice) return FALSE;
    qof_instance_get_kvp (QOF_INSTANCE(invoice), &v, 1, GNC_INVOICE_IS_CN);
    retval = G_VALUE_HOLDS_INT64(&v) && g_value_get_int64 (&v);
    g_value_unset (&v);
    return retval;
}

gncInvoiceGetNotes()

const char * gncInvoiceGetNotes

(

const GncInvoice *

invoice

)

Definition at line 870 of file gncInvoice.c.

{
    if (!invoice) return NULL;
    return invoice->notes;
}

gncInvoiceGetOwner()

const GncOwner * gncInvoiceGetOwner

(

const GncInvoice *

invoice

)

Definition at line 807 of file gncInvoice.c.

{
    if (!invoice) return NULL;
    return &invoice->owner;
}

gncInvoiceGetOwnerType()

GncOwnerType gncInvoiceGetOwnerType

(

const GncInvoice *

invoice

)

Definition at line 888 of file gncInvoice.c.

{
    const GncOwner *owner;
    g_return_val_if_fail (invoice, GNC_OWNER_NONE);
 
    owner = gncOwnerGetEndOwner (gncInvoiceGetOwner (invoice));
    return (gncOwnerGetType (owner));
}

gncInvoiceGetPostedAcc()

Account * gncInvoiceGetPostedAcc

(

const GncInvoice *

invoice

)

Definition at line 1134 of file gncInvoice.c.

{
    if (!invoice) return NULL;
    return invoice->posted_acc;
}

gncInvoiceGetPostedLot()

GNCLot * gncInvoiceGetPostedLot

(

const GncInvoice *

invoice

)

Definition at line 1122 of file gncInvoice.c.

{
    if (!invoice) return NULL;
    return invoice->posted_lot;
}

gncInvoiceGetPostedTxn()

Transaction * gncInvoiceGetPostedTxn

(

const GncInvoice *

invoice

)

Definition at line 1128 of file gncInvoice.c.

{
    if (!invoice) return NULL;
    return invoice->posted_txn;
}

gncInvoiceGetPrice()

GNCPrice * gncInvoiceGetPrice	(	GncInvoice *	invoice,
		gnc_commodity *	commodity
	)

Definition at line 1170 of file gncInvoice.c.

{
    GList *node = g_list_first (invoice->prices);
 
    while (node != NULL)
    {
        GNCPrice *curr = (GNCPrice*)node->data;
 
        if (gnc_commodity_equal (commodity, gnc_price_get_commodity (curr)))
            return curr;
 
        node = g_list_next (node);
    }
 
    return NULL;
}

gncInvoiceGetTerms()

GncBillTerm * gncInvoiceGetTerms

(

const GncInvoice *

invoice

)

Definition at line 858 of file gncInvoice.c.

{
    if (!invoice) return NULL;
    return invoice->terms;
}

gncInvoiceGetToChargeAmount()

gnc_numeric gncInvoiceGetToChargeAmount

(

const GncInvoice *

invoice

)

Definition at line 1158 of file gncInvoice.c.

{
    if (!invoice) return gnc_numeric_zero ();
    return invoice->to_charge_amount;
}

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

{
    if (!invoice) return gnc_numeric_zero ();
    return gncInvoiceGetTotalInternal (invoice, TRUE, TRUE, FALSE, 0);
}

gncInvoiceGetTotalOf()

gnc_numeric gncInvoiceGetTotalOf	(	GncInvoice *	invoice,
		GncEntryPaymentType	type
	)

Definition at line 1026 of file gncInvoice.c.

{
    if (!invoice) return gnc_numeric_zero ();
    return gncInvoiceGetTotalInternal (invoice, TRUE, TRUE, TRUE, type);
}

gncInvoiceGetTotalSubtotal()

gnc_numeric gncInvoiceGetTotalSubtotal

(

GncInvoice *

invoice

)

Definition at line 1014 of file gncInvoice.c.

{
    if (!invoice) return gnc_numeric_zero ();
    return gncInvoiceGetTotalInternal (invoice, TRUE, FALSE, FALSE, 0);
}

gncInvoiceGetTotalTax()

gnc_numeric gncInvoiceGetTotalTax

(

GncInvoice *

invoice

)

Definition at line 1020 of file gncInvoice.c.

{
    if (!invoice) return gnc_numeric_zero ();
    return gncInvoiceGetTotalInternal (invoice, FALSE, TRUE, FALSE, 0);
}

gncInvoiceGetTotalTaxList()

AccountValueList * gncInvoiceGetTotalTaxList

(

GncInvoice *

invoice

)

Return a list of tax totals accumulated per tax account.

Definition at line 1032 of file gncInvoice.c.

{
    AccountValueList *taxes;
    if (!invoice) return NULL;
 
    gncInvoiceGetNetAndTaxesInternal (invoice, FALSE, &taxes, FALSE, 0);
    return taxes;
}

gncInvoiceGetType()

GncInvoiceType gncInvoiceGetType

(

const GncInvoice *

invoice

)

Definition at line 1065 of file gncInvoice.c.

{
    if (!invoice) return GNC_INVOICE_UNDEFINED;
    switch (gncInvoiceGetOwnerType (invoice))
    {
    case GNC_OWNER_CUSTOMER:
        return (gncInvoiceGetIsCreditNote (invoice) ?
                GNC_INVOICE_CUST_CREDIT_NOTE :
                GNC_INVOICE_CUST_INVOICE);
    case GNC_OWNER_VENDOR:
        return (gncInvoiceGetIsCreditNote (invoice) ?
                GNC_INVOICE_VEND_CREDIT_NOTE :
                GNC_INVOICE_VEND_INVOICE);
    case GNC_OWNER_EMPLOYEE:
        return (gncInvoiceGetIsCreditNote (invoice) ?
                GNC_INVOICE_EMPL_CREDIT_NOTE :
                GNC_INVOICE_EMPL_INVOICE);
    default:
        PWARN ("No invoice types defined for owner %d",
               gncInvoiceGetOwnerType (invoice));
        return GNC_INVOICE_UNDEFINED;
    }
}

gncInvoiceGetTypeListForOwnerType()

GList * gncInvoiceGetTypeListForOwnerType

(

const GncOwnerType

type

)

Definition at line 1041 of file gncInvoice.c.

{
    GList *type_list = NULL;
    switch (type)
    {
    case GNC_OWNER_CUSTOMER:
        type_list = g_list_append (type_list, GINT_TO_POINTER(GNC_INVOICE_CUST_INVOICE));
        type_list = g_list_append (type_list, GINT_TO_POINTER(GNC_INVOICE_CUST_CREDIT_NOTE));
        return type_list;
    case GNC_OWNER_VENDOR:
        type_list = g_list_append (type_list, GINT_TO_POINTER(GNC_INVOICE_VEND_INVOICE));
        type_list = g_list_append (type_list, GINT_TO_POINTER(GNC_INVOICE_VEND_CREDIT_NOTE));
        return type_list;
    case GNC_OWNER_EMPLOYEE:
        type_list = g_list_append (type_list, GINT_TO_POINTER(GNC_INVOICE_EMPL_INVOICE));
        type_list = g_list_append (type_list, GINT_TO_POINTER(GNC_INVOICE_EMPL_CREDIT_NOTE));
        return type_list;
    default:
        PWARN("Bad owner type, no invoices.");
        return NULL;
    }
 
}

gncInvoiceGetTypeString()

const char * gncInvoiceGetTypeString

(

const GncInvoice *

invoice

)

Definition at line 1089 of file gncInvoice.c.

{
    GncInvoiceType type = gncInvoiceGetType (invoice);
    switch (type)
    {
    case GNC_INVOICE_CUST_INVOICE:
        return _("Invoice");
    case GNC_INVOICE_VEND_INVOICE:
        return _("Bill");
    case GNC_INVOICE_EMPL_INVOICE:
        return _("Expense");
    case GNC_INVOICE_CUST_CREDIT_NOTE:
    case GNC_INVOICE_VEND_CREDIT_NOTE:
    case GNC_INVOICE_EMPL_CREDIT_NOTE:
        return _("Credit Note");
    default:
        PWARN("Unknown invoice type");
        return NULL;
    }
}

gncInvoiceIsPaid()

gboolean gncInvoiceIsPaid

(

const GncInvoice *

invoice

)

Definition at line 1987 of file gncInvoice.c.

{
    if (!invoice) return FALSE;
    if (!invoice->posted_lot) return FALSE;
    return gnc_lot_is_closed (invoice->posted_lot);
}

gncInvoiceIsPosted()

gboolean gncInvoiceIsPosted

(

const GncInvoice *

invoice

)

Definition at line 1981 of file gncInvoice.c.

{
    if (!invoice) return FALSE;
    return GNC_IS_TRANSACTION(gncInvoiceGetPostedTxn (invoice));
}

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

{
    Transaction *txn;
    QofBook *book;
    GNCLot *lot = NULL;
    GList *iter;
    GList *splitinfo = NULL;
    gnc_numeric total;
    gboolean is_cust_doc;
    gboolean is_cn;
    const char *name, *type;
    char *lot_title;
    Account *ccard_acct = NULL;
    const GncOwner *owner;
    int denom = xaccAccountGetCommoditySCU (acc);
    AccountValueList *taxes;
 
    if (!invoice || !acc) return NULL;
    if (gncInvoiceIsPosted (invoice)) return NULL;
 
    ENTER ("");
    gncInvoiceBeginEdit (invoice);
    book = qof_instance_get_book (invoice);
 
    /* Stabilize the Billing Terms of this invoice */
    if (invoice->terms)
        gncInvoiceSetTerms (invoice,
                            gncBillTermReturnChild (invoice->terms, TRUE));
 
    /* GncEntry functions need to know if the invoice/credit note is for a customer or a vendor/employee. */
    is_cust_doc = (gncInvoiceGetOwnerType (invoice) == GNC_OWNER_CUSTOMER);
    is_cn = gncInvoiceGetIsCreditNote (invoice);
 
    /* Figure out if we need to separate out "credit-card" items */
    owner = gncOwnerGetEndOwner (gncInvoiceGetOwner (invoice));
    if (gncInvoiceGetOwnerType (invoice) == GNC_OWNER_EMPLOYEE)
        ccard_acct = gncEmployeeGetCCard (gncOwnerGetEmployee (owner));
 
    /* Create a new lot for this invoice */
    lot = gnc_lot_new (book);
    gncInvoiceAttachToLot (invoice, lot);
    gnc_lot_begin_edit (lot);
 
    type = gncInvoiceGetTypeString (invoice);
 
    /* Set the lot title */
    lot_title = g_strdup_printf ("%s %s", type, gncInvoiceGetID (invoice));
    gnc_lot_set_title (lot, lot_title);
    g_free (lot_title);
 
    /* Create a new transaction */
    txn = xaccMallocTransaction (book);
    xaccTransBeginEdit (txn);
 
    name = gncOwnerGetName (gncOwnerGetEndOwner (gncInvoiceGetOwner (invoice)));
 
    /* Set Transaction Description (Owner Name) , Num (invoice ID or type, based
     * on book option), Currency */
    xaccTransSetDescription (txn, name ? name : "");
    gnc_set_num_action (txn, NULL, gncInvoiceGetID (invoice), type);
    xaccTransSetCurrency (txn, invoice->currency);
 
    /* Entered and Posted at date */
    xaccTransSetDateEnteredSecs (txn, gnc_time (NULL));
    xaccTransSetDatePostedSecsNormalized (txn, post_date);
    gncInvoiceSetDatePosted (invoice, xaccTransRetDatePosted(txn));
 
    xaccTransSetDateDue (txn, due_date);
 
    /* Get invoice total and taxes. */
    total = gncInvoiceGetTotal (invoice);
    taxes = gncInvoiceGetTotalTaxList (invoice);
    /* The two functions above return signs relative to the document
     * We need to convert them to balance values before we can use them here
     * Note the odd construct comparing two booleans is to xor them
     * that is, only evaluate true if both are different.
     */
    if (is_cust_doc != is_cn)
    {
        GList *node;
        total = gnc_numeric_neg (total);
        for (node = taxes; node; node = node->next)
        {
            GncAccountValue *acc_val = node->data;
            acc_val->value = gnc_numeric_neg (acc_val->value);
        }
    }
 
    /* Iterate through the entries; sum up everything for each account.
     * then create the appropriate splits in this txn.
     */
 
    for (iter = gncInvoiceGetEntries (invoice); iter; iter = iter->next)
    {
        gnc_numeric value, tax;
        GncEntry * entry = iter->data;
        Account *this_acc;
 
        /* Stabilize the TaxTable in this entry */
        gncEntryBeginEdit (entry);
        if (is_cust_doc)
            gncEntrySetInvTaxTable
            (entry, gncTaxTableReturnChild (gncEntryGetInvTaxTable (entry), TRUE));
        else
        {
            gncEntrySetBillTaxTable
            (entry, gncTaxTableReturnChild (gncEntryGetBillTaxTable (entry), TRUE));
 
            /* If this is a bill, and the entry came from an invoice originally, copy the price */
            if (gncEntryGetBillable (entry))
            {
                /* We need to set the net price since it may be another tax rate for invoices than bills */
                gncEntrySetInvPrice (entry, gncEntryGetPrice (entry, FALSE, TRUE));
                gncEntrySetInvTaxIncluded (entry, FALSE);
            }
        }
        gncEntryCommitEdit (entry);
 
        /* Obtain the Entry's Value and TaxValues
           Note we use rounded values here and below to prevent creating an imbalanced transaction */
        value = gncEntryGetBalValue (entry, TRUE, is_cust_doc);
        tax   = gncEntryGetBalTaxValue (entry, TRUE, is_cust_doc);
 
        DEBUG ("Tax %" PRId64 "/%" PRId64 " on entry value %" PRId64 "/%" PRId64,
               tax.num, tax.denom, value.num, value.denom);
        /* add the value for the account split */
        this_acc = (is_cust_doc ? gncEntryGetInvAccount (entry) :
                    gncEntryGetBillAccount (entry));
        if (this_acc)
        {
            if (gnc_numeric_check (value) == GNC_ERROR_OK)
            {
                if (accumulatesplits)
                    splitinfo = gncAccountValueAdd (splitinfo, this_acc, value);
                    /* Adding to total in case of accumulatesplits will be deferred to later when each split is effectively added */
                else if (!gncInvoicePostAddSplit (book, this_acc, txn, value,
                                                  gncEntryGetDescription (entry),
                                                  type, invoice))
                {
                    /*This is an error, which shouldn't even be able to happen.
                      We can't really do anything sensible about it, and this is
                      a user-interface free zone so we can't try asking the user
                      again either, have to return NULL*/
                    PERR("Failed to add split %s", gncEntryGetDescription (entry));
                    LEAVE ("NULL");
                    return NULL;
                }
 
                /* If there is a credit-card account, and this is a CCard
                 * payment type, subtract it from the total, and instead
                 * create a split to the CC Acct with a memo of the entry
                 * description instead of the provided memo.  Note that the
                 * value reversal is the same as the post account.
                 *
                 * Note: we don't have to worry about the tax values --
                 * expense vouchers don't have them.
                 */
                if (ccard_acct && gncEntryGetBillPayment (entry) == GNC_PAYMENT_CARD)
                {
                    Split *split;
 
                    total = gnc_numeric_sub (total, value, denom,
                                             GNC_HOW_DENOM_EXACT | GNC_HOW_RND_ROUND_HALF_UP);
 
                    split = xaccMallocSplit (book);
                    xaccSplitSetMemo (split, gncEntryGetDescription (entry));
                    /* set action based on book option */
                    gnc_set_num_action (NULL, split, gncInvoiceGetID (invoice), type);
                    xaccAccountBeginEdit (ccard_acct);
                    xaccAccountInsertSplit (ccard_acct, split);
                    xaccAccountCommitEdit (ccard_acct);
                    xaccTransAppendSplit (txn, split);
                    xaccSplitSetBaseValue (split, gnc_numeric_neg (value),
                                           invoice->currency);
 
                }
 
            }
            else
                PWARN ("bad value in our entry");
        }
 
        /* check the taxes */
        if (gnc_numeric_check (tax) != GNC_ERROR_OK)
            PWARN ("bad tax in our entry");
 
    } /* for */
 
 
    /* now merge in the TaxValues */
    splitinfo = gncAccountValueAddList (splitinfo, taxes);
    gncAccountValueDestroy (taxes);
 
    /* Iterate through the splitinfo list and generate the splits */
    if (splitinfo)
        PINFO ("Processing Split List");
    for (iter = splitinfo; iter; iter = iter->next)
    {
        GncAccountValue *acc_val = iter->data;
 
        //gnc_numeric amt_rounded = gnc_numeric_convert(acc_val->value,
        //    denom, GNC_HOW_DENOM_EXACT | GNC_HOW_RND_ROUND_HALF_UP);
        if (!gncInvoicePostAddSplit (book, acc_val->account, txn, acc_val->value,
                                     memo, type, invoice))
        {
            /*This is an error, which shouldn't even be able to happen.
              We can't really do anything sensible about it, and this is
              a user-interface free zone so we can't try asking the user
              again either, have to return NULL*/
            PERR("Failed to add split %s, aborting accumulated splits.", memo);
            return NULL;
        }
    }
 
    /* If there is a ccard account, we may have an additional "to_card" payment.
     * we should make that now.
     */
    if (ccard_acct && !gnc_numeric_zero_p (invoice->to_charge_amount))
    {
        Split *split = xaccMallocSplit (book);
 
        /* To charge amount is stored in document value. We need balance value here
         * so convert if necessary. */
        gnc_numeric to_charge_bal_amount = (is_cn ? gnc_numeric_neg (invoice->to_charge_amount)
                                            : invoice->to_charge_amount);
 
        PINFO ("Process to_card payment split");
        /* Set memo. */
        xaccSplitSetMemo (split, _("Extra to Charge Card"));
        /* Set action based on book option */
        gnc_set_num_action (NULL, split, gncInvoiceGetID (invoice), type);
 
        xaccAccountBeginEdit (ccard_acct);
        xaccAccountInsertSplit (ccard_acct, split);
        xaccAccountCommitEdit (ccard_acct);
        xaccTransAppendSplit (txn, split);
        xaccSplitSetBaseValue (split, gnc_numeric_neg (to_charge_bal_amount),
                               invoice->currency);
 
        total = gnc_numeric_sub (total, to_charge_bal_amount, denom,
                                 GNC_HOW_DENOM_EXACT | GNC_HOW_RND_ROUND_HALF_UP);
    }
 
    /* Now create the Posted split (which is the opposite sign of the above splits) */
    {
        Split *split = xaccMallocSplit (book);
 
        PINFO ("Process to_card balancing split");
        /* Set memo */
        xaccSplitSetMemo (split, memo);
        /* Set action based on book option */
        gnc_set_num_action (NULL, split, gncInvoiceGetID (invoice), type);
 
        xaccAccountBeginEdit (acc);
        xaccAccountInsertSplit (acc, split);
        xaccAccountCommitEdit (acc);
        xaccTransAppendSplit (txn, split);
        xaccSplitSetBaseValue (split, gnc_numeric_neg (total),
                               invoice->currency);
 
        /* add this split to the lot */
        gnc_lot_add_split (lot, split);
    }
 
    /* Now attach this invoice to the txn and account */
    gncInvoiceAttachToTxn (invoice, txn);
    gncInvoiceSetPostedAcc (invoice, acc);
 
    xaccTransSetReadOnly (txn, _("Generated from an invoice. Try unposting the invoice."));
    xaccTransCommitEdit (txn);
 
    gncAccountValueDestroy (splitinfo);
 
    gnc_lot_commit_edit (lot);
    /* Not strictly necessary, since it was done by the Set calls
     * above, but good insurance. */
    DEBUG("Committing Invoice %s", invoice->id);
    mark_invoice (invoice);
    gncInvoiceCommitEdit (invoice);
 
    /* If requested, attempt to automatically apply open payments
     * and reverse documents to this lot to close it (or at least
     * reduce its balance) */
    if (autopay)
        gncInvoiceAutoApplyPayments (invoice);
 
    LEAVE ("");
    return txn;
}

gncInvoiceRemoveEntries()

void gncInvoiceRemoveEntries

(

GncInvoice *

invoice

)

Remove all entries from an invoice.

To be called before destroying an invoice.

Definition at line 760 of file gncInvoice.c.

{
    if (!invoice) return;
 
    // gnc{Bill,Invoice}RemoveEntry free the "entry" node.
    // Make sure to save "next" first.
    for (GList *next, *node = invoice->entries; node; node = next)
    {
        next = node->next;
        GncEntry *entry = node->data;
 
        switch (gncInvoiceGetOwnerType (invoice))
        {
        case GNC_OWNER_VENDOR:
        case GNC_OWNER_EMPLOYEE:
            // this is a vendor bill, or an expense voucher
            gncBillRemoveEntry (invoice, entry);
            break;
        case GNC_OWNER_CUSTOMER:
        default:
            // this is an invoice
            gncInvoiceRemoveEntry (invoice, entry);
            break;
        }
 
        /* If the entry is no longer referenced by any document,
         * remove it.
         */
        if (!(gncEntryGetInvoice (entry) ||
              gncEntryGetBill (entry) ||
              gncEntryGetOrder (entry)))
        {
            gncEntryBeginEdit (entry);
            gncEntryDestroy (entry);
        }
    }
}

gncInvoiceRemoveEntry()

void gncInvoiceRemoveEntry	(	GncInvoice *	invoice,
		GncEntry *	entry
	)

Definition at line 681 of file gncInvoice.c.

{
    if (!invoice || !entry) return;
 
    gncInvoiceBeginEdit (invoice);
    gncEntrySetInvoice (entry, NULL);
    invoice->entries = g_list_remove (invoice->entries, entry);
    mark_invoice (invoice);
    gncInvoiceCommitEdit (invoice);
}

gncInvoiceSetActive()

void gncInvoiceSetActive	(	GncInvoice *	invoice,
		gboolean	active
	)

Definition at line 566 of file gncInvoice.c.

{
    if (!invoice) return;
    if (invoice->active == active) return;
    gncInvoiceBeginEdit (invoice);
    invoice->active = active;
    mark_invoice (invoice);
    gncInvoiceCommitEdit (invoice);
}

gncInvoiceSetBillingID()

void gncInvoiceSetBillingID	(	GncInvoice *	invoice,
		const char *	billing_id
	)

Definition at line 528 of file gncInvoice.c.

{
    if (!invoice) return;
    SET_STR (invoice, invoice->billing_id, billing_id);
    mark_invoice (invoice);
    gncInvoiceCommitEdit (invoice);
}

gncInvoiceSetBillTo()

void gncInvoiceSetBillTo	(	GncInvoice *	invoice,
		GncOwner *	billto
	)

Definition at line 607 of file gncInvoice.c.

{
    if (!invoice || !billto) return;
    if (gncOwnerEqual (&invoice->billto, billto)) return;
 
    gncInvoiceBeginEdit (invoice);
    gncOwnerCopy (billto, &invoice->billto);
    mark_invoice (invoice);
    gncInvoiceCommitEdit (invoice);
}

gncInvoiceSetCurrency()

void gncInvoiceSetCurrency	(	GncInvoice *	invoice,
		gnc_commodity *	currency
	)

Definition at line 595 of file gncInvoice.c.

{
    if (!invoice || !currency) return;
    if (invoice->currency &&
            gnc_commodity_equal (invoice->currency, currency))
        return;
    gncInvoiceBeginEdit (invoice);
    invoice->currency = currency;
    mark_invoice (invoice);
    gncInvoiceCommitEdit (invoice);
}

gncInvoiceSetDateOpened()

void gncInvoiceSetDateOpened	(	GncInvoice *	invoice,
		time64	date
	)

Definition at line 494 of file gncInvoice.c.

{
    if (!invoice) return;
    if (date == invoice->date_opened) return;
    gncInvoiceBeginEdit (invoice);
    invoice->date_opened = date;
    mark_invoice (invoice);
    gncInvoiceCommitEdit (invoice);
}

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

{
    g_assert (date);
    gncInvoiceSetDateOpened(invoice, time64CanonicalDayTime (gdate_to_time64 (*date)));
}

gncInvoiceSetDatePosted()

void gncInvoiceSetDatePosted	(	GncInvoice *	invoice,
		time64	date
	)

Definition at line 504 of file gncInvoice.c.

{
    if (!invoice) return;
    if (date == invoice->date_posted) return;
    gncInvoiceBeginEdit (invoice);
    invoice->date_posted = date;
    mark_invoice (invoice);
    gncInvoiceCommitEdit (invoice);
}

gncInvoiceSetDocLink()

void gncInvoiceSetDocLink	(	GncInvoice *	invoice,
		const char *	doclink
	)

Definition at line 544 of file gncInvoice.c.

{
    if (!invoice || !doclink) return;
 
    gncInvoiceBeginEdit (invoice);
 
    if (doclink[0] == '\0')
    {
        qof_instance_set_kvp (QOF_INSTANCE (invoice), NULL, 1, GNC_INVOICE_DOCLINK);
    }
    else
    {
        GValue v = G_VALUE_INIT;
        g_value_init (&v, G_TYPE_STRING);
        g_value_set_static_string (&v, doclink);
        qof_instance_set_kvp (QOF_INSTANCE (invoice), &v, 1, GNC_INVOICE_DOCLINK);
        g_value_unset (&v);
    }
    qof_instance_set_dirty (QOF_INSTANCE(invoice));
    gncInvoiceCommitEdit (invoice);
}

gncInvoiceSetID()

void gncInvoiceSetID	(	GncInvoice *	invoice,
		const char *	id
	)

Definition at line 444 of file gncInvoice.c.

{
    if (!invoice || !id) return;
    SET_STR (invoice, invoice->id, id);
    mark_invoice (invoice);
    gncInvoiceCommitEdit (invoice);
}

gncInvoiceSetIsCreditNote()

void gncInvoiceSetIsCreditNote	(	GncInvoice *	invoice,
		gboolean	credit_note
	)

Definition at line 576 of file gncInvoice.c.

{
     GValue v = G_VALUE_INIT;
    if (!invoice) return;
    gncInvoiceBeginEdit (invoice);
    g_value_init (&v, G_TYPE_INT64);
    g_value_set_int64 (&v, credit_note ? 1 : 0);
    qof_instance_set_kvp (QOF_INSTANCE (invoice), &v, 1, GNC_INVOICE_IS_CN);
    g_value_unset (&v);
    mark_invoice (invoice);
    gncInvoiceCommitEdit (invoice);
 
    /* If this is a credit note, set a feature flag for it in the book
     * This will prevent older GnuCash versions that don't support
     * credit notes to open this file. */
    if (credit_note)
        gnc_features_set_used (gncInvoiceGetBook (invoice), GNC_FEATURE_CREDIT_NOTES);
}

gncInvoiceSetNotes()

void gncInvoiceSetNotes	(	GncInvoice *	invoice,
		const char *	notes
	)

Definition at line 536 of file gncInvoice.c.

{
    if (!invoice || !notes) return;
    SET_STR (invoice, invoice->notes, notes);
    mark_invoice (invoice);
    gncInvoiceCommitEdit (invoice);
}

gncInvoiceSetOwner()

void gncInvoiceSetOwner	(	GncInvoice *	invoice,
		GncOwner *	owner
	)

Definition at line 452 of file gncInvoice.c.

{
    if (!invoice || !owner) return;
    if (gncOwnerEqual (&invoice->owner, owner)) return;
    gncInvoiceBeginEdit (invoice);
    gncOwnerCopy (owner, &invoice->owner);
    mark_invoice (invoice);
    gncInvoiceCommitEdit (invoice);
}

gncInvoiceSetTerms()

void gncInvoiceSetTerms	(	GncInvoice *	invoice,
		GncBillTerm *	terms
	)

Definition at line 514 of file gncInvoice.c.

{
    if (!invoice) return;
    if (invoice->terms == terms) return;
    gncInvoiceBeginEdit (invoice);
    if (invoice->terms)
        gncBillTermDecRef (invoice->terms);
    invoice->terms = terms;
    if (invoice->terms)
        gncBillTermIncRef (invoice->terms);
    mark_invoice (invoice);
    gncInvoiceCommitEdit (invoice);
}

gncInvoiceSetToChargeAmount()

void gncInvoiceSetToChargeAmount	(	GncInvoice *	invoice,
		gnc_numeric	amount
	)

Definition at line 618 of file gncInvoice.c.

{
    if (!invoice) return;
    if (gnc_numeric_equal (invoice->to_charge_amount, amount)) return;
    gncInvoiceBeginEdit (invoice);
    invoice->to_charge_amount = amount;
    mark_invoice (invoice);
    gncInvoiceCommitEdit (invoice);
}

gncInvoiceSortEntries()

void gncInvoiceSortEntries

(

GncInvoice *

invoice

)

Call this function when an Entry is changed and you want to re-sort the list of entries.

Definition at line 750 of file gncInvoice.c.

{
    if (!invoice) return;
    invoice->entries = g_list_sort (invoice->entries,
                                   (GCompareFunc)gncEntryCompare);
    gncInvoiceBeginEdit (invoice);
    mark_invoice (invoice);
    gncInvoiceCommitEdit (invoice);
}

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

{
    Transaction *txn;
    GNCLot *lot;
    GList *lot_split_list, *lot_split_iter;
 
    if (!invoice) return FALSE;
    if (!gncInvoiceIsPosted (invoice)) return FALSE;
 
    txn = gncInvoiceGetPostedTxn (invoice);
    g_return_val_if_fail (txn, FALSE);
 
    lot = gncInvoiceGetPostedLot (invoice);
    g_return_val_if_fail (lot, FALSE);
 
    ENTER ("");
    /* Destroy the Posted Transaction */
    xaccTransClearReadOnly (txn);
    xaccTransBeginEdit (txn);
    xaccTransDestroy (txn);
    xaccTransCommitEdit (txn);
 
    /* Disconnect the lot from the invoice; re-attach to the invoice owner */
    gncInvoiceDetachFromLot (lot);
    gncOwnerAttachToLot (&invoice->owner, lot);
 
    /* Check if this invoice was linked to other lots (payments/inverse signed
     * invoices).
     * If this is the case, recreate the link transaction between all the remaining lots.
     *
     * Note that before GnuCash 2.6 payments were not stored in separate lots, but
     * always ended up in invoice lots when matched to an invoice. Over-payments
     * were copied to a new lot, to which later an invoice was added again and so on.
     * These over-payments were handled with automatic payment forward transactions.
     * You could consider these transactions to be links between lots as well, but
     * to avoid some unexpected behavior, these will not be altered here.
     */
 
    // Note: make a copy of the lot list here, when splits are deleted from the lot,
    //       the original list may be destroyed by the lot code.
    lot_split_list = g_list_copy (gnc_lot_get_split_list (lot));
    if (lot_split_list)
        PINFO ("Recreating link transactions for remaining lots");
    for (lot_split_iter = lot_split_list; lot_split_iter; lot_split_iter = lot_split_iter->next)
    {
        Split *split = lot_split_iter->data;
        GList *other_split_list, *list_iter;
        Transaction *other_txn = xaccSplitGetParent (split);
        GList *lot_list = NULL;
 
        /* Only work with transactions that link invoices and payments.
         * Note: this check also catches the possible case of NULL splits. */
        if (xaccTransGetTxnType (other_txn) != TXN_TYPE_LINK)
            continue;
 
        /* Save a list of lots this linking transaction linked to */
        other_split_list = xaccTransGetSplitList (other_txn);
        for (list_iter = other_split_list; list_iter; list_iter = list_iter->next)
        {
            Split *other_split = list_iter->data;
            GNCLot *other_lot = xaccSplitGetLot (other_split);
 
            /* Omit the lot we are about to delete */
            if (other_lot == lot)
                continue;
 
            lot_list = g_list_prepend (lot_list, other_lot);
        }
        /* Maintain original split order */
        lot_list = g_list_reverse (lot_list);
 
        /* Now remove this link transaction. */
        xaccTransClearReadOnly (other_txn);
        xaccTransBeginEdit (other_txn);
        xaccTransDestroy (other_txn);
        xaccTransCommitEdit (other_txn);
 
        /* Re-balance the saved lots as well as is possible */
        gncOwnerAutoApplyPaymentsWithLots (&invoice->owner, lot_list);
 
        /* If any of the saved lots has no more splits, then destroy it.
         * Otherwise if any has an invoice associated with it,
         * send it a modified event to reset its paid status */
        for (list_iter = lot_list; list_iter; list_iter = list_iter->next)
        {
            GNCLot *other_lot = list_iter->data;
            GncInvoice *other_invoice = gncInvoiceGetInvoiceFromLot (other_lot);
 
            if (!gnc_lot_count_splits (other_lot))
                gnc_lot_destroy (other_lot);
            else if (other_invoice)
                qof_event_gen (QOF_INSTANCE(other_invoice), QOF_EVENT_MODIFY, NULL);
        }
        g_list_free (lot_list);
    }
    g_list_free (lot_split_list);
 
    /* If the lot has no splits, then destroy it */
    if (!gnc_lot_count_splits (lot))
        gnc_lot_destroy (lot);
 
    /* Clear out the invoice posted information */
    gncInvoiceBeginEdit (invoice);
 
    invoice->posted_acc = NULL;
    invoice->posted_txn = NULL;
    invoice->posted_lot = NULL;
    invoice->date_posted = INT64_MAX;
 
    /* if we've been asked to reset the tax tables, then do so */
    if (reset_tax_tables)
    {
        gboolean is_cust_doc = (gncInvoiceGetOwnerType (invoice) == GNC_OWNER_CUSTOMER);
        GList *iter;
 
        for (iter = gncInvoiceGetEntries (invoice); iter; iter = iter->next)
        {
            GncEntry *entry = iter->data;
 
            gncEntryBeginEdit (entry);
            if (is_cust_doc)
                gncEntrySetInvTaxTable (entry,
                                        gncTaxTableGetParent (gncEntryGetInvTaxTable( entry)));
            else
                gncEntrySetBillTaxTable (entry,
                                         gncTaxTableGetParent (gncEntryGetBillTaxTable (entry)));
            gncEntryCommitEdit (entry);
        }
    }
 
    mark_invoice (invoice);
    gncInvoiceCommitEdit (invoice);
 
    LEAVE ("TRUE");
 
    return TRUE;
}