gboolean
gncOwnerReduceSplitTo (Split *split, gnc_numeric target_value)
{
gnc_numeric split_val = xaccSplitGetValue (split);
gnc_numeric rem_val;
Split *rem_split;
Transaction *txn;
GNCLot *lot;
if (gnc_numeric_positive_p (split_val) != gnc_numeric_positive_p (target_value))
return FALSE; // Split and target value have to be of the same sign
if (gnc_numeric_equal (split_val, target_value))
return FALSE; // Split already has the target value
rem_val = gnc_numeric_sub (split_val, target_value, GNC_DENOM_AUTO, GNC_HOW_DENOM_LCD); // note: values are of opposite sign
rem_split = xaccMallocSplit (xaccSplitGetBook (split));
xaccSplitCopyOnto (split, rem_split);
xaccSplitSetValue (rem_split, rem_val);
txn = xaccSplitGetParent (split);
xaccTransBeginEdit (txn);
xaccSplitSetValue (split, target_value);
xaccSplitSetParent (rem_split, txn);
xaccTransCommitEdit (txn);
lot = xaccSplitGetLot (split);
gnc_lot_add_split (lot, rem_split);
return TRUE;
}
gboolean gnc_ui_payment_is_customer_payment(const Transaction *txn)
{
SplitList *slist;
gboolean result = TRUE;
Split *assetaccount_split;
gnc_numeric amount;
if (!txn)
return result;
// We require the txn to have one split in an A/R or A/P account.
slist = xaccTransGetSplitList(txn);
if (!slist)
return result;
if (countAssetAccounts(slist) == 0)
{
g_message("No asset splits in txn \"%s\"; cannot use this for assigning a payment.",
xaccTransGetDescription(txn));
return result;
}
assetaccount_split = getFirstAssetAccountSplit(slist);
amount = xaccSplitGetValue(assetaccount_split);
result = gnc_numeric_positive_p(amount); // positive amounts == customer
//g_message("Amount=%s", gnc_numeric_to_string(amount));
return result;
}
// Note this is a recursive function. It presumes the number of splits
// in avail_splits is relatively low. With many splits the performance will
// quickly degrade.
// Careful: this function assumes all splits in avail_splits to be valid
// and with values of opposite sign of target_value
// Ignoring this can cause unexpected results!
static SplitList *
gncSLFindOffsSplits (SplitList *avail_splits, gnc_numeric target_value)
{
gint curr_recurse_level = 0;
gint max_recurse_level = g_list_length (avail_splits) - 1;
if (!avail_splits)
return NULL;
for (curr_recurse_level = 0;
curr_recurse_level <= max_recurse_level;
curr_recurse_level++)
{
SplitList *split_iter = NULL;
for (split_iter = avail_splits; split_iter; split_iter = split_iter->next)
{
Split *split = split_iter->data;
SplitList *match_splits = NULL;
gnc_numeric split_value, remaining_value;
split_value = xaccSplitGetValue (split);
// Attention: target_value and split_value are of opposite sign
// So to get the remaining target value, they should be *added*
remaining_value = gnc_numeric_add (target_value, split_value,
GNC_DENOM_AUTO, GNC_HOW_DENOM_LCD);
if (curr_recurse_level == 0)
{
if (gnc_numeric_zero_p (remaining_value))
match_splits = g_list_prepend (NULL, split);
}
else
{
if (gnc_numeric_positive_p (target_value) ==
gnc_numeric_positive_p (remaining_value))
match_splits = gncSLFindOffsSplits (split_iter->next,
remaining_value);
}
if (match_splits)
return g_list_prepend (match_splits, split);
}
}
return NULL;
}
void
gnc_price_cell_set_debt_credit_value (PriceCell * debit,
PriceCell * credit,
gnc_numeric amount)
{
/* debits are positive, credits are negative */
if (gnc_numeric_positive_p (amount))
{
gnc_price_cell_set_value (debit, amount);
gnc_price_cell_set_value (credit, gnc_numeric_zero ());
}
else
{
gnc_price_cell_set_value (debit, gnc_numeric_zero ());
gnc_price_cell_set_value (credit, gnc_numeric_neg (amount));
}
}
void gnc_ui_payment_window_set_amount (PaymentWindow *pw, gnc_numeric amount)
{
g_assert(pw);
/* Debits are negative, credits are positive */
if (gnc_numeric_positive_p (amount))
{
gnc_amount_edit_set_amount (GNC_AMOUNT_EDIT(pw->amount_credit_edit),
amount);
gnc_amount_edit_set_amount (GNC_AMOUNT_EDIT(pw->amount_debit_edit),
gnc_numeric_zero ());
}
else
{
gnc_amount_edit_set_amount (GNC_AMOUNT_EDIT(pw->amount_debit_edit),
gnc_numeric_neg (amount));
gnc_amount_edit_set_amount (GNC_AMOUNT_EDIT(pw->amount_credit_edit),
gnc_numeric_zero ());
}
}
static guint
sxftd_add_template_trans(SXFromTransInfo *sxfti)
{
Transaction *tr = sxfti->trans;
GList *tt_list = NULL;
GList *splits, *template_splits = NULL;
TTInfo *tti = gnc_ttinfo_malloc();
TTSplitInfo *ttsi;
Split *sp;
gnc_numeric runningBalance;
gnc_numeric split_value;
const char *tmpStr;
runningBalance = gnc_numeric_zero();
gnc_ttinfo_set_description(tti, xaccTransGetDescription(tr));
gnc_ttinfo_set_num(tti, gnc_get_num_action(tr, NULL));
gnc_ttinfo_set_currency(tti, xaccTransGetCurrency(tr));
for (splits = xaccTransGetSplitList(tr); splits; splits = splits->next)
{
sp = splits->data;
ttsi = gnc_ttsplitinfo_malloc();
gnc_ttsplitinfo_set_action(ttsi, gnc_get_num_action(NULL, sp));
split_value = xaccSplitGetValue(sp);
gnc_ttsplitinfo_set_memo(ttsi, xaccSplitGetMemo(sp));
runningBalance = gnc_numeric_add( runningBalance, split_value,
100, (GNC_DENOM_AUTO | GNC_HOW_DENOM_LCD) );
if (gnc_numeric_positive_p(split_value))
{
tmpStr = xaccPrintAmount( split_value,
gnc_default_print_info(FALSE) );
gnc_ttsplitinfo_set_debit_formula( ttsi, tmpStr );
}
else
{
/* Negate the numeric so it prints w/o the sign at the front. */
tmpStr = xaccPrintAmount( gnc_numeric_neg( split_value ),
gnc_default_print_info(FALSE) );
gnc_ttsplitinfo_set_credit_formula( ttsi, tmpStr );
}
/* Copy over per-split account info */
gnc_ttsplitinfo_set_account( ttsi, xaccSplitGetAccount( sp ) );
template_splits = g_list_append(template_splits, ttsi);
}
if ( ! gnc_numeric_zero_p( runningBalance )
&& !gnc_verify_dialog( (GtkWidget *)sxfti->dialog,
FALSE, "%s",
_("The Scheduled Transaction Editor "
"cannot automatically balance "
"this transaction. "
"Should it still be "
"entered?") ) )
{
return SXFTD_ERRNO_UNBALANCED_XACTION;
}
gnc_ttinfo_set_template_splits(tti, template_splits);
tt_list = g_list_append(tt_list, tti);
gnc_suspend_gui_refresh ();
xaccSchedXactionSetTemplateTrans(sxfti->sx, tt_list,
gnc_get_current_book ());
gnc_resume_gui_refresh ();
return 0;
}
static Split *
DirectionPolicyGetSplit (GNCPolicy *pcy, GNCLot *lot, short reverse)
{
Split *split;
SplitList *node;
gnc_commodity *common_currency;
gboolean want_positive;
gnc_numeric baln;
Split *osplit;
Transaction *otrans;
Timespec open_ts;
Account* lot_account;
if (!pcy || !lot || !gnc_lot_get_split_list(lot)) return NULL;
lot_account = gnc_lot_get_account(lot);
if (!lot_account) return NULL;
/* Recomputing the balance re-evaluates the lot closure */
baln = gnc_lot_get_balance (lot);
if (gnc_lot_is_closed(lot)) return NULL;
want_positive = gnc_numeric_negative_p (baln);
/* All splits in lot must share a common transaction currency. */
split = gnc_lot_get_split_list(lot)->data;
common_currency = split->parent->common_currency;
/* Don't add a split to the lot unless it will be the new last
split in the lot. Otherwise our balance tests will be wrong
and the lot may end up too thin or too fat. */
osplit = gnc_lot_get_latest_split (lot);
otrans = osplit ? xaccSplitGetParent (osplit) : 0;
open_ts = xaccTransRetDatePostedTS (otrans);
/* Walk over *all* splits in the account, till we find one that
* hasn't been assigned to a lot. Return that split.
* Make use of the fact that the splits in an account are
* already in date order; so we don't have to sort. */
node = xaccAccountGetSplitList (lot_account);
if (reverse)
{
node = g_list_last (node);
}
while (node)
{
gboolean is_match;
gboolean is_positive;
Timespec this_ts;
split = node->data;
if (split->lot) goto donext;
/* Skip it if it's too early */
this_ts = xaccTransRetDatePostedTS ( xaccSplitGetParent (split));
if ((this_ts.tv_sec < open_ts.tv_sec) ||
((this_ts.tv_sec == open_ts.tv_sec) &&
(this_ts.tv_nsec < open_ts.tv_nsec)))
{
if (reverse)
/* Going backwards, no point in looking further */
break;
goto donext;
}
/* Allow equiv currencies */
is_match = gnc_commodity_equiv (common_currency,
split->parent->common_currency);
if (FALSE == is_match) goto donext;
/* Disallow zero-amount splits in general. */
if (gnc_numeric_zero_p(split->amount)) goto donext;
is_positive = gnc_numeric_positive_p (split->amount);
if ((want_positive && is_positive) ||
((!want_positive) && (!is_positive))) return split;
donext:
if (reverse)
{
node = node->prev;
}
else
{
node = node->next;
}
}
return NULL;
}
void
gnc_stock_split_assistant_finish (GtkAssistant *assistant,
gpointer user_data)
{
StockSplitInfo *info = user_data;
GList *account_commits;
GList *node;
gnc_numeric amount;
Transaction *trans;
Account *account;
Split *split;
time64 date;
account = info->acct;
g_return_if_fail (account != NULL);
amount = gnc_amount_edit_get_amount
(GNC_AMOUNT_EDIT (info->distribution_edit));
g_return_if_fail (!gnc_numeric_zero_p (amount));
gnc_suspend_gui_refresh ();
trans = xaccMallocTransaction (gnc_get_current_book ());
xaccTransBeginEdit (trans);
xaccTransSetCurrency (trans, gnc_default_currency ());
date = gnc_date_edit_get_date (GNC_DATE_EDIT (info->date_edit));
xaccTransSetDatePostedSecsNormalized (trans, date);
{
const char *description;
description = gtk_entry_get_text (GTK_ENTRY (info->description_entry));
xaccTransSetDescription (trans, description);
}
split = xaccMallocSplit (gnc_get_current_book ());
xaccAccountBeginEdit (account);
account_commits = g_list_prepend (NULL, account);
xaccTransAppendSplit (trans, split);
xaccAccountInsertSplit (account, split);
xaccSplitSetAmount (split, amount);
xaccSplitMakeStockSplit (split);
/* Set split-action with gnc_set_num_action which is the same as
* xaccSplitSetAction with these arguments */
/* Translators: This string has a disambiguation prefix */
gnc_set_num_action (NULL, split, NULL, Q_("Action Column|Split"));
amount = gnc_amount_edit_get_amount (GNC_AMOUNT_EDIT (info->price_edit));
if (gnc_numeric_positive_p (amount))
{
QofBook *book;
GNCPrice *price;
GNCPriceDB *pdb;
GNCCurrencyEdit *ce;
Timespec ts;
ce = GNC_CURRENCY_EDIT (info->price_currency_edit);
ts.tv_sec = date;
ts.tv_nsec = 0;
price = gnc_price_create (gnc_get_current_book ());
gnc_price_begin_edit (price);
gnc_price_set_commodity (price, xaccAccountGetCommodity (account));
gnc_price_set_currency (price, gnc_currency_edit_get_currency (ce));
gnc_price_set_time (price, ts);
gnc_price_set_source (price, PRICE_SOURCE_STOCK_SPLIT);
gnc_price_set_typestr (price, PRICE_TYPE_UNK);
gnc_price_set_value (price, amount);
gnc_price_commit_edit (price);
book = gnc_get_current_book ();
pdb = gnc_pricedb_get_db (book);
if (!gnc_pricedb_add_price (pdb, price))
gnc_error_dialog (info->window, "%s", _("Error adding price."));
}
amount = gnc_amount_edit_get_amount (GNC_AMOUNT_EDIT (info->cash_edit));
if (gnc_numeric_positive_p (amount))
{
const char *memo;
memo = gtk_entry_get_text (GTK_ENTRY (info->memo_entry));
/* asset split */
account = gnc_tree_view_account_get_selected_account (GNC_TREE_VIEW_ACCOUNT(info->asset_tree));
split = xaccMallocSplit (gnc_get_current_book ());
xaccAccountBeginEdit (account);
account_commits = g_list_prepend (account_commits, account);
xaccAccountInsertSplit (account, split);
xaccTransAppendSplit (trans, split);
xaccSplitSetAmount (split, amount);
xaccSplitSetValue (split, amount);
xaccSplitSetMemo (split, memo);
/* income split */
account = gnc_tree_view_account_get_selected_account (GNC_TREE_VIEW_ACCOUNT(info->income_tree));
split = xaccMallocSplit (gnc_get_current_book ());
xaccAccountBeginEdit (account);
account_commits = g_list_prepend (account_commits, account);
xaccAccountInsertSplit (account, split);
xaccTransAppendSplit (trans, split);
xaccSplitSetAmount (split, gnc_numeric_neg (amount));
xaccSplitSetValue (split, gnc_numeric_neg (amount));
xaccSplitSetMemo (split, memo);
}
xaccTransCommitEdit (trans);
for (node = account_commits; node; node = node->next)
xaccAccountCommitEdit (node->data);
g_list_free (account_commits);
gnc_resume_gui_refresh ();
gnc_close_gui_component_by_data (ASSISTANT_STOCK_SPLIT_CM_CLASS, info);
}
void
gnc_payment_window_fill_docs_list (PaymentWindow *pw)
{
GtkListStore *store;
GList *list = NULL, *node;
g_return_if_fail (pw->docs_list_tree_view && GTK_IS_TREE_VIEW(pw->docs_list_tree_view));
/* Get a list of open lots for this owner and post account */
if (pw->owner.owner.undefined)
list = xaccAccountFindOpenLots (pw->post_acct, gncOwnerLotMatchOwnerFunc,
&pw->owner, NULL);
/* Clear the existing list */
store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(pw->docs_list_tree_view)));
gtk_list_store_clear(store);
/* Add the documents and overpayments to the tree view */
for (node = list; node; node = node->next)
{
GNCLot *lot = node->data;
time64 doc_date_time = 0;
const gchar *doc_type_str = NULL;
const gchar *doc_id_str = NULL;
const gchar *doc_deb_str = NULL;
const gchar *doc_cred_str = NULL;
GtkTreeIter iter;
Timespec doc_date;
GncInvoice *document;
gnc_numeric value = gnc_numeric_zero();
gnc_numeric debit = gnc_numeric_zero();
gnc_numeric credit = gnc_numeric_zero();
/* Find the lot's document if it exists,
* it could also be a prepayment lot. */
document = gncInvoiceGetInvoiceFromLot (lot);
/* Find the document's date or pre-payment date */
if (document)
doc_date = gncInvoiceGetDatePosted (document);
else
{
/* Calculate the payment date based on the lot splits */
Transaction *trans = xaccSplitGetParent (gnc_lot_get_latest_split (lot));
if (trans)
doc_date = xaccTransRetDatePostedTS (trans);
else
continue; /* No valid split in this lot, skip it */
}
doc_date_time = timespecToTime64 (doc_date);
/* Find the document type. No type means pre-payment in this case */
if (document)
{
doc_type_str = gncInvoiceGetTypeString (document);
}
else
doc_type_str = _("Pre-Payment");
/* Find the document id. Empty for pre-payments. */
if (document)
{
doc_id_str = gncInvoiceGetID (document);
}
/* Find the debit/credit amount.
* Invoices/vendor credit notes are debit (increasing the balance)
* Customer credit notes/bills are credit (decreasing the balance)
* Pre-payments are debit or credit depending on their sign
*/
value = gnc_lot_get_balance (lot);
if (gnc_numeric_positive_p (value))
debit = value;
else
credit = gnc_numeric_neg (value);
/* Only display non-zero debits/credits */
if (!gnc_numeric_zero_p (debit))
doc_deb_str = xaccPrintAmount (debit, gnc_default_print_info (FALSE));
if (!gnc_numeric_zero_p (credit))
doc_cred_str = xaccPrintAmount (credit, gnc_default_print_info (FALSE));
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
0, doc_date_time,
1, doc_id_str,
2, doc_type_str,
3, doc_deb_str,
4, doc_cred_str,
5, (gpointer)lot,
-1);
}
g_list_free (list);
/* Highlight the preset invoice if it's in the new list */
gnc_payment_dialog_highlight_document (pw);
}
void gncOwnerAutoApplyPaymentsWithLots (const GncOwner *owner, GList *lots)
{
GList *base_iter;
/* General note: in the code below the term "payment" can
* both mean a true payment or a document of
* the opposite sign (invoice vs credit note) relative to
* the lot being processed. In general this function will
* perform a balancing action on a set of lots, so you
* will also find frequent references to balancing instead. */
/* Payments can only be applied when at least an owner
* and a list of lots to use are given */
if (!owner) return;
if (!lots) return;
for (base_iter = lots; base_iter; base_iter = base_iter->next)
{
GNCLot *base_lot = base_iter->data;
QofBook *book;
Account *acct;
const gchar *name;
GList *lot_list, *lot_iter;
Transaction *txn = NULL;
gnc_numeric base_lot_bal, val_to_pay, val_paid = { 0, 1 };
gboolean base_bal_is_pos;
const gchar *action, *memo;
/* Only attempt to apply payments to open lots.
* Note that due to the iterative nature of this function lots
* in the list may become closed before they are evaluated as
* base lot, so we should check this for each lot. */
base_lot_bal = gnc_lot_get_balance (base_lot);
if (gnc_numeric_zero_p (base_lot_bal))
continue;
book = gnc_lot_get_book (base_lot);
acct = gnc_lot_get_account (base_lot);
name = gncOwnerGetName (gncOwnerGetEndOwner (owner));
lot_list = base_iter->next;
/* Strings used when creating splits later on. */
action = _("Lot Link");
memo = _("Internal link between invoice and payment lots");
/* Note: to balance the lot the payment to assign
* must have the opposite sign of the existing lot balance */
val_to_pay = gnc_numeric_neg (base_lot_bal);
base_bal_is_pos = gnc_numeric_positive_p (base_lot_bal);
/* Create splits in a linking transaction between lots until
* - either the invoice lot is balanced
* - or there are no more balancing lots.
*/
for (lot_iter = lot_list; lot_iter; lot_iter = lot_iter->next)
{
gnc_numeric payment_lot_balance;
Split *split;
Account *bal_acct;
gnc_numeric split_amt;
GNCLot *balancing_lot = lot_iter->data;
/* Only attempt to use open lots to balance the base lot.
* Note that due to the iterative nature of this function lots
* in the list may become closed before they are evaluated as
* base lot, so we should check this for each lot. */
if (gnc_lot_is_closed (balancing_lot))
continue;
/* Balancing transactions for invoice/payments can only happen
* in the same account. */
bal_acct = gnc_lot_get_account (balancing_lot);
if (acct != bal_acct)
continue;
payment_lot_balance = gnc_lot_get_balance (balancing_lot);
/* Only attempt to balance if the base lot and balancing lot are
* of the opposite sign. (Otherwise we would increase the balance
* of the lot - Duh */
if (base_bal_is_pos == gnc_numeric_positive_p (payment_lot_balance))
continue;
/*
* If there is less to pay than there's open in the lot; we're done -- apply the base_lot_vale.
* Note that payment_value and balance are opposite in sign, so we have to compare absolute values here
*
* Otherwise, apply the balance, subtract that from the payment_value,
* and move on to the next one.
*/
if (gnc_numeric_compare (gnc_numeric_abs (val_to_pay), gnc_numeric_abs (payment_lot_balance)) <= 0)
{
/* abs(val_to_pay) <= abs(balance) */
split_amt = val_to_pay;
}
else
{
/* abs(val_to_pay) > abs(balance)
* Remember payment_value and balance are opposite in sign,
* and we want a payment to neutralize the current balance
* so we need to negate here */
split_amt = payment_lot_balance;
}
/* If not created yet, create a new transaction linking
* the base lot and the balancing lot(s) */
if (!txn)
{
Timespec ts = xaccTransRetDatePostedTS (xaccSplitGetParent (gnc_lot_get_latest_split (base_lot)));
xaccAccountBeginEdit (acct);
txn = xaccMallocTransaction (book);
xaccTransBeginEdit (txn);
xaccTransSetDescription (txn, name ? name : "");
xaccTransSetCurrency (txn, xaccAccountGetCommodity(acct));
xaccTransSetDateEnteredSecs (txn, gnc_time (NULL));
xaccTransSetDatePostedTS (txn, &ts);
xaccTransSetTxnType (txn, TXN_TYPE_LINK);
}
/* Create the split for this link in current balancing lot */
split = xaccMallocSplit (book);
xaccSplitSetMemo (split, memo);
/* set Action using utility function */
gnc_set_num_action (NULL, split, NULL, action);
xaccAccountInsertSplit (acct, split);
xaccTransAppendSplit (txn, split);
xaccSplitSetBaseValue (split, gnc_numeric_neg (split_amt), xaccAccountGetCommodity(acct));
gnc_lot_add_split (balancing_lot, split);
/* If the balancing lot was linked to a document (invoice/credit note),
* send an event for it as well so it gets potentially updated as paid */
{
GncInvoice *this_invoice = gncInvoiceGetInvoiceFromLot(balancing_lot);
if (this_invoice)
qof_event_gen (QOF_INSTANCE(this_invoice), QOF_EVENT_MODIFY, NULL);
}
val_paid = gnc_numeric_add (val_paid, split_amt, GNC_DENOM_AUTO, GNC_HOW_DENOM_LCD);
val_to_pay = gnc_numeric_sub (val_to_pay, split_amt, GNC_DENOM_AUTO, GNC_HOW_DENOM_LCD);
if (gnc_numeric_zero_p (val_to_pay))
break;
}
/* If the above loop managed to create a transaction and some balancing splits,
* create the final split for the link transaction in the base lot */
if (txn)
{
GncInvoice *this_invoice;
Split *split = xaccMallocSplit (book);
xaccSplitSetMemo (split, memo);
/* set Action with utiltity function */
gnc_set_num_action (NULL, split, NULL, action);
xaccAccountInsertSplit (acct, split);
xaccTransAppendSplit (txn, split);
xaccSplitSetBaseValue (split, val_paid, xaccAccountGetCommodity(acct));
gnc_lot_add_split (base_lot, split);
xaccTransCommitEdit (txn);
xaccAccountCommitEdit (acct);
/* If the base lot was linked to a document (invoice/credit note),
* send an event for it as well so it gets potentially updated as paid */
this_invoice = gncInvoiceGetInvoiceFromLot(base_lot);
if (this_invoice)
qof_event_gen (QOF_INSTANCE(this_invoice), QOF_EVENT_MODIFY, NULL);
}
}
}
static gboolean
gncScrubLotDanglingPayments (GNCLot *lot)
{
SplitList * split_list, *filtered_list = NULL, *match_list = NULL, *node;
Split *ll_split = gnc_lot_get_earliest_split (lot);
Transaction *ll_trans = xaccSplitGetParent (ll_split);
gnc_numeric ll_val = xaccSplitGetValue (ll_split);
time64 ll_date = xaccTransGetDate (ll_trans);
const char *ll_desc = xaccTransGetDescription (ll_trans);
// look for free splits (i.e. not in any lot) which,
// compared to the lot link split
// - have the same date
// - have the same description
// - have an opposite sign amount
// - free split's abs value is less than or equal to ll split's abs value
split_list = xaccAccountGetSplitList(gnc_lot_get_account (lot));
for (node = split_list; node; node = node->next)
{
Split *free_split = node->data;
Transaction *free_trans;
gnc_numeric free_val;
if (NULL != xaccSplitGetLot(free_split))
continue;
free_trans = xaccSplitGetParent (free_split);
if (ll_date != xaccTransGetDate (free_trans))
continue;
if (0 != g_strcmp0 (ll_desc, xaccTransGetDescription (free_trans)))
continue;
free_val = xaccSplitGetValue (free_split);
if (gnc_numeric_positive_p (ll_val) ==
gnc_numeric_positive_p (free_val))
continue;
if (gnc_numeric_compare (gnc_numeric_abs (free_val), gnc_numeric_abs (ll_val)) > 0)
continue;
filtered_list = g_list_append(filtered_list, free_split);
}
match_list = gncSLFindOffsSplits (filtered_list, ll_val);
g_list_free (filtered_list);
for (node = match_list; node; node = node->next)
{
Split *match_split = node->data;
gnc_lot_add_split (lot, match_split);
}
if (match_list)
{
g_list_free (match_list);
return TRUE;
}
else
return FALSE;
}
static gboolean
gncScrubLotLinks (GNCLot *scrub_lot)
{
gboolean modified = FALSE, restart_needed = FALSE;
SplitList *sls_iter = NULL;
scrub_start:
restart_needed = FALSE;
// Iterate over all splits in the lot
for (sls_iter = gnc_lot_get_split_list (scrub_lot); sls_iter; sls_iter = sls_iter->next)
{
Split *sl_split = sls_iter->data;
Transaction *ll_txn = NULL; // ll_txn = "Lot Link Transaction"
SplitList *lts_iter = NULL;
if (!sl_split)
continue; // next scrub lot split
// Only lot link transactions need to be scrubbed
ll_txn = xaccSplitGetParent (sl_split);
if (!ll_txn)
{
// Ooops - the split doesn't belong to any transaction !
// This is not expected so issue a warning and continue with next split
PWARN("Encountered a split in a business lot that's not part of any transaction. "
"This is unexpected! Skipping split %p.", sl_split);
continue;
}
if (xaccTransGetTxnType (ll_txn) != TXN_TYPE_LINK)
continue; // next scrub lot split
// Iterate over all splits in the lot link transaction
for (lts_iter = xaccTransGetSplitList (ll_txn); lts_iter; lts_iter = lts_iter->next)
{
Split *ll_txn_split = lts_iter->data; // These all refer to splits in the lot link transaction
GNCLot *remote_lot = NULL; // lot at the other end of the lot link transaction
gboolean sl_is_doc_lot, rl_is_doc_lot;
if (!ll_txn_split)
continue; // next lot link transaction split
// Skip the split in the lot we're currently scrubbing
if (sl_split == ll_txn_split)
continue; // next lot link transaction split
// Only splits of opposite signed values can be scrubbed
if (gnc_numeric_positive_p (xaccSplitGetValue (sl_split)) ==
gnc_numeric_positive_p (xaccSplitGetValue (ll_txn_split)))
continue; // next lot link transaction split
// Find linked lot via split
remote_lot = xaccSplitGetLot (ll_txn_split);
if (!remote_lot)
{
// This is unexpected - write a warning message and skip this split
PWARN("Encountered a Lot Link transaction with a split that's not in any lot. "
"This is unexpected! Skipping split %p from transaction %p.", ll_txn_split, ll_txn);
continue;
}
sl_is_doc_lot = (gncInvoiceGetInvoiceFromLot (scrub_lot) != NULL);
rl_is_doc_lot = (gncInvoiceGetInvoiceFromLot (remote_lot) != NULL);
// Depending on the type of lots we're comparing, we need different actions
// - Two document lots (an invoice and a credit note):
// Special treatment - look for all document lots linked via ll_txn
// and update the memo to be of more use to the uses.
// - Two payment lots:
// (Part of) the link will be eliminated and instead (part of)
// one payment will be added to the other lot to keep the balance.
// If the payments are not equal in abs value part of the bigger payment
// will be moved to the smaller payment's lot.
// - A document and a payment lot:
// (Part of) the link will be eliminated and instead (part of) the real
// payment will be added to the document lot to handle the payment.
if (sl_is_doc_lot && rl_is_doc_lot)
gncOwnerSetLotLinkMemo (ll_txn);
else if (!sl_is_doc_lot && !rl_is_doc_lot)
{
gint cmp = gnc_numeric_compare (gnc_numeric_abs (xaccSplitGetValue (sl_split)),
gnc_numeric_abs (xaccSplitGetValue (ll_txn_split)));
if (cmp >= 0)
restart_needed = scrub_other_link (scrub_lot, sl_split, remote_lot, ll_txn_split);
else
restart_needed = scrub_other_link (remote_lot, ll_txn_split, scrub_lot, sl_split);
}
else
{
GNCLot *doc_lot = sl_is_doc_lot ? scrub_lot : remote_lot;
GNCLot *pay_lot = sl_is_doc_lot ? remote_lot : scrub_lot;
Split *ll_doc_split = sl_is_doc_lot ? sl_split : ll_txn_split;
Split *ll_pay_split = sl_is_doc_lot ? ll_txn_split : sl_split;
// Ok, let's try to move a payment from pay_lot to doc_lot
restart_needed = scrub_other_link (pay_lot, ll_pay_split, doc_lot, ll_doc_split);
}
// If we got here, the splits in our lot and ll_txn have been severely mixed up
// And our iterator lists are probably no longer valid
// So let's start over
if (restart_needed)
{
modified = TRUE;
goto scrub_start;
}
}
}
return modified;
}
Split *gncOwnerFindOffsettingSplit (GNCLot *lot, gnc_numeric target_value)
{
SplitList *ls_iter = NULL;
Split *best_split = NULL;
gnc_numeric best_val = { 0, 1};
gint best_flags = 0;
if (!lot)
return NULL;
for (ls_iter = gnc_lot_get_split_list (lot); ls_iter; ls_iter = ls_iter->next)
{
Split *split = ls_iter->data;
Transaction *txn;
gnc_numeric split_value;
gint new_flags = 0;
gint val_cmp = 0;
if (!split)
continue;
txn = xaccSplitGetParent (split);
if (!txn)
{
// Ooops - the split doesn't belong to any transaction !
// This is not expected so issue a warning and continue with next split
PWARN("Encountered a split in a payment lot that's not part of any transaction. "
"This is unexpected! Skipping split %p.", split);
continue;
}
// Check if this split has the opposite sign of the target value we want to offset
split_value = xaccSplitGetValue (split);
if (gnc_numeric_positive_p (target_value) == gnc_numeric_positive_p (split_value))
continue;
// Ok we have found a split that potentially can offset the target value
// Let's see if it's better than what we have found already.
val_cmp = gnc_numeric_compare (gnc_numeric_abs (split_value),
gnc_numeric_abs (target_value));
if (val_cmp == 0)
new_flags += is_equal;
else if (val_cmp > 0)
new_flags += is_more;
else
new_flags += is_less;
if (xaccTransGetTxnType (txn) != TXN_TYPE_LINK)
new_flags += is_pay_split;
if ((new_flags >= best_flags) &&
(gnc_numeric_compare (gnc_numeric_abs (split_value),
gnc_numeric_abs (best_val)) > 0))
{
// The new split is a better match than what we found so far
best_split = split;
best_flags = new_flags;
best_val = split_value;
}
}
return best_split;
}
void gncOwnerAutoApplyPaymentsWithLots (const GncOwner *owner, GList *lots)
{
GList *left_iter;
/* General note: in the code below the term "payment" can
* both mean a true payment or a document of
* the opposite sign (invoice vs credit note) relative to
* the lot being processed. In general this function will
* perform a balancing action on a set of lots, so you
* will also find frequent references to balancing instead. */
/* Payments can only be applied when at least an owner
* and a list of lots to use are given */
if (!owner) return;
if (!lots) return;
for (left_iter = lots; left_iter; left_iter = left_iter->next)
{
GNCLot *left_lot = left_iter->data;
gnc_numeric left_lot_bal;
gboolean left_lot_has_doc;
gboolean left_modified = FALSE;
Account *acct;
GList *right_iter;
/* Only attempt to apply payments to open lots.
* Note that due to the iterative nature of this function lots
* in the list may become empty/closed before they are evaluated as
* base lot, so we should check this for each lot. */
if (!left_lot || qof_instance_get_destroying (left_lot))
continue;
if (gnc_lot_count_splits (left_lot) == 0)
{
gnc_lot_destroy (left_lot);
continue;
}
if (gnc_lot_is_closed (left_lot))
continue;
acct = gnc_lot_get_account (left_lot);
xaccAccountBeginEdit (acct);
left_lot_bal = gnc_lot_get_balance (left_lot);
left_lot_has_doc = (gncInvoiceGetInvoiceFromLot (left_lot) != NULL);
/* Attempt to offset left_lot with any of the remaining lots. To do so
* iterate over the remaining lots adding lot links or moving payments
* around.
*/
for (right_iter = left_iter->next; right_iter; right_iter = right_iter->next)
{
GNCLot *right_lot = right_iter->data;
gnc_numeric right_lot_bal;
gboolean right_lot_has_doc;
/* Only attempt to use open lots to balance the base lot.
* Note that due to the iterative nature of this function lots
* in the list may become empty/closed before they are evaluated as
* base lot, so we should check this for each lot. */
if (!right_lot || qof_instance_get_destroying (right_lot))
continue;
if (gnc_lot_count_splits (right_lot) == 0)
{
gnc_lot_destroy (right_lot);
continue;
}
if (gnc_lot_is_closed (right_lot))
continue;
/* Balancing transactions for invoice/payments can only happen
* in the same account. */
if (acct != gnc_lot_get_account (right_lot))
continue;
/* Only attempt to balance if the base lot and balancing lot are
* of the opposite sign. (Otherwise we would increase the balance
* of the lot - Duh */
right_lot_bal = gnc_lot_get_balance (right_lot);
if (gnc_numeric_positive_p (left_lot_bal) == gnc_numeric_positive_p (right_lot_bal))
continue;
/* Ok we found two lots than can (partly) offset each other.
* Depending on the lot types, a different action is needed to accomplish this.
* 1. Both lots are document lots (invoices/credit notes)
* -> Create a lot linking transaction between the lots
* 2. Both lots are payment lots (lots without a document attached)
* -> Use part of the bigger lot to the close the smaller lot
* 3. One document lot with one payment lot
* -> Use (part of) the payment to offset (part of) the document lot,
* Which one will be closed depends on which is the bigger one
*/
right_lot_has_doc = (gncInvoiceGetInvoiceFromLot (right_lot) != NULL);
if (left_lot_has_doc && right_lot_has_doc)
gncOwnerCreateLotLink (left_lot, right_lot, owner);
else if (!left_lot_has_doc && !right_lot_has_doc)
{
gint cmp = gnc_numeric_compare (gnc_numeric_abs (left_lot_bal),
gnc_numeric_abs (right_lot_bal));
if (cmp >= 0)
gncOwnerOffsetLots (left_lot, right_lot, owner);
else
gncOwnerOffsetLots (right_lot, left_lot, owner);
}
else
{
GNCLot *doc_lot = left_lot_has_doc ? left_lot : right_lot;
GNCLot *pay_lot = left_lot_has_doc ? right_lot : left_lot;
// Ok, let's try to move a payment from pay_lot to doc_lot
gncOwnerOffsetLots (pay_lot, doc_lot, owner);
}
/* If we get here, then right_lot was modified
* If the lot has a document, send an event for send an event for it as well
* so it gets potentially updated as paid */
{
GncInvoice *this_invoice = gncInvoiceGetInvoiceFromLot(right_lot);
if (this_invoice)
qof_event_gen (QOF_INSTANCE(this_invoice), QOF_EVENT_MODIFY, NULL);
}
left_modified = TRUE;
}
/* If left_lot was modified and the lot has a document,
* send an event for send an event for it as well
* so it gets potentially updated as paid */
if (left_modified)
{
GncInvoice *this_invoice = gncInvoiceGetInvoiceFromLot(left_lot);
if (this_invoice)
qof_event_gen (QOF_INSTANCE(this_invoice), QOF_EVENT_MODIFY, NULL);
}
xaccAccountCommitEdit (acct);
}
}
