/********************************************************************\ * SchedXaction.c -- Scheduled Transaction implementation. * * Copyright (C) 2001 Joshua Sled * * * * 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 * * 59 Temple Place - Suite 330 Fax: +1-617-542-2652 * * Boston, MA 02111-1307, USA gnu@gnu.org * * * \********************************************************************/ #include "config.h" #include #include #include "FreqSpec.h" #include "GNCIdP.h" #include "SX-ttinfo.h" #include "SchedXactionP.h" #include "TransactionP.h" #include "date.h" #include "gnc-engine-util.h" #include "gnc-event-p.h" #include "gnc-session-p.h" #include "guid.h" #include "messages.h" static short module = MOD_SX; /** Local data defs *****/ void sxprivtransactionListMapDelete( gpointer data, gpointer user_data ); /** Local Prototypes *****/ static void xaccSchedXactionInit( SchedXaction *sx, GNCSession *session) { GNCBook *book; AccountGroup *ag; char *name; sx->entity_table = gnc_session_get_entity_table (session); sx->freq = xaccFreqSpecMalloc(session); book = gnc_session_get_book (session); xaccGUIDNew( &sx->guid, session ); xaccStoreEntity( sx->entity_table, sx, &sx->guid, GNC_ID_SCHEDXACTION ); g_date_clear( &sx->last_date, 1 ); g_date_clear( &sx->start_date, 1 ); g_date_clear( &sx->end_date, 1 ); sx->num_occurances_total = 0; sx->kvp_data = kvp_frame_new(); sx->autoCreateOption = FALSE; sx->autoCreateNotify = FALSE; sx->advanceCreateDays = 0; sx->advanceRemindDays = 0; sx->dirty = TRUE; /* create a new template account for our splits */ sx->template_acct = xaccMallocAccount(session); name = guid_to_string( &sx->guid ); xaccAccountSetName( sx->template_acct, name ); xaccAccountSetCommodity (sx->template_acct, gnc_commodity_new( "template", "template", "template", "template", 1 ) ); g_free( name ); xaccAccountSetType( sx->template_acct, BANK ); ag = gnc_book_get_template_group( book ); xaccGroupInsertAccount( ag, sx->template_acct ); } SchedXaction* xaccSchedXactionMalloc(GNCSession *session) { SchedXaction *sx; g_return_val_if_fail (session, NULL); sx = g_new0( SchedXaction, 1 ); xaccSchedXactionInit( sx, session ); gnc_engine_generate_event( &sx->guid, GNC_EVENT_CREATE ); return sx; } static void sxprivTransMapDelete( gpointer data, gpointer user_data ) { Transaction *t = (Transaction *) data; xaccTransBeginEdit( t ); xaccTransDestroy( t ); xaccTransCommitEdit( t ); return; } static void delete_template_trans(SchedXaction *sx) { GList *templ_acct_splits, *curr_split_listref; Split *curr_split; Transaction *split_trans; GList *templ_acct_transactions = NULL; templ_acct_splits = xaccAccountGetSplitList(sx->template_acct); for(curr_split_listref = templ_acct_splits; curr_split_listref; curr_split_listref = curr_split_listref->next) { curr_split = (Split *) curr_split_listref->data; split_trans = xaccSplitGetParent(curr_split); if(! (g_list_find(templ_acct_transactions, split_trans))) { templ_acct_transactions = g_list_prepend(templ_acct_transactions, split_trans); } } g_list_foreach(templ_acct_transactions, sxprivTransMapDelete, NULL); return; } void xaccSchedXactionFree( SchedXaction *sx ) { if ( sx == NULL ) return; xaccFreqSpecFree( sx->freq ); gnc_engine_generate_event( &sx->guid, GNC_EVENT_DESTROY ); xaccRemoveEntity( sx->entity_table, &sx->guid ); if ( sx->name ) g_free( sx->name ); /* * we have to delete the transactions in the * template account ourselves */ delete_template_trans( sx ); /* * xaccAccountDestroy removes the account from * its group for us AFAICT */ xaccAccountBeginEdit(sx->template_acct); xaccAccountDestroy(sx->template_acct); g_free( sx ); return; } FreqSpec * xaccSchedXactionGetFreqSpec( SchedXaction *sx ) { return sx->freq; } void xaccSchedXactionSetFreqSpec( SchedXaction *sx, FreqSpec *fs ) { g_return_if_fail( fs ); DEBUG("Called xaccSchedXactionSetFreqSpec"); xaccFreqSpecFree( sx->freq ); sx->freq = fs; sx->dirty = TRUE; } gchar * xaccSchedXactionGetName( SchedXaction *sx ) { return sx->name; } void xaccSchedXactionSetName( SchedXaction *sx, const gchar *newName ) { g_return_if_fail( newName != NULL ); if ( sx->name != NULL ) { g_free( sx->name ); sx->name = NULL; } sx->dirty = TRUE; sx->name = g_strdup( newName ); } GDate* xaccSchedXactionGetStartDate( SchedXaction *sx ) { return &sx->start_date; } void xaccSchedXactionSetStartDate( SchedXaction *sx, GDate* newStart ) { sx->start_date = *newStart; sx->dirty = TRUE; } gboolean xaccSchedXactionHasEndDate( SchedXaction *sx ) { return g_date_valid( &sx->end_date ); } GDate* xaccSchedXactionGetEndDate( SchedXaction *sx ) { return &sx->end_date; } void xaccSchedXactionSetEndDate( SchedXaction *sx, GDate *newEnd ) { if ( g_date_valid( newEnd ) ) { if ( g_date_compare( newEnd, &sx->start_date ) < 0 ) { /* XXX: I reject the bad data - is this the right * thing to do . * This warning is only human readable - the caller * doesn't know the call failed. This is bad */ PWARN( "New end date before start date" ); } else { sx->end_date = *newEnd; sx->dirty = TRUE; } } else { PWARN("New end date invalid"); } return; } GDate* xaccSchedXactionGetLastOccurDate( SchedXaction *sx ) { return &sx->last_date; } void xaccSchedXactionSetLastOccurDate( SchedXaction *sx, GDate* newLastOccur ) { sx->last_date = *newLastOccur; sx->dirty = TRUE; return; } gboolean xaccSchedXactionHasOccurDef( SchedXaction *sx ) { return ( xaccSchedXactionGetNumOccur( sx ) != 0 ); } gint xaccSchedXactionGetNumOccur( SchedXaction *sx ) { return sx->num_occurances_total; } void xaccSchedXactionSetNumOccur( SchedXaction *sx, gint newNum ) { sx->num_occurances_remain = sx->num_occurances_total = newNum; sx->dirty = TRUE; } gint xaccSchedXactionGetRemOccur( SchedXaction *sx ) { return sx->num_occurances_remain; } void xaccSchedXactionSetRemOccur( SchedXaction *sx, gint numRemain ) { /* FIXME This condition can be tightened up */ if ( numRemain > sx->num_occurances_total ) { PWARN("The number remaining is greater than the \ total occurrences"); } else { sx->num_occurances_remain = numRemain; sx->dirty = TRUE; } return; } kvp_value * xaccSchedXactionGetSlot( SchedXaction *sx, const char *slot ) { if (!sx) { return NULL; } return kvp_frame_get_slot(sx->kvp_data, slot); } void xaccSchedXactionSetSlot( SchedXaction *sx, const char *slot, const kvp_value *value ) { if (!sx) { return; } kvp_frame_set_slot( sx->kvp_data, slot, value ); sx->dirty = TRUE; return; } kvp_frame* xaccSchedXactionGetSlots( SchedXaction *sx ) { return sx->kvp_data; } void xaccSchedXactionSetSlots( SchedXaction *sx, kvp_frame *frm ) { sx->kvp_data = frm; sx->dirty = TRUE; } const GUID* xaccSchedXactionGetGUID( SchedXaction *sx ) { return &sx->guid; } void xaccSchedXactionSetGUID( SchedXaction *sx, GUID g ) { sx->guid = g; sx->dirty = TRUE; } void xaccSchedXactionGetAutoCreate( SchedXaction *sx, gboolean *outAutoCreate, gboolean *outNotify ) { *outAutoCreate = sx->autoCreateOption; *outNotify = sx->autoCreateNotify; return; } void xaccSchedXactionSetAutoCreate( SchedXaction *sx, gboolean newAutoCreate, gboolean newNotify ) { sx->autoCreateOption = newAutoCreate; sx->autoCreateNotify = newNotify; sx->dirty = TRUE; return; } gint xaccSchedXactionGetAdvanceCreation( SchedXaction *sx ) { return sx->advanceCreateDays; } void xaccSchedXactionSetAdvanceCreation( SchedXaction *sx, gint createDays ) { sx->advanceCreateDays = createDays; sx->dirty = TRUE; } gint xaccSchedXactionGetAdvanceReminder( SchedXaction *sx ) { return sx->advanceRemindDays; } void xaccSchedXactionSetAdvanceReminder( SchedXaction *sx, gint reminderDays ) { sx->dirty = TRUE; sx->advanceRemindDays = reminderDays; } /* FIXME: there is a bug in this, I think */ GDate xaccSchedXactionGetNextInstance( SchedXaction *sx, void *stateData ) { GDate last_occur, next_occur, tmpDate; g_date_clear( &last_occur, 1 ); g_date_clear( &next_occur, 1 ); g_date_clear( &tmpDate, 1 ); if ( g_date_valid( &sx->last_date ) ) { last_occur = sx->last_date; } if ( g_date_valid( &sx->start_date ) ) { if ( g_date_valid(&last_occur) ) { last_occur = ( g_date_compare( &last_occur, &sx->start_date ) > 0 ? last_occur : sx->start_date ); } else { last_occur = sx->start_date; } } if ( g_date_valid( &sx->start_date ) && ! g_date_valid( &sx->last_date ) ) { /* Think about this for a second, and you realize * that if the start date is _today_, we need a * last-occur date such that the 'next instance' is * after that date... one day should be good. * * This only holds for the first instance [read: if the * last[-occur]_date is invalid. */ g_date_subtract_days( &last_occur, 1 ); } xaccFreqSpecGetNextInstance( sx->freq, &last_occur, &next_occur ); /* out-of-bounds check */ if ( xaccSchedXactionHasEndDate( sx ) ) { GDate *end_date = xaccSchedXactionGetEndDate( sx ); if ( g_date_compare( &next_occur, end_date ) > 0 ) { PINFO( "next_occur past end date" ); g_date_clear( &next_occur, 1 ); } } else if ( xaccSchedXactionHasOccurDef( sx ) && stateData ) { /* FIXME: does this work? */ gint remaining; remaining = xaccSchedXactionGetRemOccur( sx ); if ( remaining == 0 ) { PINFO( "no more occurances remain" ); g_date_clear( &next_occur, 1 ); } } return next_occur; } GDate xaccSchedXactionGetInstanceAfter( SchedXaction *sx, GDate *date, void *stateData ) { GDate next_occur; xaccFreqSpecGetNextInstance( sx->freq, date, &next_occur ); if ( xaccSchedXactionHasEndDate( sx ) ) { GDate *end_date; end_date = xaccSchedXactionGetEndDate( sx ); if ( g_date_compare( &next_occur, end_date ) > 0 ) { PINFO( "next_occur past end_date" ); g_date_clear( &next_occur, 1 ); } } else if ( xaccSchedXactionHasOccurDef( sx ) && stateData ) { /* gint remaining = xaccSchedXactionGetRemOccur( sx ); */ gint *remaining = (gint*)stateData; DEBUG( "stateData [remaining]: %d", *remaining ); if ( (*remaining - 1) < 0 ) { PINFO( "next_occur is outside " "reminaing-instances window." ); g_date_clear( &next_occur, 1 ); } } return next_occur; } GList * xaccSchedXactionGetSplits( SchedXaction *sx ) { g_return_val_if_fail( sx, NULL ); return xaccAccountGetSplitList(sx->template_acct); } void xaccSchedXactionSetDirtyness( SchedXaction *sx, gboolean dirty_p) { sx->dirty = dirty_p; return; } gboolean xaccSchedXactionIsDirty(SchedXaction *sx) { return sx->dirty; } static Split * pack_split_info (TTSplitInfo *s_info, Account *parent_acct, Transaction *parent_trans, GNCSession *session) { Split *split; kvp_frame *split_frame, *sx_frame; kvp_value *tmp_value; const GUID *acc_guid; split = xaccMallocSplit(session); xaccSplitSetMemo(split, gnc_ttsplitinfo_get_memo(s_info)); xaccSplitSetAction(split, gnc_ttsplitinfo_get_action(s_info)); xaccAccountInsertSplit(parent_acct, split); split_frame = xaccSplitGetSlots(split); tmp_value = kvp_value_new_string(gnc_ttsplitinfo_get_credit_formula(s_info)); kvp_frame_set_slot_path(split_frame, tmp_value, GNC_SX_ID, GNC_SX_CREDIT_FORMULA, NULL); kvp_value_delete(tmp_value); tmp_value = kvp_value_new_string(gnc_ttsplitinfo_get_debit_formula(s_info)); kvp_frame_set_slot_path(split_frame, tmp_value, GNC_SX_ID, GNC_SX_DEBIT_FORMULA, NULL); kvp_value_delete(tmp_value); acc_guid = xaccAccountGetGUID(gnc_ttsplitinfo_get_account(s_info)); tmp_value = kvp_value_new_guid(acc_guid); kvp_frame_set_slot_path(split_frame, tmp_value, GNC_SX_ID, GNC_SX_ACCOUNT, NULL); kvp_value_delete(tmp_value); return split; } void xaccSchedXactionSetTemplateTrans(SchedXaction *sx, GList *t_t_list, GNCSession *session) { Transaction *new_trans; TTInfo *tti; TTSplitInfo *s_info; Split *new_split; GList *split_list; g_return_if_fail (session); /* delete any old transactions, if there are any */ delete_template_trans( sx ); for(;t_t_list != NULL; t_t_list = t_t_list->next) { tti = t_t_list->data; new_trans = xaccMallocTransaction(session); xaccTransBeginEdit(new_trans); xaccTransSetDescription(new_trans, gnc_ttinfo_get_description(tti)); xaccTransSetNum(new_trans, gnc_ttinfo_get_num(tti)); for(split_list = gnc_ttinfo_get_template_splits(tti); split_list; split_list = split_list->next) { s_info = split_list->data; new_split = pack_split_info(s_info, sx->template_acct, new_trans, session); xaccTransAppendSplit(new_trans, new_split); } xaccTransCommitEdit(new_trans); } } void* xaccSchedXactionCreateSequenceState( SchedXaction *sx ) { void *toRet = NULL; if ( xaccSchedXactionHasOccurDef( sx ) ) { toRet = g_new0( gint, 1 ); *(gint*)toRet = xaccSchedXactionGetRemOccur( sx ); DEBUG( "Returning state data [remaining]: %d", *(gint*)toRet ); } else { DEBUG( "Returning null state data" ); } return toRet; } void xaccSchedXactionIncrSequenceState( SchedXaction *sx, void *stateData ) { if ( xaccSchedXactionHasOccurDef( sx ) ) { gint *remaining; remaining = (gint*)stateData; *remaining = *remaining - 1; } } void xaccSchedXactionDestroySequenceState( SchedXaction *sx, void *stateData ) { if ( xaccSchedXactionHasOccurDef( sx ) ) { g_free( (gint*)stateData ); } }