GnuCash  4.901
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 occurrence 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 327 of file SchedXaction.h.

◆ xaccSchedXactionIsDirty

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

Definition at line 325 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:527

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

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

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

1116 {
1117  SXTmpStateData *toRet = NULL;
1118 
1119  if(tsd)
1120  {
1121  toRet = g_malloc(sizeof(SXTmpStateData));
1122  toRet = memcpy (toRet, tsd, sizeof (SXTmpStateData));
1123  }
1124 
1125  return toRet;
1126 }
Just the variable temporal bits from the SX structure.
Definition: SchedXaction.h:131

◆ gnc_sx_destroy_temporal_state()

void gnc_sx_destroy_temporal_state ( SXTmpStateData stateData)

Frees the given stateDate object.

Definition at line 1109 of file SchedXaction.c.

1110 {
1111  g_free(tsd);
1112 }

◆ 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
sxScheduled transaction
Returns
Defer list which must not be modified by the caller

Definition at line 1189 of file SchedXaction.c.

1190 {
1191  return sx->deferredList;
1192 }

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

962 {
963  gint toRet = -1;
964  SXTmpStateData *tsd;
965 
966  if ( stateData )
967  {
968  tsd = (SXTmpStateData*)stateData;
969  toRet = tsd->num_inst;
970  }
971  else
972  {
973  toRet = sx->instance_num;
974  }
975 
976  return toRet;
977 }
Just the variable temporal bits from the SX structure.
Definition: SchedXaction.h:131

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

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

◆ gnc_sx_get_schedule()

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

Definition at line 556 of file SchedXaction.c.

557 {
558  return sx->schedule;
559 }

◆ 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.

368 {
369  GList *rtn = NULL;
370  const GncGUID *acct_guid = qof_entity_get_guid(QOF_INSTANCE(acct));
371  GList *sx_list;
372  SchedXactions *sxactions = gnc_book_get_schedxactions(book);
373  g_return_val_if_fail( sxactions != NULL, rtn);
374  for (sx_list = sxactions->sx_list; sx_list != NULL; sx_list = sx_list->next)
375  {
376  SchedXaction *sx = (SchedXaction*)sx_list->data;
377  GList *splits = xaccSchedXactionGetSplits(sx);
378  for (; splits != NULL; splits = splits->next)
379  {
380  Split *s = (Split*)splits->data;
381  GncGUID *guid = NULL;
382  qof_instance_get (QOF_INSTANCE (s), "sx-account", &guid, NULL);
383  if (guid_equal(acct_guid, guid))
384  rtn = g_list_prepend (rtn, sx);
385 
386  guid_free (guid);
387  }
388  }
389  return g_list_reverse (rtn);
390 }
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:201
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 occurrence in the remporalStateDate.

The SX is unchanged.

Definition at line 1097 of file SchedXaction.c.

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

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

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

981 {
982  g_return_if_fail(sx);
983  if (sx->instance_num == instance_num)
984  return;
985  gnc_sx_begin_edit(sx);
986  sx->instance_num = instance_num;
987  qof_instance_set_dirty(&sx->inst);
988  gnc_sx_commit_edit(sx);
989 }

◆ gnc_sx_set_schedule()

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

Definition at line 562 of file SchedXaction.c.

563 {
564  g_return_if_fail(sx);
565  gnc_sx_begin_edit(sx);
566  sx->schedule = schedule;
567  qof_instance_set_dirty(&sx->inst);
568  gnc_sx_commit_edit(sx);
569 }

◆ SXRegister()

gboolean SXRegister ( void  )

QOF registration.

Definition at line 1243 of file SchedXaction.c.

1244 {
1245  static QofParam params[] =
1246  {
1247  {
1248  GNC_SX_NAME, QOF_TYPE_STRING, (QofAccessFunc)xaccSchedXactionGetName,
1250  },
1251  {
1252  GNC_SX_START_DATE, QOF_TYPE_DATE, (QofAccessFunc)xaccSchedXactionGetStartDateTT,
1253  (QofSetterFunc)xaccSchedXactionSetStartDateTT
1254  },
1255  {
1256  GNC_SX_LAST_DATE, QOF_TYPE_DATE, (QofAccessFunc)xaccSchedXactionGetLastOccurDateTT,
1257  (QofSetterFunc)xaccSchedXactionSetLastOccurDateTT
1258  },
1259  {
1260  GNC_SX_NUM_OCCUR, QOF_TYPE_INT64, (QofAccessFunc)xaccSchedXactionGetNumOccur,
1262  },
1263  {
1264  GNC_SX_REM_OCCUR, QOF_TYPE_INT64, (QofAccessFunc)xaccSchedXactionGetRemOccur,
1265  (QofSetterFunc)xaccSchedXactionSetRemOccur
1266  },
1267  { QOF_PARAM_BOOK, QOF_ID_BOOK, (QofAccessFunc)qof_instance_get_book, NULL },
1268  { QOF_PARAM_GUID, QOF_TYPE_GUID, (QofAccessFunc)qof_instance_get_guid, NULL },
1269  { NULL },
1270  };
1271  qof_class_register(GNC_SX_ID, NULL, params);
1272  return qof_object_register(&SXDesc);
1273 }
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:735
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:86
#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:578
gboolean qof_object_register(const QofObject *object)
Register new types of object objects.
Definition: qofobject.cpp:305

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

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

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

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