Scheduled Transactions provide a framework for remembering information about a transactions that are set to occur in the future, either once or periodically. More...

Files
file	FreqSpec.h
	Period / Date Frequency Specification.

file	SchedXaction.h
	Scheduled Transactions public handling routines.

file	SX-book.h
	Anchor Scheduled Transaction info in a book.

Data Structures
struct	SchedXaction
	A single scheduled transaction. More...

struct	SchedXactionClass

struct	SXTmpStateData
	Just the variable temporal bits from the SX structure. More...

struct	SchedXactions

struct	SchedXactionsClass

Macros
#define	ENUM_LIST_TYPE(_)

#define	ENUM_LIST_UI(_)

#define	GNC_TYPE_SCHEDXACTION (gnc_schedxaction_get_type ())

#define	GNC_SCHEDXACTION(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GNC_TYPE_SCHEDXACTION, SchedXaction))

#define	GNC_SCHEDXACTION_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GNC_TYPE_SCHEDXACTION, SchedXactionClass))

#define	GNC_IS_SCHEDXACTION(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GNC_TYPE_SCHEDXACTION))

#define	GNC_IS_SCHEDXACTION_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GNC_TYPE_SCHEDXACTION))

#define	GNC_SCHEDXACTION_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GNC_TYPE_SCHEDXACTION, SchedXactionClass))

#define	GNC_IS_SX(obj) GNC_IS_SCHEDXACTION(obj)

#define	GNC_SX(obj) GNC_SCHEDXACTION(obj)

#define	xaccSchedXactionSetGUID(X, G) qof_instance_set_guid(QOF_INSTANCE(X),(G))

#define	GNC_SX_SHARES "shares"

#define	GNC_SX_FREQ_SPEC "scheduled-frequency"

#define	GNC_SX_NAME "sched-xname"

#define	GNC_SX_START_DATE "sched-start-date"

#define	GNC_SX_LAST_DATE "sched-last-date"

#define	GNC_SX_NUM_OCCUR "sx-total-number"

#define	GNC_SX_REM_OCCUR "sx-remaining-num"

#define	xaccSchedXactionIsDirty(X) qof_instance_is_dirty (QOF_INSTANCE(X))

#define	xaccSchedXactionGetGUID(X) qof_entity_get_guid(QOF_INSTANCE(X))

#define	GNC_TYPE_SCHEDXACTIONS (gnc_schedxactions_get_type ())

#define	GNC_SCHEDXACTIONS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GNC_TYPE_SCHEDXACTIONS, SchedXactions))

#define	GNC_SCHEDXACTIONS_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GNC_TYPE_SCHEDXACTIONS, SchedXactionsClass))

#define	GNC_IS_SCHEDXACTIONS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GNC_TYPE_SCHEDXACTIONS))

#define	GNC_IS_SCHEDXACTIONS_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GNC_TYPE_SCHEDXACTIONS))

#define	GNC_SCHEDXACTIONS_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GNC_TYPE_SCHEDXACTIONS, SchedXactionsClass))

#define	GNC_IS_SXES(obj) GNC_IS_SCHEDXACTIONS(obj)

#define	GNC_SXES(obj) GNC_SCHEDXACTIONS(obj)

Enumerations
enum	FreqType { INVALID, ONCE, DAILY, WEEKLY, MONTHLY, MONTH_RELATIVE, COMPOSITE }
	Frequency specification. More...

enum	UIFreqType { UIFREQ_NONE, UIFREQ_ONCE, UIFREQ_DAILY, UIFREQ_DAILY_MF, UIFREQ_WEEKLY, UIFREQ_BI_WEEKLY, UIFREQ_SEMI_MONTHLY, UIFREQ_MONTHLY, UIFREQ_QUARTERLY, UIFREQ_TRI_ANUALLY, UIFREQ_SEMI_YEARLY, UIFREQ_YEARLY, UIFREQ_NUM_UI_FREQSPECS }
	The user's conception of the frequency. More...

Functions
GType	gnc_schedxaction_get_type (void)

SchedXaction *	xaccSchedXactionMalloc (QofBook *book)
	Creates and initializes a scheduled transaction.

void	sx_set_template_account (SchedXaction sx, Account account)

void	xaccSchedXactionDestroy (SchedXaction *sx)
	Cleans up and frees a SchedXaction and its associated data.

void	gnc_sx_begin_edit (SchedXaction *sx)

void	gnc_sx_commit_edit (SchedXaction *sx)

GList *	gnc_sx_get_schedule (const SchedXaction *sx)

void	gnc_sx_set_schedule (SchedXaction sx, GList schedule)

gchar *	xaccSchedXactionGetName (const SchedXaction *sx)

void	xaccSchedXactionSetName (SchedXaction sx, const gchar newName)
	A copy of the name is made.

const GDate *	xaccSchedXactionGetStartDate (const SchedXaction *sx)

time64	xaccSchedXactionGetStartDateTT (const SchedXaction *sx)

void	xaccSchedXactionSetStartDate (SchedXaction sx, const GDate newStart)

void	xaccSchedXactionSetStartDateTT (SchedXaction *sx, const time64 newStart)

int	xaccSchedXactionHasEndDate (const SchedXaction *sx)

const GDate *	xaccSchedXactionGetEndDate (const SchedXaction *sx)
	Returns invalid date when there is no end-date specified.

void	xaccSchedXactionSetEndDate (SchedXaction sx, const GDate newEnd)
	Set to an invalid GDate to turn off 'end-date' definition.

const GDate *	xaccSchedXactionGetLastOccurDate (const SchedXaction *sx)

time64	xaccSchedXactionGetLastOccurDateTT (const SchedXaction *sx)

void	xaccSchedXactionSetLastOccurDate (SchedXaction sx, const GDate newLastOccur)

void	xaccSchedXactionSetLastOccurDateTT (SchedXaction *sx, const time64 newLastOccur)

gboolean	xaccSchedXactionHasOccurDef (const SchedXaction *sx)
	Returns true if the scheduled transaction has a defined number of occurrences, false if not.

gint	xaccSchedXactionGetNumOccur (const SchedXaction *sx)

void	xaccSchedXactionSetNumOccur (SchedXaction *sx, gint numNum)
	Set to '0' to turn off number-of-occurrences definition.

gint	xaccSchedXactionGetRemOccur (const SchedXaction *sx)

void	xaccSchedXactionSetRemOccur (SchedXaction *sx, gint numRemain)

gint	gnc_sx_get_num_occur_daterange (const SchedXaction sx, const GDate start_date, const GDate *end_date)
	Calculates and returns the number of occurrences of the given SX in the given date range (inclusive). More...

gint	gnc_sx_get_instance_count (const SchedXaction sx, SXTmpStateData stateData)
	Get the instance count. More...

void	gnc_sx_set_instance_count (SchedXaction *sx, gint instanceNum)
	Sets the instance count to something other than the default. More...

GList *	xaccSchedXactionGetSplits (const SchedXaction *sx)

void	xaccSchedXactionSetSplits (SchedXaction sx, GList newSplits)

gboolean	xaccSchedXactionGetEnabled (const SchedXaction *sx)

void	xaccSchedXactionSetEnabled (SchedXaction *sx, gboolean newEnabled)

void	xaccSchedXactionGetAutoCreate (const SchedXaction sx, gboolean outAutoCreate, gboolean *outNotify)

void	xaccSchedXactionSetAutoCreate (SchedXaction *sx, gboolean newAutoCreate, gboolean newNotify)

gint	xaccSchedXactionGetAdvanceCreation (const SchedXaction *sx)

void	xaccSchedXactionSetAdvanceCreation (SchedXaction *sx, gint createDays)

gint	xaccSchedXactionGetAdvanceReminder (const SchedXaction *sx)

void	xaccSchedXactionSetAdvanceReminder (SchedXaction *sx, gint reminderDays)

GDate	xaccSchedXactionGetNextInstance (const SchedXaction sx, SXTmpStateData stateData)
	Returns the next occurrence of a scheduled transaction. More...

void	xaccSchedXactionSetTemplateTrans (SchedXaction sx, GList t_t_list, QofBook *book)
	Set the schedxaction's template transaction. More...

void	gnc_sx_add_defer_instance (SchedXaction sx, void deferStateData)
	Adds an instance to the deferred list of the SX. More...

void	gnc_sx_remove_defer_instance (SchedXaction sx, void deferStateData)
	Removes an instance from the deferred list. More...

GList *	gnc_sx_get_defer_instances (SchedXaction *sx)
	Returns the defer list from the SX. More...

gboolean	SXRegister (void)
	QOF registration. More...

GType	gnc_schedxactions_get_type (void)

SchedXactions *	gnc_book_get_schedxactions (QofBook *book)

void	gnc_sxes_add_sx (SchedXactions sxes, SchedXaction sx)

void	gnc_sxes_del_sx (SchedXactions sxes, SchedXaction sx)

Account *	gnc_book_get_template_root (const QofBook *book)
	Returns the template group from the book. More...

GList *	gnc_sx_get_sxes_referencing_account (QofBook book, Account acct)

Temporal state data.
These functions allow us to opaquely save the entire temporal state of ScheduledTransactions. This is used by the "since-last-run" dialog to store the initial state of SXes before modification ... if it later becomes necessary to revert an entire set of changes, we can 'revert' the SX without having to rollback all the individual state changes.
SXTmpStateData *	gnc_sx_create_temporal_state (const SchedXaction *sx)
	Allocates a new SXTmpStateData object and fills it with the current state of the given sx.

void	gnc_sx_incr_temporal_state (const SchedXaction sx, SXTmpStateData stateData)
	Calculates the next occurrence of the given SX and stores that occurrence in the remporalStateDate. More...

void	gnc_sx_destroy_temporal_state (SXTmpStateData *stateData)
	Frees the given stateDate object. More...

SXTmpStateData *	gnc_sx_clone_temporal_state (SXTmpStateData *stateData)
	Allocates and returns a one-by-one copy of the given temporal state. More...

Detailed Description

Scheduled Transactions provide a framework for remembering information about a transactions that are set to occur in the future, either once or periodically.

Macro Definition Documentation

◆ ENUM_LIST_TYPE

#define ENUM_LIST_TYPE ( _ )

Value:

_(INVALID,) \
        _(ONCE,) \
        _(DAILY,) \
        _(WEEKLY,)  \
        _(MONTHLY,) \
        _(MONTH_RELATIVE,) \
        _(COMPOSITE,)

Definition at line 34 of file FreqSpec.h.

◆ ENUM_LIST_UI

#define ENUM_LIST_UI ( _ )

Value:

_(UIFREQ_NONE,)  \
        _(UIFREQ_ONCE,)  \
        _(UIFREQ_DAILY,)  \
        _(UIFREQ_DAILY_MF,)  \
        _(UIFREQ_WEEKLY,)  \
        _(UIFREQ_BI_WEEKLY,)  \
        _(UIFREQ_SEMI_MONTHLY,)  \
        _(UIFREQ_MONTHLY,)  \
        _(UIFREQ_QUARTERLY,)  \
        _(UIFREQ_TRI_ANUALLY,)  \
        _(UIFREQ_SEMI_YEARLY,)  \
        _(UIFREQ_YEARLY,)  \
        _(UIFREQ_NUM_UI_FREQSPECS,)

Definition at line 53 of file FreqSpec.h.

◆ xaccSchedXactionGetGUID

#define xaccSchedXactionGetGUID ( X ) qof_entity_get_guid(QOF_INSTANCE(X))

Deprecated:

Definition at line 328 of file SchedXaction.h.

◆ xaccSchedXactionIsDirty

#define xaccSchedXactionIsDirty ( X ) qof_instance_is_dirty (QOF_INSTANCE(X))

Deprecated:

Definition at line 326 of file SchedXaction.h.

Enumeration Type Documentation

◆ FreqType

enum FreqType

Frequency specification.

For BI_WEEKLY, use weekly[2] SEMI_MONTHLY, use composite YEARLY, monthly[12]

Enumerator

WEEKLY

Hmmm...

This is sort of DAILY[7]...

Definition at line 43 of file FreqSpec.h.

◆ UIFreqType

enum UIFreqType

The user's conception of the frequency.

It is expected that this list will grow, while the former FreqType will not.

Enumerator
UIFREQ_NONE	no frequency
UIFREQ_ONCE	Just occurs once.
UIFREQ_DAILY	Repeat every day.
UIFREQ_DAILY_MF	Repeat Monday to Friday, skip weekend.
UIFREQ_WEEKLY	Repeat once each week.
UIFREQ_BI_WEEKLY	Repeat twice a week.
UIFREQ_SEMI_MONTHLY	Repeat twice a month.
UIFREQ_MONTHLY	Repeat once a month.
UIFREQ_QUARTERLY	Repeat every quarter.
UIFREQ_TRI_ANUALLY	Repeat three times a year.
UIFREQ_SEMI_YEARLY	Repeat twice a year.
UIFREQ_YEARLY	Repeat once a year.

Definition at line 68 of file FreqSpec.h.

Function Documentation

◆ gnc_book_get_template_root()

Account* gnc_book_get_template_root ( const QofBook * book )

Returns the template group from the book.

Definition at line 65 of file SX-book.c.

 {
     QofCollection *col;
     if (!book) return NULL;
     col = qof_book_get_collection (book, GNC_ID_SXTG);
     return gnc_collection_get_template_root (col);
 }

◆ gnc_sx_add_defer_instance()

void gnc_sx_add_defer_instance	(	SchedXaction *	sx,
		void *	deferStateData
	)

Adds an instance to the deferred list of the SX.

Added instances are added in date-sorted order.

Added instances are added in (date-)sorted order.

Definition at line 1152 of file SchedXaction.c.

 {
     sx->deferredList = g_list_insert_sorted( sx->deferredList,
                        deferStateData,
                        _temporal_state_data_cmp );
 }

◆ gnc_sx_clone_temporal_state()

SXTmpStateData* gnc_sx_clone_temporal_state ( SXTmpStateData * stateData )

Allocates and returns a one-by-one copy of the given temporal state.

The caller must destroy the returned object with gnc_sx_destroy_temporal_state() after usage.

Definition at line 1116 of file SchedXaction.c.

 {
     SXTmpStateData *toRet = NULL;
 
     if(tsd)
     {
         toRet = g_new(SXTmpStateData, 1);
         *toRet = *tsd;
     }
 
     return toRet;
 }

◆ gnc_sx_destroy_temporal_state()

void gnc_sx_destroy_temporal_state ( SXTmpStateData * stateData )

Frees the given stateDate object.

Definition at line 1110 of file SchedXaction.c.

 {
     g_free(tsd);
 }

◆ gnc_sx_get_defer_instances()

GList* gnc_sx_get_defer_instances ( SchedXaction * sx )

Returns the defer list from the SX.

This is a date-sorted state-data instance list. The list should not be modified by the caller; use the gnc_sx_{add,remove}_defer_instance() functions to modify the list.

Returns the defer list from the SX.

The list should not be modified by the caller; use the gnc_sx_{add,remove}_defer_instance() functions to modify the list.

Parameters

sx	Scheduled transaction

Returns: Defer list which must not be modified by the caller

Definition at line 1190 of file SchedXaction.c.

 {
     return sx->deferredList;
 }

◆ gnc_sx_get_instance_count()

gint gnc_sx_get_instance_count	(	const SchedXaction *	sx,
		SXTmpStateData *	stateData
	)

Get the instance count.

This is incremented by one for every created instance of the SX. Returns the instance num of the SX unless stateData is non-null, in which case it returns the instance num from the state data.

Parameters

sx	The instance whose state should be retrieved.
stateData	may be NULL.

Definition at line 962 of file SchedXaction.c.

 {
     gint toRet = -1;
     SXTmpStateData *tsd;
 
     if ( stateData )
     {
         tsd = (SXTmpStateData*)stateData;
         toRet = tsd->num_inst;
     }
     else
     {
         toRet = sx->instance_num;
     }
 
     return toRet;
 }

◆ gnc_sx_get_num_occur_daterange()

gint gnc_sx_get_num_occur_daterange	(	const SchedXaction *	sx,
		const GDate *	start_date,
		const GDate *	end_date
	)

Calculates and returns the number of occurrences of the given SX in the given date range (inclusive).

Definition at line 772 of file SchedXaction.c.

 {
     gint result = 0;
     SXTmpStateData *tmpState;
     gboolean countFirstDate;
 
     /* SX still active? If not, return now. */
     if ((xaccSchedXactionHasOccurDef(sx)
             && xaccSchedXactionGetRemOccur(sx) <= 0)
             || (xaccSchedXactionHasEndDate(sx)
                 && g_date_compare(xaccSchedXactionGetEndDate(sx), start_date) < 0))
     {
         return result;
     }
 
     tmpState = gnc_sx_create_temporal_state (sx);
 
     /* Should we count the first valid date we encounter? Only if the
      * SX has not yet occurred so far, or if its last valid date was
      * before the start date. */
     countFirstDate = !g_date_valid(&tmpState->last_date)
                      || (g_date_compare(&tmpState->last_date, start_date) < 0);
 
     /* No valid date? SX has never occurred so far. */
     if (!g_date_valid(&tmpState->last_date))
     {
         /* SX has never occurred so far */
         gnc_sx_incr_temporal_state (sx, tmpState);
         if (xaccSchedXactionHasOccurDef(sx) && tmpState->num_occur_rem < 0)
         {
             gnc_sx_destroy_temporal_state (tmpState);
             return result;
         }
     }
 
     /* Increase the tmpState until we are in our interval of
      * interest. Only calculate anything if the sx hasn't already
      * ended. */
     while (g_date_compare(&tmpState->last_date, start_date) < 0)
     {
         gnc_sx_incr_temporal_state (sx, tmpState);
         if (xaccSchedXactionHasOccurDef(sx) && tmpState->num_occur_rem < 0)
         {
             gnc_sx_destroy_temporal_state (tmpState);
             return result;
         }
     }
 
     /* Now we are in our interval of interest. Increment the
      * occurrence date until we are beyond the end of our
      * interval. Make sure to check for invalid dates here: It means
      * the SX has ended. */
     while (g_date_valid(&tmpState->last_date)
             && (g_date_compare(&tmpState->last_date, end_date) <= 0)
             && (!xaccSchedXactionHasEndDate(sx)
                 || g_date_compare(&tmpState->last_date, xaccSchedXactionGetEndDate(sx)) <= 0)
             && (!xaccSchedXactionHasOccurDef(sx)
                 /* The >=0 (i.e. the ==) is important here, otherwise
                  * we miss the last valid occurrence of a SX which is
                  * limited by num_occur */
                 || tmpState->num_occur_rem >= 0))
     {
         ++result;
         gnc_sx_incr_temporal_state (sx, tmpState);
     }
 
     /* If the first valid date shouldn't be counted, decrease the
      * result number by one. */
     if (!countFirstDate && result > 0)
         --result;
 
     gnc_sx_destroy_temporal_state (tmpState);
     return result;
 }

◆ gnc_sx_get_schedule()

GList* gnc_sx_get_schedule ( const SchedXaction * sx )

Returns: GList<Recurrence*>

Definition at line 557 of file SchedXaction.c.

 {
     return sx->schedule;
 }

◆ gnc_sx_get_sxes_referencing_account()

GList* gnc_sx_get_sxes_referencing_account	(	QofBook *	book,
		Account *	acct
	)

Returns: The list of SXes which reference the given Account. Caller should free this list.

Definition at line 367 of file SX-book.c.

 {
     GList *rtn = NULL;
     const GncGUID *acct_guid = qof_entity_get_guid(QOF_INSTANCE(acct));
     GList *sx_list;
     SchedXactions *sxactions = gnc_book_get_schedxactions(book);
     g_return_val_if_fail( sxactions != NULL, rtn);
     for (sx_list = sxactions->sx_list; sx_list != NULL; sx_list = sx_list->next)
     {
         SchedXaction *sx = (SchedXaction*)sx_list->data;
         GList *splits = xaccSchedXactionGetSplits(sx);
         for (GList *node = splits; node; node = node->next)
         {
             Split *s = (Split*)node->data;
             GncGUID *guid = NULL;
             qof_instance_get (QOF_INSTANCE (s), "sx-account", &guid, NULL);
             if (guid_equal(acct_guid, guid))
                 rtn = g_list_prepend (rtn, sx);
 
             guid_free (guid);
         }
         g_list_free (splits);
     }
     return g_list_reverse (rtn);
 }

◆ gnc_sx_incr_temporal_state()

void gnc_sx_incr_temporal_state	(	const SchedXaction *	sx,
		SXTmpStateData *	stateData
	)

Calculates the next occurrence of the given SX and stores that occurrence in the remporalStateDate.

The SX is unchanged.

Definition at line 1098 of file SchedXaction.c.

 {
     g_return_if_fail(tsd != NULL);
     tsd->last_date = xaccSchedXactionGetNextInstance (sx, tsd);
     if (xaccSchedXactionHasOccurDef (sx))
     {
         --tsd->num_occur_rem;
     }
     ++tsd->num_inst;
 }

◆ gnc_sx_remove_defer_instance()

void gnc_sx_remove_defer_instance	(	SchedXaction *	sx,
		void *	deferStateData
	)

Removes an instance from the deferred list.

If the instance is no longer useful; gnc_sx_destroy_temporal_state() it.

The saved SXTmpStateData existed for comparison only, so destroy it.

Definition at line 1164 of file SchedXaction.c.

 {
     GList *found_by_value;
 
     found_by_value = g_list_find_custom(
                          sx->deferredList, deferStateData, _temporal_state_data_cmp);
     if (found_by_value == NULL)
     {
         g_warning("unable to find deferred instance");
         return;
     }
 
     gnc_sx_destroy_temporal_state(found_by_value->data);
     sx->deferredList = g_list_delete_link(sx->deferredList, found_by_value);
 }

◆ gnc_sx_set_instance_count()

void gnc_sx_set_instance_count	(	SchedXaction *	sx,
		gint	instanceNum
	)

Sets the instance count to something other than the default.

As the default is the incorrect value '0', callers should DTRT here.

Definition at line 981 of file SchedXaction.c.

 {
     g_return_if_fail(sx);
     if (sx->instance_num == instance_num)
         return;
     gnc_sx_begin_edit(sx);
     sx->instance_num = instance_num;
     qof_instance_set_dirty(&sx->inst);
     gnc_sx_commit_edit(sx);
 }

◆ gnc_sx_set_schedule()

void gnc_sx_set_schedule	(	SchedXaction *	sx,
		GList *	schedule
	)

Parameters

[in] schedule A GList<Recurrence*>

Definition at line 563 of file SchedXaction.c.

 {
     g_return_if_fail(sx);
     gnc_sx_begin_edit(sx);
     sx->schedule = schedule;
     qof_instance_set_dirty(&sx->inst);
     gnc_sx_commit_edit(sx);
 }

◆ SXRegister()

gboolean SXRegister ( void )

QOF registration.

Definition at line 1244 of file SchedXaction.c.

 {
     static QofParam params[] =
     {
         {
             GNC_SX_NAME, QOF_TYPE_STRING, (QofAccessFunc)xaccSchedXactionGetName,
             (QofSetterFunc)xaccSchedXactionSetName
         },
         {
             GNC_SX_START_DATE, QOF_TYPE_DATE, (QofAccessFunc)xaccSchedXactionGetStartDateTT,
             (QofSetterFunc)xaccSchedXactionSetStartDateTT
         },
         {
             GNC_SX_LAST_DATE, QOF_TYPE_DATE, (QofAccessFunc)xaccSchedXactionGetLastOccurDateTT,
             (QofSetterFunc)xaccSchedXactionSetLastOccurDateTT
         },
         {
             GNC_SX_NUM_OCCUR, QOF_TYPE_INT64, (QofAccessFunc)xaccSchedXactionGetNumOccur,
             (QofSetterFunc)xaccSchedXactionSetNumOccur
         },
         {
             GNC_SX_REM_OCCUR, QOF_TYPE_INT64, (QofAccessFunc)xaccSchedXactionGetRemOccur,
             (QofSetterFunc)xaccSchedXactionSetRemOccur
         },
         { QOF_PARAM_BOOK, QOF_ID_BOOK, (QofAccessFunc)qof_instance_get_book, NULL },
         { QOF_PARAM_GUID, QOF_TYPE_GUID, (QofAccessFunc)qof_instance_get_guid, NULL },
         { NULL },
     };
     qof_class_register(GNC_SX_ID, NULL, params);
     return qof_object_register(&SXDesc);
 }

◆ xaccSchedXactionGetNextInstance()

GDate xaccSchedXactionGetNextInstance	(	const SchedXaction *	sx,
		SXTmpStateData *	stateData
	)

Returns the next occurrence of a scheduled transaction.

If the transaction hasn't occurred, then it's based off the start date. Otherwise, it's based off the last-occurrence date.

If state data is NULL, the current value of the SX is used for computation. Otherwise, the values in the state data are used. This allows the caller to correctly create a set of instances into the future for possible action without modifying the SX state until action is actually taken.

Definition at line 919 of file SchedXaction.c.

 {
     GDate prev_occur, next_occur;
 
     g_date_clear( &prev_occur, 1 );
     if ( tsd != NULL )
         prev_occur = tsd->last_date;
 
     /* If prev_occur is in the "cleared" state and sx->start_date isn't, then
      * we're at the beginning. We want to pretend prev_occur is the day before
      * the start_date in case the start_date is today so that the SX will fire
      * today. If start_date isn't valid either then the SX will fire anyway, no
      * harm done. prev_occur cannot be before start_date either.
      */
     if (g_date_valid (&sx->start_date) && (!g_date_valid ( &prev_occur ) || g_date_compare (&prev_occur, &sx->start_date)<0))
     {
         /* We must be at the beginning. */
         prev_occur = sx->start_date;
         g_date_subtract_days (&prev_occur, 1 );
     }
 
     recurrenceListNextInstance(sx->schedule, &prev_occur, &next_occur);
 
     if ( xaccSchedXactionHasEndDate( sx ) )
     {
         const GDate *end_date = xaccSchedXactionGetEndDate( sx );
         if ( g_date_compare( &next_occur, end_date ) > 0 )
         {
             g_date_clear( &next_occur, 1 );
         }
     }
     else if ( xaccSchedXactionHasOccurDef( sx ) )
     {
         if ((tsd && tsd->num_occur_rem == 0) ||
             (!tsd && sx->num_occurances_remain == 0 ))
         {
             g_date_clear( &next_occur, 1 );
         }
     }
     return next_occur;
 }

◆ xaccSchedXactionSetTemplateTrans()

void xaccSchedXactionSetTemplateTrans	(	SchedXaction *	sx,
		GList *	t_t_list,
		QofBook *	book
	)

Set the schedxaction's template transaction.

t_t_list is a glist of TTInfo's as defined in SX-ttinfo.h. The edit dialog doesn't use this mechanism; maybe it should.

Definition at line 1035 of file SchedXaction.c.

 {
     Transaction *new_trans;
     TTInfo *tti;
     TTSplitInfo *s_info;
     Split *new_split;
     GList *split_list;
 
     g_return_if_fail (book);
 
     /* 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(book);
 
         xaccTransBeginEdit(new_trans);
 
         xaccTransSetDescription(new_trans,
                                 gnc_ttinfo_get_description(tti));
 
         xaccTransSetDatePostedSecsNormalized(new_trans, gnc_time (NULL));
 
         /* Set tran-num with gnc_set_num_action which is the same as
          * xaccTransSetNum with these arguments */
         gnc_set_num_action(new_trans, NULL,
                         gnc_ttinfo_get_num(tti), NULL);
         xaccTransSetNotes (new_trans, gnc_ttinfo_get_notes (tti));
         xaccTransSetCurrency( new_trans,
                               gnc_ttinfo_get_currency(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, book);
             xaccTransAppendSplit(new_trans, new_split);
         }
         xaccTransCommitEdit(new_trans);
     }
 }

Files

Data Structures

Macros

Enumerations

Functions

Temporal state data.

Detailed Description

Macro Definition Documentation

◆ ENUM_LIST_TYPE

◆ ENUM_LIST_UI

◆ xaccSchedXactionGetGUID

◆ xaccSchedXactionIsDirty

Enumeration Type Documentation

◆ FreqType

◆ UIFreqType

Function Documentation

◆ gnc_book_get_template_root()

◆ gnc_sx_add_defer_instance()

◆ gnc_sx_clone_temporal_state()

◆ gnc_sx_destroy_temporal_state()

◆ gnc_sx_get_defer_instances()

◆ gnc_sx_get_instance_count()

◆ gnc_sx_get_num_occur_daterange()

◆ gnc_sx_get_schedule()

◆ gnc_sx_get_sxes_referencing_account()

◆ gnc_sx_incr_temporal_state()

◆ gnc_sx_remove_defer_instance()

◆ gnc_sx_set_instance_count()

◆ gnc_sx_set_schedule()

◆ SXRegister()

◆ xaccSchedXactionGetNextInstance()

◆ xaccSchedXactionSetTemplateTrans()