GnuCash  2.6.99
Files | Data Structures | Macros | Functions
Scheduled/Periodic/Recurring Transactions

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 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)
 

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)
 
void xaccSchedXactionSetStartDate (SchedXaction *sx, const GDate *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)
 
void xaccSchedXactionSetLastOccurDate (SchedXaction *sx, const GDate *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)
 
Accountgnc_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.

SXTmpStateDatagnc_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 occurence in the remporalStateDate. More...
 
void gnc_sx_destroy_temporal_state (SXTmpStateData *stateData)
 Frees the given stateDate object. More...
 
SXTmpStateDatagnc_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.

◆ xaccSchedXactionGetGUID

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

Definition at line 319 of file SchedXaction.h.

◆ xaccSchedXactionIsDirty

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

Definition at line 317 of file SchedXaction.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.

66 {
67  QofCollection *col;
68  if (!book) return NULL;
69  col = qof_book_get_collection (book, GNC_ID_SXTG);
70  return gnc_collection_get_template_root (col);
71 }
QofCollection * qof_book_get_collection(const QofBook *book, QofIdType entity_type)
Return The table of entities of the given type.
Definition: qofbook.cpp:599

◆ 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 1101 of file SchedXaction.c.

1102 {
1103  sx->deferredList = g_list_insert_sorted( sx->deferredList,
1104  deferStateData,
1105  _temporal_state_data_cmp );
1106 }

◆ 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 1071 of file SchedXaction.c.

1072 {
1073  SXTmpStateData *toRet;
1074  toRet = g_memdup (tsd, sizeof (SXTmpStateData));
1075  return toRet;
1076 }
Just the variable temporal bits from the SX structure.
Definition: SchedXaction.h:127

◆ gnc_sx_destroy_temporal_state()

void gnc_sx_destroy_temporal_state ( SXTmpStateData stateData)

Frees the given stateDate object.

Definition at line 1065 of file SchedXaction.c.

1066 {
1067  g_free(tsd);
1068 }

◆ 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 modifiy the list.

Parameters
sxScheduled transaction
Returns
Defer list which must not be modified by the caller

Definition at line 1139 of file SchedXaction.c.

1140 {
1141  return sx->deferredList;
1142 }

◆ 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
sxThe instance whose state should be retrieved.
stateDatamay be NULL.

Definition at line 917 of file SchedXaction.c.

918 {
919  gint toRet = -1;
920  SXTmpStateData *tsd;
921 
922  if ( stateData )
923  {
924  tsd = (SXTmpStateData*)stateData;
925  toRet = tsd->num_inst;
926  }
927  else
928  {
929  toRet = sx->instance_num;
930  }
931 
932  return toRet;
933 }
Just the variable temporal bits from the SX structure.
Definition: SchedXaction.h:127

◆ 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 727 of file SchedXaction.c.

728 {
729  gint result = 0;
730  SXTmpStateData *tmpState;
731  gboolean countFirstDate;
732 
733  /* SX still active? If not, return now. */
735  && xaccSchedXactionGetRemOccur(sx) <= 0)
736  || (xaccSchedXactionHasEndDate(sx)
737  && g_date_compare(xaccSchedXactionGetEndDate(sx), start_date) < 0))
738  {
739  return result;
740  }
741 
742  tmpState = gnc_sx_create_temporal_state (sx);
743 
744  /* Should we count the first valid date we encounter? Only if the
745  * SX has not yet occurred so far, or if its last valid date was
746  * before the start date. */
747  countFirstDate = !g_date_valid(&tmpState->last_date)
748  || (g_date_compare(&tmpState->last_date, start_date) < 0);
749 
750  /* No valid date? SX has never occurred so far. */
751  if (!g_date_valid(&tmpState->last_date))
752  {
753  /* SX has never occurred so far */
754  gnc_sx_incr_temporal_state (sx, tmpState);
755  if (xaccSchedXactionHasOccurDef(sx) && tmpState->num_occur_rem < 0)
756  {
758  return result;
759  }
760  }
761 
762  /* Increase the tmpState until we are in our interval of
763  * interest. Only calculate anything if the sx hasn't already
764  * ended. */
765  while (g_date_compare(&tmpState->last_date, start_date) < 0)
766  {
767  gnc_sx_incr_temporal_state (sx, tmpState);
768  if (xaccSchedXactionHasOccurDef(sx) && tmpState->num_occur_rem < 0)
769  {
771  return result;
772  }
773  }
774 
775  /* Now we are in our interval of interest. Increment the
776  * occurrence date until we are beyond the end of our
777  * interval. Make sure to check for invalid dates here: It means
778  * the SX has ended. */
779  while (g_date_valid(&tmpState->last_date)
780  && (g_date_compare(&tmpState->last_date, end_date) <= 0)
781  && (!xaccSchedXactionHasEndDate(sx)
782  || g_date_compare(&tmpState->last_date, xaccSchedXactionGetEndDate(sx)) <= 0)
784  /* The >=0 (i.e. the ==) is important here, otherwise
785  * we miss the last valid occurrence of a SX which is
786  * limited by num_occur */
787  || tmpState->num_occur_rem >= 0))
788  {
789  ++result;
790  gnc_sx_incr_temporal_state (sx, tmpState);
791  }
792 
793  /* If the first valid date shouldn't be counted, decrease the
794  * result number by one. */
795  if (!countFirstDate && result > 0)
796  --result;
797 
799  return result;
800 }
const GDate * xaccSchedXactionGetEndDate(const SchedXaction *sx)
Returns invalid date when there is no end-date specified.
Definition: SchedXaction.c:628
void gnc_sx_destroy_temporal_state(SXTmpStateData *tsd)
Frees the given stateDate object.
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...
Just the variable temporal bits from the SX structure.
Definition: SchedXaction.h:127
void gnc_sx_incr_temporal_state(const SchedXaction *sx, SXTmpStateData *tsd)
Calculates the next occurrence of the given SX and stores that occurence in the remporalStateDate.
gboolean xaccSchedXactionHasOccurDef(const SchedXaction *sx)
Returns true if the scheduled transaction has a defined number of occurrences, false if not...
Definition: SchedXaction.c:679

◆ gnc_sx_get_schedule()

GList* gnc_sx_get_schedule ( const SchedXaction *  sx)
Returns
GList<Recurrence*>

Definition at line 559 of file SchedXaction.c.

560 {
561  return sx->schedule;
562 }

◆ 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 366 of file SX-book.c.

367 {
368  GList *rtn = NULL;
369  const GncGUID *acct_guid = qof_entity_get_guid(QOF_INSTANCE(acct));
370  GList *sx_list;
371  SchedXactions *sxactions = gnc_book_get_schedxactions(book);
372  g_return_val_if_fail( sxactions != NULL, rtn);
373  for (sx_list = sxactions->sx_list; sx_list != NULL; sx_list = sx_list->next)
374  {
375  SchedXaction *sx = (SchedXaction*)sx_list->data;
376  GList *splits = xaccSchedXactionGetSplits(sx);
377  for (; splits != NULL; splits = splits->next)
378  {
379  Split *s = (Split*)splits->data;
380  GncGUID *guid = NULL;
381  qof_instance_get (QOF_INSTANCE (s), "sx-account", &guid, NULL);
382  if (guid_equal(acct_guid, guid))
383  {
384  rtn = g_list_append(rtn, sx);
385  }
386  }
387  }
388  return rtn;
389 }
void qof_instance_get(const QofInstance *inst, const gchar *first_prop,...)
Wrapper for g_object_get.
gboolean guid_equal(const GncGUID *guid_1, const GncGUID *guid_2)
Given two GUIDs, return TRUE if they are non-NULL and equal.
Definition: guid.cpp:202
const GncGUID * qof_entity_get_guid(gconstpointer ent)
The type used to store guids in C.
Definition: guid.h:75

◆ 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 occurence in the remporalStateDate.

The SX is unchanged.

Definition at line 1053 of file SchedXaction.c.

1054 {
1055  g_return_if_fail(tsd != NULL);
1056  tsd->last_date = xaccSchedXactionGetNextInstance (sx, tsd);
1057  if (xaccSchedXactionHasOccurDef (sx))
1058  {
1059  --tsd->num_occur_rem;
1060  }
1061  ++tsd->num_inst;
1062 }
GDate xaccSchedXactionGetNextInstance(const SchedXaction *sx, SXTmpStateData *tsd)
Returns the next occurrence of a scheduled transaction.
Definition: SchedXaction.c:874
gboolean xaccSchedXactionHasOccurDef(const SchedXaction *sx)
Returns true if the scheduled transaction has a defined number of occurrences, false if not...
Definition: SchedXaction.c:679

◆ 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 1113 of file SchedXaction.c.

1114 {
1115  GList *found_by_value;
1116 
1117  found_by_value = g_list_find_custom(
1118  sx->deferredList, deferStateData, _temporal_state_data_cmp);
1119  if (found_by_value == NULL)
1120  {
1121  g_warning("unable to find deferred instance");
1122  return;
1123  }
1124 
1125  gnc_sx_destroy_temporal_state(found_by_value->data);
1126  sx->deferredList = g_list_delete_link(sx->deferredList, found_by_value);
1127 }
void gnc_sx_destroy_temporal_state(SXTmpStateData *tsd)
Frees the given stateDate object.

◆ 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 936 of file SchedXaction.c.

937 {
938  g_return_if_fail(sx);
939  if (sx->instance_num == instance_num)
940  return;
941  gnc_sx_begin_edit(sx);
942  sx->instance_num = instance_num;
943  qof_instance_set_dirty(&sx->inst);
944  gnc_sx_commit_edit(sx);
945 }

◆ gnc_sx_set_schedule()

void gnc_sx_set_schedule ( SchedXaction *  sx,
GList *  schedule 
)
Parameters
[in]scheduleA GList<Recurrence*>

Definition at line 565 of file SchedXaction.c.

566 {
567  g_return_if_fail(sx);
568  gnc_sx_begin_edit(sx);
569  sx->schedule = schedule;
570  qof_instance_set_dirty(&sx->inst);
571  gnc_sx_commit_edit(sx);
572 }

◆ SXRegister()

gboolean SXRegister ( void  )

QOF registration.

Definition at line 1190 of file SchedXaction.c.

1191 {
1192  static QofParam params[] =
1193  {
1194  {
1195  GNC_SX_NAME, QOF_TYPE_STRING, (QofAccessFunc)xaccSchedXactionGetName,
1197  },
1198  {
1199  GNC_SX_START_DATE, QOF_TYPE_DATE, (QofAccessFunc)xaccSchedXactionGetStartDate,
1200  (QofSetterFunc)xaccSchedXactionSetStartDate
1201  },
1202  {
1203  GNC_SX_LAST_DATE, QOF_TYPE_DATE, (QofAccessFunc)xaccSchedXactionGetLastOccurDate,
1204  (QofSetterFunc)xaccSchedXactionSetLastOccurDate
1205  },
1206  {
1207  GNC_SX_NUM_OCCUR, QOF_TYPE_INT64, (QofAccessFunc)xaccSchedXactionGetNumOccur,
1209  },
1210  {
1211  GNC_SX_REM_OCCUR, QOF_TYPE_INT64, (QofAccessFunc)xaccSchedXactionGetRemOccur,
1212  (QofSetterFunc)xaccSchedXactionSetRemOccur
1213  },
1214  { QOF_PARAM_BOOK, QOF_ID_BOOK, (QofAccessFunc)qof_instance_get_book, NULL },
1215  { QOF_PARAM_GUID, QOF_TYPE_GUID, (QofAccessFunc)qof_instance_get_guid, NULL },
1216  { NULL },
1217  };
1218  qof_class_register(GNC_SX_ID, NULL, params);
1219  return qof_object_register(&SXDesc);
1220 }
const GncGUID * qof_instance_get_guid(gconstpointer inst)
Return the GncGUID of this instance.
QofBook * qof_instance_get_book(gconstpointer inst)
Return the book pointer.
void xaccSchedXactionSetNumOccur(SchedXaction *sx, gint new_num)
Set to &#39;0&#39; to turn off number-of-occurrences definition.
Definition: SchedXaction.c:691
void qof_class_register(QofIdTypeConst obj_name, QofSortFunc default_sort_function, const QofParam *params)
This function registers a new object class with the Qof subsystem.
Definition: qofclass.cpp:89
#define QOF_PARAM_BOOK
"Known" Object Parameters – all objects must support these
Definition: qofquery.h:109
void(* QofSetterFunc)(gpointer, gpointer)
The QofSetterFunc defines an function pointer for parameter setters.
Definition: qofclass.h:184
gpointer(* QofAccessFunc)(gpointer object, const QofParam *param)
The QofAccessFunc defines an arbitrary function pointer for access functions.
Definition: qofclass.h:177
void xaccSchedXactionSetName(SchedXaction *sx, const gchar *newName)
A copy of the name is made.
Definition: SchedXaction.c:581
gboolean qof_object_register(const QofObject *object)
Register new types of object objects.
Definition: qofobject.cpp:320

◆ 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 874 of file SchedXaction.c.

875 {
876  GDate prev_occur, next_occur;
877 
878  g_date_clear( &prev_occur, 1 );
879  if ( tsd != NULL )
880  prev_occur = tsd->last_date;
881 
882  /* If prev_occur is in the "cleared" state and sx->start_date isn't, then
883  * we're at the beginning. We want to pretend prev_occur is the day before
884  * the start_date in case the start_date is today so that the SX will fire
885  * today. If start_date isn't valid either then the SX will fire anyway, no
886  * harm done.
887  */
888  if (! g_date_valid( &prev_occur ) && g_date_valid(&sx->start_date))
889  {
890  /* We must be at the beginning. */
891  prev_occur = sx->start_date;
892  g_date_subtract_days( &prev_occur, 1 );
893  }
894 
895  recurrenceListNextInstance(sx->schedule, &prev_occur, &next_occur);
896 
897  if ( xaccSchedXactionHasEndDate( sx ) )
898  {
899  const GDate *end_date = xaccSchedXactionGetEndDate( sx );
900  if ( g_date_compare( &next_occur, end_date ) > 0 )
901  {
902  g_date_clear( &next_occur, 1 );
903  }
904  }
905  else if ( xaccSchedXactionHasOccurDef( sx ) )
906  {
907  if ((tsd && tsd->num_occur_rem == 0) ||
908  (!tsd && sx->num_occurances_remain == 0 ))
909  {
910  g_date_clear( &next_occur, 1 );
911  }
912  }
913  return next_occur;
914 }
const GDate * xaccSchedXactionGetEndDate(const SchedXaction *sx)
Returns invalid date when there is no end-date specified.
Definition: SchedXaction.c:628
gboolean xaccSchedXactionHasOccurDef(const SchedXaction *sx)
Returns true if the scheduled transaction has a defined number of occurrences, false if not...
Definition: SchedXaction.c:679

◆ 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 990 of file SchedXaction.c.

992 {
993  Transaction *new_trans;
994  TTInfo *tti;
995  TTSplitInfo *s_info;
996  Split *new_split;
997  GList *split_list;
998 
999  g_return_if_fail (book);
1000 
1001  /* delete any old transactions, if there are any */
1002  delete_template_trans( sx );
1003 
1004  for (; t_t_list != NULL; t_t_list = t_t_list->next)
1005  {
1006  tti = t_t_list->data;
1007 
1008  new_trans = xaccMallocTransaction(book);
1009 
1010  xaccTransBeginEdit(new_trans);
1011 
1012  xaccTransSetDescription(new_trans,
1013  gnc_ttinfo_get_description(tti));
1014 
1016 
1017  /* Set tran-num with gnc_set_num_action which is the same as
1018  * xaccTransSetNum with these arguments */
1019  gnc_set_num_action(new_trans, NULL,
1020  gnc_ttinfo_get_num(tti), NULL);
1021  xaccTransSetNotes (new_trans, gnc_ttinfo_get_notes (tti));
1022  xaccTransSetCurrency( new_trans,
1023  gnc_ttinfo_get_currency(tti) );
1024 
1025  for (split_list = gnc_ttinfo_get_template_splits(tti);
1026  split_list;
1027  split_list = split_list->next)
1028  {
1029  s_info = split_list->data;
1030  new_split = pack_split_info(s_info, sx->template_acct,
1031  new_trans, book);
1032  xaccTransAppendSplit(new_trans, new_split);
1033  }
1034  xaccTransCommitEdit(new_trans);
1035  }
1036 }
#define xaccTransAppendSplit(t, s)
Add a split to the transaction.
Definition: Transaction.h:357
Transaction * xaccMallocTransaction(QofBook *book)
The xaccMallocTransaction() will malloc memory and initialize it.
Definition: Transaction.c:517
void xaccTransSetDatePostedSecsNormalized(Transaction *trans, time64 time)
This function sets the posted date of the transaction, specified by a time64 (see ctime(3))...
Definition: Transaction.c:1975
void xaccTransSetNotes(Transaction *trans, const char *notes)
Sets the transaction Notes.
Definition: Transaction.c:2181
void xaccTransSetDescription(Transaction *trans, const char *desc)
Sets the transaction Description.
Definition: Transaction.c:2149
void xaccTransSetCurrency(Transaction *trans, gnc_commodity *curr)
Set a new currency on a transaction.
Definition: Transaction.c:1414
void xaccTransCommitEdit(Transaction *trans)
The xaccTransCommitEdit() method indicates that the changes to the transaction and its splits are com...
Definition: Transaction.c:1642
void xaccTransBeginEdit(Transaction *trans)
The xaccTransBeginEdit() method must be called before any changes are made to a transaction or any of...
Definition: Transaction.c:1443
time64 gnc_time(time64 *tbuf)
get the current local time
Definition: gnc-date.cpp:239