/**
* e_cal_util_split_at_instance:
* @icalcomp: A (recurring) #icalcomponent
* @rid: The base RECURRENCE-ID to remove
* @master_dtstart: The DTSTART of the master object
*
* Splits a recurring @icalcomp into two at time @rid. The returned icalcomponent
* is modified @icalcomp which contains recurrences beginning at @rid, inclusive.
* The instance identified by @rid should exist. The @master_dtstart can be
* a null time, then it is read from the @icalcomp.
*
* Use e_cal_util_remove_instances() with E_CAL_OBJ_MOD_THIS_AND_FUTURE mode
* on the @icalcomp to remove the overlapping interval from it, if needed.
*
* Returns: the split icalcomponent, or %NULL.
*
* Since: 3.16
**/
icalcomponent *
e_cal_util_split_at_instance (icalcomponent *icalcomp,
struct icaltimetype rid,
struct icaltimetype master_dtstart)
{
icalproperty *prop;
struct instance_data instance;
struct icaltimetype start, end;
struct icaldurationtype duration;
GSList *remove_props = NULL, *link;
g_return_val_if_fail (icalcomp != NULL, NULL);
g_return_val_if_fail (!icaltime_is_null_time (rid), NULL);
/* Make sure this is really recurring */
if (!icalcomponent_get_first_property (icalcomp, ICAL_RRULE_PROPERTY) &&
!icalcomponent_get_first_property (icalcomp, ICAL_RDATE_PROPERTY))
return NULL;
/* Make sure the specified instance really exists */
start = icaltime_convert_to_zone (rid, icaltimezone_get_utc_timezone ());
end = start;
icaltime_adjust (&end, 0, 0, 0, 1);
instance.start = icaltime_as_timet (start);
instance.found = FALSE;
icalcomponent_foreach_recurrence (icalcomp, start, end,
check_instance, &instance);
/* Make the copy */
icalcomp = icalcomponent_new_clone (icalcomp);
e_cal_util_remove_instances_ex (icalcomp, rid, E_CAL_OBJ_MOD_THIS_AND_PRIOR, TRUE, FALSE);
start = rid;
if (icaltime_is_null_time (master_dtstart))
master_dtstart = icalcomponent_get_dtstart (icalcomp);
duration = icalcomponent_get_duration (icalcomp);
/* Expect that DTSTART and DTEND are already set when the instance could not be found */
if (instance.found) {
icalcomponent_set_dtstart (icalcomp, start);
/* Update either DURATION or DTEND */
if (icaltime_is_null_time (icalcomponent_get_dtend (icalcomp))) {
icalcomponent_set_duration (icalcomp, duration);
} else {
end = start;
if (duration.is_neg)
icaltime_adjust (&end, -duration.days - 7 * duration.weeks, -duration.hours, -duration.minutes, -duration.seconds);
else
icaltime_adjust (&end, duration.days + 7 * duration.weeks, duration.hours, duration.minutes, duration.seconds);
icalcomponent_set_dtend (icalcomp, end);
}
}
/* any RRULE with 'count' should be shortened */
for (prop = icalcomponent_get_first_property (icalcomp, ICAL_RRULE_PROPERTY);
prop;
prop = icalcomponent_get_next_property (icalcomp, ICAL_RRULE_PROPERTY)) {
struct icaltimetype recur;
struct icalrecurrencetype rule;
rule = icalproperty_get_rrule (prop);
if (rule.count != 0) {
gint occurrences_count = 0;
icalrecur_iterator *iter;
iter = icalrecur_iterator_new (rule, master_dtstart);
while (recur = icalrecur_iterator_next (iter), !icaltime_is_null_time (recur) && occurrences_count < rule.count) {
if (icaltime_compare (recur, rid) >= 0)
break;
occurrences_count++;
}
icalrecur_iterator_free (iter);
if (icaltime_is_null_time (recur)) {
remove_props = g_slist_prepend (remove_props, prop);
} else {
rule.count -= occurrences_count;
icalproperty_set_rrule (prop, rule);
icalproperty_remove_parameter_by_name (prop, "X-EVOLUTION-ENDDATE");
}
}
}
for (link = remove_props; link; link = g_slist_next (link)) {
prop = link->data;
icalcomponent_remove_property (icalcomp, prop);
}
g_slist_free (remove_props);
return icalcomp;
}
/**
* e_cal_util_get_component_occur_times:
* @comp: an #ECalComponent
* @start: (out): Location to store the start time
* @end: (out): Location to store the end time
* @tz_cb: (closure tz_cb_data) (scope call): The #ECalRecurResolveTimezoneFn to call
* @tz_cb_data: (closure): User data to be passed to the @tz_cb callback
* @default_timezone: The default timezone
* @kind: the type of component, indicated with an icalcomponent_kind
*
* Find out when the component starts and stops, being careful about
* recurrences.
*
* Since: 2.32
**/
void
e_cal_util_get_component_occur_times (ECalComponent *comp,
time_t *start,
time_t *end,
ECalRecurResolveTimezoneFn tz_cb,
gpointer tz_cb_data,
const icaltimezone *default_timezone,
icalcomponent_kind kind)
{
struct icalrecurrencetype ir;
ECalComponentDateTime dt_start, dt_end;
g_return_if_fail (comp != NULL);
g_return_if_fail (start != NULL);
g_return_if_fail (end != NULL);
e_cal_recur_ensure_end_dates (comp, FALSE, tz_cb, tz_cb_data);
/* Get dtstart of the component and convert it to UTC */
e_cal_component_get_dtstart (comp, &dt_start);
if ((*start = componenttime_to_utc_timet (&dt_start, tz_cb, tz_cb_data, default_timezone)) == -1)
*start = _TIME_MIN;
e_cal_component_free_datetime (&dt_start);
/* find out end date of component */
*end = _TIME_MAX;
if (kind == ICAL_VTODO_COMPONENT) {
/* max from COMPLETED and DUE properties */
struct icaltimetype *tt = NULL;
time_t completed_time = -1, due_time = -1, max_time;
ECalComponentDateTime dt_due;
e_cal_component_get_completed (comp, &tt);
if (tt) {
/* COMPLETED must be in UTC. */
completed_time = icaltime_as_timet_with_zone (
*tt, icaltimezone_get_utc_timezone ());
e_cal_component_free_icaltimetype (tt);
}
e_cal_component_get_due (comp, &dt_due);
if (dt_due.value != NULL)
due_time = componenttime_to_utc_timet (
&dt_due, tz_cb, tz_cb_data,
default_timezone);
e_cal_component_free_datetime (&dt_due);
max_time = MAX (completed_time, due_time);
if (max_time != -1)
*end = max_time;
} else {
/* ALARMS, EVENTS: DTEND and reccurences */
if (e_cal_component_has_recurrences (comp)) {
GSList *rrules = NULL;
GSList *exrules = NULL;
GSList *elem;
GSList *rdates = NULL;
/* Do the RRULEs, EXRULEs and RDATEs*/
e_cal_component_get_rrule_property_list (comp, &rrules);
e_cal_component_get_exrule_property_list (comp, &exrules);
e_cal_component_get_rdate_list (comp, &rdates);
for (elem = rrules; elem; elem = elem->next) {
time_t rule_end;
icaltimezone *utc_zone;
icalproperty *prop = elem->data;
ir = icalproperty_get_rrule (prop);
utc_zone = icaltimezone_get_utc_timezone ();
rule_end = e_cal_recur_obtain_enddate (
&ir, prop, utc_zone, TRUE);
if (rule_end == -1) /* repeats forever */
*end = _TIME_MAX;
else if (rule_end > *end) /* new maximum */
*end = rule_end;
}
/* Do the EXRULEs. */
for (elem = exrules; elem; elem = elem->next) {
icalproperty *prop = elem->data;
time_t rule_end;
icaltimezone *utc_zone;
ir = icalproperty_get_exrule (prop);
utc_zone = icaltimezone_get_utc_timezone ();
rule_end = e_cal_recur_obtain_enddate (
&ir, prop, utc_zone, TRUE);
if (rule_end == -1) /* repeats forever */
*end = _TIME_MAX;
else if (rule_end > *end)
*end = rule_end;
}
/* Do the RDATEs */
for (elem = rdates; elem; elem = elem->next) {
ECalComponentPeriod *p = elem->data;
time_t rdate_end = _TIME_MAX;
/* FIXME: We currently assume RDATEs are in the same timezone
* as DTSTART. We should get the RDATE timezone and convert
* to the DTSTART timezone first. */
/* Check if the end date or duration is set, libical seems to set
* second to -1 to denote an unset time */
if (p->type != E_CAL_COMPONENT_PERIOD_DATETIME || p->u.end.second != -1)
rdate_end = icaltime_as_timet (icaltime_add (p->start, p->u.duration));
else
rdate_end = icaltime_as_timet (p->u.end);
if (rdate_end == -1) /* repeats forever */
*end = _TIME_MAX;
else if (rdate_end > *end)
*end = rdate_end;
}
e_cal_component_free_period_list (rdates);
}
/* Get dtend of the component and convert it to UTC */
e_cal_component_get_dtend (comp, &dt_end);
if (dt_end.value) {
time_t dtend_time;
dtend_time = componenttime_to_utc_timet (
&dt_end, tz_cb, tz_cb_data, default_timezone);
if (dtend_time == -1 || (dtend_time > *end))
*end = dtend_time;
}
e_cal_component_free_datetime (&dt_end);
}
}
void test_recur_file()
{
icalset *cin = 0;
struct icaltimetype next;
icalcomponent *itr;
icalproperty *desc, *dtstart, *rrule;
struct icalrecurrencetype recur;
icalrecur_iterator* ritr;
time_t tt;
char* file;
int num_recurs_found = 0;
icalfileset_options options = {O_RDONLY, 0644, 0};
icalerror_set_error_state(ICAL_PARSE_ERROR, ICAL_ERROR_NONFATAL);
#ifndef WIN32
signal(SIGALRM,sig_alrm);
#endif
file = getenv("ICAL_RECUR_FILE");
if (!file)
file = TEST_DATADIR "/recur.txt";
#ifndef WIN32
alarm(15); /* to get file lock */
#endif
cin = icalset_new(ICAL_FILE_SET, file, &options);
#ifndef WIN32
alarm(0);
#endif
ok("opening file with recurring events", (cin!=NULL));
assert(cin!=NULL);
for (itr = icalfileset_get_first_component(cin);
itr != 0;
itr = icalfileset_get_next_component(cin)){
int badcomp = 0;
int expected_events = 0;
char msg[128];
struct icaltimetype start = icaltime_null_time();
struct icaltimetype startmin = icaltime_from_timet(1,0);
struct icaltimetype endmax = icaltime_null_time();
const char *desc_str = "malformed component";
desc = icalcomponent_get_first_property(itr,ICAL_DESCRIPTION_PROPERTY);
dtstart = icalcomponent_get_first_property(itr,ICAL_DTSTART_PROPERTY);
rrule = icalcomponent_get_first_property(itr,ICAL_RRULE_PROPERTY);
if (desc) {
desc_str = icalproperty_get_description(desc);
}
ok((char*)desc_str, !(desc == 0 || dtstart == 0 || rrule == 0));
if (desc == 0 || dtstart == 0 || rrule == 0) {
badcomp = 1;
if (VERBOSE) {
printf("\n******** Error in input component ********\n");
printf("The following component is malformed:\n %s\n", desc_str);
}
continue;
}
if (VERBOSE) {
printf("\n\n#### %s\n",desc_str);
printf("#### %s\n",icalvalue_as_ical_string(icalproperty_get_value(rrule)));
}
recur = icalproperty_get_rrule(rrule);
start = icalproperty_get_dtstart(dtstart);
ritr = icalrecur_iterator_new(recur,start);
tt = icaltime_as_timet(start);
if (VERBOSE)
printf("#### %s\n",ctime(&tt ));
icalrecur_iterator_free(ritr);
for(ritr = icalrecur_iterator_new(recur,start),
next = icalrecur_iterator_next(ritr);
!icaltime_is_null_time(next);
next = icalrecur_iterator_next(ritr)){
tt = icaltime_as_timet(next);
if (VERBOSE)
printf(" %s",ctime(&tt ));
}
icalrecur_iterator_free(ritr);
num_recurs_found = 0;
expected_events = get_expected_numevents(itr);
icalcomponent_foreach_recurrence(itr, startmin, endmax,
recur_callback, &num_recurs_found);
sprintf(msg," expecting total of %d events", expected_events);
int_is(msg, num_recurs_found, expected_events);
}
icalset_free(cin);
}
static void
e_cal_util_remove_instances_ex (icalcomponent *icalcomp,
struct icaltimetype rid,
ECalObjModType mod,
gboolean keep_rid,
gboolean can_add_exrule)
{
icalproperty *prop;
struct icaltimetype itt, recur;
struct icalrecurrencetype rule;
icalrecur_iterator *iter;
GSList *remove_props = NULL, *rrules = NULL, *link;
g_return_if_fail (icalcomp != NULL);
g_return_if_fail (mod != E_CAL_OBJ_MOD_ALL);
/* First remove RDATEs and EXDATEs in the indicated range. */
for (prop = icalcomponent_get_first_property (icalcomp, ICAL_RDATE_PROPERTY);
prop;
prop = icalcomponent_get_next_property (icalcomp, ICAL_RDATE_PROPERTY)) {
struct icaldatetimeperiodtype period;
period = icalproperty_get_rdate (prop);
if (time_matches_rid (period.time, rid, mod) && (!keep_rid ||
icaltime_compare (period.time, rid) != 0))
remove_props = g_slist_prepend (remove_props, prop);
}
for (prop = icalcomponent_get_first_property (icalcomp, ICAL_EXDATE_PROPERTY);
prop;
prop = icalcomponent_get_next_property (icalcomp, ICAL_EXDATE_PROPERTY)) {
itt = icalproperty_get_exdate (prop);
if (time_matches_rid (itt, rid, mod) && (!keep_rid ||
icaltime_compare (itt, rid) != 0))
remove_props = g_slist_prepend (remove_props, prop);
}
for (link = remove_props; link; link = g_slist_next (link)) {
prop = link->data;
icalcomponent_remove_property (icalcomp, prop);
}
g_slist_free (remove_props);
remove_props = NULL;
/* If we're only removing one instance, just add an EXDATE. */
if (mod == E_CAL_OBJ_MOD_THIS) {
prop = icalproperty_new_exdate (rid);
icalcomponent_add_property (icalcomp, prop);
return;
}
/* Otherwise, iterate through RRULEs */
/* FIXME: this may generate duplicate EXRULEs */
for (prop = icalcomponent_get_first_property (icalcomp, ICAL_RRULE_PROPERTY);
prop;
prop = icalcomponent_get_next_property (icalcomp, ICAL_RRULE_PROPERTY)) {
rrules = g_slist_prepend (rrules, prop);
}
for (link = rrules; link; link = g_slist_next (link)) {
prop = link->data;
rule = icalproperty_get_rrule (prop);
iter = icalrecur_iterator_new (rule, rid);
recur = icalrecur_iterator_next (iter);
if (mod & E_CAL_OBJ_MOD_THIS_AND_FUTURE) {
/* Truncate the rule at rid. */
if (!icaltime_is_null_time (recur)) {
/* Use count if it was used */
if (rule.count > 0) {
gint occurrences_count = 0;
icalrecur_iterator *count_iter;
struct icaltimetype count_recur;
count_iter = icalrecur_iterator_new (rule, icalcomponent_get_dtstart (icalcomp));
while (count_recur = icalrecur_iterator_next (count_iter), !icaltime_is_null_time (count_recur) && occurrences_count < rule.count) {
if (icaltime_compare (count_recur, rid) >= 0)
break;
occurrences_count++;
}
icalrecur_iterator_free (count_iter);
if (keep_rid && icaltime_compare (count_recur, rid) == 0)
occurrences_count++;
/* The caller should make sure that the remove will keep at least one instance */
g_warn_if_fail (occurrences_count > 0);
rule.count = occurrences_count;
} else {
if (keep_rid && icaltime_compare (recur, rid) == 0)
rule.until = icaltime_add (rid, icalcomponent_get_duration (icalcomp));
else
rule.until = rid;
icaltime_adjust (&rule.until, 0, 0, 0, -1);
}
icalproperty_set_rrule (prop, rule);
icalproperty_remove_parameter_by_name (prop, "X-EVOLUTION-ENDDATE");
}
} else {
/* (If recur == rid, skip to the next occurrence) */
if (!keep_rid && icaltime_compare (recur, rid) == 0)
recur = icalrecur_iterator_next (iter);
/* If there is a recurrence after rid, add
* an EXRULE to block instances up to rid.
* Otherwise, just remove the RRULE.
*/
if (!icaltime_is_null_time (recur)) {
if (can_add_exrule) {
rule.count = 0;
/* iCalendar says we should just use rid
* here, but Outlook/Exchange handle
* UNTIL incorrectly.
*/
if (keep_rid && icaltime_compare (recur, rid) == 0) {
struct icaldurationtype duration = icalcomponent_get_duration (icalcomp);
duration.is_neg = !duration.is_neg;
rule.until = icaltime_add (rid, duration);
} else
rule.until = icaltime_add (rid, icalcomponent_get_duration (icalcomp));
prop = icalproperty_new_exrule (rule);
icalcomponent_add_property (icalcomp, prop);
}
} else {
remove_props = g_slist_prepend (remove_props, prop);
}
}
icalrecur_iterator_free (iter);
}
for (link = remove_props; link; link = g_slist_next (link)) {
prop = link->data;
icalcomponent_remove_property (icalcomp, prop);
}
g_slist_free (remove_props);
g_slist_free (rrules);
}
icalcomponent *icalbdbset_form_a_matched_recurrence_component(icalsetiter *itr)
{
icalcomponent *comp = NULL;
struct icaltimetype start, next;
icalproperty *dtstart, *rrule, *prop, *due;
struct icalrecurrencetype recur;
icaltimezone *u_zone;
int orig_time_was_utc = 0;
comp = itr->last_component;
if (comp == NULL || itr->gauge == NULL) {
return NULL;
}
rrule = icalcomponent_get_first_property(comp, ICAL_RRULE_PROPERTY);
/* if there is no RRULE, simply return to the caller */
if (rrule == NULL) {
return NULL;
}
u_zone = icaltimezone_get_builtin_timezone(itr->tzid);
/* use UTC, if that's all we have. */
if (!u_zone) {
u_zone = icaltimezone_get_utc_timezone();
}
recur = icalproperty_get_rrule(rrule);
start = icaltime_from_timet(time(0), 0);
if (icalcomponent_isa(comp) == ICAL_VEVENT_COMPONENT) {
dtstart = icalcomponent_get_first_property(comp, ICAL_DTSTART_PROPERTY);
if (dtstart) {
start = icalproperty_get_dtstart(dtstart);
}
} else if (icalcomponent_isa(comp) == ICAL_VTODO_COMPONENT) {
due = icalcomponent_get_first_property(comp, ICAL_DUE_PROPERTY);
if (due) {
start = icalproperty_get_due(due);
}
}
/* Convert to the user's timezone in order to be able to compare the results
* from the rrule iterator. */
if (icaltime_is_utc(start)) {
start = icaltime_convert_to_zone(start, u_zone);
orig_time_was_utc = 1;
}
if (itr->ritr == NULL) {
itr->ritr = icalrecur_iterator_new(recur, start);
next = icalrecur_iterator_next(itr->ritr);
itr->last_component = comp;
} else {
next = icalrecur_iterator_next(itr->ritr);
if (icaltime_is_null_time(next)) {
/* no more recurrence, returns */
itr->last_component = NULL;
icalrecur_iterator_free(itr->ritr);
itr->ritr = NULL;
/* no more pending matched occurrence,
* all the pending matched occurrences have been returned */
return NULL;
} else {
itr->last_component = comp;
}
}
/* if it is excluded, return NULL to the caller */
if (icalproperty_recurrence_is_excluded(comp, &start, &next)) {
(void)icalrecur_iterator_next(itr->ritr);
return NULL;
}
/* set recurrence-id value to the property if the property already exist;
* add the recurrence id property and the value if the property does not exist */
prop = icalcomponent_get_first_property(comp, ICAL_RECURRENCEID_PROPERTY);
if (prop == 0) {
icalcomponent_add_property(comp, icalproperty_new_recurrenceid(next));
} else {
icalproperty_set_recurrenceid(prop, next);
}
if (orig_time_was_utc) {
next = icaltime_convert_to_zone(next, icaltimezone_get_utc_timezone());
}
if (itr->gauge == 0 || icalgauge_compare(itr->gauge, comp) == 1) {
/* find a matched and return it */
return comp;
}
/* not matched */
return NULL;
}
icalcomponent *icalbdbsetiter_to_next(icalset *set, icalsetiter *i)
{
icalcomponent *comp = NULL;
struct icaltimetype start, next;
icalproperty *dtstart, *rrule, *prop, *due;
struct icalrecurrencetype recur;
icaltimezone *u_zone;
int g = 0;
int orig_time_was_utc = 0;
_unused(set);
do {
/* no pending occurrence, read the next component */
if (i->last_component == NULL) {
comp = icalcompiter_next(&(i->iter));
} else {
comp = i->last_component;
}
/* no next component, simply return */
if (comp == 0) {
return NULL;
}
if (i->gauge == 0) {
return comp;
}
/* finding the next matched component and return it to the caller */
rrule = icalcomponent_get_first_property(comp, ICAL_RRULE_PROPERTY);
g = icalgauge_get_expand(i->gauge);
/* a recurring component with expand query */
if (rrule != 0 && g == 1) {
u_zone = icaltimezone_get_builtin_timezone(i->tzid);
/* use UTC, if that's all we have. */
if (!u_zone) {
u_zone = icaltimezone_get_utc_timezone();
}
recur = icalproperty_get_rrule(rrule);
start = icaltime_from_timet(time(0), 0);
if (icalcomponent_isa(comp) == ICAL_VEVENT_COMPONENT) {
dtstart = icalcomponent_get_first_property(comp, ICAL_DTSTART_PROPERTY);
if (dtstart) {
start = icalproperty_get_dtstart(dtstart);
}
} else if (icalcomponent_isa(comp) == ICAL_VTODO_COMPONENT) {
due = icalcomponent_get_first_property(comp, ICAL_DUE_PROPERTY);
if (due) {
start = icalproperty_get_due(due);
}
}
/* Convert to the user's timezone in order to be able to compare
* the results from the rrule iterator. */
if (icaltime_is_utc(start)) {
start = icaltime_convert_to_zone(start, u_zone);
orig_time_was_utc = 1;
}
if (i->ritr == NULL) {
i->ritr = icalrecur_iterator_new(recur, start);
next = icalrecur_iterator_next(i->ritr);
i->last_component = comp;
} else {
next = icalrecur_iterator_next(i->ritr);
if (icaltime_is_null_time(next)) {
i->last_component = NULL;
icalrecur_iterator_free(i->ritr);
i->ritr = NULL;
/* no more occurrence, should go to get next component */
continue;
} else {
i->last_component = comp;
}
}
/* if it is excluded, do next one */
if (icalproperty_recurrence_is_excluded(comp, &start, &next)) {
next = icalrecur_iterator_next(i->ritr);
continue;
}
/* set recurrence-id value to the property if the property already exist;
* add the recurrence id property and the value if the property does not exist */
prop = icalcomponent_get_first_property(comp, ICAL_RECURRENCEID_PROPERTY);
if (prop == 0) {
icalcomponent_add_property(comp, icalproperty_new_recurrenceid(next));
} else {
icalproperty_set_recurrenceid(prop, next);
}
if (orig_time_was_utc) {
next = icaltime_convert_to_zone(next, icaltimezone_get_utc_timezone());
}
}
/* end of recurring event with expand query */
if (comp != 0 && (i->gauge == 0 || icalgauge_compare(i->gauge, comp) == 1)) {
/* found a matched, return it */
return comp;
}
} while (comp != 0);
return NULL; /*unreachable */
}
icalsetiter icalbdbset_begin_component(icalset *set, icalcomponent_kind kind,
icalgauge *gauge, const char *tzid)
{
icalsetiter itr = icalsetiter_null;
icalcomponent *comp = NULL;
icalcompiter citr;
icalbdbset *bset;
struct icaltimetype start, next;
icalproperty *dtstart, *rrule, *prop, *due;
struct icalrecurrencetype recur;
icaltimezone *u_zone;
int g = 0;
int orig_time_was_utc = 0;
icalerror_check_arg_re((set != 0), "set", icalsetiter_null);
bset = (icalbdbset *) set;
itr.gauge = gauge;
itr.tzid = tzid;
citr = icalcomponent_begin_component(bset->cluster, kind);
comp = icalcompiter_deref(&citr);
if (gauge == 0) {
itr.iter = citr;
return itr;
}
/* if there is a gauge, the first matched component is returned */
while (comp != 0) {
/* check if it is a recurring component and with guage expand, if so
* we need to add recurrence-id property to the given component */
rrule = icalcomponent_get_first_property(comp, ICAL_RRULE_PROPERTY);
g = icalgauge_get_expand(gauge);
if (rrule != 0 && g == 1) {
/* it is a recurring event */
u_zone = icaltimezone_get_builtin_timezone(itr.tzid);
/* use UTC, if that's all we have. */
if (!u_zone) {
u_zone = icaltimezone_get_utc_timezone();
}
recur = icalproperty_get_rrule(rrule);
start = icaltime_from_timet(time(0), 0);
if (icalcomponent_isa(comp) == ICAL_VEVENT_COMPONENT) {
dtstart = icalcomponent_get_first_property(comp, ICAL_DTSTART_PROPERTY);
if (dtstart) {
start = icalproperty_get_dtstart(dtstart);
}
} else if (icalcomponent_isa(comp) == ICAL_VTODO_COMPONENT) {
due = icalcomponent_get_first_property(comp, ICAL_DUE_PROPERTY);
if (due) {
start = icalproperty_get_due(due);
}
}
/* Convert to the user's timezone in order to be able to compare
* the results from the rrule iterator. */
if (icaltime_is_utc(start)) {
start = icaltime_convert_to_zone(start, u_zone);
orig_time_was_utc = 1;
}
if (itr.last_component == NULL) {
itr.ritr = icalrecur_iterator_new(recur, start);
next = icalrecur_iterator_next(itr.ritr);
itr.last_component = comp;
} else {
next = icalrecur_iterator_next(itr.ritr);
if (icaltime_is_null_time(next)) {
itr.last_component = NULL;
icalrecur_iterator_free(itr.ritr);
itr.ritr = NULL;
/* no matched occurrence */
goto getNextComp;
} else {
itr.last_component = comp;
}
}
/* if it is excluded, do next one */
if (icalproperty_recurrence_is_excluded(comp, &start, &next)) {
next = icalrecur_iterator_next(itr.ritr);
continue;
}
/* add recurrence-id value to the property if the property already exist;
* add the recurrence id property and the value if the property does not exist */
prop = icalcomponent_get_first_property(comp, ICAL_RECURRENCEID_PROPERTY);
if (prop == 0) {
icalcomponent_add_property(comp, icalproperty_new_recurrenceid(next));
} else {
icalproperty_set_recurrenceid(prop, next);
}
/* convert the next recurrence time into the user's timezone */
if (orig_time_was_utc) {
next = icaltime_convert_to_zone(next, icaltimezone_get_utc_timezone());
}
}
/* end of a recurring event */
if (gauge == 0 || icalgauge_compare(itr.gauge, comp) == 1) {
/* find a matched and return it */
itr.iter = citr;
return itr;
}
/* if it is a recurring but no matched occurrence has been found OR
* it is not a recurring and no matched component has been found,
* read the next component to find out */
getNextComp:
if ((rrule != NULL && itr.last_component == NULL) || (rrule == NULL)) {
(void)icalcompiter_next(&citr);
comp = icalcompiter_deref(&citr);
}
} /* while */
/* no matched component has found */
return icalsetiter_null;
}
static int gn_ical2calnote_real(icalcomponent *comp, gn_calnote *calnote, int id)
{
int retval = GN_ERR_FAILED;
struct icaltimetype dtstart = {0}, dtend = {0};
icalcomponent *compresult = NULL;
if (id < 1)
id = 1;
/* iterate through the component */
iterate_cal(comp, 0, &id, &compresult, ICAL_VEVENT_COMPONENT);
if (!compresult) {
dprintf("No component found.\n");
retval = GN_ERR_EMPTYLOCATION;
} else {
const char *str;
icalcomponent *alarm = {0};
icalproperty *rrule;
struct icalrecurrencetype recur;
retval = GN_ERR_NONE;
calnote->phone_number[0] = 0;
/* type */
str = comp_get_category(compresult);
calnote->type = str2calnote_type(str);
switch (calnote->type) {
case GN_CALNOTE_CALL:
/* description goes into text */
/* TODO: UTF8 --> ascii */
snprintf(calnote->phone_number, GN_CALNOTE_NUMBER_MAX_LENGTH-1, "%s", icalcomponent_get_summary(compresult));
str = icalcomponent_get_description(compresult);
break;
default:
/* summary goes into text */
/* TODO: UTF8 --> ascii */
str = icalcomponent_get_summary(compresult);
break;
}
if (str) {
snprintf(calnote->text, GN_CALNOTE_MAX_LENGTH - 1, "%s", str);
}
/* start time */
dtstart = icalcomponent_get_dtstart(compresult);
if (!icaltime_is_null_time(dtstart)) {
calnote->time.year = dtstart.year;
calnote->time.month = dtstart.month;
calnote->time.day = dtstart.day;
if (!icaltime_is_date(dtstart)) {
calnote->time.hour = dtstart.hour;
calnote->time.minute = dtstart.minute;
calnote->time.second = dtstart.second;
/* TODO: what about time zones? */
}
}
/* end time */
memset(&calnote->end_time, 0, sizeof(calnote->end_time));
dtend = icalcomponent_get_dtend(compresult);
if (!icaltime_is_null_time(dtend)) {
calnote->end_time.year = dtend.year;
calnote->end_time.month = dtend.month;
calnote->end_time.day = dtend.day;
if (!icaltime_is_date(dtend)) {
calnote->end_time.hour = dtend.hour;
calnote->end_time.minute = dtend.minute;
calnote->end_time.second = dtend.second;
/* TODO: what about time zones? */
}
}
/* alarm */
alarm = icalcomponent_get_first_component(compresult, ICAL_VALARM_COMPONENT);
if (alarm) {
icalproperty *trigger = NULL;
trigger = icalcomponent_get_first_property(alarm, ICAL_TRIGGER_PROPERTY);
if (trigger) {
struct icaltriggertype trigger_value;
struct icaltimetype alarm_start;
icalproperty *property;
trigger_value = icalvalue_get_trigger(icalproperty_get_value(trigger));
if (icaltriggertype_is_null_trigger(trigger_value) ||
icaltriggertype_is_bad_trigger(trigger_value)) {
calnote->alarm.enabled = 0;
} else {
if (icaltime_is_null_time(trigger_value.time)) {
memcpy(&alarm_start, &dtstart, sizeof(struct icaltimetype));
} else {
memcpy(&alarm_start, &trigger_value.time, sizeof(struct icaltimetype));
}
if (!(icaldurationtype_is_bad_duration(trigger_value.duration) ||
icaldurationtype_is_null_duration(trigger_value.duration))) {
alarm_start = icaltime_add(alarm_start, trigger_value.duration);
}
calnote->alarm.enabled = 1;
calnote->alarm.timestamp.year = alarm_start.year;
calnote->alarm.timestamp.month = alarm_start.month;
calnote->alarm.timestamp.day = alarm_start.day;
calnote->alarm.timestamp.hour = alarm_start.hour;
calnote->alarm.timestamp.minute = alarm_start.minute;
calnote->alarm.timestamp.second = alarm_start.second;
/* TODO: time zone? */
property = icalcomponent_get_first_property(alarm, ICAL_ACTION_PROPERTY);
calnote->alarm.tone = icalproperty_get_action(property) == ICAL_ACTION_AUDIO ? 1 : 0;
}
}
}
/* recurrence */
rrule = icalcomponent_get_first_property(compresult, ICAL_RRULE_PROPERTY);
if (rrule) {
recur = icalproperty_get_rrule(rrule);
calnote->occurrences = recur.count;
switch (recur.freq) {
case ICAL_SECONDLY_RECURRENCE:
dprintf("Not supported recurrence type. Approximating recurrence\n");
calnote->recurrence = recur.interval / 3600;
if (!calnote->recurrence)
calnote->recurrence = 1;
break;
case ICAL_MINUTELY_RECURRENCE:
dprintf("Not supported recurrence type. Approximating recurrence\n");
calnote->recurrence = recur.interval / 60;
if (!calnote->recurrence)
calnote->recurrence = 1;
break;
case ICAL_HOURLY_RECURRENCE:
calnote->recurrence = recur.interval;
break;
case ICAL_DAILY_RECURRENCE:
calnote->recurrence = recur.interval * 24;
break;
case ICAL_WEEKLY_RECURRENCE:
calnote->recurrence = recur.interval * 24 * 7;
break;
case ICAL_MONTHLY_RECURRENCE:
calnote->recurrence = GN_CALNOTE_MONTHLY;
break;
case ICAL_YEARLY_RECURRENCE:
calnote->recurrence = GN_CALNOTE_YEARLY;
break;
case ICAL_NO_RECURRENCE:
calnote->recurrence = GN_CALNOTE_NEVER;
break;
default:
dprintf("Not supported recurrence type. Assuming never\n");
calnote->recurrence = GN_CALNOTE_NEVER;
break;
}
}
str = icalcomponent_get_location(compresult);
if (!str)
str = "";
snprintf(calnote->mlocation, sizeof(calnote->mlocation), "%s", str);
}
if (compresult) {
#ifdef DEBUG
char *temp;
temp = icalcomponent_as_ical_string(compresult);
dprintf("Component found\n%s\n", temp);
free(temp);
#endif
icalcomponent_free(compresult);
}
return retval;
}
int main(int argc, char *argv[])
{
icalset *cin;
struct icaltimetype next;
icalcomponent *itr;
icalproperty *desc, *dtstart, *rrule;
struct icalrecurrencetype recur;
icalrecur_iterator* ritr;
time_t tt;
char* file;
icalerror_set_error_state(ICAL_PARSE_ERROR, ICAL_ERROR_NONFATAL);
#ifndef WIN32
signal(SIGALRM,sig_alrm);
#endif
if (argc <= 1) {
file = "../../test-data/recur.txt";
} else if (argc == 2) {
file = argv[1];
} else {
fprintf(stderr,"usage: recur [input file]\n");
exit(1);
}
#ifndef WIN32
alarm(300); /* to get file lock */
#endif
cin = icalfileset_new(file);
#ifndef WIN32
alarm(0);
#endif
if(cin == 0) {
fprintf(stderr,"recur: can't open file %s\n",file);
exit(1);
}
for (itr = icalfileset_get_first_component(cin);
itr != 0;
itr = icalfileset_get_next_component(cin)) {
struct icaltimetype start = icaltime_from_timet(1,0);
struct icaltimetype end = icaltime_today();
desc = icalcomponent_get_first_property(itr,ICAL_DESCRIPTION_PROPERTY);
dtstart = icalcomponent_get_first_property(itr,ICAL_DTSTART_PROPERTY);
rrule = icalcomponent_get_first_property(itr,ICAL_RRULE_PROPERTY);
if (desc == 0 || dtstart == 0 || rrule == 0) {
printf("\n******** Error in input component ********\n");
printf("The following component is malformed:\n %s\n",
icalcomponent_as_ical_string(itr));
continue;
}
printf("\n\n#### %s\n",icalproperty_get_description(desc));
printf("#### %s\n",icalvalue_as_ical_string(icalproperty_get_value(rrule)));
recur = icalproperty_get_rrule(rrule);
start = icalproperty_get_dtstart(dtstart);
ritr = icalrecur_iterator_new(recur,start);
tt = icaltime_as_timet(start);
printf("#### %s\n",ctime(&tt ));
icalrecur_iterator_free(ritr);
for(ritr = icalrecur_iterator_new(recur,start),
next = icalrecur_iterator_next(ritr);
!icaltime_is_null_time(next);
next = icalrecur_iterator_next(ritr)) {
tt = icaltime_as_timet(next);
printf(" %s",ctime(&tt ));
}
icalrecur_iterator_free(ritr);
icalcomponent_foreach_recurrence(itr, start, end,
recur_callback, NULL);
}
icalset_free(cin);
icaltimezone_free_builtin_timezones();
icalmemory_free_ring();
free_zone_directory();
return 0;
}
void parse_iCal(icalcomponent* comp)
{
icalcomponent * c;
icalproperty * rrule;
icalproperty * exdate;
icalrecur_iterator * data;
struct icaldurationtype offset;
struct icaltimetype time_start;
struct icaltimetype time_end;
struct icaltimetype time_next;
struct icaltimetype exdatetime;
struct icaltimetype now;
struct icalrecurrencetype recur;
int i = 0;
double duration;
// Get offset:
time_t t = time(NULL);
struct tm lt = {0};
localtime_r(&t, <);
if (debug_flag)
{
printf("Offset to GMT is %lds.\n", lt.tm_gmtoff);
}
offset.days = 0;
offset.weeks = 0;
offset.hours = 0;
offset.minutes = 0;
offset.seconds = 0;
offset.hours = lt.tm_gmtoff / 3600;
if (lt.tm_gmtoff < 0) {
offset.is_neg = 1;
} else {
offset.is_neg = 0;
}
// Get time now:
now = icaltime_today();
// Read each event:
for (c = icalcomponent_get_first_component(comp,ICAL_VEVENT_COMPONENT) ;
c != 0 ;
c = icalcomponent_get_next_component(comp,ICAL_VEVENT_COMPONENT)
)
{
// Get details about the event:
const char * summary = icalcomponent_get_summary(c);
const char * description = icalcomponent_get_description(c);
// Help:
if (debug_flag)
{
if (summary != NULL)
{
printf("summary: %s\n", summary);
}
if (description != NULL)
{
printf("description: %s\n", description);
}
}
// Ranging time:
time_start = icalcomponent_get_dtstart (c);
time_end = icalcomponent_get_dtend (c);
duration = difftime(icaltime_as_timet(time_end), icaltime_as_timet(time_start));
// Rules:
rrule = icalcomponent_get_first_property(c,ICAL_RRULE_PROPERTY);
recur = icalproperty_get_rrule(rrule);
data = icalrecur_iterator_new (recur, time_start);
// Find next event:
while (1)
{
time_next = icalrecur_iterator_next (data);
if (icaltime_is_null_time(time_next) == 1) break;
if (icaltime_compare(time_next, now) >= 0) break;
}
// Help:
if (debug_flag)
{
dump_icaltimetype("time start", time_start);
dump_icaltimetype("time end", time_end);
dump_icaltimetype("until", recur.until);
dump_icaltimetype("time next", time_next);
}
// One shot event:
if (
icaltime_is_null_time(time_next) == 1
&&
icaltime_compare(time_start, now) < 0
)
{
if (debug_flag) printf ("event (one shot) is in the past\n");
continue;
}
// Old event: discard recurent events finished before today...
if (
icaltime_is_null_time(recur.until) == 0
&&
icaltime_compare(recur.until, now) < 0
)
{
if (debug_flag) printf ("event is recurent in the past ...\n");
continue;
}
// Some help:
if (debug_flag > 2)
{
dump_icalrecurrencetype(recur);
}
// Set time and hours:
struct icaltimetype local_time_start = icaltime_add(time_start, offset);
printf ("%d %d ", local_time_start.minute, local_time_start.hour);
// Set option depending of recurence:
switch (recur.freq)
{
// Weekly: OK but need to remove days not needed... ?
case ICAL_WEEKLY_RECURRENCE:
printf ("%s", "* * ");
for (i = 0; recur.by_day[i] != 32639; i++)
{
printf ("%02d", icalrecurrencetype_day_day_of_week(recur.by_day[i]) -1);
if (recur.by_day[i+1] != 32639)
{
printf ("%s", ",");
}
}
printf ("%s", " ");
break;
// Happening each month:
case ICAL_MONTHLY_RECURRENCE:
// The Xth of the month:
if (recur.by_month_day[0] != 32639)
{
printf ("%02d * * ", recur.by_month_day[0]);
}
// Day of the week:
else
{
printf ("%d %d * ", time_next.day, time_next.month);
}
break;
// Event happening each year ... OK???
// OK: one shoot.
case ICAL_YEARLY_RECURRENCE:
case ICAL_NO_RECURRENCE:
default:
printf ("%02d %02d * ",
local_time_start.day,
local_time_start.month
);
}
// How many valid exclude dates:
exdate = icalcomponent_get_first_property(c, ICAL_EXDATE_PROPERTY);
unsigned int num_ex = 0;
if (exdate != NULL)
{
for (; exdate != NULL; exdate = icalcomponent_get_next_property(c, ICAL_EXDATE_PROPERTY) )
{
exdatetime = icalvalue_get_datetime(icalproperty_get_value(exdate));
if (icaltime_compare(exdatetime, now) >= 0)
{
num_ex++;
}
}
}
if (num_ex > 0)
{
exdate = icalcomponent_get_first_property(c, ICAL_EXDATE_PROPERTY);
for (; exdate != NULL; exdate = icalcomponent_get_next_property(c, ICAL_EXDATE_PROPERTY) )
{
exdatetime = icalvalue_get_datetime(icalproperty_get_value(exdate));
if (icaltime_compare(exdatetime, now) >= 0)
{
struct icaltimetype local_exdatetime = icaltime_add(exdatetime, offset);
printf ("%s", "[ \"$(date \"+\\\%Y\\\%m\\\%d\")\" = \"");
printf ("%04d%02d%02d", local_exdatetime.year, local_exdatetime.month, local_exdatetime.day);
printf ("%s", "\" ] || ");
}
}
}
// And the action:
printf ("%s %.0f\n",
summary,
duration
);
icalrecur_iterator_free (data);
}
}
static void
icaltimezone_expand_vtimezone (icalcomponent *comp,
int end_year,
icalarray *changes)
{
icaltimezonechange change;
icalproperty *prop;
struct icaltimetype dtstart, occ;
struct icalrecurrencetype rrule;
icalrecur_iterator* rrule_iterator;
struct icaldatetimeperiodtype rdate;
int found_dtstart = 0, found_tzoffsetto = 0, found_tzoffsetfrom = 0;
int has_recurrence = 0;
/* First we check if it is a STANDARD or DAYLIGHT component, and
just return if it isn't. */
if (icalcomponent_isa (comp) == ICAL_XSTANDARD_COMPONENT)
change.is_daylight = 0;
else if (icalcomponent_isa (comp) == ICAL_XDAYLIGHT_COMPONENT)
change.is_daylight = 1;
else
return;
/* Step through each of the properties to find the DTSTART,
TZOFFSETFROM and TZOFFSETTO. We can't expand recurrences here
since we need these properties before we can do that. */
prop = icalcomponent_get_first_property (comp, ICAL_ANY_PROPERTY);
while (prop) {
switch (icalproperty_isa (prop)) {
case ICAL_DTSTART_PROPERTY:
dtstart = icalproperty_get_dtstart (prop);
found_dtstart = 1;
break;
case ICAL_TZOFFSETTO_PROPERTY:
change.utc_offset = icalproperty_get_tzoffsetto (prop);
/*printf ("Found TZOFFSETTO: %i\n", change.utc_offset);*/
found_tzoffsetto = 1;
break;
case ICAL_TZOFFSETFROM_PROPERTY:
change.prev_utc_offset = icalproperty_get_tzoffsetfrom (prop);
/*printf ("Found TZOFFSETFROM: %i\n", change.prev_utc_offset);*/
found_tzoffsetfrom = 1;
break;
case ICAL_RDATE_PROPERTY:
case ICAL_RRULE_PROPERTY:
has_recurrence = 1;
break;
default:
/* Just ignore any other properties. */
break;
}
prop = icalcomponent_get_next_property (comp, ICAL_ANY_PROPERTY);
}
/* If we didn't find a DTSTART, TZOFFSETTO and TZOFFSETFROM we have to
ignore the component. FIXME: Add an error property? */
if (!found_dtstart || !found_tzoffsetto || !found_tzoffsetfrom)
return;
#if 0
printf ("\n Expanding component DTSTART (Y/M/D): %i/%i/%i %i:%02i:%02i\n",
dtstart.year, dtstart.month, dtstart.day,
dtstart.hour, dtstart.minute, dtstart.second);
#endif
/* If the STANDARD/DAYLIGHT component has no recurrence data, we just add
a single change for the DTSTART. */
if (!has_recurrence) {
change.year = dtstart.year;
change.month = dtstart.month;
change.day = dtstart.day;
change.hour = dtstart.hour;
change.minute = dtstart.minute;
change.second = dtstart.second;
/* Convert to UTC. */
icaltimezone_adjust_change (&change, 0, 0, 0, -change.prev_utc_offset);
#if 0
printf (" Appending single DTSTART (Y/M/D): %i/%02i/%02i %i:%02i:%02i\n",
change.year, change.month, change.day,
change.hour, change.minute, change.second);
#endif
/* Add the change to the array. */
icalarray_append (changes, &change);
return;
}
/* The component has recurrence data, so we expand that now. */
prop = icalcomponent_get_first_property (comp, ICAL_ANY_PROPERTY);
while (prop) {
#if 0
printf ("Expanding property...\n");
#endif
switch (icalproperty_isa (prop)) {
case ICAL_RDATE_PROPERTY:
rdate = icalproperty_get_rdate (prop);
change.year = rdate.time.year;
change.month = rdate.time.month;
change.day = rdate.time.day;
/* RDATEs with a DATE value inherit the time from
the DTSTART. */
if (icaltime_is_date(rdate.time)) {
change.hour = dtstart.hour;
change.minute = dtstart.minute;
change.second = dtstart.second;
} else {
change.hour = rdate.time.hour;
change.minute = rdate.time.minute;
change.second = rdate.time.second;
/* The spec was a bit vague about whether RDATEs were in local
time or UTC so we support both to be safe. So if it is in
UTC we have to add the UTC offset to get a local time. */
if (!icaltime_is_utc(rdate.time))
icaltimezone_adjust_change (&change, 0, 0, 0,
-change.prev_utc_offset);
}
#if 0
printf (" Appending RDATE element (Y/M/D): %i/%02i/%02i %i:%02i:%02i\n",
change.year, change.month, change.day,
change.hour, change.minute, change.second);
#endif
icalarray_append (changes, &change);
break;
case ICAL_RRULE_PROPERTY:
rrule = icalproperty_get_rrule (prop);
/* If the rrule UNTIL value is set and is in UTC, we convert it to
a local time, since the recurrence code has no way to convert
it itself. */
if (!icaltime_is_null_time (rrule.until) && rrule.until.is_utc) {
#if 0
printf (" Found RRULE UNTIL in UTC.\n");
#endif
/* To convert from UTC to a local time, we use the TZOFFSETFROM
since that is the offset from UTC that will be in effect
when each of the RRULE occurrences happens. */
icaltime_adjust (&rrule.until, 0, 0, 0,
change.prev_utc_offset);
rrule.until.is_utc = 0;
}
rrule_iterator = icalrecur_iterator_new (rrule, dtstart);
for (;;) {
occ = icalrecur_iterator_next (rrule_iterator);
if (occ.year > end_year || icaltime_is_null_time (occ))
break;
change.year = occ.year;
change.month = occ.month;
change.day = occ.day;
change.hour = occ.hour;
change.minute = occ.minute;
change.second = occ.second;
#if 0
printf (" Appending RRULE element (Y/M/D): %i/%02i/%02i %i:%02i:%02i\n",
change.year, change.month, change.day,
change.hour, change.minute, change.second);
#endif
icaltimezone_adjust_change (&change, 0, 0, 0,
-change.prev_utc_offset);
icalarray_append (changes, &change);
}
icalrecur_iterator_free (rrule_iterator);
break;
default:
break;
}
prop = icalcomponent_get_next_property (comp, ICAL_ANY_PROPERTY);
}
}
