/* Return the string entry for transfer column when template */
const char *
gnc_tree_util_split_reg_template_get_transfer_entry (Split *split)
{
static char *name = NULL;
kvp_frame *kvpf;
if (!split)
return NULL;
kvpf = xaccSplitGetSlots (split);
g_free (name);
if (kvpf)
{
Account *account;
GncGUID *guid;
guid = kvp_value_get_guid(
kvp_frame_get_slot_path (kvpf, "sched-xaction", "account", NULL));
account = xaccAccountLookup (guid, gnc_get_current_book ());
name = account ? gnc_get_account_name_for_register (account) : NULL;
}
else
name = NULL;
return name;
}
static void
gnc_template_register_save_shares_cell (BasicCell * cell,
gpointer save_data,
gpointer user_data)
{
SRSaveData *sd = save_data;
kvp_frame *kvpf;
char *sharesStr = "(x + y)/42";
g_return_if_fail (gnc_basic_cell_has_name (cell, SHRS_CELL));
kvpf = xaccSplitGetSlots (sd->split);
/* FIXME: shares cells are numeric by definition. */
DEBUG ("kvp_frame before: %s\n", kvp_frame_to_string (kvpf));
/* sharesStr = gnc_numeric_to_string( sharesStr ); */
kvp_frame_set_slot_path (kvpf,
kvp_value_new_string (sharesStr),
GNC_SX_ID,
GNC_SX_SHARES,
NULL);
DEBUG ("kvp_frame after: %s\n", kvp_frame_to_string (kvpf));
/* set the shares to an innocuous value */
/* Note that this marks the split dirty */
xaccSplitSetSharePriceAndAmount (sd->split,
gnc_numeric_create (0, 1),
gnc_numeric_create (0, 1));
}
static void
gnc_template_register_save_xfrm_cell (BasicCell * cell,
gpointer save_data,
gpointer user_data)
{
SRSaveData *sd = save_data;
SplitRegister *reg = user_data;
SRInfo *info = gnc_split_register_get_info (reg);
Account *template_acc;
const GncGUID *acctGUID;
kvp_frame *kvpf;
Account *acct;
g_return_if_fail (gnc_basic_cell_has_name (cell, XFRM_CELL));
/* save the account GncGUID into the kvp_data. */
acct = gnc_split_register_get_account (reg, XFRM_CELL);
if (!acct)
{
PERR ("unknown account");
return;
}
acctGUID = xaccAccountGetGUID (acct);
kvpf = xaccSplitGetSlots (sd->split);
kvp_frame_set_slot_path (kvpf, kvp_value_new_guid(acctGUID),
GNC_SX_ID, GNC_SX_ACCOUNT, NULL);
template_acc = xaccAccountLookup (&info->template_account,
gnc_get_current_book ());
/* set the actual account to the fake account for these templates */
xaccAccountInsertSplit (template_acc, sd->split);
qof_instance_set_dirty (QOF_INSTANCE (sd->split));
}
const char *
gnc_tree_util_split_reg_template_get_fcred_entry (Split *split)
{
kvp_frame *kvpf = xaccSplitGetSlots (split);
return kvp_value_get_string(
kvp_frame_get_slot_path (kvpf, "sched-xaction", "credit-formula", NULL));
}
/* Used several places in a transaction edit where many other
* parameters are also being set, so individual commits wouldn't be
* appropriate. */
void gnc_import_set_split_online_id(Split * split,
const gchar * string_value)
{
kvp_frame * frame;
xaccTransBeginEdit (xaccSplitGetParent (split));
frame = xaccSplitGetSlots(split);
kvp_frame_set_str (frame, "online_id", string_value);
qof_instance_set_dirty (QOF_INSTANCE (split));
}
static gboolean
spl_slots_handler(xmlNodePtr node, gpointer data)
{
struct split_pdata *pdata = data;
gboolean successful;
successful = dom_tree_to_kvp_frame_given(node,
xaccSplitGetSlots (pdata->split));
g_return_val_if_fail(successful, FALSE);
return TRUE;
}
static gboolean
_get_template_split_account(GncSxInstance *instance, Split *template_split, Account **split_acct, GList **creation_errors)
{
GncGUID *acct_guid;
kvp_frame *split_kvpf;
kvp_value *kvp_val;
split_kvpf = xaccSplitGetSlots(template_split);
/* contains the guid of the split's actual account. */
kvp_val = kvp_frame_get_slot_path(split_kvpf,
GNC_SX_ID,
GNC_SX_ACCOUNT,
NULL);
if (kvp_val == NULL)
{
GString *err = g_string_new("");
g_string_printf(err, "Null account kvp value for SX [%s], cancelling creation.",
xaccSchedXactionGetName(instance->parent->sx));
g_critical("%s", err->str);
if (creation_errors != NULL)
*creation_errors = g_list_append(*creation_errors, err);
else
g_string_free(err, TRUE);
return FALSE;
}
acct_guid = kvp_value_get_guid( kvp_val );
*split_acct = xaccAccountLookup(acct_guid, gnc_get_current_book());
if (*split_acct == NULL)
{
char guid_str[GUID_ENCODING_LENGTH+1];
GString *err;
guid_to_string_buff((const GncGUID*)acct_guid, guid_str);
err = g_string_new("");
g_string_printf(err, "Unknown account for guid [%s], cancelling SX [%s] creation.",
guid_str, xaccSchedXactionGetName(instance->parent->sx));
g_critical("%s", err->str);
if (creation_errors != NULL)
*creation_errors = g_list_append(*creation_errors, err);
else
g_string_free(err, TRUE);
return FALSE;
}
return TRUE;
}
static void
_get_sx_formula_value(GncSxInstance *instance, Split *template_split, gnc_numeric *numeric, GList **creation_errors, const char *formula_key)
{
kvp_frame *split_kvpf;
kvp_value *kvp_val;
char *formula_str, *parseErrorLoc;
split_kvpf = xaccSplitGetSlots(template_split);
kvp_val = kvp_frame_get_slot_path(split_kvpf,
GNC_SX_ID,
formula_key,
NULL);
formula_str = kvp_value_get_string(kvp_val);
if (formula_str != NULL && strlen(formula_str) != 0)
{
GHashTable *parser_vars = gnc_sx_instance_get_variables_for_parser(instance->variable_bindings);
if (!gnc_exp_parser_parse_separate_vars(formula_str,
numeric,
&parseErrorLoc,
parser_vars))
{
GString *err = g_string_new("");
g_string_printf(err, "Error parsing SX [%s] key [%s]=formula [%s] at [%s]: %s",
xaccSchedXactionGetName(instance->parent->sx),
formula_key,
formula_str,
parseErrorLoc,
gnc_exp_parser_error_string());
g_critical("%s", err->str);
if (creation_errors != NULL)
*creation_errors = g_list_append(*creation_errors, err);
else
g_string_free(err, TRUE);
}
if (parser_vars != NULL)
{
g_hash_table_destroy(parser_vars);
}
}
}
GList*
gnc_sx_get_sxes_referencing_account(QofBook *book, Account *acct)
{
GList *rtn = NULL;
const GncGUID *acct_guid = qof_entity_get_guid(QOF_INSTANCE(acct));
GList *sx_list = gnc_book_get_schedxactions(book)->sx_list;
for (; sx_list != NULL; sx_list = sx_list->next)
{
SchedXaction *sx = (SchedXaction*)sx_list->data;
GList *splits = xaccSchedXactionGetSplits(sx);
for (; splits != NULL; splits = splits->next)
{
Split *s = (Split*)splits->data;
KvpFrame *frame = kvp_frame_get_frame(xaccSplitGetSlots(s), GNC_SX_ID);
GncGUID *sx_split_acct_guid = kvp_frame_get_guid(frame, GNC_SX_ACCOUNT);
if (guid_equal(acct_guid, sx_split_acct_guid))
{
rtn = g_list_append(rtn, sx);
}
}
}
return rtn;
}
static void
gnc_template_register_save_debcred_cell (BasicCell * cell,
gpointer save_data,
gpointer user_data)
{
SRSaveData *sd = save_data;
SplitRegister *reg = user_data;
kvp_frame *kvpf;
const char *value;
char *error_loc;
gnc_numeric new_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;
kvpf = xaccSplitGetSlots (sd->split);
DEBUG ("kvp_frame before: %s\n", kvp_frame_to_string (kvpf));
/* amountStr = gnc_numeric_to_string (new_amount); */
value = gnc_table_layout_get_cell_value (reg->table->layout, FCRED_CELL);
kvp_frame_set_slot_path (kvpf, kvp_value_new_string (value),
GNC_SX_ID,
GNC_SX_CREDIT_FORMULA,
NULL);
/* 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(value, &new_amount, &error_loc, NULL);
if (!parse_result)
{
new_amount = gnc_numeric_zero();
}
kvp_frame_set_slot_path (kvpf, kvp_value_new_numeric (new_amount),
GNC_SX_ID,
GNC_SX_CREDIT_NUMERIC,
NULL);
value = gnc_table_layout_get_cell_value (reg->table->layout, FDEBT_CELL);
kvp_frame_set_slot_path (kvpf,
kvp_value_new_string (value),
GNC_SX_ID,
GNC_SX_DEBIT_FORMULA,
NULL);
/* 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(value, &new_amount, &error_loc, NULL);
if (!parse_result)
{
new_amount = gnc_numeric_zero();
}
kvp_frame_set_slot_path (kvpf, kvp_value_new_numeric (new_amount),
GNC_SX_ID,
GNC_SX_DEBIT_NUMERIC,
NULL);
DEBUG ("kvp_frame after: %s\n", kvp_frame_to_string (kvpf));
/* 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;
}
static gint
_get_vars_helper(Transaction *txn, void *var_hash_data)
{
GHashTable *var_hash = (GHashTable*)var_hash_data;
GList *split_list;
kvp_frame *kvpf;
kvp_value *kvp_val;
Split *s;
char *str;
gnc_commodity *first_cmdty = NULL;
split_list = xaccTransGetSplitList(txn);
if (split_list == NULL)
{
return 1;
}
for ( ; split_list; split_list = split_list->next)
{
gnc_commodity *split_cmdty = NULL;
GncGUID *acct_guid;
Account *acct;
s = (Split*)split_list->data;
kvpf = xaccSplitGetSlots(s);
kvp_val = kvp_frame_get_slot_path(kvpf,
GNC_SX_ID,
GNC_SX_ACCOUNT,
NULL);
acct_guid = kvp_value_get_guid(kvp_val);
acct = xaccAccountLookup(acct_guid, gnc_get_current_book());
split_cmdty = xaccAccountGetCommodity(acct);
if (first_cmdty == NULL)
{
first_cmdty = split_cmdty;
}
if (! gnc_commodity_equal(split_cmdty, first_cmdty))
{
GncSxVariable *var;
GString *var_name;
const gchar *split_mnemonic, *first_mnemonic;
var_name = g_string_sized_new(16);
split_mnemonic = gnc_commodity_get_mnemonic(split_cmdty);
first_mnemonic = gnc_commodity_get_mnemonic(first_cmdty);
g_string_printf(var_name, "%s -> %s",
split_mnemonic ? split_mnemonic : "(null)",
first_mnemonic ? first_mnemonic : "(null)");
var = gnc_sx_variable_new(g_strdup(var_name->str));
g_hash_table_insert(var_hash, g_strdup(var->name), var);
g_string_free(var_name, TRUE);
}
// existing... ------------------------------------------
kvp_val = kvp_frame_get_slot_path(kvpf,
GNC_SX_ID,
GNC_SX_CREDIT_FORMULA,
NULL);
if (kvp_val != NULL)
{
str = kvp_value_get_string(kvp_val);
if (str && strlen(str) != 0)
{
gnc_sx_parse_vars_from_formula(str, var_hash, NULL);
}
}
kvp_val = kvp_frame_get_slot_path(kvpf,
GNC_SX_ID,
GNC_SX_DEBIT_FORMULA,
NULL);
if (kvp_val != NULL)
{
str = kvp_value_get_string(kvp_val);
if (str && strlen(str) != 0)
{
gnc_sx_parse_vars_from_formula(str, var_hash, NULL);
}
}
}
return 0;
}
static xmlNodePtr
split_to_dom_tree(const gchar *tag, Split *spl)
{
xmlNodePtr ret;
ret = xmlNewNode(NULL, BAD_CAST tag);
xmlAddChild(ret, guid_to_dom_tree("split:id", xaccSplitGetGUID(spl)));
{
char *memo = g_strdup (xaccSplitGetMemo(spl));
if (memo && g_strcmp0(memo, "") != 0)
{
xmlNewTextChild(ret, NULL, BAD_CAST "split:memo",
checked_char_cast (memo));
}
g_free (memo);
}
{
char *action = g_strdup (xaccSplitGetAction(spl));
if (action && g_strcmp0(action, "") != 0)
{
xmlNewTextChild(ret, NULL, BAD_CAST "split:action",
checked_char_cast (action));
}
g_free (action);
}
{
char tmp[2];
tmp[0] = xaccSplitGetReconcile(spl);
tmp[1] = '\0';
xmlNewTextChild(ret, NULL, BAD_CAST "split:reconciled-state",
BAD_CAST tmp);
}
add_timespec(ret, "split:reconcile-date",
xaccSplitRetDateReconciledTS(spl), FALSE);
add_gnc_num(ret, "split:value", xaccSplitGetValue(spl));
add_gnc_num(ret, "split:quantity", xaccSplitGetAmount(spl));
{
Account * account = xaccSplitGetAccount (spl);
xmlAddChild (ret, guid_to_dom_tree("split:account",
xaccAccountGetGUID (account)));
}
{
GNCLot * lot = xaccSplitGetLot (spl);
if (lot)
{
xmlAddChild (ret, guid_to_dom_tree("split:lot",
gnc_lot_get_guid(lot)));
}
}
{
xmlNodePtr kvpnode = kvp_frame_to_dom_tree("split:slots",
xaccSplitGetSlots(spl));
if (kvpnode)
{
xmlAddChild(ret, kvpnode);
}
}
return ret;
}
const gchar * gnc_import_get_split_online_id(Split * split)
{
kvp_frame * frame;
frame = xaccSplitGetSlots(split);
return kvp_frame_get_string(frame, "online_id");
}
