/** Adds a split to a transaction.
* @param trans The transaction to add a split to
* @param account The split's account
* @param amount The split's amount
* @param rec_state The split's reconcile status
* @param rec_date The split's reconcile date
* @param price The split's conversion rate from account commodity to transaction commodity
*/
static void trans_add_split (Transaction* trans, Account* account, GncNumeric amount,
const boost::optional<std::string>& action,
const boost::optional<std::string>& memo,
const boost::optional<char>& rec_state,
const boost::optional<GncDate>& rec_date,
const boost::optional<GncNumeric> price)
{
QofBook* book = xaccTransGetBook (trans);
auto split = xaccMallocSplit (book);
xaccSplitSetAccount (split, account);
xaccSplitSetParent (split, trans);
xaccSplitSetAmount (split, static_cast<gnc_numeric>(amount));
auto trans_curr = xaccTransGetCurrency(trans);
auto acct_comm = xaccAccountGetCommodity(account);
GncNumeric value;
if (gnc_commodity_equiv(trans_curr, acct_comm))
value = amount;
else if (price)
value = amount * *price;
else
{
auto time = xaccTransRetDatePosted (trans);
/* Import data didn't specify price, let's lookup the nearest in time */
auto nprice =
gnc_pricedb_lookup_nearest_in_time64(gnc_pricedb_get_db(book),
acct_comm, trans_curr, time);
if (nprice)
{
/* Found a usable price. Let's check if the conversion direction is right */
GncNumeric rate;
if (gnc_commodity_equiv(gnc_price_get_currency(nprice), trans_curr))
rate = gnc_price_get_value(nprice);
else
rate = static_cast<GncNumeric>(gnc_price_get_value(nprice)).inv();
value = amount * rate;
}
else
{
PWARN("No price found, using a price of 1.");
value = amount;
}
}
xaccSplitSetValue (split, static_cast<gnc_numeric>(value));
if (memo)
xaccSplitSetMemo (split, memo->c_str());
/* Note, this function assumes the num/action switch is done at a higher level
* if needed by the book option */
if (action)
xaccSplitSetAction (split, action->c_str());
if (rec_state && *rec_state != 'n')
xaccSplitSetReconcile (split, *rec_state);
if (rec_state && *rec_state == YREC && rec_date)
xaccSplitSetDateReconciledSecs (split,
static_cast<time64>(GncDateTime(*rec_date, DayPart::neutral)));
}
static void
test_dom_tree_to_commodity_ref(void)
{
int i;
for (i = 0; i < 20; i++)
{
gnc_commodity *test_com1;
gchar *test_str1;
gchar *test_str2;
gnc_commodity *test_com2;
xmlNodePtr test_node;
QofBook *book;
book = qof_book_new ();
test_str1 = get_random_string();
test_str2 = get_random_string();
test_com1 = gnc_commodity_new(book, NULL, test_str1, test_str2, NULL, 0);
test_node = commodity_ref_to_dom_tree("test-com", test_com1);
test_com2 = dom_tree_to_commodity_ref_no_engine(test_node, book);
do_test(gnc_commodity_equiv(test_com1, test_com2),
"dom_tree_to_commodity_ref_no_engine");
xmlFreeNode(test_node);
gnc_commodity_destroy(test_com1);
gnc_commodity_destroy(test_com2);
g_free(test_str1);
g_free(test_str2);
qof_book_destroy (book);
}
}
/**
* Get the existing currency accumulator matching the given currency and
* total-mode, or create a new one.
**/
static GNCCurrencyAcc *
gnc_ui_get_currency_accumulator(GList **list, gnc_commodity * currency, gint total_mode)
{
GList *current;
GNCCurrencyAcc *found;
for (current = g_list_first(*list); current; current = g_list_next(current))
{
found = current->data;
if ((gnc_commodity_equiv(currency, found->currency))
&& (found->total_mode == total_mode))
{
return found;
}
}
found = g_new0 (GNCCurrencyAcc, 1);
found->currency = currency;
found->assets = gnc_numeric_zero ();
found->profits = gnc_numeric_zero ();
found->total_mode = total_mode;
*list = g_list_append (*list, found);
return found;
}
static gboolean
test_add_commodity (const char* tag, gpointer globaldata, gpointer data)
{
com_data* gdata = (com_data*)globaldata;
do_test_args (gnc_commodity_equiv ((gnc_commodity*)data, gdata->com),
"gnc_commodity_sixtp_parser_create",
__FILE__, __LINE__, "%d", gdata->value);
gnc_commodity_destroy ((gnc_commodity*)data);
return TRUE;
}
/* Do we need an exchange rate */
static gboolean
gtu_sr_needs_exchange_rate (GncTreeViewSplitReg *view, Transaction *trans, Split *split)
{
gnc_commodity *split_com, *txn_curr, *reg_com;
ENTER("gtu_sr_needs_exchange_rate - trans %p and split %p", trans, split);
txn_curr = xaccTransGetCurrency (trans);
split_com = xaccAccountGetCommodity (xaccSplitGetAccount (split));
if (split_com && txn_curr && !gnc_commodity_equiv (split_com, txn_curr))
{
LEAVE("gtu_sr_needs_exchange_rate split_com to txn_curr return TRUE");
return TRUE;
}
reg_com = gnc_tree_view_split_reg_get_reg_commodity (view);
if (split_com && reg_com && !gnc_commodity_equiv (split_com, reg_com))
{
LEAVE("gtu_sr_needs_exchange_rate split_com and reg_com return TRUE");
return TRUE;
}
LEAVE("No Exchange rate needed");
return FALSE;
}
/* Get the rate from the price db */
static gnc_numeric
gtu_sr_get_rate_from_db (gnc_commodity *from, gnc_commodity *to)
{
GNCPrice *prc;
QofBook *book = gnc_get_current_book ();
prc = gnc_pricedb_lookup_latest (gnc_pricedb_get_db (book), from, to);
if (!prc)
return gnc_numeric_create (100, 100);
if (gnc_commodity_equiv(from, gnc_price_get_currency(prc)))
return gnc_numeric_invert(gnc_price_get_value(prc));
return gnc_price_get_value(prc);
}
static Split *
get_balance_split (Transaction *trans, Account *root, Account *account,
gnc_commodity *commodity)
{
Split *balance_split;
gchar *accname;
if (!account ||
!gnc_commodity_equiv (commodity, xaccAccountGetCommodity(account)))
{
if (!root)
{
root = gnc_book_get_root_account (xaccTransGetBook (trans));
if (NULL == root)
{
/* This can't occur, things should be in books */
PERR ("Bad data corruption, no root account in book");
return NULL;
}
}
accname = g_strconcat (_("Imbalance"), "-",
gnc_commodity_get_mnemonic (commodity), NULL);
account = xaccScrubUtilityGetOrMakeAccount (root, commodity,
accname, ACCT_TYPE_BANK, FALSE);
g_free (accname);
if (!account)
{
PERR ("Can't get balancing account");
return NULL;
}
}
balance_split = xaccTransFindSplitByAccount(trans, account);
/* Put split into account before setting split value */
if (!balance_split)
{
balance_split = xaccMallocSplit (qof_instance_get_book(trans));
xaccTransBeginEdit (trans);
xaccSplitSetParent(balance_split, trans);
xaccSplitSetAccount(balance_split, account);
xaccTransCommitEdit (trans);
}
return balance_split;
}
static void
refresh_details_page (StockSplitInfo *info)
{
GNCPrintAmountInfo print_info;
gnc_commodity *commodity, *currency;
Account *account;
QofBook *book;
GNCPriceDB *db;
GList *prices;
account = info->acct;
g_return_if_fail (account != NULL);
print_info = gnc_account_print_info (account, FALSE);
gnc_amount_edit_set_print_info (GNC_AMOUNT_EDIT (info->distribution_edit),
print_info);
gnc_amount_edit_set_fraction (GNC_AMOUNT_EDIT (info->distribution_edit),
xaccAccountGetCommoditySCU (account));
commodity = xaccAccountGetCommodity (account);
book = gnc_account_get_book (account);
db = gnc_pricedb_get_db(book);
prices = gnc_pricedb_lookup_latest_any_currency(db, commodity);
if (prices)
{
/* Use the first existing price */
if (gnc_commodity_equiv (commodity, gnc_price_get_currency(prices->data)))
currency = gnc_price_get_commodity(prices->data);
else
currency = gnc_price_get_currency(prices->data);
}
else
{
/* Take a wild guess. */
currency = gnc_default_currency ();
}
gnc_price_list_destroy(prices);
gnc_currency_edit_set_currency
(GNC_CURRENCY_EDIT (info->price_currency_edit),
currency);
}
static void
add_balance_split (Transaction *trans, gnc_numeric imbalance,
Account *root, Account *account)
{
const gnc_commodity *commodity;
gnc_numeric old_value, new_value;
Split *balance_split;
gnc_commodity *currency = xaccTransGetCurrency (trans);
balance_split = get_balance_split(trans, root, account, currency);
if (!balance_split)
{
/* Error already logged */
LEAVE("");
return;
}
account = xaccSplitGetAccount(balance_split);
xaccTransBeginEdit (trans);
old_value = xaccSplitGetValue (balance_split);
/* Note: We have to round for the commodity's fraction, NOT any
* already existing denominator (bug #104343), because either one
* of the denominators might already be reduced. */
new_value = gnc_numeric_sub (old_value, imbalance,
gnc_commodity_get_fraction(currency),
GNC_HOW_RND_ROUND_HALF_UP);
xaccSplitSetValue (balance_split, new_value);
commodity = xaccAccountGetCommodity (account);
if (gnc_commodity_equiv (currency, commodity))
{
xaccSplitSetAmount (balance_split, new_value);
}
xaccSplitScrub (balance_split);
xaccTransCommitEdit (trans);
}
gboolean
equals_node_val_vs_commodity(xmlNodePtr node, const gnc_commodity *com,
QofBook *book)
{
gnc_commodity *cmpcom;
g_return_val_if_fail(node, FALSE);
g_return_val_if_fail(com, FALSE);
cmpcom = dom_tree_to_commodity_ref_no_engine(node, book);
g_return_val_if_fail(cmpcom, FALSE);
if (gnc_commodity_equiv(com, cmpcom))
{
gnc_commodity_destroy(cmpcom);
return TRUE;
}
else
{
gnc_commodity_destroy(cmpcom);
return FALSE;
}
}
static gnc_commodity *
FindCommonExclSCurrency (SplitList *splits,
gnc_commodity * ra, gnc_commodity * rb,
Split *excl_split)
{
GList *node;
if (!splits) return NULL;
for (node = splits; node; node = node->next)
{
Split *s = node->data;
gnc_commodity * sa, * sb;
if (s == excl_split) continue;
g_return_val_if_fail (s->acc, NULL);
sa = DxaccAccountGetCurrency (s->acc);
sb = xaccAccountGetCommodity (s->acc);
if (ra && rb)
{
int aa = !gnc_commodity_equiv(ra, sa);
int ab = !gnc_commodity_equiv(ra, sb);
int ba = !gnc_commodity_equiv(rb, sa);
int bb = !gnc_commodity_equiv(rb, sb);
if ( (!aa) && bb) rb = NULL;
else if ( (!ab) && ba) rb = NULL;
else if ( (!ba) && ab) ra = NULL;
else if ( (!bb) && aa) ra = NULL;
else if ( aa && bb && ab && ba )
{
ra = NULL;
rb = NULL;
}
if (!ra)
{
ra = rb;
rb = NULL;
}
}
else if (ra && !rb)
{
int aa = !gnc_commodity_equiv(ra, sa);
int ab = !gnc_commodity_equiv(ra, sb);
if ( aa && ab ) ra = NULL;
}
else if (!ra && rb)
{
int aa = !gnc_commodity_equiv(rb, sa);
int ab = !gnc_commodity_equiv(rb, sb);
ra = ( aa && ab ) ? NULL : rb;
}
if ((!ra) && (!rb)) return NULL;
}
return (ra);
}
void
xaccSplitScrub (Split *split)
{
Account *account;
Transaction *trans;
gnc_numeric value, amount;
gnc_commodity *currency, *acc_commodity;
int scu;
if (!split) return;
ENTER ("(split=%p)", split);
trans = xaccSplitGetParent (split);
if (!trans)
{
LEAVE("no trans");
return;
}
account = xaccSplitGetAccount (split);
/* If there's no account, this split is an orphan.
* We need to fix that first, before proceeding.
*/
if (!account)
{
xaccTransScrubOrphans (trans);
account = xaccSplitGetAccount (split);
}
/* Grrr... the register gnc_split_register_load() line 203 of
* src/register/ledger-core/split-register-load.c will create
* free-floating bogus transactions. Ignore these for now ...
*/
if (!account)
{
PINFO ("Free Floating Transaction!");
LEAVE ("no account");
return;
}
/* Split amounts and values should be valid numbers */
value = xaccSplitGetValue (split);
if (gnc_numeric_check (value))
{
value = gnc_numeric_zero();
xaccSplitSetValue (split, value);
}
amount = xaccSplitGetAmount (split);
if (gnc_numeric_check (amount))
{
amount = gnc_numeric_zero();
xaccSplitSetAmount (split, amount);
}
currency = xaccTransGetCurrency (trans);
/* If the account doesn't have a commodity,
* we should attempt to fix that first.
*/
acc_commodity = xaccAccountGetCommodity(account);
if (!acc_commodity)
{
xaccAccountScrubCommodity (account);
}
if (!acc_commodity || !gnc_commodity_equiv(acc_commodity, currency))
{
LEAVE ("(split=%p) inequiv currency", split);
return;
}
scu = MIN (xaccAccountGetCommoditySCU (account),
gnc_commodity_get_fraction (currency));
if (gnc_numeric_same (amount, value, scu, GNC_HOW_RND_ROUND_HALF_UP))
{
LEAVE("(split=%p) different values", split);
return;
}
/*
* This will be hit every time you answer yes to the dialog "The
* current transaction has changed. Would you like to record it.
*/
PINFO ("Adjusted split with mismatched values, desc=\"%s\" memo=\"%s\""
" old amount %s %s, new amount %s",
trans->description, split->memo,
gnc_num_dbg_to_string (xaccSplitGetAmount(split)),
gnc_commodity_get_mnemonic (currency),
gnc_num_dbg_to_string (xaccSplitGetValue(split)));
xaccTransBeginEdit (trans);
xaccSplitSetAmount (split, value);
xaccTransCommitEdit (trans);
LEAVE ("(split=%p)", split);
}
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;
}
static void
gnc_main_window_summary_refresh (GNCMainSummary * summary)
{
Account *root;
char asset_string[256];
char profit_string[256];
GNCCurrencyAcc *currency_accum;
GList *currency_list;
GList *current;
GNCSummarybarOptions options;
root = gnc_get_current_root_account ();
options.default_currency = xaccAccountGetCommodity(root);
if(options.default_currency == NULL)
{
options.default_currency = gnc_default_currency ();
}
options.euro = gnc_gconf_get_bool(GCONF_GENERAL, KEY_ENABLE_EURO, NULL);
options.grand_total =
gnc_gconf_get_bool(GCONF_SECTION, KEY_GRAND_TOTAL, NULL);
options.non_currency =
gnc_gconf_get_bool(GCONF_SECTION, KEY_NON_CURRENCY, NULL);
options.start_date = gnc_accounting_period_fiscal_start();
options.end_date = gnc_accounting_period_fiscal_end();
currency_list = NULL;
/* grand total should be first in the list */
if (options.grand_total)
{
gnc_ui_get_currency_accumulator (¤cy_list, options.default_currency,
TOTAL_GRAND_TOTAL);
}
/* Make sure there's at least one accumulator in the list. */
gnc_ui_get_currency_accumulator (¤cy_list, options.default_currency,
TOTAL_SINGLE);
gnc_ui_accounts_recurse(root, ¤cy_list, options);
{
GtkTreeIter iter;
char asset_amount_string[256], profit_amount_string[256];
struct lconv *lc;
lc = gnc_localeconv();
g_object_ref(summary->datamodel);
gtk_combo_box_set_model(GTK_COMBO_BOX(summary->totals_combo), NULL);
gtk_list_store_clear(summary->datamodel);
for (current = g_list_first(currency_list); current; current = g_list_next(current))
{
const char *mnemonic;
gchar *total_mode_label;
currency_accum = current->data;
if (gnc_commodity_equiv (currency_accum->currency, gnc_locale_default_currency ()))
mnemonic = lc->currency_symbol;
else
mnemonic = gnc_commodity_get_mnemonic (currency_accum->currency);
if (mnemonic == NULL)
mnemonic = "";
*asset_string = '\0';
xaccSPrintAmount(asset_amount_string,
currency_accum->assets,
gnc_commodity_print_info(currency_accum->currency, TRUE));
*profit_string = '\0';
xaccSPrintAmount(profit_amount_string,
currency_accum->profits,
gnc_commodity_print_info(currency_accum->currency, TRUE));
gtk_list_store_append(summary->datamodel, &iter);
total_mode_label = get_total_mode_label(mnemonic, currency_accum->total_mode);
gtk_list_store_set(summary->datamodel, &iter,
COLUMN_MNEMONIC_TYPE, total_mode_label,
COLUMN_ASSETS, _("Net Assets:"),
COLUMN_ASSETS_VALUE, asset_amount_string,
COLUMN_PROFITS, _("Profits:"),
COLUMN_PROFITS_VALUE, profit_amount_string,
-1);
g_free(total_mode_label);
}
gtk_combo_box_set_model(GTK_COMBO_BOX(summary->totals_combo),
GTK_TREE_MODEL(summary->datamodel));
g_object_unref(summary->datamodel);
gtk_combo_box_set_active(GTK_COMBO_BOX(summary->totals_combo), 0);
}
/* Free the list we created for this */
for (current = g_list_first(currency_list);
current;
current = g_list_next(current))
{
g_free(current->data);
}
g_list_free(currency_list);
}
gboolean
gnc_tree_util_split_reg_get_debcred_entry (GncTreeViewSplitReg *view,
Transaction *trans, Split *split,
gboolean is_blank, gnc_numeric *ret_num,
GNCPrintAmountInfo *ret_print_info)
{
GncTreeModelSplitReg *model;
gnc_commodity *currency;
model = gnc_tree_view_split_reg_get_model_from_view (view);
currency = xaccTransGetCurrency (trans);
if (!currency)
currency = gnc_default_currency ();
if (is_blank)
{
gnc_numeric imbalance;
Account *acc;
imbalance = xaccTransGetImbalanceValue (trans);
if (gnc_numeric_zero_p (imbalance))
return FALSE;
if (xaccTransUseTradingAccounts (trans))
{
MonetaryList *imbal_list;
gnc_monetary *imbal_mon;
imbal_list = xaccTransGetImbalance (trans);
if (!imbal_list)
{
/* No commodity imbalance, there shouldn't be a value imablance. */
return FALSE;
}
if (imbal_list->next)
{
/* Multiple currency imbalance. */
gnc_monetary_list_free (imbal_list);
return FALSE;
}
imbal_mon = imbal_list->data;
if (!gnc_commodity_equal (gnc_monetary_commodity (*imbal_mon), currency))
{
/* Imbalance is in wrong currency */
gnc_monetary_list_free (imbal_list);
return FALSE;
}
if (!gnc_numeric_equal (gnc_monetary_value (*imbal_mon), imbalance))
{
/* Value and commodity imbalances differ */
gnc_monetary_list_free (imbal_list);
return FALSE;
}
/* Done with the imbalance list */
gnc_monetary_list_free (imbal_list);
}
imbalance = gnc_numeric_neg (imbalance);
acc = gnc_tree_model_split_reg_get_anchor (model);
if (gnc_tree_util_split_reg_needs_conv_rate (view, trans, acc))
{
imbalance = gnc_numeric_mul (imbalance,
xaccTransGetAccountConvRate (trans, acc),
gnc_commodity_get_fraction (currency),
GNC_HOW_RND_ROUND_HALF_UP);
}
else
{
imbalance = gnc_numeric_convert (imbalance,
gnc_commodity_get_fraction (currency),
GNC_HOW_RND_ROUND_HALF_UP);
}
*ret_num = imbalance;
*ret_print_info = gnc_account_print_info (acc, FALSE);
return TRUE;
}
{
gnc_numeric amount;
gnc_commodity *split_commodity;
GNCPrintAmountInfo print_info;
Account *account;
gnc_commodity *commodity;
account = gnc_tree_model_split_reg_get_anchor (model);
commodity = xaccAccountGetCommodity (account);
split_commodity = xaccAccountGetCommodity (xaccSplitGetAccount (split));
if (xaccTransUseTradingAccounts (trans))
{
gboolean use_symbol, is_current = FALSE;
Split *current_split = gnc_tree_view_split_reg_get_current_split (view);
RowDepth depth = gnc_tree_view_reg_get_selected_row_depth (view);
if ((split == current_split) && (depth == SPLIT3))
is_current = TRUE;
if (model->type == STOCK_REGISTER2 ||
model->type == CURRENCY_REGISTER2 ||
model->type == PORTFOLIO_LEDGER2)
{
gnc_commodity *amount_commodity;
/* security register. If this split has price and shares columns,
use the value, otherwise use the amount. */
if (gtu_sr_use_security (view))
{
amount = xaccSplitGetValue (split);
amount_commodity = currency;
}
else
{
amount = xaccSplitGetAmount (split);
amount_commodity = split_commodity;
}
/* Show the currency if it is not the default currency */
if (is_current ||
gnc_commodity_equiv (amount_commodity, gnc_default_currency ()))
use_symbol = FALSE;
else
use_symbol = TRUE;
print_info = gnc_commodity_print_info (amount_commodity, use_symbol);
}
else
{
/* non-security register, always use the split amount. */
amount = xaccSplitGetAmount (split);
if (is_current ||
gnc_commodity_equiv (split_commodity, commodity))
use_symbol = FALSE;
else
use_symbol = TRUE;
print_info = gnc_commodity_print_info (split_commodity, use_symbol);
}
}
else
{
/* If this account is not a stock/mutual/currency account, and
* currency != the account commodity, then use the SplitAmount
* instead of the SplitValue.
*/
switch (model->type)
{
case STOCK_REGISTER2:
case CURRENCY_REGISTER2:
case PORTFOLIO_LEDGER2:
amount = xaccSplitGetValue (split);
print_info = gnc_commodity_print_info (currency, FALSE);
break;
default:
if (commodity && !gnc_commodity_equal (commodity, currency))
/* Convert this to the "local" value */
amount = xaccSplitConvertAmount (split, account);
else
amount = xaccSplitGetValue (split);
print_info = gnc_account_print_info (account, FALSE);
break;
}
}
if (gnc_numeric_zero_p (amount))
return FALSE;
*ret_num = amount;
*ret_print_info = print_info;
return TRUE;
}
}
void
xaccLotScrubDoubleBalance (GNCLot *lot)
{
gnc_commodity *currency = NULL;
SplitList *snode;
GList *node;
gnc_numeric zero = gnc_numeric_zero();
gnc_numeric value = zero;
if (!lot) return;
ENTER ("lot=%s", kvp_frame_get_string (gnc_lot_get_slots (lot), "/title"));
for (snode = gnc_lot_get_split_list(lot); snode; snode = snode->next)
{
Split *s = snode->data;
xaccSplitComputeCapGains (s, NULL);
}
/* We double-check only closed lots */
if (FALSE == gnc_lot_is_closed (lot)) return;
for (snode = gnc_lot_get_split_list(lot); snode; snode = snode->next)
{
Split *s = snode->data;
Transaction *trans = s->parent;
/* Check to make sure all splits in the lot have a common currency */
if (NULL == currency)
{
currency = trans->common_currency;
}
if (FALSE == gnc_commodity_equiv (currency, trans->common_currency))
{
/* This lot has mixed currencies. Can't double-balance.
* Silently punt */
PWARN ("Lot with multiple currencies:\n"
"\ttrans=%s curr=%s", xaccTransGetDescription(trans),
gnc_commodity_get_fullname(trans->common_currency));
break;
}
/* Now, total up the values */
value = gnc_numeric_add (value, xaccSplitGetValue (s),
GNC_DENOM_AUTO, GNC_HOW_DENOM_EXACT);
PINFO ("Split=%p value=%s Accum Lot value=%s", s,
gnc_num_dbg_to_string (s->value),
gnc_num_dbg_to_string (value));
}
if (FALSE == gnc_numeric_equal (value, zero))
{
/* Unhandled error condition. Not sure what to do here,
* Since the ComputeCapGains should have gotten it right.
* I suppose there might be small rounding errors, a penny or two,
* the ideal thing would to figure out why there's a rounding
* error, and fix that.
*/
PERR ("Closed lot fails to double-balance !! lot value=%s",
gnc_num_dbg_to_string (value));
for (node = gnc_lot_get_split_list(lot); node; node = node->next)
{
Split *s = node->data;
PERR ("s=%p amt=%s val=%s", s,
gnc_num_dbg_to_string(s->amount),
gnc_num_dbg_to_string(s->value));
}
}
LEAVE ("lot=%s", kvp_frame_get_string (gnc_lot_get_slots (lot), "/title"));
}