/** * e_cal_util_is_first_instance: * @comp: an #ECalComponent instance * @rid: a recurrence ID * @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 * * Returns whether the given @rid is the first instance of * the recurrence defined in the @comp. * * Return: Whether the @rid identifies the first instance of @comp. * * Since: 3.16 **/ gboolean e_cal_util_is_first_instance (ECalComponent *comp, struct icaltimetype rid, ECalRecurResolveTimezoneFn tz_cb, gpointer tz_cb_data) { CheckFirstInstanceData ifs; icalcomponent *icalcomp; time_t start, end; g_return_val_if_fail (E_IS_CAL_COMPONENT (comp), FALSE); g_return_val_if_fail (!icaltime_is_null_time (rid), FALSE); ifs.rid = rid; ifs.matches = FALSE; icalcomp = e_cal_component_get_icalcomponent (comp); start = icaltime_as_timet (icalcomponent_get_dtstart (icalcomp)) - 24 * 60 * 60; end = icaltime_as_timet (icalcomponent_get_dtend (icalcomp)) + 24 * 60 * 60; e_cal_recur_generate_instances (comp, start, end, check_first_instance_cb, &ifs, tz_cb, tz_cb_data, icaltimezone_get_utc_timezone ()); return ifs.matches; }
static void calendar_appointment_generate_occurrences (CalendarAppointment *appointment, icalcomponent *ical, ECalClient *cal, time_t start, time_t end, icaltimezone *default_zone) { ECalComponent *ecal; g_assert (appointment->occurrences == NULL); ecal = e_cal_component_new (); e_cal_component_set_icalcomponent (ecal, icalcomponent_new_clone (ical)); e_cal_recur_generate_instances (ecal, start, end, calendar_appointment_collect_occurrence, &appointment->occurrences, (ECalRecurResolveTimezoneFn) resolve_timezone_id, cal, default_zone); g_object_unref (ecal); appointment->occurrences = g_slist_reverse (appointment->occurrences); }
/* * (occurrences-count? START END) * (occurrences-count?) * * Counts occurrences either in the given time range (the first variant) * or in the time range defined by the expression itself (the second variant). * If the time range cannot be determined, then -1 is returned. */ static ESExpResult * func_occurrences_count (ESExp *esexp, gint argc, ESExpResult **argv, gpointer data) { SearchContext *ctx = data; time_t start, end; ESExpResult *result; icaltimezone *default_zone; /* Check argument types */ if (argc != 2 && argc != 0) { e_sexp_fatal_error ( esexp, _("\"%s\" expects none or two arguments"), "occurrences-count"); return NULL; } if (argc == 2) { if (argv[0]->type != ESEXP_RES_TIME) { e_sexp_fatal_error ( esexp, _("\"%s\" expects the first argument to be a time_t"), "occurrences-count"); return NULL; } start = argv[0]->value.time; if (argv[1]->type != ESEXP_RES_TIME) { e_sexp_fatal_error ( esexp, _("\"%s\" expects the second argument to be a time_t"), "occurrences-count"); return NULL; } end = argv[1]->value.time; } else if (ctx->expr_range_set) { start = ctx->expr_range_start; end = ctx->expr_range_end; } else { result = e_sexp_result_new (esexp, ESEXP_RES_INT); result->value.number = -1; return result; } default_zone = icaltimezone_get_utc_timezone (); ctx->occurrences_count = 0; e_cal_recur_generate_instances ( ctx->comp, start, end, count_instances_time_range_cb, ctx, resolve_tzid, ctx, default_zone); result = e_sexp_result_new (esexp, ESEXP_RES_INT); result->value.number = ctx->occurrences_count; return result; }
/** * e_cal_util_generate_alarms_for_comp: * @comp: The #ECalComponent to generate alarms from * @start: Start time * @end: End time * @omit: Alarm types to omit * @resolve_tzid: (closure user_data) (scope call): Callback for resolving * timezones * @user_data: (closure): Data to be passed to the resolve_tzid callback * @default_timezone: The timezone used to resolve DATE and floating DATE-TIME * values. * * Generates alarm instances for a calendar component. Returns the instances * structure, or %NULL if no alarm instances occurred in the specified time * range. * * Returns: (allow-none) (transfer full): a list of all the alarms found for the * given component in the given time range. The list of alarms should be freed * by using e_cal_component_free_alarm_list(). */ ECalComponentAlarms * e_cal_util_generate_alarms_for_comp (ECalComponent *comp, time_t start, time_t end, ECalComponentAlarmAction *omit, ECalRecurResolveTimezoneFn resolve_tzid, gpointer user_data, icaltimezone *default_timezone) { GList *alarm_uids; time_t alarm_start, alarm_end; struct alarm_occurrence_data aod; ECalComponentAlarms *alarms; if (!e_cal_component_has_alarms (comp)) return NULL; alarm_uids = e_cal_component_get_alarm_uids (comp); compute_alarm_range ( comp, alarm_uids, start, end, &alarm_start, &alarm_end); aod.alarm_uids = alarm_uids; aod.start = start; aod.end = end; aod.omit = omit; aod.triggers = NULL; aod.n_triggers = 0; e_cal_recur_generate_instances ( comp, alarm_start, alarm_end, add_alarm_occurrences_cb, &aod, resolve_tzid, user_data, default_timezone); /* We add the ABSOLUTE triggers separately */ generate_absolute_triggers ( comp, &aod, resolve_tzid, user_data, default_timezone); cal_obj_uid_list_free (alarm_uids); if (aod.n_triggers == 0) return NULL; /* Create the component alarm instances structure */ alarms = g_new (ECalComponentAlarms, 1); alarms->comp = comp; g_object_ref (G_OBJECT (alarms->comp)); alarms->alarms = g_slist_sort (aod.triggers, compare_alarm_instance); return alarms; }
/* (occur-in-time-range? START END TZLOC) * * START - time_t, start of the time range, in UTC * END - time_t, end of the time range, in UTC * TZLOC - optional string with timezone location to use * as default timezone; if not set, UTC is used * * Returns a boolean indicating whether the component has any occurrences in the * specified time range. */ static ESExpResult * func_occur_in_time_range (ESExp *esexp, gint argc, ESExpResult **argv, gpointer data) { SearchContext *ctx = data; time_t start, end; ESExpResult *result; icaltimezone *default_zone = NULL; /* Check argument types */ if (argc != 2 && argc != 3) { e_sexp_fatal_error ( esexp, _("\"%s\" expects two or three arguments"), "occur-in-time-range"); return NULL; } if (argv[0]->type != ESEXP_RES_TIME) { e_sexp_fatal_error ( esexp, _("\"%s\" expects the first " "argument to be a time_t"), "occur-in-time-range"); return NULL; } start = argv[0]->value.time; if (argv[1]->type != ESEXP_RES_TIME) { e_sexp_fatal_error ( esexp, _("\"%s\" expects the second " "argument to be a time_t"), "occur-in-time-range"); return NULL; } end = argv[1]->value.time; if (argc == 3) { if (argv[2]->type != ESEXP_RES_STRING) { e_sexp_fatal_error ( esexp, _("\"%s\" expects the third " "argument to be a string"), "occur-in-time-range"); return NULL; } default_zone = resolve_tzid (argv[2]->value.string, ctx); } if (!default_zone) default_zone = icaltimezone_get_utc_timezone (); /* See if the object occurs in the specified time range */ ctx->occurs = FALSE; e_cal_recur_generate_instances ( ctx->comp, start, end, (ECalRecurInstanceFn) check_instance_time_range_cb, ctx, resolve_tzid, ctx, default_zone); result = e_sexp_result_new (esexp, ESEXP_RES_BOOL); result->value.boolean = ctx->occurs; return result; }
static icalcomponent * create_user_free_busy (ECalBackendHttp *cbhttp, const gchar *address, const gchar *cn, time_t start, time_t end) { GSList *slist = NULL, *l; icalcomponent *vfb; icaltimezone *utc_zone; ECalBackendSExp *obj_sexp; ECalBackendHttpPrivate *priv; ECalBackendStore *store; gchar *query, *iso_start, *iso_end; priv = cbhttp->priv; store = priv->store; /* create the (unique) VFREEBUSY object that we'll return */ vfb = icalcomponent_new_vfreebusy (); if (address != NULL) { icalproperty *prop; icalparameter *param; prop = icalproperty_new_organizer (address); if (prop != NULL && cn != NULL) { param = icalparameter_new_cn (cn); icalproperty_add_parameter (prop, param); } if (prop != NULL) icalcomponent_add_property (vfb, prop); } utc_zone = icaltimezone_get_utc_timezone (); icalcomponent_set_dtstart (vfb, icaltime_from_timet_with_zone (start, FALSE, utc_zone)); icalcomponent_set_dtend (vfb, icaltime_from_timet_with_zone (end, FALSE, utc_zone)); /* add all objects in the given interval */ iso_start = isodate_from_time_t (start); iso_end = isodate_from_time_t (end); query = g_strdup_printf ( "occur-in-time-range? (make-time \"%s\") (make-time \"%s\")", iso_start, iso_end); obj_sexp = e_cal_backend_sexp_new (query); g_free (query); g_free (iso_start); g_free (iso_end); if (!obj_sexp) return vfb; slist = e_cal_backend_store_get_components (store); for (l = slist; l; l = g_slist_next (l)) { ECalComponent *comp = l->data; icalcomponent *icalcomp, *vcalendar_comp; icalproperty *prop; icalcomp = e_cal_component_get_icalcomponent (comp); if (!icalcomp) continue; /* If the event is TRANSPARENT, skip it. */ prop = icalcomponent_get_first_property ( icalcomp, ICAL_TRANSP_PROPERTY); if (prop) { icalproperty_transp transp_val = icalproperty_get_transp (prop); if (transp_val == ICAL_TRANSP_TRANSPARENT || transp_val == ICAL_TRANSP_TRANSPARENTNOCONFLICT) continue; } if (!e_cal_backend_sexp_match_comp ( obj_sexp, l->data, E_TIMEZONE_CACHE (cbhttp))) continue; vcalendar_comp = icalcomponent_get_parent (icalcomp); if (!vcalendar_comp) vcalendar_comp = icalcomp; e_cal_recur_generate_instances ( comp, start, end, free_busy_instance, vfb, resolve_tzid, vcalendar_comp, icaltimezone_get_utc_timezone ()); } g_object_unref (obj_sexp); return vfb; }