GnuCash  3.1-61-g61071b9
Files | Data Structures | Macros | Enumerations | 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 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)
 
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,)
Hmmm...
Definition: FreqSpec.h:43

Definition at line 34 of file FreqSpec.h.

◆ ENUM_LIST_UI

#define ENUM_LIST_UI (   _)
Value:
_(UIFREQ_NUM_UI_FREQSPECS,)
Repeat twice a year.
Definition: FreqSpec.h:68
no frequency
Definition: FreqSpec.h:68
Repeat once each week.
Definition: FreqSpec.h:68
Repeat every day.
Definition: FreqSpec.h:68
Repeat three times a year.
Definition: FreqSpec.h:68
Repeat twice a month.
Definition: FreqSpec.h:68
Repeat twice a week.
Definition: FreqSpec.h:68
Just occurs once.
Definition: FreqSpec.h:68
Repeat every quarter.
Definition: FreqSpec.h:68
Repeat Monday to Friday, skip weekend.
Definition: FreqSpec.h:68
Repeat once a year.
Definition: FreqSpec.h:68
Repeat once a month.
Definition: FreqSpec.h:68

Definition at line 53 of file FreqSpec.h.

◆ xaccSchedXactionGetGUID

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

Definition at line 323 of file SchedXaction.h.

◆ xaccSchedXactionIsDirty

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

Definition at line 321 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.

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:554

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

1150 {
1151  sx->deferredList = g_list_insert_sorted( sx->deferredList,
1152  deferStateData,
1153  _temporal_state_data_cmp );
1154 }

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

1120 {
1121  SXTmpStateData *toRet;
1122  toRet = g_memdup (tsd, sizeof (SXTmpStateData));
1123  return toRet;
1124 }
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 1113 of file SchedXaction.c.

1114 {
1115  g_free(tsd);
1116 }

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

1188 {
1189  return sx->deferredList;
1190 }

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

966 {
967  gint toRet = -1;
968  SXTmpStateData *tsd;
969 
970  if ( stateData )
971  {
972  tsd = (SXTmpStateData*)stateData;
973  toRet = tsd->num_inst;
974  }
975  else
976  {
977  toRet = sx->instance_num;
978  }
979 
980  return toRet;
981 }
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 775 of file SchedXaction.c.

776 {
777  gint result = 0;
778  SXTmpStateData *tmpState;
779  gboolean countFirstDate;
780 
781  /* SX still active? If not, return now. */
783  && xaccSchedXactionGetRemOccur(sx) <= 0)
784  || (xaccSchedXactionHasEndDate(sx)
785  && g_date_compare(xaccSchedXactionGetEndDate(sx), start_date) < 0))
786  {
787  return result;
788  }
789 
790  tmpState = gnc_sx_create_temporal_state (sx);
791 
792  /* Should we count the first valid date we encounter? Only if the
793  * SX has not yet occurred so far, or if its last valid date was
794  * before the start date. */
795  countFirstDate = !g_date_valid(&tmpState->last_date)
796  || (g_date_compare(&tmpState->last_date, start_date) < 0);
797 
798  /* No valid date? SX has never occurred so far. */
799  if (!g_date_valid(&tmpState->last_date))
800  {
801  /* SX has never occurred so far */
802  gnc_sx_incr_temporal_state (sx, tmpState);
803  if (xaccSchedXactionHasOccurDef(sx) && tmpState->num_occur_rem < 0)
804  {
806  return result;
807  }
808  }
809 
810  /* Increase the tmpState until we are in our interval of
811  * interest. Only calculate anything if the sx hasn't already
812  * ended. */
813  while (g_date_compare(&tmpState->last_date, start_date) < 0)
814  {
815  gnc_sx_incr_temporal_state (sx, tmpState);
816  if (xaccSchedXactionHasOccurDef(sx) && tmpState->num_occur_rem < 0)
817  {
819  return result;
820  }
821  }
822 
823  /* Now we are in our interval of interest. Increment the
824  * occurrence date until we are beyond the end of our
825  * interval. Make sure to check for invalid dates here: It means
826  * the SX has ended. */
827  while (g_date_valid(&tmpState->last_date)
828  && (g_date_compare(&tmpState->last_date, end_date) <= 0)
829  && (!xaccSchedXactionHasEndDate(sx)
830  || g_date_compare(&tmpState->last_date, xaccSchedXactionGetEndDate(sx)) <= 0)
832  /* The >=0 (i.e. the ==) is important here, otherwise
833  * we miss the last valid occurrence of a SX which is
834  * limited by num_occur */
835  || tmpState->num_occur_rem >= 0))
836  {
837  ++result;
838  gnc_sx_incr_temporal_state (sx, tmpState);
839  }
840 
841  /* If the first valid date shouldn't be counted, decrease the
842  * result number by one. */
843  if (!countFirstDate && result > 0)
844  --result;
845 
847  return result;
848 }
const GDate * xaccSchedXactionGetEndDate(const SchedXaction *sx)
Returns invalid date when there is no end-date specified.
Definition: SchedXaction.c:655
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:727

◆ gnc_sx_get_schedule()

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

Definition at line 560 of file SchedXaction.c.

561 {
562  return sx->schedule;
563 }

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

1102 {
1103  g_return_if_fail(tsd != NULL);
1104  tsd->last_date = xaccSchedXactionGetNextInstance (sx, tsd);
1105  if (xaccSchedXactionHasOccurDef (sx))
1106  {
1107  --tsd->num_occur_rem;
1108  }
1109  ++tsd->num_inst;
1110 }
GDate xaccSchedXactionGetNextInstance(const SchedXaction *sx, SXTmpStateData *tsd)
Returns the next occurrence of a scheduled transaction.
Definition: SchedXaction.c:922
gboolean xaccSchedXactionHasOccurDef(const SchedXaction *sx)
Returns true if the scheduled transaction has a defined number of occurrences, false if not...
Definition: SchedXaction.c:727

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

1162 {
1163  GList *found_by_value;
1164 
1165  found_by_value = g_list_find_custom(
1166  sx->deferredList, deferStateData, _temporal_state_data_cmp);
1167  if (found_by_value == NULL)
1168  {
1169  g_warning("unable to find deferred instance");
1170  return;
1171  }
1172 
1173  gnc_sx_destroy_temporal_state(found_by_value->data);
1174  sx->deferredList = g_list_delete_link(sx->deferredList, found_by_value);
1175 }
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 984 of file SchedXaction.c.

985 {
986  g_return_if_fail(sx);
987  if (sx->instance_num == instance_num)
988  return;
989  gnc_sx_begin_edit(sx);
990  sx->instance_num = instance_num;
991  qof_instance_set_dirty(&sx->inst);
992  gnc_sx_commit_edit(sx);
993 }

◆ gnc_sx_set_schedule()

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

Definition at line 566 of file SchedXaction.c.

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

◆ SXRegister()

gboolean SXRegister ( void  )

QOF registration.

Definition at line 1238 of file SchedXaction.c.

1239 {
1240  static QofParam params[] =
1241  {
1242  {
1243  GNC_SX_NAME, QOF_TYPE_STRING, (QofAccessFunc)xaccSchedXactionGetName,
1245  },
1246  {
1247  GNC_SX_START_DATE, QOF_TYPE_DATE, (QofAccessFunc)xaccSchedXactionGetStartDateTT,
1248  (QofSetterFunc)xaccSchedXactionSetStartDateTT
1249  },
1250  {
1251  GNC_SX_LAST_DATE, QOF_TYPE_DATE, (QofAccessFunc)xaccSchedXactionGetLastOccurDateTT,
1252  (QofSetterFunc)xaccSchedXactionSetLastOccurDateTT
1253  },
1254  {
1255  GNC_SX_NUM_OCCUR, QOF_TYPE_INT64, (QofAccessFunc)xaccSchedXactionGetNumOccur,
1257  },
1258  {
1259  GNC_SX_REM_OCCUR, QOF_TYPE_INT64, (QofAccessFunc)xaccSchedXactionGetRemOccur,
1260  (QofSetterFunc)xaccSchedXactionSetRemOccur
1261  },
1262  { QOF_PARAM_BOOK, QOF_ID_BOOK, (QofAccessFunc)qof_instance_get_book, NULL },
1263  { QOF_PARAM_GUID, QOF_TYPE_GUID, (QofAccessFunc)qof_instance_get_guid, NULL },
1264  { NULL },
1265  };
1266  qof_class_register(GNC_SX_ID, NULL, params);
1267  return qof_object_register(&SXDesc);
1268 }
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:739
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:582
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 922 of file SchedXaction.c.

923 {
924  GDate prev_occur, next_occur;
925 
926  g_date_clear( &prev_occur, 1 );
927  if ( tsd != NULL )
928  prev_occur = tsd->last_date;
929 
930  /* If prev_occur is in the "cleared" state and sx->start_date isn't, then
931  * we're at the beginning. We want to pretend prev_occur is the day before
932  * the start_date in case the start_date is today so that the SX will fire
933  * today. If start_date isn't valid either then the SX will fire anyway, no
934  * harm done.
935  */
936  if (! g_date_valid( &prev_occur ) && g_date_valid(&sx->start_date))
937  {
938  /* We must be at the beginning. */
939  prev_occur = sx->start_date;
940  g_date_subtract_days( &prev_occur, 1 );
941  }
942 
943  recurrenceListNextInstance(sx->schedule, &prev_occur, &next_occur);
944 
945  if ( xaccSchedXactionHasEndDate( sx ) )
946  {
947  const GDate *end_date = xaccSchedXactionGetEndDate( sx );
948  if ( g_date_compare( &next_occur, end_date ) > 0 )
949  {
950  g_date_clear( &next_occur, 1 );
951  }
952  }
953  else if ( xaccSchedXactionHasOccurDef( sx ) )
954  {
955  if ((tsd && tsd->num_occur_rem == 0) ||
956  (!tsd && sx->num_occurances_remain == 0 ))
957  {
958  g_date_clear( &next_occur, 1 );
959  }
960  }
961  return next_occur;
962 }
const GDate * xaccSchedXactionGetEndDate(const SchedXaction *sx)
Returns invalid date when there is no end-date specified.
Definition: SchedXaction.c:655
gboolean xaccSchedXactionHasOccurDef(const SchedXaction *sx)
Returns true if the scheduled transaction has a defined number of occurrences, false if not...
Definition: SchedXaction.c:727

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

1040 {
1041  Transaction *new_trans;
1042  TTInfo *tti;
1043  TTSplitInfo *s_info;
1044  Split *new_split;
1045  GList *split_list;
1046 
1047  g_return_if_fail (book);
1048 
1049  /* delete any old transactions, if there are any */
1050  delete_template_trans( sx );
1051 
1052  for (; t_t_list != NULL; t_t_list = t_t_list->next)
1053  {
1054  tti = t_t_list->data;
1055 
1056  new_trans = xaccMallocTransaction(book);
1057 
1058  xaccTransBeginEdit(new_trans);
1059 
1060  xaccTransSetDescription(new_trans,
1061  gnc_ttinfo_get_description(tti));
1062 
1064 
1065  /* Set tran-num with gnc_set_num_action which is the same as
1066  * xaccTransSetNum with these arguments */
1067  gnc_set_num_action(new_trans, NULL,
1068  gnc_ttinfo_get_num(tti), NULL);
1069  xaccTransSetNotes (new_trans, gnc_ttinfo_get_notes (tti));
1070  xaccTransSetCurrency( new_trans,
1071  gnc_ttinfo_get_currency(tti) );
1072 
1073  for (split_list = gnc_ttinfo_get_template_splits(tti);
1074  split_list;
1075  split_list = split_list->next)
1076  {
1077  s_info = split_list->data;
1078  new_split = pack_split_info(s_info, sx->template_acct,
1079  new_trans, book);
1080  xaccTransAppendSplit(new_trans, new_split);
1081  }
1082  xaccTransCommitEdit(new_trans);
1083  }
1084 }
#define xaccTransAppendSplit(t, s)
Add a split to the transaction.
Definition: Transaction.h:361
Transaction * xaccMallocTransaction(QofBook *book)
The xaccMallocTransaction() will malloc memory and initialize it.
Definition: Transaction.c:509
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:1962
void xaccTransSetNotes(Transaction *trans, const char *notes)
Sets the transaction Notes.
Definition: Transaction.c:2154
void xaccTransSetDescription(Transaction *trans, const char *desc)
Sets the transaction Description.
Definition: Transaction.c:2122
void xaccTransSetCurrency(Transaction *trans, gnc_commodity *curr)
Set a new currency on a transaction.
Definition: Transaction.c:1400
void xaccTransCommitEdit(Transaction *trans)
The xaccTransCommitEdit() method indicates that the changes to the transaction and its splits are com...
Definition: Transaction.c:1628
void xaccTransBeginEdit(Transaction *trans)
The xaccTransBeginEdit() method must be called before any changes are made to a transaction or any of...
Definition: Transaction.c:1429
time64 gnc_time(time64 *tbuf)
get the current local time
Definition: gnc-date.cpp:248