Invoice

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_ACC   "account"
#define	INVOICE_POST_TXN   "posted_txn"
#define	INVOICE_POST_LOT   "posted_lot"
#define	INVOICE_IS_CN   "credit_note"
#define	INVOICE_TYPE   "type"
#define	INVOICE_TYPE_STRING   "type_string"
#define	INVOICE_BILLTO   "bill-to"
#define	INVOICE_ENTRIES   "list_of_entries"
#define	INVOICE_JOB   "invoice_job"
#define	INVOICE_FROM_LOT   "invoice-from-lot"
#define	INVOICE_FROM_TXN   "invoice-from-txn"
#define	gncInvoiceGetGUID(x)   qof_instance_get_guid(QOF_INSTANCE(x))
#define	gncInvoiceRetGUID(x)   (x ? *(qof_instance_get_guid(QOF_INSTANCE(x))) : *(guid_null()))

Typedefs
typedef struct _gncInvoice	GncInvoice
typedef struct _gncInvoiceClass	GncInvoiceClass
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)
void	gncBillRemoveEntry (GncInvoice *bill, GncEntry *entry)
void	gncInvoiceSortEntries (GncInvoice *invoice)
void	gncInvoiceRemoveEntries (GncInvoice *invoice)
gnc_numeric	gncInvoiceGetTotal (GncInvoice *invoice)
gnc_numeric	gncInvoiceGetTotalOf (GncInvoice *invoice, GncEntryPaymentType type)
gnc_numeric	gncInvoiceGetTotalSubtotal (GncInvoice *invoice)
gnc_numeric	gncInvoiceGetTotalTax (GncInvoice *invoice)
EntryList *	gncInvoiceGetEntries (GncInvoice *invoice)
GNCPrice *	gncInvoiceGetPrice (GncInvoice *invoice, gnc_commodity *commodity)
gboolean	gncInvoiceAmountPositive (const GncInvoice *invoice)
GHashTable *	gncInvoiceGetForeignCurrencies (const GncInvoice *invoice)
Transaction *	gncInvoicePostToAccount (GncInvoice *invoice, Account *acc, Timespec *posted_date, Timespec *due_date, const char *memo, gboolean accumulatesplits, gboolean autopay)
gboolean	gncInvoiceUnpost (GncInvoice *invoice, gboolean reset_tax_tables)
void	gncInvoiceAutoApplyPayments (GncInvoice *invoice)
void	gncInvoiceApplyPayment (const GncInvoice *invoice, Transaction *txn, Account *xfer_acc, gnc_numeric amount, gnc_numeric exch, Timespec date, const char *memo, const char *num)
GncInvoice *	gncInvoiceGetInvoiceFromTxn (const Transaction *txn)
GncInvoice *	gncInvoiceGetInvoiceFromLot (GNCLot *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)

Create/Destroy Functions
GncInvoice *	gncInvoiceCreate (QofBook *book)
void	gncInvoiceDestroy (GncInvoice *invoice)
GncInvoice *	gncInvoiceCopy (const GncInvoice *other_invoice)

Set Functions
void	gncInvoiceSetID (GncInvoice *invoice, const char *id)
void	gncInvoiceSetOwner (GncInvoice *invoice, GncOwner *owner)
void	gncInvoiceSetDateOpenedGDate (GncInvoice *invoice, const GDate *date)
void	gncInvoiceSetDateOpened (GncInvoice *invoice, Timespec date)
void	gncInvoiceSetDatePosted (GncInvoice *invoice, Timespec date)
void	gncInvoiceSetTerms (GncInvoice *invoice, GncBillTerm *terms)
void	gncInvoiceSetBillingID (GncInvoice *invoice, const char *billing_id)
void	gncInvoiceSetNotes (GncInvoice *invoice, const char *notes)
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)
Timespec	gncInvoiceGetDateOpened (const GncInvoice *invoice)
Timespec	gncInvoiceGetDatePosted (const GncInvoice *invoice)
Timespec	gncInvoiceGetDateDue (const GncInvoice *invoice)
GncBillTerm *	gncInvoiceGetTerms (const GncInvoice *invoice)
const char *	gncInvoiceGetBillingID (const GncInvoice *invoice)
const char *	gncInvoiceGetNotes (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

#define gncInvoiceGetGUID

(

x

)

qof_instance_get_guid(QOF_INSTANCE(x))

deprecated functions

Definition at line 307 of file gncInvoice.h.

Function Documentation

void gncBillAddEntry	(	GncInvoice *	bill,
		GncEntry *	entry
	)

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

Definition at line 686 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);
}

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

void gncInvoiceApplyPayment	(	const GncInvoice *	invoice,
		Transaction *	txn,
		Account *	xfer_acc,
		gnc_numeric	amount,
		gnc_numeric	exch,
		Timespec	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 gncOwnerCreatePaymentLot and gncOwnerAutoApplyPaymentsWithLots. See their descriptions for more details on what happens exactly.

Definition at line 1830 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 = gncOwnerCreatePaymentLot (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);
}

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

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;
    gint64 is_cn;

    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;

    is_cn = kvp_frame_get_gint64(from->inst.kvp_data, GNC_INVOICE_IS_CN);
    kvp_frame_set_gint64(invoice->inst.kvp_data, GNC_INVOICE_IS_CN, is_cn);

    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;

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

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

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

Definition at line 1926 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;
    Timespec    date_opened;
    Timespec    date_posted;

    gnc_numeric to_charge_amount;
#endif

    return TRUE;
}

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

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

GncInvoice* gncInvoiceGetInvoiceFromLot

(

GNCLot *

lot

)

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

Definition at line 1174 of file gncInvoice.c.

{
    GncGUID *guid = NULL;
    QofBook *book;

    if (!lot) return NULL;

    book = gnc_lot_get_book (lot);
    qof_instance_get (QOF_INSTANCE (lot), "invoice", &guid, NULL);
    return gncInvoiceLookup(book, guid);
}

GncInvoice* gncInvoiceGetInvoiceFromTxn

(

const Transaction *

txn

)

Given a transaction, find and return the Invoice

Definition at line 1203 of file gncInvoice.c.

{
    GncGUID *guid = NULL;
    QofBook *book;

    if (!txn) return NULL;

    book = xaccTransGetBook (txn);
    qof_instance_get (QOF_INSTANCE (txn), "invoice", &guid, NULL);
    return gncInvoiceLookup(book, guid);
}

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

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

Transaction* gncInvoicePostToAccount	(	GncInvoice *	invoice,
		Account *	acc,
		Timespec *	posted_date,
		Timespec *	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 1363 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;

    if (!invoice || !acc) return NULL;

    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);
    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));
    if (post_date)
    {
        xaccTransSetDatePostedTS (txn, post_date);
        gncInvoiceSetDatePosted (invoice, *post_date);
    }

    if (due_date)
        xaccTransSetDateDueTS (txn, due_date);

    /* Iterate through the entries; sum up everything for each account.
     * then create the appropriate splits in this txn.
     */
    total = gnc_numeric_zero();
    for (iter = gncInvoiceGetEntries(invoice); iter; iter = iter->next)
    {
        gnc_numeric value, tax;
        GList *taxes;
        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))
                gncEntrySetInvPrice (entry, gncEntryGetBillPrice (entry));
        }
        gncEntryCommitEdit (entry);

        /* Obtain the Entry's Value and TaxValues */
        value = gncEntryGetBalValue (entry, FALSE, is_cust_doc);
        tax   = gncEntryGetBalTaxValue (entry, FALSE, is_cust_doc);
        taxes = gncEntryGetBalTaxValues (entry, is_cust_doc);

        /* 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);
                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*/
                    return NULL;
                }

                /* If there is a credit-card account, and this is a CCard
                 * payment type, the don't add it to 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;

                    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
                    total = gnc_numeric_add (total, value, GNC_DENOM_AUTO, GNC_HOW_DENOM_LCD);

            }
            else
                g_warning ("bad value in our entry");
        }

        /* now merge in the TaxValues */
        splitinfo = gncAccountValueAddList (splitinfo, taxes);

        /* ... and add the tax total */
        if (gnc_numeric_check (tax) == GNC_ERROR_OK)
            total = gnc_numeric_add (total, tax, GNC_DENOM_AUTO, GNC_HOW_DENOM_LCD);
        else
            g_warning ("bad tax in our entry");

        gncAccountValueDestroy (taxes);
    } /* for */

    /* Iterate through the splitinfo list and generate the splits */
    for (iter = splitinfo; iter; iter = iter->next)
    {
        GncAccountValue *acc_val = iter->data;
        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*/
            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);

        /* 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,
                                 GNC_DENOM_AUTO, GNC_HOW_DENOM_LCD);
    }

    /* Now create the Posted split (which is the opposite sign of the above splits) */
    {
        Split *split = xaccMallocSplit (book);

        /* 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, lot, and account */
    gncInvoiceAttachToLot (invoice, lot);
    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);

    return txn;
}

void gncInvoiceRemoveEntries

(

GncInvoice *

invoice

)

Remove all entries from an invoice. To be called before destroying an invoice.

Definition at line 727 of file gncInvoice.c.

{
    GList *node;

    if (!invoice) return;

    for (node = invoice->entries; node; node = 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);
        }
    }
}

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

Set the DateOpened using a GDate argument. (Note: Internally this stores the date in a Timespec as created through timespecCanonicalDayTime()).

Definition at line 480 of file gncInvoice.c.

{
    g_assert (date);
    gncInvoiceSetDateOpened(invoice, timespecCanonicalDayTime(gdate_to_timespec(*date)));
}

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

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

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

    /* 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));
    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_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.tv_sec = invoice->date_posted.tv_nsec = 0;

    /* 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);

    return TRUE;
}