aherman
/
gnucash
mirror of https://github.com/Gnucash/gnucash
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '59be2dc692'
${ noResults }
gnucash/src/engine/Period.c

889 lines
29 KiB
Raw Blame History

/********************************************************************\
* Period.c -- Implement accounting Periods *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License as *
* published by the Free Software Foundation; either version 2 of *
* the License, or (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License*
* along with this program; if not, contact: *
* *
* Free Software Foundation Voice: +1-617-542-5942 *
* 51 Franklin Street, Fifth Floor Fax: +1-617-542-2652 *
* Boston, MA 02110-1301, USA gnu@gnu.org *
\********************************************************************/
/*
* FILE:
* Period.c
*
* FUNCTION:
* Implement accounting periods, using design described in
* src/doc/books.txt
*
* CAUTION: poorly tested.
*
* HISTORY:
* Created by Linas Vepstas November 2001
* Copyright (c) 2001-2003 Linas Vepstas <linas@linas.org>
*/
#include "config.h"
#include "AccountP.h"
#include "qof.h"
#include "gnc-lot.h"
#include "gnc-pricedb.h"
#include "gnc-pricedb-p.h"
#include "Period.h"
#include "Transaction.h"
#include "TransactionP.h"
/* This static indicates the debugging module that this .o belongs to. */
static QofLogModule log_module = GNC_MOD_BOOK;
/* ================================================================ */
static inline Account *
xaccAccountLookupTwin (Account *acc, QofBook *book)
{
return (Account *) qof_instance_lookup_twin (QOF_INSTANCE(acc), book);
}
/* ================================================================ */
/* Reparent transaction to new book. This routine does this by
* deleting the transaction in the old book, and creating a copy
* in the new book. While technically correct, this is maybe too
* much churn on the backend ...
*/
void
gnc_book_insert_trans_clobber (QofBook *book, Transaction *trans)
{
QofCollection *col;
Transaction *newtrans;
GList *node;
if (!trans || !book) return;
/* If this is the same book, its a no-op. */
if (qof_instance_get_book(trans) == book) return;
ENTER ("trans=%p %s", trans, trans->description);
newtrans = xaccDupeTransaction (trans);
for (node = newtrans->splits; node; node = node->next)
{
Split *s = node->data;
s->parent = newtrans;
}
/* Utterly wipe out the transaction from the old book. */
xaccTransBeginEdit (trans);
xaccTransDestroy (trans);
xaccTransCommitEdit (trans);
/* Fiddle the transaction into place in the new book */
col = qof_book_get_collection (book, GNC_ID_TRANS);
qof_collection_insert_entity (col, &newtrans->inst);
qof_instance_set_book(newtrans, book);
col = qof_book_get_collection (book, GNC_ID_SPLIT);
xaccTransBeginEdit (newtrans);
for (node = newtrans->splits; node; node = node->next)
{
Account *twin;
Split *s = node->data;
/* move the split into the new book ... */
qof_instance_set_book(s, book);
qof_collection_insert_entity(col, &s->inst);
/* find the twin account, and re-parent to that. */
twin = xaccAccountLookupTwin (s->acc, book);
if (!twin)
{
PERR ("near-fatal: twin account not found");
}
else
{
xaccAccountInsertSplit (twin, s);
g_object_set(twin, "sort-dirty", TRUE, "balance-dirty", TRUE, NULL);
}
}
xaccTransCommitEdit (newtrans);
qof_event_gen (&newtrans->inst, QOF_EVENT_CREATE, NULL);
LEAVE ("trans=%p %s", trans, trans->description);
}
/* ================================================================ */
/* Reparent transaction to new book. This routine does this by
* moving GUID's to the new book's entity tables.
*/
void
gnc_book_insert_trans (QofBook *book, Transaction *trans)
{
QofCollection *col;
QofBook *trans_book;
GList *node;
if (!trans || !book) return;
/* If this is the same book, its a no-op. */
trans_book = qof_instance_get_book(trans);
if (trans_book == book) return;
/* If the old and new book don't share backends, then clobber-copy;
* i.e. destroy it in one backend, create it in another. */
if (qof_book_get_backend(book) != qof_book_get_backend(trans_book))
{
gnc_book_insert_trans_clobber (book, trans);
return;
}
ENTER ("trans=%p %s", trans, trans->description);
/* Fiddle the transaction into place in the new book */
xaccTransBeginEdit (trans);
col = qof_book_get_collection (book, GNC_ID_TRANS);
qof_instance_set_book(trans, book);
qof_collection_insert_entity (col, &trans->inst);
col = qof_book_get_collection (book, GNC_ID_SPLIT);
for (node = trans->splits; node; node = node->next)
{
Account *twin;
Split *s = node->data;
/* Move the splits over (only if they haven't already been moved). */
if (qof_instance_get_book(s) != book)
{
qof_instance_set_book(s, book);
qof_collection_insert_entity (col, &s->inst);
}
/* Find the twin account, and re-parent to that. */
twin = xaccAccountLookupTwin (s->acc, book);
if (!twin)
{
PERR ("near-fatal: twin account not found");
}
else
{
/* Move the split too, if it hasn't been moved already */
if (s->acc != twin)
{
xaccAccountInsertSplit (twin, s);
g_object_set(twin, "sort-dirty", TRUE, "balance-dirty", TRUE, NULL);
}
}
}
xaccTransCommitEdit (trans);
qof_event_gen (&trans->inst, QOF_EVENT_MODIFY, NULL);
LEAVE ("trans=%p %s", trans, trans->description);
}
/* ================================================================ */
/* Reparent lot to new book. This routine does this by
* completely deleting and recreating the lot.
*/
void
gnc_book_insert_lot_clobber (QofBook *book, GNCLot *lot)
{
PERR ("Not Implemented");
}
/* ================================================================ */
/* Reparent lot to new book. This routine does this by
* moving GUID's to the new book's entity tables.
*/
void
gnc_book_insert_lot (QofBook *book, GNCLot *lot)
{
QofCollection *col;
SplitList *snode;
Account *twin;
if (!lot || !book) return;
/* If this is the same book, its a no-op. */
if (gnc_lot_get_book(lot) == book) return;
if (qof_book_get_backend(book) !=
qof_book_get_backend(gnc_lot_get_book(lot)))
{
gnc_book_insert_lot_clobber (book, lot);
return;
}
ENTER ("lot=%p", lot);
col = qof_book_get_collection (book, GNC_ID_LOT);
qof_instance_set_book(lot, book);
qof_collection_insert_entity (col, QOF_INSTANCE(lot));
/* Move the splits over (only if they haven't already been moved). */
col = qof_book_get_collection (book, GNC_ID_SPLIT);
for (snode = gnc_lot_get_split_list(lot); snode; snode = snode->next)
{
Split *s = snode->data;
if (qof_instance_get_book(s) != book)
{
qof_instance_set_book(s, book);
qof_collection_insert_entity (col, &s->inst);
}
}
twin = xaccAccountLookupTwin (gnc_lot_get_account(lot), book);
if (!twin)
{
PERR ("near-fatal: twin account not found");
}
else
{
xaccAccountInsertLot (twin, lot);
}
LEAVE ("lot=%p", lot);
}
/* ================================================================ */
void
gnc_book_insert_price (QofBook *book, GNCPrice *pr)
{
QofCollection *col;
QofBook *pr_book;
if (!pr || !book) return;
/* If this is the same book, its a no-op. */
pr_book = qof_instance_get_book(pr);
if (pr_book == book) return;
/* If the old and new book don't share backends, then clobber-copy;
* i.e. destroy it in one backend, create it in another. */
if (qof_book_get_backend(book) != qof_book_get_backend(pr_book))
{
gnc_book_insert_price_clobber (book, pr);
return;
}
ENTER ("price=%p", pr);
/* Fiddle the price into place in the new book */
gnc_price_ref (pr);
gnc_price_begin_edit (pr);
col = qof_book_get_collection (book, GNC_ID_PRICE);
qof_instance_set_book(pr, book);
qof_collection_insert_entity (col, &pr->inst);
gnc_pricedb_remove_price (pr->db, pr);
gnc_pricedb_add_price (gnc_pricedb_get_db (book), pr);
gnc_price_commit_edit (pr);
gnc_price_unref (pr);
LEAVE ("price=%p", pr);
}
/* ================================================================ */
void
gnc_book_insert_price_clobber (QofBook *book, GNCPrice *pr)
{
PERR ("Not Implemented");
}
/* ================================================================ */
/* The following routines determine whether a given lot or
* transaction is linked or related to another lot that is 'open'.
* These return true if so.
*
* An 'open transaction' is a transaction that has a split
* that belongs to an 'open lot'. An 'open lot' is one that
* is not closed, OR ONE THAT HAS a split in it that belongs to
* an open transaction.
*
* The need for this recursive definition is that some lots,
* even though themselves closed, are participants in transactions
* that cannot be moved to a closed book, and thus, by association
* can't be moved either.
*
* Lots contain pointers to splits, and transactions contain
* pointers to splits. Together, these form a graph, which may
* be cyclic. We want to walk the entire graph, and determine
* whether there are any open lots in it. The walk must be
* recursive, and because it might be cyclic, we use a marker
* to break the cycles.
*/
static gboolean trans_has_open_lot_tree (Transaction *trans);
static gboolean lot_has_open_trans_tree (GNCLot *lot);
static gboolean
trans_has_open_lot_tree (Transaction *trans)
{
SplitList *split_list, *node;
if (1 == trans->marker) return FALSE;
if (2 == trans->marker) return TRUE;
trans->marker = 1;
split_list = xaccTransGetSplitList (trans);
for (node = split_list; node; node = node->next)
{
Split *s = node->data;
GNCLot *lot = s->lot;
if (NULL == lot) continue;
if ((FALSE == gnc_lot_is_closed(lot)) ||
(lot_has_open_trans_tree (lot)))
{
trans->marker = 2;
return TRUE;
}
}
return FALSE;
}
static gboolean
lot_has_open_trans_tree (GNCLot *lot)
{
SplitList *split_list, *snode;
if (1 == gnc_lot_get_marker(lot)) return FALSE;
if (2 == gnc_lot_get_marker(lot)) return TRUE;
gnc_lot_set_marker(lot, 1);
if (FALSE == gnc_lot_is_closed(lot))
{
gnc_lot_set_marker(lot, 2);
return TRUE;
}
split_list = gnc_lot_get_split_list (lot);
for (snode = split_list; snode; snode = snode->next)
{
Split *s = snode->data;
Transaction *trans = s->parent;
if (trans_has_open_lot_tree (trans))
{
gnc_lot_set_marker(lot, 2);
return TRUE;
}
}
return FALSE;
}
/* ================================================================ */
/* The following routines remove 'open lots' and 'open transactions'
* from the lists passed in.
*/
static LotList *
lot_list_preen_open_lots (LotList *lot_list)
{
LotList *lnode;
ENTER (" ");
for (lnode = lot_list; lnode; )
{
GNCLot *lot = lnode->data;
LotList *lnext = lnode->next;
if (lot_has_open_trans_tree (lot))
lot_list = g_list_delete_link(lot_list, lnode);
lnode = lnext;
}
LEAVE (" ");
return lot_list;
}
static TransList *
trans_list_preen_open_lots (TransList *trans_list)
{
TransList *tnode;
ENTER (" ");
for (tnode = trans_list; tnode; )
{
Transaction *trans = tnode->data;
TransList *tnext = tnode->next;
if (trans_has_open_lot_tree (trans))
{
trans_list = g_list_remove_link (trans_list, tnode);
/* XXX freeing this node somehow leads to glib g_list
* memory corruption which later takes down the system.
* I don't see why. */
/* g_list_free_1 (tnode); */
}
tnode = tnext;
}
LEAVE (" ");
return trans_list;
}
/* ================================================================ */
/* clear the markers for the above routines */
static void
clear_markers (Account *account, gpointer dummy)
{
GList *lp;
if (!account) return;
for (lp = xaccAccountGetSplitList(account); lp; lp = lp->next)
{
Split *s = lp->data;
Transaction *trans = s->parent;
GNCLot *lot = s->lot;
trans->marker = 0;
if (lot) gnc_lot_set_marker(lot, 0);
}
}
/* ================================================================ */
/* Return a unique list of lots that are involved with the listed
* transactions.
*/
static LotList *
create_lot_list_from_trans_list (TransList *trans_list)
{
LotList *lot_list = NULL;
TransList *tnode;
for (tnode = trans_list; tnode; tnode = tnode->next)
{
Transaction *trans = tnode->data;
SplitList *split_list = xaccTransGetSplitList (trans);
SplitList *snode;
for (snode = split_list; snode; snode = snode->next)
{
Split *s = snode->data;
GNCLot *lot = xaccSplitGetLot(s);
if (NULL == lot) continue;
if (g_list_find (lot_list, lot)) continue;
lot_list = g_list_prepend (lot_list, lot);
}
}
return lot_list;
}
/* ================================================================ */
void
gnc_book_partition_pricedb (QofBook *dest_book, QofBook *src_book, QofQuery *query)
{
GNCPriceDB *src_pdb, *dest_pdb;
GList *price_list, *pnode;
if (!src_book || !dest_book || !query) return;
ENTER (" src_book=%p dest_book=%p", src_book, dest_book);
src_pdb = gnc_pricedb_get_db (src_book);
dest_pdb = gnc_pricedb_get_db (dest_book);
gnc_pricedb_begin_edit (src_pdb);
gnc_pricedb_begin_edit (dest_pdb);
gnc_pricedb_set_bulk_update (dest_pdb, TRUE);
qof_query_set_book (query, src_book);
price_list = qof_query_run (query);
printf ("duude XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX prices\n");
for (pnode = price_list; pnode; pnode = pnode->next)
{
GNCPrice *pr = pnode->data;
gnc_book_insert_price (dest_book, pr);
}
gnc_pricedb_set_bulk_update (dest_pdb, FALSE);
gnc_pricedb_commit_edit (dest_pdb);
gnc_pricedb_commit_edit (src_pdb);
LEAVE (" src_book=%p dest_book=%p", src_book, dest_book);
}
/* ================================================================ */
void
gnc_book_partition_txn (QofBook *dest_book, QofBook *src_book, QofQuery *query)
{
gnc_commodity_table *src_tbl, *dst_tbl;
Account *src_root, *dst_root;
time_t now;
TransList *trans_list, *tnode;
LotList *lot_list, *lnode;
QofInstance *book_inst;
if (!src_book || !dest_book || !query) return;
ENTER (" src_book=%p dest_book=%p", src_book, dest_book);
/* First, copy the book's KVP tree */
/* hack alert -- FIXME -- this should really be a merge, not a
* clobber copy, but I am too lazy to write a kvp merge routine,
* and it is not needed for the current usage. */
kvp_frame_delete (qof_book_get_slots(dest_book));
book_inst = (QofInstance*)dest_book;
book_inst->kvp_data = kvp_frame_copy (qof_book_get_slots(src_book));
/* Next, copy the commodity tables */
src_tbl = gnc_commodity_table_get_table (src_book);
dst_tbl = gnc_commodity_table_get_table (dest_book);
gnc_commodity_table_copy (dst_tbl, src_tbl, dest_book);
/* Next, copy all of the accounts */
/* hack alert -- FIXME -- this should really be a merge, not a
* clobber copy, but I am too lazy to write an account-group merge
* routine, and it is not needed for the current usage. */
src_root = gnc_book_get_root_account (src_book);
dst_root = gnc_book_get_root_account (dest_book);
gnc_account_copy_children (dst_root, src_root);
/* Next, run the query */
xaccAccountBeginEdit (dst_root);
xaccAccountBeginEdit (src_root);
qof_query_set_book (query, src_book);
trans_list = qof_query_run (query);
/* Preen: remove open lots/ open trnasactions */
gnc_account_foreach_descendant(src_root, clear_markers, NULL);
trans_list = trans_list_preen_open_lots (trans_list);
lot_list = create_lot_list_from_trans_list (trans_list);
lot_list = lot_list_preen_open_lots (lot_list);
/* Move closed lots over to destination. Do this before moving
* the txn's, so that the lots don't get trashed. */
for (lnode = lot_list; lnode; lnode = lnode->next)
{
GNCLot *lot = lnode->data;
gnc_book_insert_lot (dest_book, lot);
}
/* Move the transactions over to the destination book. */
for (tnode = trans_list; tnode; tnode = tnode->next)
{
Transaction *trans = tnode->data;
gnc_book_insert_trans (dest_book, trans);
}
xaccAccountCommitEdit (src_root);
xaccAccountCommitEdit (dst_root);
/* Make note of the sibling books */
now = time(0);
gnc_kvp_bag_add (qof_book_get_slots(src_book), "gemini", now,
"book_guid", qof_book_get_guid(dest_book),
NULL);
gnc_kvp_bag_add (qof_book_get_slots(dest_book), "gemini", now,
"book_guid", qof_book_get_guid(src_book),
NULL);
LEAVE (" ");
}
/* ================================================================ */
/* Find nearest equity account */
static Account *
find_nearest_equity_acct (Account *acc)
{
QofBook *book;
GList *acc_list, *node;
Account *parent, *root, *candidate;
parent = gnc_account_get_parent (acc);
g_return_val_if_fail (parent, NULL);
/* See if we can find an equity account that is peered to this
* account. If not, check succssively higher levels. */
while (parent != NULL)
{
acc_list = gnc_account_get_children(parent);
for (node = acc_list; node; node = node->next)
{
candidate = (Account *) node->data;
if ((ACCT_TYPE_EQUITY == xaccAccountGetType (candidate)) &&
gnc_commodity_equiv(xaccAccountGetCommodity(acc),
xaccAccountGetCommodity(candidate)))
{
return candidate;
}
}
g_list_free(acc_list);
parent = gnc_account_get_parent (parent);
}
/* If we got to here, then we are at the root account, and there is no
* equity account to be found. So we need to create one. */
book = gnc_account_get_book(acc);
root = gnc_book_get_root_account(book);
candidate = xaccMallocAccount (book);
xaccAccountBeginEdit (candidate);
gnc_account_append_child (root, candidate);
xaccAccountSetType (candidate, ACCT_TYPE_EQUITY);
xaccAccountSetName (candidate, xaccAccountGetTypeStr(ACCT_TYPE_EQUITY));
xaccAccountSetCommodity (candidate, xaccAccountGetCommodity(acc));
xaccAccountCommitEdit (candidate);
return candidate;
}
/* ================================================================ */
/* Traverse all accounts, get account balances */
static void
add_closing_balances (Account *parent,
QofBook *open_book,
QofBook *closed_book,
Account *equity_account,
Timespec *post_date, Timespec *date_entered,
const char *desc)
{
GList *acc_list, *node;
if (!parent) return;
ENTER (" enter=%s post=%s desc=%s", gnc_print_date(*date_entered),
gnc_print_date (*post_date), desc);
xaccAccountBeginEdit (equity_account);
/* Walk accounts in closed book */
acc_list = gnc_account_get_children(parent);
for (node = acc_list; node; node = node->next)
{
KvpFrame *cwd;
Account *twin;
Account * candidate = (Account *) node->data;
GNCAccountType tip = xaccAccountGetType (candidate);
/* Find the peer account of this account in the open book */
twin = xaccAccountLookupTwin (candidate, open_book);
/* -------------------------------- */
/* Add KVP to open account, indicating the progenitor
* of this account. */
xaccAccountBeginEdit (twin);
cwd = xaccAccountGetSlots (twin);
kvp_frame_set_guid (cwd, "/book/prev-acct", qof_entity_get_guid (QOF_INSTANCE(candidate)));
kvp_frame_set_guid (cwd, "/book/prev-book", qof_book_get_guid(closed_book));
qof_instance_set_slots(QOF_INSTANCE(twin), twin->inst.kvp_data);
/* -------------------------------- */
/* Add KVP to closed account, indicating where
* the next book is. */
xaccAccountBeginEdit (candidate);
cwd = xaccAccountGetSlots (candidate);
kvp_frame_set_guid (cwd, "/book/next-book", qof_book_get_guid(open_book));
kvp_frame_set_guid (cwd, "/book/next-acct", qof_entity_get_guid (QOF_INSTANCE(twin)));
qof_instance_set_slots(QOF_INSTANCE(candidate), candidate->inst.kvp_data);
/* -------------------------------- */
/* We need to carry a balance on any account that is not
* and income or expense or equity account */
if ((ACCT_TYPE_INCOME != tip) && (ACCT_TYPE_EXPENSE != tip) &&
(ACCT_TYPE_EQUITY != tip && ACCT_TYPE_TRADING != tip))
{
gnc_numeric baln;
baln = xaccAccountGetBalance (candidate);
/* Don't bother with creating the equity balance if its zero */
if (FALSE == gnc_numeric_zero_p(baln))
{
Split *se, *st;
Transaction *trans;
Account *equity;
/* Find the equity account into which we'll poke the
* balancing transaction */
if (NULL == equity_account)
{
equity = find_nearest_equity_acct (twin);
xaccAccountBeginEdit (equity);
}
else
{
equity = equity_account;
}
/* -------------------------------- */
/* Create the balancing transaction */
trans = xaccMallocTransaction (open_book);
xaccTransBeginEdit (trans);
xaccTransSetDatePostedTS (trans, post_date);
xaccTransSetDateEnteredTS (trans, date_entered);
xaccTransSetDescription (trans, desc);
xaccTransSetCurrency (trans, xaccAccountGetCommodity(equity));
st = xaccMallocSplit(open_book);
xaccTransAppendSplit(trans, st);
xaccAccountInsertSplit (twin, st);
se = xaccMallocSplit(open_book);
xaccTransAppendSplit(trans, se);
xaccAccountInsertSplit (equity, se);
xaccSplitSetAmount (st, baln);
xaccSplitSetValue (st, baln);
xaccSplitSetAmount (se, gnc_numeric_neg(baln));
xaccSplitSetValue (se, gnc_numeric_neg(baln));
/* Add KVP data showing where the balancing
* transaction came from */
cwd = xaccTransGetSlots (trans);
kvp_frame_set_guid (cwd, "/book/closed-book", qof_book_get_guid(closed_book));
kvp_frame_set_guid (cwd, "/book/closed-acct", qof_entity_get_guid(QOF_INSTANCE(candidate)));
xaccTransCommitEdit (trans);
if (NULL == equity_account)
{
xaccAccountCommitEdit (equity);
}
/* -------------------------------- */
/* Add KVP to closed account, indicating where the
* balance was carried forward to. */
cwd = xaccAccountGetSlots (candidate);
kvp_frame_set_guid (cwd, "/book/balancing-trans", xaccTransGetGUID(trans));
}
}
/* We left an open dangling above ... */
xaccAccountCommitEdit (candidate);
xaccAccountCommitEdit (twin);
/* Recurse down to the children */
if (gnc_account_n_children(candidate) > 0)
{
PINFO ("add closing baln to subaccts of %s",
xaccAccountGetDescription(candidate));
add_closing_balances (candidate, open_book, closed_book,
equity_account,
post_date, date_entered, desc);
}
}
g_list_free(acc_list);
xaccAccountCommitEdit (equity_account);
LEAVE (" ");
}
/* ================================================================ */
static void
period_begin_edit (QofBook *src_book, QofBook *dest_book)
{
/*
QofBackend *be;
be = qof_book_get_backend(src_book);
if (be && be->begin)
{
// (*be->begin)(be, GNC_ID_PERIOD, dest_book);
}
*/
}
static void
period_commit_edit (QofBook *src_book, QofBook *dest_book)
{
/*
QofBackend *be;
be = qof_book_get_backend(src_book);
if (be && be->commit)
{
// (*be->commit)(be, GNC_ID_PERIOD, dest_book);
}
*/
}
/* ================================================================ */
/* Split a book into two by date */
QofBook *
gnc_book_close_period (QofBook *existing_book, Timespec calve_date,
Account *equity_account,
const char * memo)
{
QofQuery *txn_query, *prc_query;
QofQueryPredData *pred_data;
GSList *param_list;
QofBook *closing_book;
KvpFrame *exist_cwd, *partn_cwd;
Timespec ts;
if (!existing_book) return NULL;
ENTER (" date=%s memo=%s", gnc_print_date(calve_date), memo);
/* Setup closing book */
closing_book = qof_book_new();
qof_book_set_backend (closing_book, qof_book_get_backend(existing_book));
qof_book_mark_closed(closing_book);
period_begin_edit (existing_book, closing_book);
/* Get all transactions that are *earlier* than the calve date,
* and put them in the new book. */
txn_query = qof_query_create_for (GNC_ID_TRANS);
pred_data = qof_query_date_predicate (QOF_COMPARE_LTE,
QOF_DATE_MATCH_NORMAL,
calve_date);
param_list = qof_query_build_param_list (TRANS_DATE_POSTED, NULL);
qof_query_add_term (txn_query, param_list, pred_data, QOF_QUERY_FIRST_TERM);
gnc_book_partition_txn (closing_book, existing_book, txn_query);
qof_query_destroy (txn_query);
/* Move prices over too */
prc_query = qof_query_create_for (GNC_ID_PRICE);
pred_data = qof_query_date_predicate (QOF_COMPARE_LTE,
QOF_DATE_MATCH_NORMAL,
calve_date);
param_list = qof_query_build_param_list (PRICE_DATE, NULL);
qof_query_add_term (prc_query, param_list, pred_data, QOF_QUERY_FIRST_TERM);
gnc_book_partition_pricedb (closing_book, existing_book, prc_query);
qof_query_destroy (prc_query);
/* Now add the various identifying kvp's */
/* cwd == 'current working directory' */
exist_cwd = qof_book_get_slots(existing_book);
partn_cwd = qof_book_get_slots(closing_book);
/* Mark the boundary date between the books */
kvp_frame_set_timespec (exist_cwd, "/book/open-date", calve_date);
kvp_frame_set_timespec (partn_cwd, "/book/close-date", calve_date);
/* Mark partition as being closed */
ts.tv_sec = time(0);
ts.tv_nsec = 0;
kvp_frame_set_timespec (partn_cwd, "/book/log-date", ts);
/* Set up pointers to each book from the other. */
kvp_frame_set_guid (partn_cwd, "/book/next-book", qof_book_get_guid(existing_book));
kvp_frame_set_guid (exist_cwd, "/book/prev-book", qof_book_get_guid(closing_book));
/* add in transactions to equity accounts that will
* hold the colsing balances */
add_closing_balances (gnc_book_get_root_account(closing_book),
existing_book, closing_book,
equity_account,
&calve_date, &ts, memo);
period_commit_edit (existing_book, closing_book);
LEAVE (" ");
return closing_book;
}
/* ============================= END OF FILE ====================== */
Reference in new issue View Git Blame Copy Permalink