GnuCash  4.12-71-gadd45021a8+
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 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:606

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

1160 {
1161  sx->deferredList = g_list_insert_sorted( sx->deferredList,
1162  deferStateData,
1163  _temporal_state_data_cmp );
1164 }

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

1124 {
1125  SXTmpStateData *toRet = NULL;
1126 
1127  if(tsd)
1128  {
1129  toRet = g_malloc(sizeof(SXTmpStateData));
1130  toRet = memcpy (toRet, tsd, sizeof (SXTmpStateData));
1131  }
1132 
1133  return toRet;
1134 }
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 1117 of file SchedXaction.c.

1118 {
1119  g_free(tsd);
1120 }

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

1198 {
1199  return sx->deferredList;
1200 }

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

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

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

◆ gnc_sx_get_schedule()

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

Definition at line 564 of file SchedXaction.c.

565 {
566  return sx->schedule;
567 }

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

The SX is unchanged.

Definition at line 1105 of file SchedXaction.c.

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

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

1172 {
1173  GList *found_by_value;
1174 
1175  found_by_value = g_list_find_custom(
1176  sx->deferredList, deferStateData, _temporal_state_data_cmp);
1177  if (found_by_value == NULL)
1178  {
1179  g_warning("unable to find deferred instance");
1180  return;
1181  }
1182 
1183  gnc_sx_destroy_temporal_state(found_by_value->data);
1184  sx->deferredList = g_list_delete_link(sx->deferredList, found_by_value);
1185 }
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 988 of file SchedXaction.c.

989 {
990  g_return_if_fail(sx);
991  if (sx->instance_num == instance_num)
992  return;
993  gnc_sx_begin_edit(sx);
994  sx->instance_num = instance_num;
995  qof_instance_set_dirty(&sx->inst);
996  gnc_sx_commit_edit(sx);
997 }

◆ gnc_sx_set_schedule()

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

Definition at line 570 of file SchedXaction.c.

571 {
572  g_return_if_fail(sx);
573  gnc_sx_begin_edit(sx);
574  sx->schedule = schedule;
575  qof_instance_set_dirty(&sx->inst);
576  gnc_sx_commit_edit(sx);
577 }

◆ SXRegister()

gboolean SXRegister ( void  )

QOF registration.

Definition at line 1248 of file SchedXaction.c.

1249 {
1250  static QofParam params[] =
1251  {
1252  {
1253  GNC_SX_NAME, QOF_TYPE_STRING, (QofAccessFunc)xaccSchedXactionGetName,
1255  },
1256  {
1257  GNC_SX_START_DATE, QOF_TYPE_DATE, (QofAccessFunc)xaccSchedXactionGetStartDateTT,
1258  (QofSetterFunc)xaccSchedXactionSetStartDateTT
1259  },
1260  {
1261  GNC_SX_LAST_DATE, QOF_TYPE_DATE, (QofAccessFunc)xaccSchedXactionGetLastOccurDateTT,
1262  (QofSetterFunc)xaccSchedXactionSetLastOccurDateTT
1263  },
1264  {
1265  GNC_SX_NUM_OCCUR, QOF_TYPE_INT64, (QofAccessFunc)xaccSchedXactionGetNumOccur,
1267  },
1268  {
1269  GNC_SX_REM_OCCUR, QOF_TYPE_INT64, (QofAccessFunc)xaccSchedXactionGetRemOccur,
1270  (QofSetterFunc)xaccSchedXactionSetRemOccur
1271  },
1272  { QOF_PARAM_BOOK, QOF_ID_BOOK, (QofAccessFunc)qof_instance_get_book, NULL },
1273  { QOF_PARAM_GUID, QOF_TYPE_GUID, (QofAccessFunc)qof_instance_get_guid, NULL },
1274  { NULL },
1275  };
1276  qof_class_register(GNC_SX_ID, NULL, params);
1277  return qof_object_register(&SXDesc);
1278 }
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:743
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:586
gboolean qof_object_register(const QofObject *object)
Register new types of object objects.
Definition: qofobject.cpp:317

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

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

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

1044 {
1045  Transaction *new_trans;
1046  TTInfo *tti;
1047  TTSplitInfo *s_info;
1048  Split *new_split;
1049  GList *split_list;
1050 
1051  g_return_if_fail (book);
1052 
1053  /* delete any old transactions, if there are any */
1054  delete_template_trans( sx );
1055 
1056  for (; t_t_list != NULL; t_t_list = t_t_list->next)
1057  {
1058  tti = t_t_list->data;
1059 
1060  new_trans = xaccMallocTransaction(book);
1061 
1062  xaccTransBeginEdit(new_trans);
1063 
1064  xaccTransSetDescription(new_trans,
1065  gnc_ttinfo_get_description(tti));
1066 
1068 
1069  /* Set tran-num with gnc_set_num_action which is the same as
1070  * xaccTransSetNum with these arguments */
1071  gnc_set_num_action(new_trans, NULL,
1072  gnc_ttinfo_get_num(tti), NULL);
1073  xaccTransSetNotes (new_trans, gnc_ttinfo_get_notes (tti));
1074  xaccTransSetCurrency( new_trans,
1075  gnc_ttinfo_get_currency(tti) );
1076 
1077  for (split_list = gnc_ttinfo_get_template_splits(tti);
1078  split_list;
1079  split_list = split_list->next)
1080  {
1081  s_info = split_list->data;
1082  new_split = pack_split_info(s_info, sx->template_acct,
1083  new_trans, book);
1084  xaccTransAppendSplit(new_trans, new_split);
1085  }
1086  xaccTransCommitEdit(new_trans);
1087  }
1088 }
#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:1426
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:273