+/*
+ * Phase 6 of "hunt for conflicts"
+ * called by ical_conflicts_phase5()
+ *
+ * Now both the proposed and existing events have been boiled down to start and end times.
+ * Check for overlap and output any conflicts.
+ */
+void ical_conflicts_phase6(struct icaltimetype t1start,
+ struct icaltimetype t1end,
+ struct icaltimetype t2start,
+ struct icaltimetype t2end,
+ long existing_msgnum,
+ char *conflict_event_uid,
+ char *conflict_event_summary,
+ char *compare_uid)
+{
+
+ /* debugging cruft */
+ // time_t tt;
+ // tt = icaltime_as_timet(t1start);
+ // CtdlLogPrintf(CTDL_DEBUG, "PROPOSED START: %s", ctime(&tt));
+ // tt = icaltime_as_timet(t1end);
+ // CtdlLogPrintf(CTDL_DEBUG, " PROPOSED END: %s", ctime(&tt));
+ // tt = icaltime_as_timet(t2start);
+ // CtdlLogPrintf(CTDL_DEBUG, "EXISTING START: %s", ctime(&tt));
+ // tt = icaltime_as_timet(t2end);
+ // CtdlLogPrintf(CTDL_DEBUG, " EXISTING END: %s", ctime(&tt));
+
+ /* compare and output */
+
+ if (ical_ctdl_is_overlap(t1start, t1end, t2start, t2end)) {
+ cprintf("%ld||%s|%s|%d|\n",
+ existing_msgnum,
+ conflict_event_uid,
+ conflict_event_summary,
+ ( ((strlen(compare_uid)>0)
+ &&(!strcasecmp(compare_uid,
+ conflict_event_uid))) ? 1 : 0
+ )
+ );
+ }
+
+}
+
+
+
/*
- * Backend for ical_hunt_for_conflicts()
+ * Phase 5 of "hunt for conflicts"
+ * Called by ical_conflicts_phase4()
+ *
+ * We have the proposed event boiled down to start and end times.
+ * Now check it against an existing event.
*/
-void ical_hunt_for_conflicts_backend(long msgnum, void *data) {
- icalcomponent *cal;
- struct CtdlMessage *msg = NULL;
- struct ical_respond_data ird;
- struct icaltimetype t1start, t1end, t2start, t2end;
- icalproperty *p;
+void ical_conflicts_phase5(struct icaltimetype t1start,
+ struct icaltimetype t1end,
+ icalcomponent *existing_event,
+ long existing_msgnum,
+ char *compare_uid)
+{
char conflict_event_uid[SIZ];
char conflict_event_summary[SIZ];
- char compare_uid[SIZ];
+ struct icaltimetype t2start, t2end;
+ icalproperty *p;
- cal = (icalcomponent *)data;
- strcpy(compare_uid, "");
+ /* recur variables */
+ icalproperty *rrule = NULL;
+ struct icalrecurrencetype recur;
+ icalrecur_iterator *ritr = NULL;
+ struct icaldurationtype dur;
+ int num_recur = 0;
+
+ /* initialization */
strcpy(conflict_event_uid, "");
strcpy(conflict_event_summary, "");
+ t2start = icaltime_null_time();
+ t2end = icaltime_null_time();
+
+ /* existing event stuff */
+ p = ical_ctdl_get_subprop(existing_event, ICAL_DTSTART_PROPERTY);
+ if (p == NULL) return;
+ if (p != NULL) t2start = icalproperty_get_dtstart(p);
+
+ p = ical_ctdl_get_subprop(existing_event, ICAL_DTEND_PROPERTY);
+ if (p != NULL) {
+ t2end = icalproperty_get_dtend(p);
+ dur = icaltime_subtract(t2end, t2start);
+ }
+
+ rrule = ical_ctdl_get_subprop(existing_event, ICAL_RRULE_PROPERTY);
+ if (rrule) {
+ recur = icalproperty_get_rrule(rrule);
+ ritr = icalrecur_iterator_new(recur, t2start);
+ CtdlLogPrintf(CTDL_DEBUG, "Recurrence found: %s\n", icalrecurrencetype_as_string(&recur));
+ }
+
+ do {
+ p = ical_ctdl_get_subprop(existing_event, ICAL_UID_PROPERTY);
+ if (p != NULL) {
+ strcpy(conflict_event_uid, icalproperty_get_comment(p));
+ }
+
+ p = ical_ctdl_get_subprop(existing_event, ICAL_SUMMARY_PROPERTY);
+ if (p != NULL) {
+ strcpy(conflict_event_summary, icalproperty_get_comment(p));
+ }
+
+ ical_conflicts_phase6(t1start, t1end, t2start, t2end,
+ existing_msgnum, conflict_event_uid, conflict_event_summary, compare_uid
+ );
+
+ if (rrule) {
+ t2start = icalrecur_iterator_next(ritr);
+ if (!icaltime_is_null_time(t2end)) {
+ t2end = icaltime_add(t2start, dur);
+ }
+ ++num_recur;
+ }
+
+ } while ( (rrule) && (!icaltime_is_null_time(t2start)) && (num_recur < MAX_RECUR) );
+ if (num_recur > 0) CtdlLogPrintf(CTDL_DEBUG, "Iterated over existing event %d times.\n", num_recur);
+}
- msg = CtdlFetchMessage(msgnum, 1);
- if (msg == NULL) return;
- memset(&ird, 0, sizeof ird);
- strcpy(ird.desired_partnum, "_HUNT_");
- mime_parser(msg->cm_fields['M'],
- NULL,
- *ical_locate_part, /* callback function */
- NULL, NULL,
- (void *) &ird, /* user data */
- 0
- );
- CtdlFreeMessage(msg);
- if (ird.cal == NULL) return;
+
+/*
+ * Phase 4 of "hunt for conflicts"
+ * Called by ical_hunt_for_conflicts_backend()
+ *
+ * At this point we've got it boiled down to two icalcomponent events in memory.
+ * If they conflict, output something to the client.
+ */
+void ical_conflicts_phase4(icalcomponent *proposed_event,
+ icalcomponent *existing_event,
+ long existing_msgnum)
+{
+ struct icaltimetype t1start, t1end;
t1start = icaltime_null_time();
t1end = icaltime_null_time();
- t2start = icaltime_null_time();
- t1end = icaltime_null_time();
+ icalproperty *p;
+ char compare_uid[SIZ];
- /* Now compare cal to ird.cal */
- p = ical_ctdl_get_subprop(ird.cal, ICAL_DTSTART_PROPERTY);
- if (p == NULL) return;
- if (p != NULL) t2start = icalproperty_get_dtstart(p);
-
- p = ical_ctdl_get_subprop(ird.cal, ICAL_DTEND_PROPERTY);
- if (p != NULL) t2end = icalproperty_get_dtend(p);
+ /* recur variables */
+ icalproperty *rrule = NULL;
+ struct icalrecurrencetype recur;
+ icalrecur_iterator *ritr = NULL;
+ struct icaldurationtype dur;
+ int num_recur = 0;
- p = ical_ctdl_get_subprop(cal, ICAL_DTSTART_PROPERTY);
+ /* initialization */
+ strcpy(compare_uid, "");
+
+ /* proposed event stuff */
+
+ p = ical_ctdl_get_subprop(proposed_event, ICAL_DTSTART_PROPERTY);
if (p == NULL) return;
if (p != NULL) t1start = icalproperty_get_dtstart(p);
- p = ical_ctdl_get_subprop(cal, ICAL_DTEND_PROPERTY);
- if (p != NULL) t1end = icalproperty_get_dtend(p);
-
- p = ical_ctdl_get_subprop(cal, ICAL_UID_PROPERTY);
+ p = ical_ctdl_get_subprop(proposed_event, ICAL_DTEND_PROPERTY);
if (p != NULL) {
- strcpy(compare_uid, icalproperty_get_comment(p));
+ t1end = icalproperty_get_dtend(p);
+ dur = icaltime_subtract(t1end, t1start);
}
- p = ical_ctdl_get_subprop(ird.cal, ICAL_UID_PROPERTY);
- if (p != NULL) {
- strcpy(conflict_event_uid, icalproperty_get_comment(p));
+ rrule = ical_ctdl_get_subprop(proposed_event, ICAL_RRULE_PROPERTY);
+ if (rrule) {
+ recur = icalproperty_get_rrule(rrule);
+ ritr = icalrecur_iterator_new(recur, t1start);
+ CtdlLogPrintf(CTDL_DEBUG, "Recurrence found: %s\n", icalrecurrencetype_as_string(&recur));
}
- p = ical_ctdl_get_subprop(ird.cal, ICAL_SUMMARY_PROPERTY);
+ p = ical_ctdl_get_subprop(proposed_event, ICAL_UID_PROPERTY);
if (p != NULL) {
- strcpy(conflict_event_summary, icalproperty_get_comment(p));
+ strcpy(compare_uid, icalproperty_get_comment(p));
}
- icalcomponent_free(ird.cal);
+ do {
+ ical_conflicts_phase5(t1start, t1end, existing_event, existing_msgnum, compare_uid);
- if (ical_ctdl_is_overlap(t1start, t1end, t2start, t2end)) {
- cprintf("%ld||%s|%s|%d|\n",
- msgnum,
- conflict_event_uid,
- conflict_event_summary,
- ( ((strlen(compare_uid)>0)
- &&(!strcasecmp(compare_uid,
- conflict_event_uid))) ? 1 : 0
- )
- );
- }
+ if (rrule) {
+ t1start = icalrecur_iterator_next(ritr);
+ if (!icaltime_is_null_time(t1end)) {
+ t1end = icaltime_add(t1start, dur);
+ }
+ ++num_recur;
+ }
+
+ } while ( (rrule) && (!icaltime_is_null_time(t1start)) && (num_recur < MAX_RECUR) );
+ if (num_recur > 0) CtdlLogPrintf(CTDL_DEBUG, "Iterated over proposed event %d times.\n", num_recur);
+}
+
+
+
+/*
+ * Phase 3 of "hunt for conflicts"
+ * Called by ical_hunt_for_conflicts()
+ */
+void ical_hunt_for_conflicts_backend(long msgnum, void *data) {
+ icalcomponent *proposed_event;
+ struct CtdlMessage *msg = NULL;
+ struct ical_respond_data ird;
+
+ proposed_event = (icalcomponent *)data;
+
+ msg = CtdlFetchMessage(msgnum, 1);
+ if (msg == NULL) return;
+ memset(&ird, 0, sizeof ird);
+ strcpy(ird.desired_partnum, "_HUNT_");
+ mime_parser(msg->cm_fields['M'],
+ NULL,
+ *ical_locate_part, /* callback function */
+ NULL, NULL,
+ (void *) &ird, /* user data */
+ 0
+ );
+ CtdlFreeMessage(msg);
+
+ if (ird.cal == NULL) return;
+
+ ical_conflicts_phase4(proposed_event, ird.cal, msgnum);
+ icalcomponent_free(ird.cal);
}
/*
* Phase 2 of "hunt for conflicts" operation.
* At this point we have a calendar object which represents the VEVENT that
- * we're considering adding to the calendar. Now hunt through the user's
+ * is proposed for addition to the calendar. Now hunt through the user's
* calendar room, and output zero or more existing VEVENTs which conflict
* with this one.
*/
{
if (!threading)
{
+
+ /* Tell libical to return errors instead of aborting if it gets bad data */
+ icalerror_errors_are_fatal = 0;
+
+ /* Initialize our hook functions */
CtdlRegisterMessageHook(ical_obj_beforesave, EVT_BEFORESAVE);
CtdlRegisterMessageHook(ical_obj_aftersave, EVT_AFTERSAVE);
CtdlRegisterSessionHook(ical_create_room, EVT_LOGIN);
projects / citadel.git / blobdiff