gnc_numeric
gnc_convert_from_euro(const gnc_commodity * currency, gnc_numeric value)
{
gnc_euro_rate_struct * result;
if (currency == NULL)
return gnc_numeric_zero ();
if (!gnc_commodity_is_iso(currency))
return gnc_numeric_zero ();
result = bsearch(currency,
gnc_euro_rates,
sizeof(gnc_euro_rates) / sizeof(gnc_euro_rate_struct),
sizeof(gnc_euro_rate_struct),
gnc_euro_rate_compare);
if (result == NULL)
return gnc_numeric_zero ();
{
gnc_numeric rate;
rate = double_to_gnc_numeric (result->rate, 100000, GNC_HOW_RND_ROUND_HALF_UP);
/* EC Regulation 1103/97 states we should use "Round half away from zero"
* See http://europa.eu/legislation_summaries/economic_and_monetary_affairs/institutional_and_economic_framework/l25025_en.htm */
return gnc_numeric_mul (value, rate, gnc_commodity_get_fraction (currency),
GNC_HOW_RND_ROUND_HALF_UP);
}
}
/* Create/Destroy Functions */
GncEmployee *gncEmployeeCreate (QofBook *book)
{
GncEmployee *employee;
if (!book) return NULL;
employee = g_object_new (GNC_TYPE_EMPLOYEE, NULL);
qof_instance_init_data (&employee->inst, _GNC_MOD_NAME, book);
employee->id = CACHE_INSERT ("");
employee->username = CACHE_INSERT ("");
employee->language = CACHE_INSERT ("");
employee->acl = CACHE_INSERT ("");
employee->addr = gncAddressCreate (book, &employee->inst);
employee->workday = gnc_numeric_zero();
employee->rate = gnc_numeric_zero();
employee->active = TRUE;
if (gs_address_event_handler_id == 0)
{
gs_address_event_handler_id = qof_event_register_handler(listen_for_address_events, NULL);
}
qof_event_gen (&employee->inst, QOF_EVENT_CREATE, NULL);
return employee;
}
/**
* 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;
}
/* Create/Destroy Functions */
GncCustomer *gncCustomerCreate (QofBook *book)
{
GncCustomer *cust;
if (!book) return NULL;
cust = g_object_new (GNC_TYPE_CUSTOMER, NULL);
qof_instance_init_data (&cust->inst, _GNC_MOD_NAME, book);
cust->id = CACHE_INSERT ("");
cust->name = CACHE_INSERT ("");
cust->notes = CACHE_INSERT ("");
cust->addr = gncAddressCreate (book, &cust->inst);
cust->taxincluded = GNC_TAXINCLUDED_USEGLOBAL;
cust->active = TRUE;
cust->jobs = NULL;
cust->discount = gnc_numeric_zero();
cust->credit = gnc_numeric_zero();
cust->shipaddr = gncAddressCreate (book, &cust->inst);
if (gs_address_event_handler_id == 0)
{
gs_address_event_handler_id = qof_event_register_handler(listen_for_address_events, NULL);
}
qof_event_gen (&cust->inst, QOF_EVENT_CREATE, NULL);
return cust;
}
static gnc_numeric gncEntryGetIntDiscountValue (GncEntry *entry, gboolean round, gboolean is_cust_doc)
{
if (!entry) return gnc_numeric_zero();
gncEntryRecomputeValues (entry);
if (round)
return (is_cust_doc ? entry->i_disc_value_rounded : gnc_numeric_zero());
else
return (is_cust_doc ? entry->i_disc_value : gnc_numeric_zero());
}
static void
gnc_template_register_save_debcred_cell (BasicCell * cell,
gpointer save_data,
gpointer user_data)
{
SRSaveData *sd = save_data;
SplitRegister *reg = user_data;
const char *credit_formula, *debit_formula;
char *error_loc;
gnc_numeric credit_amount, debit_amount;
gboolean parse_result;
g_return_if_fail (gnc_basic_cell_has_name (cell, FDEBT_CELL) ||
gnc_basic_cell_has_name (cell, FCRED_CELL));
if (sd->handled_dc)
return;
/* amountStr = gnc_numeric_to_string (new_amount); */
credit_formula = gnc_table_layout_get_cell_value (reg->table->layout,
FCRED_CELL);
/* If the value can be parsed into a numeric result (without any
* further variable definitions), store that numeric value
* additionally in the kvp. Otherwise store a zero numeric
* there.*/
parse_result = gnc_exp_parser_parse_separate_vars(credit_formula,
&credit_amount,
&error_loc, NULL);
if (!parse_result)
credit_amount = gnc_numeric_zero();
debit_formula = gnc_table_layout_get_cell_value (reg->table->layout,
FDEBT_CELL);
/* If the value can be parsed into a numeric result, store that
* numeric value additionally. See above comment.*/
parse_result = gnc_exp_parser_parse_separate_vars(debit_formula,
&debit_amount,
&error_loc, NULL);
if (!parse_result)
debit_amount = gnc_numeric_zero();
qof_instance_set (QOF_INSTANCE (sd->split),
"sx-credit-formula", credit_formula,
"sx-credit-numeric", &credit_amount,
"sx-debit-formula", debit_formula,
"sx-debit-numeric", &debit_amount,
NULL);
/* set the amount to an innocuous value */
/* Note that this marks the split dirty */
xaccSplitSetValue (sd->split, gnc_numeric_create (0, 1));
sd->handled_dc = TRUE;
}
/*
* Given an owner, extract the open balance from the owner and then
* convert it to the desired currency.
*/
gnc_numeric
gncOwnerGetBalanceInCurrency (const GncOwner *owner,
const gnc_commodity *report_currency)
{
gnc_numeric balance = gnc_numeric_zero ();
GList *acct_list, *acct_node, *acct_types, *lot_list = NULL, *lot_node;
QofBook *book;
gnc_commodity *owner_currency;
GNCPriceDB *pdb;
g_return_val_if_fail (owner, gnc_numeric_zero ());
/* Get account list */
book = qof_instance_get_book (qofOwnerGetOwner (owner));
acct_list = gnc_account_get_descendants (gnc_book_get_root_account (book));
acct_types = gncOwnerGetAccountTypesList (owner);
owner_currency = gncOwnerGetCurrency (owner);
/* For each account */
for (acct_node = acct_list; acct_node; acct_node = acct_node->next)
{
Account *account = acct_node->data;
/* Check if this account can have lots for the owner, otherwise skip to next */
if (g_list_index (acct_types, (gpointer)xaccAccountGetType (account))
== -1)
continue;
if (!gnc_commodity_equal (owner_currency, xaccAccountGetCommodity (account)))
continue;
/* Get a list of open lots for this owner and account */
lot_list = xaccAccountFindOpenLots (account, gncOwnerLotMatchOwnerFunc,
(gpointer)owner, NULL);
/* For each lot */
for (lot_node = lot_list; lot_node; lot_node = lot_node->next)
{
GNCLot *lot = lot_node->data;
gnc_numeric lot_balance = gnc_lot_get_balance (lot);
GncInvoice *invoice = gncInvoiceGetInvoiceFromLot(lot);
if (invoice)
balance = gnc_numeric_add (balance, lot_balance,
gnc_commodity_get_fraction (owner_currency), GNC_HOW_RND_ROUND_HALF_UP);
}
}
pdb = gnc_pricedb_get_db (book);
if (report_currency)
balance = gnc_pricedb_convert_balance_latest_price (
pdb, balance, owner_currency, report_currency);
return balance;
}
gnc_numeric
kvp_value_get_numeric(const KvpValue * value)
{
if (!value) return gnc_numeric_zero ();
if (value->type == KVP_TYPE_NUMERIC)
{
return value->value.numeric;
}
else
{
return gnc_numeric_zero ();
}
}
static gnc_numeric
get_final_balance (GHashTable *hash, Account *account)
{
gnc_numeric *balance;
if (!hash || !account)
return gnc_numeric_zero ();
balance = g_hash_table_lookup(hash, account);
if (balance)
return *balance;
return gnc_numeric_zero ();
}
/********************************************************************\
* gnc_split_scm_get_value *
* return the value of a scheme split *
* *
* Args: split_scm - the scheme split *
* Returns: value of scheme split *
\********************************************************************/
gnc_numeric
gnc_split_scm_get_value(SCM split_scm)
{
SCM result;
initialize_scm_functions();
if (!gnc_is_split_scm(split_scm))
return gnc_numeric_zero ();
result = scm_call_1(getters.split_scm_value, split_scm);
if (!gnc_numeric_p(result))
return gnc_numeric_zero ();
return gnc_scm_to_numeric(result);
}
static gnc_numeric
get_numeric_val( gpointer pObject )
{
slot_info_t* pInfo = (slot_info_t*)pObject;
g_return_val_if_fail( pObject != NULL, gnc_numeric_zero() );
if ( kvp_value_get_type( pInfo->pKvpValue ) == KVP_TYPE_NUMERIC )
{
return kvp_value_get_numeric( pInfo->pKvpValue );
}
else
{
return gnc_numeric_zero();
}
}
GncTaxTableEntry * gncTaxTableEntryCreate (void)
{
GncTaxTableEntry *entry;
entry = g_new0 (GncTaxTableEntry, 1);
entry->amount = gnc_numeric_zero ();
return entry;
}
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);
}
// Amount with Symbol or not
static gchar*
add_amount (gchar *so_far, Split *split, gboolean t_void, gboolean symbol, gint line_type, CsvExportInfo *info)
{
const gchar *amt;
gchar *conv;
gchar *result;
if (line_type == TRANS_COMPLEX)
result = g_strconcat (so_far, "", info->mid_sep, NULL);
else
{
if (symbol)
{
if (t_void)
amt = xaccPrintAmount (gnc_numeric_zero(), gnc_split_amount_print_info (split, TRUE));
else
amt = xaccPrintAmount (xaccSplitGetAmount (split), gnc_split_amount_print_info (split, TRUE));
}
else
{
if (t_void)
amt = xaccPrintAmount (xaccSplitVoidFormerAmount (split), gnc_split_amount_print_info (split, FALSE));
else
amt = xaccPrintAmount (xaccSplitGetAmount (split), gnc_split_amount_print_info (split, FALSE));
}
conv = csv_txn_test_field_string (info, amt);
result = g_strconcat (so_far, conv, info->mid_sep, NULL);
g_free (conv);
}
g_free (so_far);
return result;
}
/** This function tells the owner tree view whether or not to filter
* out a particular owner. Owners may be filtered if the user
* has decided not to display inactive owners, or if the
* user has requested that owners with a zero total not be shown.
*
* @param owner The owner that is being evaluated.
*
* @param user_data A pointer to the OwnerFilterDialog struct.
*
* @return TRUE if the owner should be visible. FALSE if the
* owner should be hidden. */
gboolean
gnc_plugin_page_owner_tree_filter_owners (GncOwner *owner,
gpointer user_data)
{
OwnerFilterDialog *fd = user_data;
gnc_numeric total;
ENTER("owner %p:%s", owner, gncOwnerGetName(owner));
if (!fd->show_inactive && !gncOwnerGetActive (owner))
{
LEAVE(" hide: inactive");
return FALSE;
}
if (!fd->show_zero_total)
{
/* FIXME I'm not aware of any functions to get an owner's "balance" yet.
* This should be implemented before this function does anything useful.
* The code below is copied from the tree-view-account source to serve
* as an example.
total = gncOwnerGetBalanceInCurrency (owner, NULL, TRUE);
*/
total = gnc_numeric_zero();
if (gnc_numeric_zero_p(total))
{
LEAVE(" hide: zero balance");
return FALSE;
}
}
return TRUE;
}
static gnc_numeric
get_numeric_val( gpointer pObject )
{
slot_info_t* pInfo = (slot_info_t*)pObject;
g_return_val_if_fail( pObject != NULL, gnc_numeric_zero() );
if (pInfo->pKvpValue->get_type() == KvpValue::Type::NUMERIC)
{
return pInfo->pKvpValue->get<gnc_numeric>();
}
else
{
return gnc_numeric_zero();
}
}
int
gnc_sx_parse_vars_from_formula(const char *formula,
GHashTable *var_hash,
gnc_numeric *result)
{
gnc_numeric num;
char *errLoc = NULL;
int toRet = 0;
GHashTable *parser_vars;
// convert var_hash -> variables for the parser.
parser_vars = gnc_sx_instance_get_variables_for_parser(var_hash);
num = gnc_numeric_zero();
if (!gnc_exp_parser_parse_separate_vars(formula, &num, &errLoc, parser_vars))
{
toRet = -1;
}
// convert back.
g_hash_table_foreach(parser_vars, (GHFunc)_var_numeric_to_sx_var, var_hash);
g_hash_table_destroy(parser_vars);
if (result != NULL)
{
*result = num;
}
return toRet;
}
/* Create/Destroy Functions */
GncEntry *gncEntryCreate (QofBook *book)
{
GncEntry *entry;
gnc_numeric zero = gnc_numeric_zero ();
if (!book) return NULL;
entry = g_object_new (GNC_TYPE_ENTRY, NULL);
qof_instance_init_data (&entry->inst, _GNC_MOD_NAME, book);
entry->desc = CACHE_INSERT ("");
entry->action = CACHE_INSERT ("");
entry->notes = CACHE_INSERT ("");
entry->quantity = zero;
entry->i_price = zero;
entry->i_taxable = TRUE;
entry->i_discount = zero;
entry->i_disc_type = GNC_AMT_TYPE_PERCENT;
entry->i_disc_how = GNC_DISC_PRETAX;
entry->b_price = zero;
entry->b_taxable = TRUE;
entry->billto.type = GNC_OWNER_CUSTOMER;
entry->b_payment = GNC_PAYMENT_CASH;
entry->values_dirty = TRUE;
qof_event_gen (&entry->inst, QOF_EVENT_CREATE, NULL);
return entry;
}
void
xaccQueryAddBalanceMatch(QofQuery *q, QofQueryCompare bal, QofQueryOp op)
{
xaccQueryAddNumericMatch(
(q), gnc_numeric_zero(), QOF_NUMERIC_MATCH_ANY,
((bal) ? QOF_COMPARE_EQUAL : QOF_COMPARE_NEQ), (op),
SPLIT_TRANS, TRANS_IMBALANCE, 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));
}
}
gnc_numeric
gnc_numeric_convert(gnc_numeric in, int64_t denom, int how)
{
GncNumeric a (in), b (gnc_numeric_zero());
GncDenom d (a, b, denom, how);
a.round (d);
return static_cast<gnc_numeric>(a);
}
static QofSession*
create_session(void)
{
QofSession* session = qof_session_new();
QofBook* book = qof_session_get_book( session );
Account* root = gnc_book_get_root_account( book );
Account* acct1;
Account* acct2;
KvpFrame* frame;
Transaction* tx;
Split* spl1;
Split* spl2;
Timespec ts;
struct timeval tv;
gnc_commodity_table* table;
gnc_commodity* currency;
table = gnc_commodity_table_get_table( book );
currency = gnc_commodity_table_lookup( table, GNC_COMMODITY_NS_CURRENCY, "CAD" );
acct1 = xaccMallocAccount( book );
xaccAccountSetType( acct1, ACCT_TYPE_BANK );
xaccAccountSetName( acct1, "Bank 1" );
xaccAccountSetCommodity( acct1, currency );
frame = qof_instance_get_slots( QOF_INSTANCE(acct1) );
kvp_frame_set_gint64( frame, "int64-val", 100 );
kvp_frame_set_double( frame, "double-val", 3.14159 );
kvp_frame_set_numeric( frame, "numeric-val", gnc_numeric_zero() );
time( &(tv.tv_sec) );
tv.tv_usec = 0;
ts.tv_sec = tv.tv_sec;
ts.tv_nsec = 1000 * tv.tv_usec;
kvp_frame_set_timespec( frame, "timespec-val", ts );
kvp_frame_set_string( frame, "string-val", "abcdefghijklmnop" );
kvp_frame_set_guid( frame, "guid-val", qof_instance_get_guid( QOF_INSTANCE(acct1) ) );
gnc_account_append_child( root, acct1 );
acct2 = xaccMallocAccount( book );
xaccAccountSetType( acct2, ACCT_TYPE_BANK );
xaccAccountSetName( acct2, "Bank 1" );
tx = xaccMallocTransaction( book );
xaccTransBeginEdit( tx );
xaccTransSetCurrency( tx, currency );
spl1 = xaccMallocSplit( book );
xaccTransAppendSplit( tx, spl1 );
spl2 = xaccMallocSplit( book );
xaccTransAppendSplit( tx, spl2 );
xaccTransCommitEdit( tx );
return session;
}
static gnc_numeric gncEntryGetIntTaxValue (GncEntry *entry, gboolean round, gboolean is_cust_doc)
{
if (!entry) return gnc_numeric_zero();
gncEntryRecomputeValues (entry);
if (round)
return (is_cust_doc ? entry->i_tax_value_rounded : entry->b_tax_value_rounded);
else
return (is_cust_doc ? entry->i_tax_value : entry->b_tax_value);
}
static gnc_numeric
gnc_payment_dialog_calculate_selected_total (PaymentWindow *pw)
{
GtkTreeSelection *selection;
gnc_numeric val = gnc_numeric_zero();
if (!pw->docs_list_tree_view || !GTK_IS_TREE_VIEW(pw->docs_list_tree_view))
return gnc_numeric_zero();
/* Figure out if anything is set in the current list */
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(pw->docs_list_tree_view));
gtk_tree_selection_selected_foreach (selection,
calculate_selected_total_helper,
(gpointer) &val);
return val;
}
gnc_numeric
gnc_price_cell_get_value (PriceCell *cell)
{
if (cell == NULL)
return gnc_numeric_zero ();
gnc_price_cell_parse (cell, FALSE);
return cell->amount;
}
static gnc_numeric
get_amount (gpointer pObj)
{
budget_amount_info_t* info = (budget_amount_info_t*)pObj;
g_return_val_if_fail (pObj != NULL, gnc_numeric_zero ());
return gnc_budget_get_account_period_value (info->budget, info->account,
info->period_num);
}
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;
}
gnc_numeric
gnc_tree_util_split_reg_get_value_for (GncTreeViewSplitReg *view, Transaction *trans, Split *split, gboolean is_blank)
{
gnc_numeric ret_num;
GNCPrintAmountInfo ret_print_info;
if (gnc_tree_util_split_reg_get_debcred_entry (view, trans, split, is_blank, &ret_num, &ret_print_info))
return ret_num;
else
return gnc_numeric_zero();
}
void
gnc_price_cell_blank (PriceCell *cell)
{
if (cell == NULL)
return;
cell->amount = gnc_numeric_zero ();
cell->need_to_parse = FALSE;
gnc_basic_cell_set_value_internal (&cell->cell, "");
}
gnc_numeric
recurrenceGetAccountPeriodValue(const Recurrence *r, Account *acc, guint n)
{
time64 t1, t2;
// FIXME: maybe zero is not best error return val.
g_return_val_if_fail(r && acc, gnc_numeric_zero());
t1 = recurrenceGetPeriodTime(r, n, FALSE);
t2 = recurrenceGetPeriodTime(r, n, TRUE);
return xaccAccountGetBalanceChangeForPeriod (acc, t1, t2, TRUE);
}
