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

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 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);
}

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;
}

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;
}

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);
}

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);
        }
    }
}

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)));
}

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;
}