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;
}
static void
test_num_print_info (gnc_numeric n, GNCPrintAmountInfo print_info, int line)
{
gnc_numeric n_parsed = gnc_numeric_zero();
const char *s;
gboolean ok, print_ok;
auto msg = "[PrintAmountInternal()] Bad numeric from rounding: GNC_ERROR_OVERFLOW.";
auto log_domain = "gnc.gui";
auto loglevel = static_cast<GLogLevelFlags>(G_LOG_LEVEL_WARNING);
auto check = test_error_struct_new (log_domain, loglevel, msg);
/* Throws overflows during rounding step in xaccPrintAmount when the "fraction" is high. See bug 665707. */
auto hdlr = g_log_set_handler (log_domain, loglevel,
(GLogFunc)test_checked_handler, &check);
s = xaccPrintAmount (n, print_info);
print_ok = (s && s[0] != '\0');
if (!print_ok)
return;
ok = xaccParseAmount (s, print_info.monetary, &n_parsed, NULL);
g_log_remove_handler (log_domain, hdlr);
do_test_args (ok, "parsing failure", __FILE__, __LINE__,
"num: %s, string %s (line %d)", gnc_numeric_to_string (n), s, line);
ok = gnc_numeric_equal (n, n_parsed);
do_test_args (ok, "not equal", __FILE__, __LINE__,
"start: %s, string %s, finish: %s (line %d)",
gnc_numeric_to_string (n), s,
gnc_numeric_to_string (n_parsed), line);
test_error_struct_free (check);
}
gboolean gncTaxTableEntryEqual(const GncTaxTableEntry *a, const GncTaxTableEntry *b)
{
if (a == NULL && b == NULL) return TRUE;
if (a == NULL || b == NULL) return FALSE;
if (!xaccAccountEqual(a->account, b->account, TRUE))
{
PWARN("accounts differ");
return FALSE;
}
if (a->type != b->type)
{
PWARN("types differ");
return FALSE;
}
if (!gnc_numeric_equal(a->amount, b->amount))
{
PWARN("amounts differ");
return FALSE;
}
return TRUE;
}
void gncEmployeeSetRate (GncEmployee *employee, gnc_numeric rate)
{
if (!employee) return;
if (gnc_numeric_equal (rate, employee->rate)) return;
gncEmployeeBeginEdit (employee);
employee->rate = rate;
mark_employee (employee);
gncEmployeeCommitEdit (employee);
}
void gncCustomerSetCredit (GncCustomer *cust, gnc_numeric credit)
{
if (!cust) return;
if (gnc_numeric_equal (credit, cust->credit)) return;
gncCustomerBeginEdit (cust);
cust->credit = credit;
mark_customer (cust);
gncCustomerCommitEdit (cust);
}
void gncEmployeeSetWorkday (GncEmployee *employee, gnc_numeric workday)
{
if (!employee) return;
if (gnc_numeric_equal (workday, employee->workday)) return;
gncEmployeeBeginEdit (employee);
employee->workday = workday;
mark_employee (employee);
gncEmployeeCommitEdit (employee);
}
void gncCustomerSetDiscount (GncCustomer *cust, gnc_numeric discount)
{
if (!cust) return;
if (gnc_numeric_equal (discount, cust->discount)) return;
gncCustomerBeginEdit (cust);
cust->discount = discount;
mark_customer (cust);
gncCustomerCommitEdit (cust);
}
static gnc_numeric
gnc_transaction_adjust_trading_splits (Transaction* trans, Account *root)
{
GList* splits;
gnc_numeric imbalance = gnc_numeric_zero();
for (splits = trans->splits; splits; splits = splits->next)
{
Split *split = splits->data;
Split *balance_split = NULL;
gnc_numeric value, amount;
gnc_commodity *commodity, *txn_curr = xaccTransGetCurrency (trans);
if (! xaccTransStillHasSplit (trans, split)) continue;
commodity = xaccAccountGetCommodity (xaccSplitGetAccount(split));
if (!commodity)
{
PERR("Split has no commodity");
continue;
}
balance_split = find_trading_split (trans, root, commodity);
if (balance_split != split)
/* this is not a trading split */
imbalance = gnc_numeric_add(imbalance, xaccSplitGetValue (split),
GNC_DENOM_AUTO, GNC_HOW_DENOM_EXACT);
/* Ignore splits where value or amount is zero */
value = xaccSplitGetValue (split);
amount = xaccSplitGetAmount (split);
if (gnc_numeric_zero_p(amount) || gnc_numeric_zero_p(value))
continue;
if (balance_split && balance_split != split)
{
gnc_numeric convrate = gnc_numeric_div (amount, value,
GNC_DENOM_AUTO, GNC_HOW_DENOM_REDUCE);
gnc_numeric old_value, new_value;
old_value = xaccSplitGetValue(balance_split);
new_value = gnc_numeric_div (xaccSplitGetAmount(balance_split),
convrate,
gnc_commodity_get_fraction(txn_curr),
GNC_HOW_RND_ROUND_HALF_UP);
if (! gnc_numeric_equal (old_value, new_value))
{
xaccTransBeginEdit (trans);
xaccSplitSetValue (balance_split, new_value);
xaccSplitScrub (balance_split);
xaccTransCommitEdit (trans);
}
}
}
return imbalance;
}
int
gnc_numeric_same(gnc_numeric a, gnc_numeric b, gint64 denom,
gint how)
{
gnc_numeric aconv, bconv;
aconv = gnc_numeric_convert(a, denom, how);
bconv = gnc_numeric_convert(b, denom, how);
return(gnc_numeric_equal(aconv, bconv));
}
static void set_value_price_cell(BasicCell *cell, gnc_numeric new_value)
{
PriceCell *pcell = (PriceCell*) cell;
if (!cell)
return;
if (gnc_numeric_equal (new_value, gnc_price_cell_get_value(pcell)))
return;
gnc_price_cell_set_value (pcell, new_value);
gnc_basic_cell_set_changed (cell, TRUE);
}
static xmlNodePtr
find_appropriate_node (xmlNodePtr node, Split* spl)
{
xmlNodePtr mark;
for (mark = node->xmlChildrenNode; mark; mark = mark->next)
{
gboolean account_guid_good = FALSE;
gboolean amount_good = FALSE;
xmlNodePtr mark2;
for (mark2 = mark->xmlChildrenNode; mark2; mark2 = mark2->next)
{
if (g_strcmp0 ((char*)mark2->name, "split:value") == 0)
{
gnc_numeric* num = dom_tree_to_gnc_numeric (mark2);
if (gnc_numeric_equal (*num, xaccSplitGetValue (spl)))
{
amount_good = TRUE;
}
g_free (num);
}
else if (g_strcmp0 ((char*)mark2->name, "split:account") == 0)
{
GncGUID* accid = dom_tree_to_guid (mark2);
Account* account = xaccSplitGetAccount (spl);
if (guid_equal (accid, xaccAccountGetGUID (account)))
{
account_guid_good = TRUE;
}
g_free (accid);
}
if (account_guid_good && amount_good)
{
return mark;
}
}
}
return NULL;
}
static void
test_numeric_fcn (QofBook *book, const char *message,
void (*set) (GncEmployee *, gnc_numeric),
gnc_numeric (*get)(const GncEmployee *))
{
GncEmployee *employee = gncEmployeeCreate (book);
gnc_numeric num = gnc_numeric_create (17, 1);
do_test (!gncEmployeeIsDirty (employee), "test if start dirty");
gncEmployeeBeginEdit (employee);
set (employee, num);
do_test (gncEmployeeIsDirty (employee), "test dirty later");
gncEmployeeCommitEdit (employee);
do_test (gncEmployeeIsDirty (employee), "test dirty after commit");
do_test (gnc_numeric_equal (get (employee), num), message);
gncEmployeeSetActive (employee, FALSE);
count++;
}
static gchar *
test_gnc_nums_internal(gnc_numeric to_test)
{
gchar *ret = NULL;
gnc_numeric *to_compare = NULL;
xmlNodePtr to_gen = NULL;
to_gen = gnc_numeric_to_dom_tree("test-num", &to_test);
if (!to_gen)
{
ret = "no dom tree created";
}
else
{
to_compare = dom_tree_to_gnc_numeric(to_gen);
if (!to_compare)
{
ret = "no gnc_numeric parsed";
}
else
{
if (!gnc_numeric_equal(to_test, *to_compare))
{
ret = "numerics compared different";
}
}
}
if (to_compare)
{
g_free(to_compare);
}
if (to_gen)
{
xmlFreeNode(to_gen);
}
return ret;
}
static void
test_numeric_fcn (QofBook *book, const char *message,
void (*set) (GncEmployee *, gnc_numeric),
gnc_numeric (*get)(const GncEmployee *))
{
GncEmployee *employee = gncEmployeeCreate (book);
gnc_numeric num = gnc_numeric_create (17, 1);
do_test (!gncEmployeeIsDirty (employee), "test if start dirty");
gncEmployeeBeginEdit (employee);
set (employee, num);
/* Employee record should be dirty */
do_test (gncEmployeeIsDirty (employee), "test dirty later");
gncEmployeeCommitEdit (employee);
/* Employee record should be not dirty */
/* Skip, because will always fail without a backend.
* It's not possible to load a backend in the engine code
* without having circular dependencies.
*/
// do_test (!gncEmployeeIsDirty (employee), "test dirty after commit");
do_test (gnc_numeric_equal (get (employee), num), message);
gncEmployeeSetActive (employee, FALSE);
count++;
}
static void
test_num_print_info (gnc_numeric n, GNCPrintAmountInfo print_info, int line)
{
gnc_numeric n_parsed = gnc_numeric_zero();
const char *s;
gboolean ok, print_ok;
s = xaccPrintAmount (n, print_info);
print_ok = (s && s[0] != '\0');
if (!print_ok)
return;
ok = xaccParseAmount (s, print_info.monetary, &n_parsed, NULL);
do_test_args (ok, "parsing failure", __FILE__, __LINE__,
"num: %s, string %s (line %d)", gnc_numeric_to_string (n), s, line);
ok = gnc_numeric_equal (n, n_parsed);
do_test_args (ok, "not equal", __FILE__, __LINE__,
"start: %s, string %s, finish: %s (line %d)",
gnc_numeric_to_string (n), s,
gnc_numeric_to_string (n_parsed), line);
}
static AB_IMEXPORTER_ACCOUNTINFO *
bal_accountinfo_cb(AB_IMEXPORTER_ACCOUNTINFO *element, gpointer user_data)
{
GncABImExContextImport *data = user_data;
Account *gnc_acc;
AB_ACCOUNT_STATUS *item, *best = NULL;
const GWEN_TIME *best_time = NULL;
const AB_BALANCE *booked_bal, *noted_bal;
const AB_VALUE *booked_val = NULL, *noted_val = NULL;
gdouble booked_value, noted_value;
gnc_numeric value;
time64 booked_tt = 0;
GtkWidget *dialog;
gboolean show_recn_window = FALSE;
g_return_val_if_fail(element && data, NULL);
if (data->awaiting & IGNORE_BALANCES)
/* Ignore them */
return NULL;
if (!AB_ImExporterAccountInfo_GetFirstAccountStatus(element))
/* No balance found */
return NULL;
else
data->awaiting |= FOUND_BALANCES;
/* Lookup the most recent ACCOUNT_STATUS available */
item = AB_ImExporterAccountInfo_GetFirstAccountStatus(element);
while (item)
{
const GWEN_TIME *item_time = AB_AccountStatus_GetTime(item);
if (!best || GWEN_Time_Diff(best_time, item_time) < 0.0)
{
best = item;
best_time = item_time;
}
item = AB_ImExporterAccountInfo_GetNextAccountStatus(element);
}
booked_bal = AB_AccountStatus_GetBookedBalance(best);
if (!(data->awaiting & AWAIT_BALANCES))
{
/* Ignore zero balances if we don't await a balance */
if (!booked_bal || AB_Value_IsZero(AB_Balance_GetValue(booked_bal)))
return NULL;
/* Ask the user whether to import unawaited non-zero balance */
if (gnc_verify_dialog(data->parent, TRUE, "%s",
_("The bank has sent balance information "
"in its response."
"\n"
"Do you want to import it?")))
{
data->awaiting |= AWAIT_BALANCES;
}
else
{
data->awaiting |= IGNORE_BALANCES;
return NULL;
}
}
/* Lookup the corresponding gnucash account */
gnc_acc = gnc_ab_accinfo_to_gnc_acc(element);
if (!gnc_acc) return NULL;
data->gnc_acc = gnc_acc;
/* Lookup booked balance and time */
if (booked_bal)
{
const GWEN_TIME *ti = AB_Balance_GetTime(booked_bal);
if (ti)
{
booked_tt = GWEN_Time_toTime_t(ti);
}
else
{
/* No time found? Use today because the HBCI query asked for today's
* balance. */
booked_tt = gnc_time64_get_day_start(gnc_time(NULL));
}
booked_val = AB_Balance_GetValue(booked_bal);
if (booked_val)
{
booked_value = AB_Value_GetValueAsDouble(booked_val);
}
else
{
g_warning("bal_accountinfo_cb: booked_val == NULL. Assuming 0");
booked_value = 0.0;
}
}
else
{
g_warning("bal_accountinfo_cb: booked_bal == NULL. Assuming 0");
booked_tt = 0;
booked_value = 0.0;
}
/* Lookup noted balance */
noted_bal = AB_AccountStatus_GetNotedBalance(best);
if (noted_bal)
{
noted_val = AB_Balance_GetValue(noted_bal);
if (noted_val)
noted_value = AB_Value_GetValueAsDouble(noted_val);
else
{
g_warning("bal_accountinfo_cb: noted_val == NULL. Assuming 0");
noted_value = 0.0;
}
}
else
{
g_warning("bal_accountinfo_cb: noted_bal == NULL. Assuming 0");
noted_value = 0.0;
}
value = double_to_gnc_numeric(booked_value,
xaccAccountGetCommoditySCU(gnc_acc),
GNC_HOW_RND_ROUND_HALF_UP);
if (noted_value == 0.0 && booked_value == 0.0)
{
dialog = gtk_message_dialog_new(
GTK_WINDOW(data->parent),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_INFO,
GTK_BUTTONS_OK,
"%s",
/* Translators: Strings from this file are needed only in
* countries that have one of aqbanking's Online Banking
* techniques available. This is 'OFX DirectConnect'
* (U.S. and others), 'HBCI' (in Germany), or 'YellowNet'
* (Switzerland). If none of these techniques are available
* in your country, you may safely ignore strings from the
* import-export/hbci subdirectory. */
_("The downloaded Online Banking Balance was zero.\n\n"
"Either this is the correct balance, or your bank does not "
"support Balance download in this Online Banking version. "
"In the latter case you should choose a different "
"Online Banking version number in the Online Banking "
"(AqBanking or HBCI) Setup. After that, try again to "
"download the Online Banking Balance."));
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}
else
{
gnc_numeric reconc_balance = xaccAccountGetReconciledBalance(gnc_acc);
gchar *booked_str = gnc_AB_VALUE_to_readable_string(booked_val);
gchar *message1 = g_strdup_printf(
_("Result of Online Banking job: \n"
"Account booked balance is %s"),
booked_str);
gchar *message2 =
(noted_value == 0.0) ?
g_strdup("") :
g_strdup_printf(_("For your information: This account also "
"has a noted balance of %s\n"),
gnc_AB_VALUE_to_readable_string(noted_val));
if (gnc_numeric_equal(value, reconc_balance))
{
const gchar *message3 =
_("The booked balance is identical to the current "
"reconciled balance of the account.");
dialog = gtk_message_dialog_new(
GTK_WINDOW(data->parent),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_INFO,
GTK_BUTTONS_OK,
"%s\n%s\n%s",
message1, message2, message3);
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(GTK_WIDGET(dialog));
}
else
{
const char *message3 = _("Reconcile account now?");
show_recn_window = gnc_verify_dialog(data->parent, TRUE, "%s\n%s\n%s",
message1, message2, message3);
}
g_free(booked_str);
g_free(message1);
g_free(message2);
}
/* Show reconciliation window */
if (show_recn_window)
recnWindowWithBalance(data->parent, gnc_acc, value, booked_tt);
return NULL;
}
static void
check_equality_operator (void)
{
int i, m;
gint mult;
gint64 f, deno, numer;
gnc_numeric big, rbig;
gnc_numeric val, mval;
gnc_numeric bval, rval;
/* Check equality operator for some large numer/denom values */
numer = 1 << 30;
numer <<= 30; /* we don't trust cpp to compute 1<<60 correctly */
deno = 1 << 30;
deno <<= 20;
rbig = gnc_numeric_create (numer, deno);
big = gnc_numeric_create (1 << 10, 1);
do_test (gnc_numeric_equal(big, rbig), "equal to billion");
big = gnc_numeric_create (1 << 20, 1 << 10);
do_test (gnc_numeric_equal(big, rbig), "equal to 1<<20/1<<10");
big = gnc_numeric_create (1 << 30, 1 << 20);
do_test (gnc_numeric_equal(big, rbig), "equal to 1<<30/1<<20");
numer = 1 << 30;
numer <<= 30; /* we don't trust cpp to compute 1<<60 correctly */
deno = 1 << 30;
rbig = gnc_numeric_create (numer, deno);
big = gnc_numeric_create (1 << 30, 1);
do_test (gnc_numeric_equal(big, rbig), "equal to 1<<30");
numer = 1 << 30;
numer <<= 10;
big = gnc_numeric_create (numer, 1 << 10);
do_test (gnc_numeric_equal(big, rbig), "equal to 1<<40/1<<10");
numer <<= 10;
big = gnc_numeric_create (numer, 1 << 20);
do_test (gnc_numeric_equal(big, rbig), "equal to 1<<50/1<<20");
/* We assume RAND_MAX is less that 1<<32 */
for (i = 0; i < NREPS; i++)
{
deno = rand() / 2;
mult = rand() / 2;
numer = rand() / 2;
/* avoid 0 */
if (deno == 0 || mult == 0)
{
i--;
continue;
}
val = gnc_numeric_create (numer, deno);
mval = gnc_numeric_create (numer * mult, deno * mult);
/* The reduced version should be equivalent */
bval = gnc_numeric_reduce (val);
rval = gnc_numeric_reduce (mval);
check_unary_op (gnc_numeric_eq,
bval, rval, mval, "expected %s got %s = reduce(%s)");
/* The unreduced versions should be equal */
check_unary_op (gnc_numeric_equal,
val, mval, mval, "expected %s = %s");
/* Certain modulo's should be very cleary un-equal; this
* helps stop funky modulo-64 aliasing in compares that
* might creep in. */
mval.denom >>= 1;
mval.num >>= 1;
m = 0;
f = mval.denom;
while (f % 2 == 0)
{
f >>= 1;
m++;
}
if (1 < m)
{
gint64 nn = 1 << (32 - m);
nn <<= 32;
nn += mval.num;
val = gnc_numeric_create (2 * nn, 2 * mval.denom);
check_unary_op (gnc_numeric_unequal,
val, mval, mval, "expected unequality %s != %s");
}
}
}
static gboolean
gnc_numeric_unequal (gnc_numeric a, gnc_numeric b)
{
return (0 == gnc_numeric_equal (a, b));
}
void
templ_list_row_activated_cb(GtkTreeView *view, GtkTreePath *path,
GtkTreeViewColumn *column, gpointer user_data)
{
GncABTransDialog *td = user_data;
GtkTreeModel *model;
GtkTreeIter iter;
GncABTransTempl *templ;
const gchar *old_name, *new_name;
const gchar *old_account, *new_account;
const gchar *old_bankcode, *new_bankcode;
const gchar *old_purpose, *new_purpose;
const gchar *old_purpose_cont, *new_purpose_cont;
GtkWidget *amount_widget;
const gchar *old_amount_text;
gnc_numeric old_amount, new_amount;
g_return_if_fail(td);
ENTER("td=%p", td);
if (!gtk_tree_model_get_iter(GTK_TREE_MODEL(td->template_list_store), &iter,
path))
{
LEAVE("Could not get iter");
return;
}
gtk_tree_model_get(GTK_TREE_MODEL(td->template_list_store), &iter,
TEMPLATE_POINTER, &templ, -1);
/* Get old values */
old_name = gtk_entry_get_text(GTK_ENTRY(td->recp_name_entry));
old_account = gtk_entry_get_text(GTK_ENTRY(td->recp_account_entry));
old_bankcode = gtk_entry_get_text(GTK_ENTRY(td->recp_bankcode_entry));
old_purpose = gtk_entry_get_text(GTK_ENTRY(td->purpose_entry));
old_purpose_cont = gtk_entry_get_text(GTK_ENTRY(td->purpose_cont_entry));
amount_widget = gnc_amount_edit_gtk_entry(GNC_AMOUNT_EDIT(td->amount_edit));
old_amount_text = gtk_entry_get_text(GTK_ENTRY(amount_widget));
old_amount = gnc_amount_edit_get_amount(GNC_AMOUNT_EDIT(td->amount_edit));
/* Get new values */
new_name = gnc_ab_trans_templ_get_recp_name(templ);
new_account = gnc_ab_trans_templ_get_recp_account(templ);
new_bankcode = gnc_ab_trans_templ_get_recp_bankcode(templ);
new_purpose = gnc_ab_trans_templ_get_purpose(templ);
new_purpose_cont = gnc_ab_trans_templ_get_purpose_cont(templ);
new_amount = gnc_ab_trans_templ_get_amount(templ);
if (!new_name) new_name = "";
if (!new_account) new_account = "";
if (!new_bankcode) new_bankcode = "";
if (!new_purpose) new_purpose = "";
if (!new_purpose_cont) new_purpose_cont = "";
/* Check for differences to avoid overwriting entered text */
if ((*old_name && strcmp(old_name, new_name))
|| (*old_account && strcmp(old_account, new_account))
|| (*old_bankcode && strcmp(old_bankcode, new_bankcode))
|| (*old_purpose && strcmp(old_purpose, new_purpose))
|| (*old_purpose_cont && strcmp(old_purpose_cont, new_purpose_cont))
|| (*old_amount_text && !gnc_numeric_equal(old_amount, new_amount)))
{
if (!gnc_verify_dialog(
td->parent, FALSE,
_("Do you really want to overwrite your changes with the "
"contents of the template \"%s\"?"),
gnc_ab_trans_templ_get_name(templ)))
{
LEAVE("aborted");
return;
}
}
/* Fill in */
gtk_entry_set_text(GTK_ENTRY(td->recp_name_entry), new_name);
gtk_entry_set_text(GTK_ENTRY(td->recp_account_entry), new_account);
gtk_entry_set_text(GTK_ENTRY(td->recp_bankcode_entry), new_bankcode);
gtk_entry_set_text(GTK_ENTRY(td->purpose_entry), new_purpose);
gtk_entry_set_text(GTK_ENTRY(td->purpose_cont_entry), new_purpose_cont);
gnc_amount_edit_set_amount(GNC_AMOUNT_EDIT(td->amount_edit), new_amount);
LEAVE(" ");
}
gboolean gncEmployeeEqual(const GncEmployee* a, const GncEmployee* b)
{
if (a == NULL && b == NULL) return TRUE;
if (a == NULL || b == NULL ) return FALSE;
g_return_val_if_fail(GNC_IS_EMPLOYEE(a), FALSE);
g_return_val_if_fail(GNC_IS_EMPLOYEE(b), FALSE);
if (safe_strcmp(a->id, b->id) != 0)
{
PWARN("IDs differ: %s vs %s", a->id, b->id);
return FALSE;
}
if (safe_strcmp(a->username, b->username) != 0)
{
PWARN("Usernames differ: %s vs %s", a->username, b->username);
return FALSE;
}
if (!gncAddressEqual(a->addr, b->addr))
{
PWARN("Addresses differ");
return FALSE;
}
if (!gnc_commodity_equal(a->currency, b->currency))
{
PWARN("Currencies differ");
return FALSE;
}
if (a->active != b->active)
{
PWARN("Active flags differ");
return FALSE;
}
if (safe_strcmp(a->language, b->language) != 0)
{
PWARN("Languages differ: %s vs %s", a->language, b->language);
return FALSE;
}
if (safe_strcmp(a->acl, b->acl) != 0)
{
PWARN("ACLs differ: %s vs %s", a->acl, b->acl);
return FALSE;
}
if (!xaccAccountEqual(a->ccard_acc, b->ccard_acc, TRUE))
{
PWARN("Accounts differ");
return FALSE;
}
if (!gnc_numeric_equal(a->workday, b->workday))
{
PWARN("Workdays differ");
return FALSE;
}
if (!gnc_numeric_equal(a->rate, b->rate))
{
PWARN("Rates differ");
return FALSE;
}
return TRUE;
}
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;
}
}
static const char*
equals_node_val_vs_split_internal (xmlNodePtr node, Split* spl)
{
xmlNodePtr mark;
for (mark = node->children; mark != NULL; mark = mark->next)
{
if (g_strcmp0 ((char*)mark->name, "split:id") == 0)
{
GncGUID* id = dom_tree_to_guid (mark);
if (!guid_equal (id, xaccSplitGetGUID (spl)))
{
g_free (id);
return "ids differ";
}
g_free (id);
}
else if (g_strcmp0 ((char*)mark->name, "split:memo") == 0)
{
char* memo = dom_tree_to_text (mark);
if (g_strcmp0 (memo, xaccSplitGetMemo (spl)) != 0)
{
g_free (memo);
return "memos differ";
}
g_free (memo);
}
else if (g_strcmp0 ((char*)mark->name, "split:reconciled-state") == 0)
{
char* rs = dom_tree_to_text (mark);
if (rs[0] != xaccSplitGetReconcile (spl))
{
g_free (rs);
return "states differ";
}
g_free (rs);
}
else if (g_strcmp0 ((char*)mark->name, "split:value") == 0)
{
gnc_numeric* num = dom_tree_to_gnc_numeric (mark);
gnc_numeric val = xaccSplitGetValue (spl);
if (!gnc_numeric_equal (*num, val))
{
g_free (num);
return g_strdup_printf ("values differ: %" G_GINT64_FORMAT "/%"
G_GINT64_FORMAT " v %" G_GINT64_FORMAT
"/%" G_GINT64_FORMAT,
(*num).num, (*num).denom,
val.num, val.denom);
}
g_free (num);
}
else if (g_strcmp0 ((char*)mark->name, "split:quantity") == 0)
{
gnc_numeric* num = dom_tree_to_gnc_numeric (mark);
gnc_numeric val = xaccSplitGetAmount (spl);
if (!gnc_numeric_equal (*num, val))
{
return g_strdup_printf ("quantities differ under _equal: %"
G_GINT64_FORMAT "/%" G_GINT64_FORMAT
" v %" G_GINT64_FORMAT "/%"
G_GINT64_FORMAT,
(*num).num, (*num).denom,
val.num, val.denom);
}
if (!gnc_numeric_equal (*num, val))
{
g_free (num);
return g_strdup_printf ("quantities differ: %" G_GINT64_FORMAT
"/%" G_GINT64_FORMAT " v %"
G_GINT64_FORMAT "/%" G_GINT64_FORMAT,
(*num).num, (*num).denom,
val.num, val.denom);
}
g_free (num);
}
else if (g_strcmp0 ((char*)mark->name, "split:account") == 0)
{
GncGUID* id = dom_tree_to_guid (mark);
Account* account = xaccSplitGetAccount (spl);
if (!guid_equal (id, xaccAccountGetGUID (account)))
{
g_free (id);
return "accounts differ";
}
g_free (id);
}
}
return NULL;
}
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"));
}
static gboolean
scrub_other_link (GNCLot *from_lot, Split *ll_from_split,
GNCLot *to_lot, Split *ll_to_split)
{
Split *real_from_split; // This refers to the split in the payment lot representing the payment itself
gboolean modified = FALSE;
gnc_numeric real_from_val;
gnc_numeric from_val = xaccSplitGetValue (ll_from_split);
gnc_numeric to_val = xaccSplitGetValue (ll_to_split);
Transaction *ll_txn = xaccSplitGetParent (ll_to_split);
// Per iteration we can only scrub at most min (val-doc-split, val-pay-split)
// So set the ceiling for finding a potential offsetting split in the lot
if (gnc_numeric_compare (gnc_numeric_abs (from_val), gnc_numeric_abs (to_val)) >= 0)
from_val = gnc_numeric_neg (to_val);
// Next we have to find the original payment split so we can
// add (part of) it to the document lot
real_from_split = gncOwnerFindOffsettingSplit (from_lot, from_val);
if (!real_from_split)
return FALSE; // No usable split in the payment lot
// We now have found 3 splits involved in the scrub action:
// 2 lot link splits which we want to reduce
// 1 other split to move into the original lot instead of the lot link split
// As said only value of the split can be offset.
// So split the bigger ones in two if needed and continue with equal valued splits only
// The remainder is added to the lot link transaction and the lot to keep everything balanced
// and will be processed in a future iteration
modified = reduce_biggest_split (ll_from_split, ll_to_split);
modified |= reduce_biggest_split (real_from_split, ll_from_split);
modified |= reduce_biggest_split (ll_from_split, ll_to_split);
// At this point ll_to_split and real_from_split should have the same value
// If not, flag a warning and skip to the next iteration
to_val = xaccSplitGetValue (ll_to_split);
from_val = xaccSplitGetValue (ll_from_split);
real_from_val = xaccSplitGetValue (real_from_split);
if (!gnc_numeric_equal (real_from_val, to_val))
{
// This is unexpected - write a warning message and skip this split
PWARN("real_from_val (%s) and to_val (%s) differ. "
"This is unexpected! Skip scrubbing of real_from_split %p against ll_to_split %p.",
gnc_numeric_to_string (real_from_val), // gnc_numeric_denom (real_from_val),
gnc_numeric_to_string (to_val), // gnc_numeric_denom (to_val),
real_from_split, ll_to_split);
return modified;
}
// Now do the actual split dance
// - move real payment split to doc lot
// - delete both lot link splits from the lot link transaction
gnc_lot_add_split (to_lot, real_from_split);
xaccTransBeginEdit (ll_txn);
xaccSplitDestroy (ll_to_split);
xaccSplitDestroy (ll_from_split);
xaccTransCommitEdit (ll_txn);
// Cleanup the lots
xaccScrubMergeLotSubSplits (to_lot, FALSE);
xaccScrubMergeLotSubSplits (from_lot, FALSE);
return TRUE; // We did change splits/transactions/lots...
}
static gboolean
ght_gnc_numeric_equal(gconstpointer v1, gconstpointer v2)
{
gnc_numeric n1 = *(gnc_numeric *)v1, n2 = *(gnc_numeric *)v2;
return gnc_numeric_equal(n1, n2);
}
void
xaccTransScrubImbalance (Transaction *trans, Account *root,
Account *account)
{
const gnc_commodity *currency;
if (!trans) return;
ENTER ("()");
/* Must look for orphan splits even if there is no imbalance. */
xaccTransScrubSplits (trans);
/* Return immediately if things are balanced. */
if (xaccTransIsBalanced (trans))
{
LEAVE ("transaction is balanced");
return;
}
currency = xaccTransGetCurrency (trans);
if (! xaccTransUseTradingAccounts (trans))
{
gnc_numeric imbalance;
/* Make the value sum to zero */
imbalance = xaccTransGetImbalanceValue (trans);
if (! gnc_numeric_zero_p (imbalance))
{
PINFO ("Value unbalanced transaction");
add_balance_split (trans, imbalance, root, account);
}
}
else
{
MonetaryList *imbal_list;
MonetaryList *imbalance_commod;
GList *splits;
gnc_numeric imbalance;
Split *balance_split = NULL;
/* If there are existing trading splits, adjust the price or exchange
rate in each of them to agree with the non-trading splits for the
same commodity. If there are multiple non-trading splits for the
same commodity in the transaction this will use the exchange rate in
the last such split. This shouldn't happen, and if it does then there's
not much we can do about it anyway.
While we're at it, compute the value imbalance ignoring existing
trading splits. */
imbalance = gnc_numeric_zero();
for (splits = trans->splits; splits; splits = splits->next)
{
Split *split = splits->data;
gnc_numeric value, amount;
gnc_commodity *commodity;
if (! xaccTransStillHasSplit (trans, split)) continue;
commodity = xaccAccountGetCommodity (xaccSplitGetAccount(split));
if (!commodity)
{
PERR("Split has no commodity");
continue;
}
balance_split = find_trading_split (trans, root, commodity);
if (balance_split != split)
/* this is not a trading split */
imbalance = gnc_numeric_add(imbalance, xaccSplitGetValue (split),
GNC_DENOM_AUTO, GNC_HOW_DENOM_EXACT);
/* Ignore splits where value or amount is zero */
value = xaccSplitGetValue (split);
amount = xaccSplitGetAmount (split);
if (gnc_numeric_zero_p(amount) || gnc_numeric_zero_p(value))
continue;
if (balance_split && balance_split != split)
{
gnc_numeric convrate = gnc_numeric_div (amount, value,
GNC_DENOM_AUTO, GNC_HOW_DENOM_REDUCE);
gnc_numeric old_value, new_value;
old_value = xaccSplitGetValue(balance_split);
new_value = gnc_numeric_div (xaccSplitGetAmount(balance_split),
convrate,
gnc_commodity_get_fraction(currency),
GNC_HOW_RND_ROUND_HALF_UP);
if (! gnc_numeric_equal (old_value, new_value))
{
xaccTransBeginEdit (trans);
xaccSplitSetValue (balance_split, new_value);
xaccSplitScrub (balance_split);
xaccTransCommitEdit (trans);
}
}
}
/* Balance the value, ignoring existing trading splits */
if (! gnc_numeric_zero_p (imbalance))
{
PINFO ("Value unbalanced transaction");
add_balance_split (trans, imbalance, root, account);
}
/* If the transaction is balanced, nothing more to do */
imbal_list = xaccTransGetImbalance (trans);
if (!imbal_list)
{
LEAVE("transaction is balanced");
return;
}
PINFO ("Currency unbalanced transaction");
for (imbalance_commod = imbal_list; imbalance_commod;
imbalance_commod = imbalance_commod->next)
{
gnc_monetary *imbal_mon = imbalance_commod->data;
gnc_commodity *commodity;
gnc_numeric old_amount, new_amount;
gnc_numeric old_value, new_value, val_imbalance;
GList *splits;
commodity = gnc_monetary_commodity (*imbal_mon);
balance_split = get_trading_split(trans, root, commodity);
if (!balance_split)
{
/* Error already logged */
gnc_monetary_list_free(imbal_list);
LEAVE("");
return;
}
account = xaccSplitGetAccount(balance_split);
if (! gnc_commodity_equal (currency, commodity))
{
/* Find the value imbalance in this commodity */
val_imbalance = gnc_numeric_zero();
for (splits = trans->splits; splits; splits = splits->next)
{
Split *split = splits->data;
if (xaccTransStillHasSplit (trans, split) &&
gnc_commodity_equal (commodity,
xaccAccountGetCommodity(xaccSplitGetAccount(split))))
val_imbalance = gnc_numeric_add (val_imbalance, xaccSplitGetValue (split),
GNC_DENOM_AUTO, GNC_HOW_DENOM_EXACT);
}
}
xaccTransBeginEdit (trans);
old_amount = xaccSplitGetAmount (balance_split);
new_amount = gnc_numeric_sub (old_amount, gnc_monetary_value(*imbal_mon),
gnc_commodity_get_fraction(commodity),
GNC_HOW_RND_ROUND_HALF_UP);
xaccSplitSetAmount (balance_split, new_amount);
if (gnc_commodity_equal (currency, commodity))
{
/* Imbalance commodity is the transaction currency, value in the
split must be the same as the amount */
xaccSplitSetValue (balance_split, new_amount);
}
else
{
old_value = xaccSplitGetValue (balance_split);
new_value = gnc_numeric_sub (old_value, val_imbalance,
gnc_commodity_get_fraction(currency),
GNC_HOW_RND_ROUND_HALF_UP);
xaccSplitSetValue (balance_split, new_value);
}
xaccSplitScrub (balance_split);
xaccTransCommitEdit (trans);
}
gnc_monetary_list_free(imbal_list);
if (!gnc_numeric_zero_p(xaccTransGetImbalanceValue(trans)))
{
/* This is probably because there are splits with zero amount
and non-zero value. These are usually realized gain/loss
splits. Add a reversing split for each of them to balance
the value. */
/* Copy the split list so we don't see the splits we're adding */
GList *splits_dup = g_list_copy(trans->splits);
for (splits = splits_dup; splits; splits = splits->next)
{
Split *split = splits->data;
if (! xaccTransStillHasSplit(trans, split)) continue;
if (!gnc_numeric_zero_p(xaccSplitGetValue(split)) &&
gnc_numeric_zero_p(xaccSplitGetAmount(split)))
{
gnc_commodity *commodity;
gnc_numeric old_value, new_value;
commodity = xaccAccountGetCommodity(xaccSplitGetAccount(split));
if (!commodity)
{
PERR("Split has no commodity");
continue;
}
balance_split = get_trading_split(trans, root, commodity);
if (!balance_split)
{
/* Error already logged */
gnc_monetary_list_free(imbal_list);
LEAVE("");
return;
}
account = xaccSplitGetAccount(balance_split);
xaccTransBeginEdit (trans);
old_value = xaccSplitGetValue (balance_split);
new_value = gnc_numeric_sub (old_value, xaccSplitGetValue(split),
gnc_commodity_get_fraction(currency),
GNC_HOW_RND_ROUND_HALF_UP);
xaccSplitSetValue (balance_split, new_value);
/* Don't change the balance split's amount since the amount
is zero in the split we're working on */
xaccSplitScrub (balance_split);
xaccTransCommitEdit (trans);
}
}
g_list_free(splits_dup);
if (!gnc_numeric_zero_p(xaccTransGetImbalanceValue(trans)))
PERR("Balancing currencies unbalanced value");
}
}
LEAVE ("()");
}
void
xaccTransScrubCurrency (Transaction *trans)
{
SplitList *node;
gnc_commodity *currency;
if (!trans) return;
/* If there are any orphaned splits in a transaction, then the
* this routine will fail. Therefore, we want to make sure that
* there are no orphans (splits without parent account).
*/
xaccTransScrubOrphans (trans);
currency = xaccTransGetCurrency (trans);
if (currency && gnc_commodity_is_currency(currency)) return;
currency = xaccTransFindCommonCurrency (trans, qof_instance_get_book(trans));
if (currency)
{
xaccTransBeginEdit (trans);
xaccTransSetCurrency (trans, currency);
xaccTransCommitEdit (trans);
}
else
{
if (NULL == trans->splits)
{
PWARN ("Transaction \"%s\" has no splits in it!", trans->description);
}
else
{
SplitList *node;
char guid_str[GUID_ENCODING_LENGTH + 1];
guid_to_string_buff(xaccTransGetGUID(trans), guid_str);
PWARN ("no common transaction currency found for trans=\"%s\" (%s);",
trans->description, guid_str);
for (node = trans->splits; node; node = node->next)
{
Split *split = node->data;
if (NULL == split->acc)
{
PWARN (" split=\"%s\" is not in any account!", split->memo);
}
else
{
gnc_commodity *currency = xaccAccountGetCommodity(split->acc);
PWARN ("setting to split=\"%s\" account=\"%s\" commodity=\"%s\"",
split->memo, xaccAccountGetName(split->acc),
gnc_commodity_get_mnemonic(currency));
xaccTransBeginEdit (trans);
xaccTransSetCurrency (trans, currency);
xaccTransCommitEdit (trans);
return;
}
}
}
return;
}
for (node = trans->splits; node; node = node->next)
{
Split *sp = node->data;
if (!gnc_numeric_equal(xaccSplitGetAmount (sp),
xaccSplitGetValue (sp)))
{
gnc_commodity *acc_currency;
acc_currency = sp->acc ? xaccAccountGetCommodity(sp->acc) : NULL;
if (acc_currency == currency)
{
/* This Split needs fixing: The transaction-currency equals
* the account-currency/commodity, but the amount/values are
* inequal i.e. they still correspond to the security
* (amount) and the currency (value). In the new model, the
* value is the amount in the account-commodity -- so it
* needs to be set to equal the amount (since the
* account-currency doesn't exist anymore).
*
* Note: Nevertheless we lose some information here. Namely,
* the information that the 'amount' in 'account-old-security'
* was worth 'value' in 'account-old-currency'. Maybe it would
* be better to store that information in the price database?
* But then, for old currency transactions there is still the
* 'other' transaction, which is going to keep that
* information. So I don't bother with that here. -- cstim,
* 2002/11/20. */
PWARN ("Adjusted split with mismatched values, desc=\"%s\" memo=\"%s\""
" old amount %s %s, new amount %s",
trans->description, sp->memo,
gnc_num_dbg_to_string (xaccSplitGetAmount(sp)),
gnc_commodity_get_mnemonic (currency),
gnc_num_dbg_to_string (xaccSplitGetValue(sp)));
xaccTransBeginEdit (trans);
xaccSplitSetAmount (sp, xaccSplitGetValue(sp));
xaccTransCommitEdit (trans);
}
/*else
{
PINFO ("Ok: Split '%s' Amount %s %s, value %s %s",
xaccSplitGetMemo (sp),
gnc_num_dbg_to_string (amount),
gnc_commodity_get_mnemonic (currency),
gnc_num_dbg_to_string (value),
gnc_commodity_get_mnemonic (acc_currency));
}*/
}
}
}
static void
check_reciprocal(void)
{
gnc_numeric a, b, ans, val;
double flo;
val = gnc_numeric_create(-60, 20);
check_unary_op (gnc_numeric_eq, gnc_numeric_create (-3, -1),
gnc_numeric_convert(val, GNC_DENOM_RECIPROCAL(1),
GNC_HOW_RND_NEVER),
val, "expected %s got %s = (%s as RECIP(1))");
a = gnc_numeric_create(200, 100);
b = gnc_numeric_create(300, 100);
/* 2 + 3 = 5 */
ans = gnc_numeric_add(a, b, GNC_DENOM_RECIPROCAL(1), GNC_HOW_RND_NEVER);
check_binary_op (gnc_numeric_create(5, -1),
ans, a, b, "expected %s got %s = %s + %s for reciprocal");
/* 2 + 3 = 5 */
a = gnc_numeric_create(2, -1);
b = gnc_numeric_create(300, 100);
ans = gnc_numeric_add(a, b, GNC_DENOM_RECIPROCAL(1), GNC_HOW_RND_NEVER);
check_binary_op (gnc_numeric_create(5, -1),
ans, a, b, "expected %s got %s = %s + %s for reciprocal");
/* check gnc_numeric_to_double */
flo = gnc_numeric_to_double(gnc_numeric_create(5, -1));
do_test ((5.0 == flo), "reciprocal conversion");
/* check gnc_numeric_compare */
a = gnc_numeric_create(2, 1);
b = gnc_numeric_create(2, -1);
do_test((0 == gnc_numeric_compare(a, b)), " 2 == 2 ");
a = gnc_numeric_create(2, 1);
b = gnc_numeric_create(3, -1);
do_test((-1 == gnc_numeric_compare(a, b)), " 2 < 3 ");
a = gnc_numeric_create(-2, 1);
b = gnc_numeric_create(2, -1);
do_test((-1 == gnc_numeric_compare(a, b)), " -2 < 2 ");
a = gnc_numeric_create(2, -1);
b = gnc_numeric_create(3, -1);
do_test((-1 == gnc_numeric_compare(a, b)), " 2 < 3 ");
/* check for equality */
a = gnc_numeric_create(2, 1);
b = gnc_numeric_create(2, -1);
do_test(gnc_numeric_equal(a, b), " 2 == 2 ");
/* check gnc_numeric_mul */
a = gnc_numeric_create(2, 1);
b = gnc_numeric_create(3, -1);
ans = gnc_numeric_mul(a, b, GNC_DENOM_RECIPROCAL(1), GNC_HOW_RND_NEVER);
check_binary_op (gnc_numeric_create(6, -1),
ans, a, b, "expected %s got %s = %s * %s for reciprocal");
/* check gnc_numeric_div */
/* -60 / 20 = -3 */
a = gnc_numeric_create(-60, 1);
b = gnc_numeric_create(2, -10);
ans = gnc_numeric_div(a, b, GNC_DENOM_RECIPROCAL(1), GNC_HOW_RND_NEVER);
check_binary_op (gnc_numeric_create(-3, -1),
ans, a, b, "expected %s got %s = %s / %s for reciprocal");
/* 60 / 20 = 3 */
a = gnc_numeric_create(60, 1);
b = gnc_numeric_create(2, -10);
ans = gnc_numeric_div(a, b, GNC_DENOM_RECIPROCAL(1), GNC_HOW_RND_NEVER);
check_binary_op (gnc_numeric_create(3, -1),
ans, a, b, "expected %s got %s = %s / %s for reciprocal");
}
gboolean gncBillTermEqual(const GncBillTerm *a, const GncBillTerm *b)
{
if (a == NULL && b == NULL) return TRUE;
if (a == NULL || b == NULL) return FALSE;
g_return_val_if_fail(GNC_IS_BILLTERM(a), FALSE);
g_return_val_if_fail(GNC_IS_BILLTERM(b), FALSE);
if (g_strcmp0(a->name, b->name) != 0)
{
PWARN("Names differ: %s vs %s", a->name, b->name);
return FALSE;
}
if (g_strcmp0(a->desc, b->desc) != 0)
{
PWARN("Descriptions differ: %s vs %s", a->desc, b->desc);
return FALSE;
}
if (a->type != b->type)
{
PWARN("Types differ");
return FALSE;
}
if (a->due_days != b->due_days)
{
PWARN("Due days differ: %d vs %d", a->due_days, b->due_days);
return FALSE;
}
if (a->disc_days != b->disc_days)
{
PWARN("Discount days differ: %d vs %d", a->disc_days, b->disc_days);
return FALSE;
}
if (!gnc_numeric_equal(a->discount, b->discount))
{
PWARN("Discounts differ");
return FALSE;
}
if (a->cutoff != b->cutoff)
{
PWARN("Cutoffs differ: %d vs %d", a->cutoff, b->cutoff);
return FALSE;
}
if (a->invisible != b->invisible)
{
PWARN("Invisible flags differ");
return FALSE;
}
// gint64 refcount;
// GncBillTerm * parent; /* if non-null, we are an immutable child */
// GncBillTerm * child; /* if non-null, we have not changed */
// GList * children; /* list of children for disconnection */
return TRUE;
}