35 #include <glib/gi18n.h>
37 #include <qofinstance-p.h>
39 #include "gncCustomerP.h"
40 #include "gncEmployeeP.h"
43 #include "gncOwnerP.h"
44 #include "gncVendorP.h"
50 #include "engine-helpers.h"
52 #define _GNC_MOD_NAME GNC_ID_OWNER
54 #define GNC_OWNER_ID "gncOwner"
63 o->type = GNC_OWNER_NONE;
79 case GNC_OWNER_UNDEFINED :
81 case GNC_OWNER_CUSTOMER :
83 gncCustomerBeginEdit(owner->owner.customer);
88 gncJobBeginEdit(owner->owner.job);
91 case GNC_OWNER_VENDOR :
93 gncVendorBeginEdit(owner->owner.vendor);
96 case GNC_OWNER_EMPLOYEE :
98 gncEmployeeBeginEdit(owner->owner.employee);
104 void gncOwnerCommitEdit (
GncOwner *owner)
109 case GNC_OWNER_NONE :
110 case GNC_OWNER_UNDEFINED :
112 case GNC_OWNER_CUSTOMER :
114 gncCustomerCommitEdit(owner->owner.customer);
119 gncJobCommitEdit(owner->owner.job);
122 case GNC_OWNER_VENDOR :
124 gncVendorCommitEdit(owner->owner.vendor);
127 case GNC_OWNER_EMPLOYEE :
129 gncEmployeeCommitEdit(owner->owner.employee);
135 void gncOwnerDestroy (
GncOwner *owner)
140 case GNC_OWNER_NONE :
141 case GNC_OWNER_UNDEFINED :
143 case GNC_OWNER_CUSTOMER :
145 gncCustomerDestroy(owner->owner.customer);
150 gncJobDestroy(owner->owner.job);
153 case GNC_OWNER_VENDOR :
155 gncVendorDestroy(owner->owner.vendor);
158 case GNC_OWNER_EMPLOYEE :
160 gncEmployeeDestroy(owner->owner.employee);
166 void gncOwnerInitUndefined (
GncOwner *owner, gpointer obj)
169 owner->type = GNC_OWNER_UNDEFINED;
170 owner->owner.undefined = obj;
176 owner->type = GNC_OWNER_CUSTOMER;
177 owner->owner.customer = customer;
183 owner->type = GNC_OWNER_JOB;
184 owner->owner.job = job;
190 owner->type = GNC_OWNER_VENDOR;
191 owner->owner.vendor = vendor;
197 owner->type = GNC_OWNER_EMPLOYEE;
198 owner->owner.employee = employee;
203 if (!owner)
return GNC_OWNER_NONE;
218 case GNC_OWNER_NONE :
223 case GNC_OWNER_UNDEFINED :
228 case GNC_OWNER_CUSTOMER :
230 type = GNC_ID_CUSTOMER;
238 case GNC_OWNER_VENDOR :
240 type = GNC_ID_VENDOR;
243 case GNC_OWNER_EMPLOYEE :
245 type = GNC_ID_EMPLOYEE;
264 case GNC_OWNER_NONE :
268 case GNC_OWNER_UNDEFINED :
272 case GNC_OWNER_CUSTOMER :
274 ent = QOF_INSTANCE(owner->owner.customer);
279 ent = QOF_INSTANCE(owner->owner.job);
282 case GNC_OWNER_VENDOR :
284 ent = QOF_INSTANCE(owner->owner.vendor);
287 case GNC_OWNER_EMPLOYEE :
289 ent = QOF_INSTANCE(owner->owner.employee);
303 if (0 == g_strcmp0(ent->
e_type, GNC_ID_CUSTOMER))
305 owner->type = GNC_OWNER_CUSTOMER;
308 else if (0 == g_strcmp0(ent->
e_type, GNC_ID_JOB))
310 owner->type = GNC_OWNER_JOB;
311 gncOwnerInitJob(owner, (
GncJob*)ent);
313 else if (0 == g_strcmp0(ent->
e_type, GNC_ID_VENDOR))
315 owner->type = GNC_OWNER_VENDOR;
316 gncOwnerInitVendor(owner, (
GncVendor*)ent);
318 else if (0 == g_strcmp0(ent->
e_type, GNC_ID_EMPLOYEE))
320 owner->type = GNC_OWNER_EMPLOYEE;
325 owner->type = GNC_OWNER_NONE;
326 owner->owner.undefined = NULL;
335 return (GNC_IS_VENDOR(ent) ||
336 GNC_IS_CUSTOMER(ent) ||
337 GNC_IS_EMPLOYEE(ent) ||
342 if (!owner)
return NULL;
343 if (owner->type != GNC_OWNER_UNDEFINED)
return NULL;
344 return owner->owner.undefined;
349 if (!owner)
return NULL;
350 if (owner->type != GNC_OWNER_CUSTOMER)
return NULL;
351 return owner->owner.customer;
356 if (!owner)
return NULL;
357 if (owner->type != GNC_OWNER_JOB)
return NULL;
358 return owner->owner.job;
363 if (!owner)
return NULL;
364 if (owner->type != GNC_OWNER_VENDOR)
return NULL;
365 return owner->owner.vendor;
370 if (!owner)
return NULL;
371 if (owner->type != GNC_OWNER_EMPLOYEE)
return NULL;
372 return owner->owner.employee;
377 if (!src || !dest)
return;
378 if (src == dest)
return;
379 memcpy (dest, src,
sizeof (*dest));
384 if (!a || !b)
return FALSE;
386 return (a->owner.undefined == b->owner.undefined);
397 const char * gncOwnerGetID (
const GncOwner *owner)
399 if (!owner)
return NULL;
403 case GNC_OWNER_UNDEFINED:
406 case GNC_OWNER_CUSTOMER:
407 return gncCustomerGetID (owner->owner.customer);
409 return gncJobGetID (owner->owner.job);
410 case GNC_OWNER_VENDOR:
411 return gncVendorGetID (owner->owner.vendor);
412 case GNC_OWNER_EMPLOYEE:
413 return gncEmployeeGetID (owner->owner.employee);
417 const char * gncOwnerGetName (
const GncOwner *owner)
419 if (!owner)
return NULL;
423 case GNC_OWNER_UNDEFINED:
426 case GNC_OWNER_CUSTOMER:
427 return gncCustomerGetName (owner->owner.customer);
429 return gncJobGetName (owner->owner.job);
430 case GNC_OWNER_VENDOR:
431 return gncVendorGetName (owner->owner.vendor);
432 case GNC_OWNER_EMPLOYEE:
433 return gncEmployeeGetName (owner->owner.employee);
439 if (!owner)
return NULL;
443 case GNC_OWNER_UNDEFINED:
447 case GNC_OWNER_CUSTOMER:
448 return gncCustomerGetAddr (owner->owner.customer);
449 case GNC_OWNER_VENDOR:
450 return gncVendorGetAddr (owner->owner.vendor);
451 case GNC_OWNER_EMPLOYEE:
452 return gncEmployeeGetAddr (owner->owner.employee);
458 if (!owner)
return NULL;
462 case GNC_OWNER_UNDEFINED:
465 case GNC_OWNER_CUSTOMER:
466 return gncCustomerGetCurrency (owner->owner.customer);
467 case GNC_OWNER_VENDOR:
468 return gncVendorGetCurrency (owner->owner.vendor);
469 case GNC_OWNER_EMPLOYEE:
470 return gncEmployeeGetCurrency (owner->owner.employee);
472 return gncOwnerGetCurrency (gncJobGetOwner (owner->owner.job));
476 gboolean gncOwnerGetActive (
const GncOwner *owner)
478 if (!owner)
return FALSE;
482 case GNC_OWNER_UNDEFINED:
485 case GNC_OWNER_CUSTOMER:
486 return gncCustomerGetActive (owner->owner.customer);
487 case GNC_OWNER_VENDOR:
488 return gncVendorGetActive (owner->owner.vendor);
489 case GNC_OWNER_EMPLOYEE:
490 return gncEmployeeGetActive (owner->owner.employee);
492 return gncJobGetActive (owner->owner.job);
498 if (!owner)
return NULL;
503 case GNC_OWNER_UNDEFINED:
506 case GNC_OWNER_CUSTOMER:
510 case GNC_OWNER_VENDOR:
512 case GNC_OWNER_EMPLOYEE:
518 gncOwnerSetActive (
const GncOwner *owner, gboolean active)
523 case GNC_OWNER_CUSTOMER:
524 gncCustomerSetActive (owner->owner.customer, active);
526 case GNC_OWNER_VENDOR:
527 gncVendorSetActive (owner->owner.vendor, active);
529 case GNC_OWNER_EMPLOYEE:
530 gncEmployeeSetActive (owner->owner.employee, active);
533 gncJobSetActive (owner->owner.job, active);
536 case GNC_OWNER_UNDEFINED:
552 if (!owner)
return NULL;
556 case GNC_OWNER_UNDEFINED:
559 case GNC_OWNER_CUSTOMER:
560 case GNC_OWNER_VENDOR:
561 case GNC_OWNER_EMPLOYEE:
564 return gncJobGetOwner (owner->owner.job);
570 if (!a && !b)
return 0;
571 if (!a && b)
return 1;
572 if (a && !b)
return -1;
574 if (a->type != b->type)
575 return (a->type - b->type);
580 case GNC_OWNER_UNDEFINED:
583 case GNC_OWNER_CUSTOMER:
584 return gncCustomerCompare (a->owner.customer, b->owner.customer);
585 case GNC_OWNER_VENDOR:
587 case GNC_OWNER_EMPLOYEE:
588 return gncEmployeeCompare (a->owner.employee, b->owner.employee);
590 return gncJobCompare (a->owner.job, b->owner.job);
596 if (!owner)
return NULL;
605 gnc_lot_begin_edit (lot);
611 gnc_lot_commit_edit (lot);
618 GncOwnerType type = GNC_OWNER_NONE;
621 if (!lot || !owner)
return FALSE;
623 book = gnc_lot_get_book (lot);
625 GNC_OWNER_TYPE, &type64,
626 GNC_OWNER_GUID, &guid,
628 type = (GncOwnerType) type64;
631 case GNC_OWNER_CUSTOMER:
632 gncOwnerInitCustomer (owner, gncCustomerLookup (book, guid));
634 case GNC_OWNER_VENDOR:
635 gncOwnerInitVendor (owner, gncVendorLookup (book, guid));
637 case GNC_OWNER_EMPLOYEE:
638 gncOwnerInitEmployee (owner, gncEmployeeLookup (book, guid));
641 gncOwnerInitJob (owner, gncJobLookup (book, guid));
647 return (owner->owner.undefined != NULL);
652 if (!owner)
return FALSE;
653 return (owner->owner.undefined != NULL);
659 const GncOwner *req_owner = user_data;
688 da = gncInvoiceGetDateDue (ia);
693 db = gncInvoiceGetDateDue (ib);
704 const char *memo,
const char *num)
710 Split *xfer_split = NULL;
714 if (!owner || !posted_acc || !xfer_acc)
return NULL;
715 g_return_val_if_fail (owner->owner.undefined != NULL, NULL);
718 book = gnc_account_get_book (posted_acc);
720 commodity = gncOwnerGetCurrency (owner);
731 xfer_split = xaccTransFindSplitByAccount(txn, xfer_acc);
735 g_message(
"Uh oh, mismatching currency/commodity between selected transaction and owner. We fall back to manual creation of a new transaction.");
741 g_message(
"Huh? Asset account not found anymore. Fully deleting old txn and now creating a new one.");
756 if (split == xfer_split)
758 gnc_set_num_action (NULL, split, num, _(
"Payment"));
793 gnc_set_num_action (NULL, split, num, _(
"Payment"));
818 gnc_set_num_action (NULL, split, num, _(
"Payment"));
826 payment_lot = gnc_lot_new (book);
831 gnc_set_num_action (txn, NULL, num, _(
"Payment"));
851 Split *best_split = NULL;
860 Split *split = ls_iter->data;
875 PWARN(
"Encountered a split in a payment lot that's not part of any transaction. "
876 "This is unexpected! Skipping split %p.", split);
890 new_flags += is_equal;
891 else if (val_cmp > 0)
892 new_flags += is_more;
894 new_flags += is_less;
897 new_flags += is_pay_split;
899 if ((new_flags >= best_flags) &&
905 best_flags = new_flags;
906 best_val = split_value;
936 xaccSplitSetParent (rem_split, txn);
948 gchar *memo_prefix = _(
"Offset between documents: ");
952 GList *titles = NULL, *titer;
963 Split *split = lts_iter->data;
979 title = g_strdup_printf (
"%s %s", gncInvoiceGetTypeString (invoice), gncInvoiceGetID (invoice));
981 titles = g_list_insert_sorted (titles, title, (GCompareFunc)g_strcmp0);
982 splits = g_list_prepend (splits, split);
989 new_memo = g_strconcat (memo_prefix, titles->data, NULL);
990 for (titer = titles->next; titer; titer = titer->next)
992 gchar *tmp_memo = g_strconcat (new_memo,
" - ", titer->data, NULL);
996 g_list_free_full (titles, g_free);
999 for (siter = splits; siter; siter = siter->next)
1005 g_list_free (splits);
1015 get_ll_transaction_from_lot (
GNCLot *lot)
1028 Split *ls = ls_iter->data;
1037 Split *ts = ts_iter->data;
1058 const gchar *action = _(
"Lot Link");
1092 ll_txn = get_ll_transaction_from_lot (from_lot);
1095 ll_txn = get_ll_transaction_from_lot (to_lot);
1130 gnc_set_num_action (NULL, split, NULL, action);
1140 gnc_set_num_action (NULL, split, NULL, action);
1172 PWARN (
"from_lot %p is a document lot. That is not allowed in gncOwnerOffsetLots", from_lot);
1215 for (left_iter = lots; left_iter; left_iter = left_iter->next)
1217 GNCLot *left_lot = left_iter->data;
1219 gboolean left_lot_has_doc;
1220 gboolean left_modified = FALSE;
1230 if (gnc_lot_count_splits (left_lot) == 0)
1232 gnc_lot_destroy (left_lot);
1233 left_iter->data = NULL;
1249 for (right_iter = left_iter->next; right_iter; right_iter = right_iter->next)
1251 GNCLot *right_lot = right_iter->data;
1253 gboolean right_lot_has_doc;
1261 if (gnc_lot_count_splits (right_lot) == 0)
1263 gnc_lot_destroy (right_lot);
1264 right_iter->data = NULL;
1294 if (left_lot_has_doc && right_lot_has_doc)
1295 gncOwnerCreateLotLink (left_lot, right_lot, owner);
1296 else if (!left_lot_has_doc && !right_lot_has_doc)
1301 gncOwnerOffsetLots (left_lot, right_lot, owner);
1303 gncOwnerOffsetLots (right_lot, left_lot, owner);
1307 GNCLot *doc_lot = left_lot_has_doc ? left_lot : right_lot;
1308 GNCLot *pay_lot = left_lot_has_doc ? right_lot : left_lot;
1310 gncOwnerOffsetLots (pay_lot, doc_lot, owner);
1320 qof_event_gen (QOF_INSTANCE(this_invoice), QOF_EVENT_MODIFY, NULL);
1322 left_modified = TRUE;
1332 qof_event_gen (QOF_INSTANCE(this_invoice), QOF_EVENT_MODIFY, NULL);
1351 const char *memo,
const char *num, gboolean auto_pay)
1353 GNCLot *payment_lot = NULL;
1354 GList *selected_lots = NULL;
1357 if (!owner || !posted_acc
1359 g_return_if_fail (owner->owner.undefined);
1364 amount, exch, date, memo, num);
1367 selected_lots = lots;
1370 (gpointer)owner, NULL);
1377 selected_lots = g_list_prepend (selected_lots, payment_lot);
1379 g_list_free (selected_lots);
1385 g_return_val_if_fail (owner, NULL);
1389 case GNC_OWNER_CUSTOMER:
1391 case GNC_OWNER_VENDOR:
1392 case GNC_OWNER_EMPLOYEE:
1403 g_return_val_if_fail (owner, NULL);
1404 g_return_val_if_fail (gncOwnerGetCurrency(owner), NULL);
1406 return (g_list_prepend (NULL, gncOwnerGetCurrency(owner)));
1421 GList *acct_list, *acct_node, *acct_types, *lot_list = NULL, *lot_node;
1426 g_return_val_if_fail (owner, gnc_numeric_zero ());
1432 owner_currency = gncOwnerGetCurrency (owner);
1435 for (acct_node = acct_list; acct_node; acct_node = acct_node->next)
1437 Account *account = acct_node->data;
1450 (gpointer)owner, NULL);
1452 for (lot_node = lot_list; lot_node; lot_node = lot_node->next)
1454 GNCLot *lot = lot_node->data;
1465 if (report_currency)
1467 pdb, balance, owner_currency, report_currency);
1477 owner_from_lot (
GNCLot *lot)
1481 if (!lot)
return NULL;
1493 { OWNER_FROM_LOT, _GNC_MOD_NAME, (
QofAccessFunc)owner_from_lot, NULL },
1502 if (!book || !owner || !type || !guid)
return FALSE;
1504 if (0 == g_strcmp0(type, GNC_ID_CUSTOMER))
1506 GncCustomer *customer = gncCustomerLookup(book, guid);
1507 gncOwnerInitCustomer(owner, customer);
1508 return (NULL != customer);
1510 else if (0 == g_strcmp0(type, GNC_ID_JOB))
1512 GncJob *job = gncJobLookup(book, guid);
1513 gncOwnerInitJob(owner, job);
1514 return (NULL != job);
1516 else if (0 == g_strcmp0(type, GNC_ID_VENDOR))
1518 GncVendor *vendor = gncVendorLookup(book, guid);
1519 gncOwnerInitVendor(owner, vendor);
1520 return (NULL != vendor);
1522 else if (0 == g_strcmp0(type, GNC_ID_EMPLOYEE))
1524 GncEmployee *employee = gncEmployeeLookup(book, guid);
1525 gncOwnerInitEmployee(owner, employee);
1526 return (NULL != employee);
1531 gboolean gncOwnerRegister (
void)
1541 { OWNER_PARENTG, QOF_TYPE_GUID, (
QofAccessFunc)gncOwnerGetEndGUID, NULL },
1542 { OWNER_NAME, QOF_TYPE_STRING, (
QofAccessFunc)gncOwnerGetName, NULL },
void xaccSplitSetValue(Split *s, gnc_numeric amt)
GList * gncOwnerGetCommoditiesList(const GncOwner *owner)
#define xaccTransAppendSplit(t, s)
Transaction * xaccMallocTransaction(QofBook *book)
gboolean gnc_numeric_equal(gnc_numeric a, gnc_numeric b)
void xaccSplitSetBaseValue(Split *s, gnc_numeric value, const gnc_commodity *base_currency)
gboolean xaccScrubMergeLotSubSplits(GNCLot *lot, gboolean strict)
const GncGUID * gncOwnerGetGUID(const GncOwner *owner)
char xaccTransGetTxnType(const Transaction *trans)
int gnc_commodity_get_fraction(const gnc_commodity *cm)
time64 timespecToTime64(Timespec ts)
Business Interface: Object OWNERs.
const GncGUID * qof_instance_get_guid(gconstpointer)
void qof_instance_get(const QofInstance *inst, const gchar *first_param,...)
Wrapper for g_object_get.
Split * xaccTransGetSplit(const Transaction *trans, int i)
GList * gncOwnerGetAccountTypesList(const GncOwner *owner)
QofBook * qof_instance_get_book(gconstpointer)
GNCAccountType xaccAccountGetType(const Account *acc)
gboolean xaccSplitDestroy(Split *split)
Utilities to Convert Stock Accounts to use Lots.
const gchar * QofIdTypeConst
gnc_numeric gnc_numeric_neg(gnc_numeric a)
void xaccSplitCopyOnto(const Split *from_split, Split *to_split)
void qof_instance_set(QofInstance *inst, const gchar *first_param,...)
Wrapper for g_object_set Group setting multiple parameters in a single begin/commit/rollback.
void qof_class_register(QofIdTypeConst obj_name, QofSortFunc default_sort_fcn, const QofParam *params)
gboolean gnc_commodity_equal(const gnc_commodity *a, const gnc_commodity *b)
void gnc_lot_add_split(GNCLot *lot, Split *split)
void xaccTransSetDescription(Transaction *trans, const char *desc)
gboolean gncOwnerEqual(const GncOwner *a, const GncOwner *b)
gnc_numeric gnc_numeric_add(gnc_numeric a, gnc_numeric b, gint64 denom, gint how)
Use a 64-bit unsigned int timespec.
gboolean gnc_numeric_zero_p(gnc_numeric a)
Transaction * xaccSplitGetParent(const Split *split)
API for Transactions and Splits (journal entries)
gpointer(* QofAccessFunc)(gpointer object, const QofParam *param)
gint gnc_numeric_compare(gnc_numeric a, gnc_numeric b)
QofBook * xaccSplitGetBook(const Split *split)
void gncOwnerBeginEdit(GncOwner *owner)
gboolean gncOwnerIsValid(const GncOwner *owner)
GNCPriceDB * gnc_pricedb_get_db(QofBook *book)
Split * gnc_lot_get_earliest_split(GNCLot *lot)
QofInstance * qofOwnerGetOwner(const GncOwner *owner)
gnc_numeric gnc_pricedb_convert_balance_latest_price(GNCPriceDB *pdb, gnc_numeric balance, const gnc_commodity *balance_currency, const gnc_commodity *new_currency)
void xaccTransSetCurrency(Transaction *trans, gnc_commodity *curr)
void gncOwnerAutoApplyPaymentsWithLots(const GncOwner *owner, GList *lots)
Split * gnc_lot_get_latest_split(GNCLot *lot)
void xaccTransDestroy(Transaction *trans)
#define PWARN(format, args...)
gint timespec_cmp(const Timespec *ta, const Timespec *tb)
int xaccTransCountSplits(const Transaction *trans)
void xaccTransSetTxnType(Transaction *trans, char type)
int gncOwnerGCompareFunc(const GncOwner *a, const GncOwner *b)
void xaccSplitSetAmount(Split *s, gnc_numeric amt)
void gncOwnerApplyPayment(const GncOwner *owner, Transaction *txn, GList *lots, Account *posted_acc, Account *xfer_acc, gnc_numeric amount, gnc_numeric exch, Timespec date, const char *memo, const char *num, gboolean auto_pay)
gnc_numeric gnc_numeric_mul(gnc_numeric a, gnc_numeric b, gint64 denom, gint how)
void xaccSplitSetMemo(Split *split, const char *memo)
gint gncOwnerLotsSortFunc(GNCLot *lotA, GNCLot *lotB)
gboolean gncOwnerReduceSplitTo(Split *split, gnc_numeric target_value)
gnc_numeric gncOwnerGetBalanceInCurrency(const GncOwner *owner, const gnc_commodity *report_currency)
SplitList * gnc_lot_get_split_list(const GNCLot *lot)
QofIdTypeConst qofOwnerGetType(const GncOwner *owner)
int gncOwnerCompare(const GncOwner *a, const GncOwner *b)
void qofOwnerSetEntity(GncOwner *owner, QofInstance *ent)
int(* QofSortFunc)(gconstpointer, gconstpointer)
void gncOwnerAttachToLot(const GncOwner *owner, GNCLot *lot)
QofIdTypeConst gncOwnerTypeToQofIdType(GncOwnerType t)
gpointer gncOwnerGetUndefined(const GncOwner *owner)
gboolean gncOwnerGetOwnerFromLot(GNCLot *lot, GncOwner *owner)
gnc_numeric gnc_numeric_abs(gnc_numeric a)
void xaccTransCommitEdit(Transaction *trans)
void xaccTransBeginEdit(Transaction *trans)
int gncVendorCompare(const GncVendor *a, const GncVendor *b)
gboolean gnc_numeric_positive_p(gnc_numeric a)
Split * xaccMallocSplit(QofBook *book)
gboolean GNC_IS_OWNER(QofInstance *ent)
gnc_numeric gnc_numeric_sub(gnc_numeric a, gnc_numeric b, gint64 denom, gint how)
GncOwnerType gncOwnerGetType(const GncOwner *owner)
const GncOwner * gncOwnerGetEndOwner(const GncOwner *owner)
GList * gnc_account_get_descendants(const Account *account)
GncInvoice * gncInvoiceGetInvoiceFromLot(GNCLot *lot)
Business Invoice Interface.
GncJob * gncOwnerGetJob(const GncOwner *owner)
GNCLot * gncOwnerCreatePaymentLot(const GncOwner *owner, Transaction *txn, Account *posted_acc, Account *xfer_acc, gnc_numeric amount, gnc_numeric exch, Timespec date, const char *memo, const char *num)
gboolean gncOwnerLotMatchOwnerFunc(GNCLot *lot, gpointer user_data)
gboolean gnc_lot_is_closed(GNCLot *lot)
gnc_numeric xaccSplitGetValue(const Split *split)
void xaccAccountBeginEdit(Account *acc)
gnc_commodity * xaccAccountGetCommodity(const Account *acc)
const GncGUID * guid_null(void)
gnc_commodity * xaccTransGetCurrency(const Transaction *trans)
#define xaccAccountInsertSplit(acc, s)
Timespec xaccTransRetDatePostedTS(const Transaction *trans)
Split * gncOwnerFindOffsettingSplit(GNCLot *lot, gnc_numeric target_value)
GncVendor * gncOwnerGetVendor(const GncOwner *owner)
GncCustomer * gncOwnerGetCustomer(const GncOwner *owner)
time64 gnc_time(time64 *tbuf)
get the current local time
const char * xaccSplitGetMemo(const Split *split)
void gncOwnerSetLotLinkMemo(Transaction *ll_txn)
Account * gnc_lot_get_account(const GNCLot *lot)
LotList * xaccAccountFindOpenLots(const Account *acc, gboolean(*match_func)(GNCLot *lot, gpointer user_data), gpointer user_data, GCompareFunc sort_func)
void xaccTransSetDateEnteredSecs(Transaction *trans, time64 secs)
void qof_event_gen(QofInstance *entity, QofEventId event_type, gpointer event_data)
Invoke all registered event handlers using the given arguments.
GncEmployee * gncOwnerGetEmployee(const GncOwner *owner)
API for Transactions and Splits (journal entries)
void xaccAccountCommitEdit(Account *acc)
GncOwner * gncOwnerNew(void)
SplitList * xaccTransGetSplitList(const Transaction *trans)
Commodity handling public routines.
gnc_numeric gnc_lot_get_balance(GNCLot *lot)
GNCLot * xaccSplitGetLot(const Split *split)
const gchar * QofLogModule
void xaccTransSetDatePostedTS(Transaction *trans, const Timespec *ts)
void timespecFromTime64(Timespec *ts, time64 t)