void
dates_new_cb (GtkWidget *source, DatesData *d)
{
icalcomponent *comp;
struct icalperiodtype period;
if (!dates_view_get_selected_period (d->view, &period)) {
struct icaltimetype date, now;
/* Create a default time event */
date = *(dates_view_get_date (d->view));
now = icaltime_current_time_with_zone (date.zone);
date.is_date = FALSE;
now.is_date = FALSE;
period.duration = icaldurationtype_null_duration ();
period.duration.minutes = 0;
/* New events default to starting at 9am */
period.duration.hours = 9;
period.start = icaltime_add (
date, period.duration);
/* NOTE: 11 is the magic number where we're viewing a
* month or more. See dates_zoom_change.
*/
period.duration.hours = (d->zoom >= 11) ? 8 : 2;
period.end = icaltime_add (period.start, period.duration);
}
comp = icalcomponent_new_vevent ();
icalcomponent_set_dtstart (comp, period.start);
icalcomponent_set_dtend (comp, period.end);
icalcomponent_set_summary (comp, _("New event"));
dates_new (d, comp, TRUE);
}
static gpointer
alter_cal_client (gpointer user_data)
{
ECalClient *cal_client = user_data;
GError *error = NULL;
icalcomponent *icalcomp;
struct icaltimetype now;
gchar *uid = NULL;
g_return_val_if_fail (cal_client != NULL, NULL);
now = icaltime_current_time_with_zone (icaltimezone_get_utc_timezone ());
icalcomp = icalcomponent_new (ICAL_VEVENT_COMPONENT);
icalcomponent_set_summary (icalcomp, "Initial event summary");
icalcomponent_set_dtstart (icalcomp, now);
icalcomponent_set_dtend (icalcomp, icaltime_from_timet (icaltime_as_timet (now) + 60 * 60 * 60, 0));
if (!e_cal_client_create_object_sync (cal_client, icalcomp, &uid, NULL, &error))
g_error ("create object sync: %s", error->message);
icalcomponent_set_uid (icalcomp, uid);
icalcomponent_set_summary (icalcomp, "Modified event summary");
if (!e_cal_client_modify_object_sync (cal_client, icalcomp, CALOBJ_MOD_ALL, NULL, &error))
g_error ("modify object sync: %s", error->message);
if (!e_cal_client_remove_object_sync (cal_client, uid, NULL, CALOBJ_MOD_ALL, NULL, &error))
g_error ("remove object sync: %s", error->message);
g_free (uid);
icalcomponent_free (icalcomp);
return FALSE;
}
static void
adjust_dtstart_day_to_rrule (icalcomponent *comp, struct icalrecurrencetype rule)
{
time_t now, year_start;
struct icaltimetype start, comp_start, iter_start, itime;
icalrecur_iterator *iter;
now = time (NULL);
itime = icaltime_from_timet (now, 0);
itime.month = itime.day = 1;
itime.hour = itime.minute = itime.second = 0;
year_start = icaltime_as_timet(itime);
comp_start = icalcomponent_get_dtstart (comp);
start = icaltime_from_timet (year_start, 0);
iter = icalrecur_iterator_new (rule, start);
iter_start = icalrecur_iterator_next (iter);
icalrecur_iterator_free (iter);
if (iter_start.day != comp_start.day) {
comp_start.day = iter_start.day;
icalcomponent_set_dtstart (comp, comp_start);
}
}
gint
main (gint argc,
gchar **argv)
{
ECalClient *cal_client;
GError *error = NULL;
icalcomponent *icalcomp;
struct icaltimetype now;
gchar *uid = NULL;
main_initialize ();
cal_client = new_temp_client (E_CAL_CLIENT_SOURCE_TYPE_EVENTS, NULL);
g_return_val_if_fail (cal_client != NULL, FALSE);
if (!e_client_open_sync (E_CLIENT (cal_client), FALSE, NULL, &error)) {
report_error ("client open sync", &error);
g_object_unref (cal_client);
return 1;
}
now = icaltime_current_time_with_zone (icaltimezone_get_utc_timezone ());
icalcomp = icalcomponent_new (ICAL_VEVENT_COMPONENT);
icalcomponent_set_summary (icalcomp, "Test event summary");
icalcomponent_set_dtstart (icalcomp, now);
icalcomponent_set_dtend (icalcomp, icaltime_from_timet (icaltime_as_timet (now) + 60 * 60 * 60, 0));
if (!e_cal_client_create_object_sync (cal_client, icalcomp, &uid, NULL, &error)) {
report_error ("create object sync", &error);
icalcomponent_free (icalcomp);
g_object_unref (cal_client);
return 1;
}
icalcomponent_free (icalcomp);
g_free (uid);
/* synchronously without main-loop */
if (!test_sync (cal_client)) {
g_object_unref (cal_client);
return 1;
}
start_in_thread_with_main_loop (test_sync_in_thread, cal_client);
if (!e_client_remove_sync (E_CLIENT (cal_client), NULL, &error)) {
report_error ("client remove sync", &error);
g_object_unref (cal_client);
return 1;
}
g_object_unref (cal_client);
if (get_main_loop_stop_result () == 0)
g_print ("Test finished successfully.\n");
return get_main_loop_stop_result ();
}
gint
main (gint argc,
gchar **argv)
{
ECal *cal;
gchar *uri = NULL;
ECalComponent *e_component;
ECalComponent *e_component_final;
icalcomponent *component;
icalcomponent *component_final;
struct icaltimetype icaltime;
gchar *uid;
g_type_init ();
cal = ecal_test_utils_cal_new_temp (&uri, E_CAL_SOURCE_TYPE_EVENT);
ecal_test_utils_cal_open (cal, FALSE);
ecal_test_utils_create_component (cal, INITIAL_BEGIN_TIME,
INITIAL_BEGIN_TIMEZONE, INITIAL_END_TIME,
INITIAL_END_TIMEZONE, EVENT_SUMMARY, &e_component,
&uid);
component = e_cal_component_get_icalcomponent (e_component);
component_final = ecal_test_utils_cal_get_object (cal, uid);
ecal_test_utils_cal_assert_objects_equal_shallow (component,
component_final);
icalcomponent_free (component_final);
/* make and commit changes */
icaltime = icaltime_from_string (FINAL_BEGIN_TIME);
icalcomponent_set_dtstart (component, icaltime);
ecal_test_utils_cal_component_set_icalcomponent (e_component,
component);
ecal_test_utils_cal_modify_object (cal, component, CALOBJ_MOD_ALL);
/* verify */
component_final = ecal_test_utils_cal_get_object (cal, uid);
e_component_final = e_cal_component_new ();
ecal_test_utils_cal_component_set_icalcomponent (e_component_final,
component_final);
ecal_test_utils_cal_assert_e_cal_components_equal (e_component,
e_component_final);
/* Clean-up */
ecal_test_utils_cal_remove (cal);
g_object_unref (e_component_final);
g_free (uid);
icalcomponent_free (component);
return 0;
}
static icalcomponent *
create_object (void)
{
icalcomponent *icalcomp;
struct icaltimetype now;
now = icaltime_current_time_with_zone (icaltimezone_get_utc_timezone ());
icalcomp = icalcomponent_new (ICAL_VEVENT_COMPONENT);
icalcomponent_set_summary (icalcomp, "To-be-sent event summary");
icalcomponent_set_dtstart (icalcomp, now);
icalcomponent_set_dtend (icalcomp, icaltime_from_timet_with_zone (icaltime_as_timet (now) + 60 * 60 * 60, 0, NULL));
return icalcomp;
}
static void
test_modify_object (ETestServerFixture *fixture,
gconstpointer user_data)
{
ECal *cal;
ECalComponent *e_component;
ECalComponent *e_component_final;
icalcomponent *component;
icalcomponent *component_final;
struct icaltimetype icaltime;
gchar *uid;
cal = E_TEST_SERVER_UTILS_SERVICE (fixture, ECal);
ecal_test_utils_create_component (
cal,
INITIAL_BEGIN_TIME, INITIAL_BEGIN_TIMEZONE,
INITIAL_END_TIME, INITIAL_END_TIMEZONE,
EVENT_SUMMARY, &e_component, &uid);
component = e_cal_component_get_icalcomponent (e_component);
component_final = ecal_test_utils_cal_get_object (cal, uid);
ecal_test_utils_cal_assert_objects_equal_shallow (
component, component_final);
icalcomponent_free (component_final);
/* make and commit changes */
icaltime = icaltime_from_string (FINAL_BEGIN_TIME);
icalcomponent_set_dtstart (component, icaltime);
ecal_test_utils_cal_component_set_icalcomponent (
e_component, component);
ecal_test_utils_cal_modify_object (cal, component, CALOBJ_MOD_ALL);
/* verify */
component_final = ecal_test_utils_cal_get_object (cal, uid);
e_component_final = e_cal_component_new ();
ecal_test_utils_cal_component_set_icalcomponent (
e_component_final, component_final);
ecal_test_utils_cal_assert_e_cal_components_equal (
e_component, e_component_final);
g_object_unref (e_component_final);
g_free (uid);
icalcomponent_free (component);
}
static void
setup_cal (ECalClient *cal_client)
{
GError *error = NULL;
icalcomponent *icalcomp;
struct icaltimetype now;
gchar *uid = NULL;
now = icaltime_current_time_with_zone (icaltimezone_get_utc_timezone ());
icalcomp = icalcomponent_new (ICAL_VEVENT_COMPONENT);
icalcomponent_set_summary (icalcomp, "Test event summary");
icalcomponent_set_dtstart (icalcomp, now);
icalcomponent_set_dtend (icalcomp, icaltime_from_timet (icaltime_as_timet (now) + 60 * 60 * 60, 0));
if (!e_cal_client_create_object_sync (cal_client, icalcomp, &uid, NULL, &error))
g_error ("create object sync: %s", error->message);
icalcomponent_free (icalcomp);
g_free (uid);
}
static void
get_revision_compare_cycle (ECalClient *client)
{
icalcomponent *icalcomp;
struct icaltimetype now;
gchar *revision_before = NULL, *revision_after = NULL, *uid = NULL;
GError *error = NULL;
/* Build up new component */
now = icaltime_current_time_with_zone (icaltimezone_get_utc_timezone ());
icalcomp = icalcomponent_new (ICAL_VEVENT_COMPONENT);
icalcomponent_set_summary (icalcomp, "Test event summary");
icalcomponent_set_dtstart (icalcomp, now);
icalcomponent_set_dtend (icalcomp, icaltime_from_timet (icaltime_as_timet (now) + 60 * 60 * 60, 0));
if (!e_client_get_backend_property_sync (E_CLIENT (client), CLIENT_BACKEND_PROPERTY_REVISION,
&revision_before, NULL, &error))
g_error ("Error getting book revision: %s", error->message);
if (!e_cal_client_create_object_sync (client, icalcomp, &uid, NULL, &error))
g_error ("Error creating object: %s", error->message);
if (!e_client_get_backend_property_sync (E_CLIENT (client), CLIENT_BACKEND_PROPERTY_REVISION,
&revision_after, NULL, &error))
g_error ("Error getting book revision: %s", error->message);
g_assert (revision_before);
g_assert (revision_after);
g_assert (strcmp (revision_before, revision_after) != 0);
g_message ("Passed cycle, revision before '%s' revision after '%s'",
revision_before, revision_after);
g_free (revision_before);
g_free (revision_after);
g_free (uid);
icalcomponent_free (icalcomp);
}
static gchar *
create_object (ECalClient *cal_client)
{
icalcomponent *icalcomp;
struct icaltimetype now;
gchar *uid = NULL;
GError *error = NULL;
g_return_val_if_fail (cal_client != NULL, NULL);
now = icaltime_current_time_with_zone (icaltimezone_get_utc_timezone ());
icalcomp = icalcomponent_new (ICAL_VEVENT_COMPONENT);
icalcomponent_set_summary (icalcomp, "To-be-removed event summary");
icalcomponent_set_dtstart (icalcomp, now);
icalcomponent_set_dtend (icalcomp, icaltime_from_timet_with_zone (icaltime_as_timet (now) + 60 * 60 * 60, 0, NULL));
if (!e_cal_client_create_object_sync (cal_client, icalcomp, &uid, NULL, &error))
g_error ("create object sync: %s", error->message);
icalcomponent_free (icalcomp);
return uid;
}
/**
* 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;
}
int main(int argc, char *argv[])
{
icalcomponent *c, *next_c = NULL;
int i = 0;
int dont_remove;
icalfileset_options options = { O_RDONLY, 0644, 0, NULL };
icalset *f = icalset_new(ICAL_FILE_SET, TEST_DATADIR "/process-incoming.ics", &options);
icalset *trash = icalset_new_file("trash.ics");
icalset *cal = icalset_new(ICAL_FILE_SET, TEST_DATADIR "/process-calendar.ics", &options);
icalset *out = icalset_new_file("outgoing.ics");
const char *this_user = "******";
_unused(argc);
_unused(argv);
assert(f != 0);
assert(cal != 0);
assert(trash != 0);
assert(out != 0);
/* Foreach incoming message */
for (c = icalset_get_first_component(f); c != 0; c = next_c) {
icalproperty_xlicclass class;
icalcomponent *match;
icalcomponent *inner;
icalcomponent *reply = 0;
assert(c != 0);
inner = icalcomponent_get_first_real_component(c);
i++;
reply = 0;
dont_remove = 0;
if (inner == 0) {
printf("Bad component, no inner\n %s\n", icalcomponent_as_ical_string(c));
continue;
}
/* Find a booked component that is matched to the incoming
message, based on the incoming component's UID, SEQUENCE
and RECURRENCE-ID */
match = icalset_fetch_match(cal, c);
class = icalclassify(c, match, this_user);
/* Print out the notes associated with the incoming component
and the matched component in the */
{
const char *inc_note = 0;
const char *match_note = 0;
icalproperty *p;
for (p = icalcomponent_get_first_property(c, ICAL_X_PROPERTY);
p != 0; p = icalcomponent_get_next_property(c, ICAL_X_PROPERTY)) {
if (strcmp(icalproperty_get_x_name(p), "X-LIC-NOTE") == 0) {
inc_note = icalproperty_get_x(p);
}
}
if (match != 0) {
for (p = icalcomponent_get_first_property(match, ICAL_X_PROPERTY);
p != 0;
p = icalcomponent_get_next_property(match, ICAL_X_PROPERTY)) {
if (strcmp(icalproperty_get_x_name(p), "X-LIC-NOTE") == 0) {
match_note = icalproperty_get_x(p);
}
}
}
if (inc_note != 0) {
printf("Incoming: %s\n", inc_note);
}
if (match_note != 0) {
printf("Match : %s\n", match_note);
}
}
/* Main processing structure */
switch (class) {
case ICAL_XLICCLASS_NONE:{
char temp[1024];
/* Huh? Return an error to sender */
icalrestriction_check(c);
icalcomponent_convert_errors(c);
snprintf(temp, 1024,
"I can't understand the component you sent.\n"
"Here is the component you sent, possibly with error messages:\n"
"%s",
icalcomponent_as_ical_string(c));
reply = icalmessage_new_error_reply(c, this_user, temp, "", ICAL_UNKNOWN_STATUS);
break;
}
case ICAL_XLICCLASS_PUBLISHNEW:{
/* Don't accept published events from anyone but
self. If self, fall through to ICAL_XLICCLASS_REQUESTNEW */
}
case ICAL_XLICCLASS_REQUESTNEW:{
/* Book the new component if it does not overlap
anything. If the time is busy and the start time is
an even modulo 4, delegate to
[email protected]. If the time is busy and
is 1 modulo 4, counterpropose for the first
available free time. Otherwise, deline the meeting */
icalcomponent *overlaps = icalclassify_find_overlaps(cal, c);
if (overlaps == 0) {
/* No overlaps, book the meeting */
/* icalset_add_component(cal,icalcomponent_new_clone(c));*/
/* Return a reply */
reply =
icalmessage_new_accept_reply(
c, this_user, "I can make it to this meeting");
(void)icalset_add_component(out, reply);
} else {
/* There was a conflict, so delegate, counterpropose
or decline it */
struct icaltimetype dtstart = icalcomponent_get_dtstart(c);
if (dtstart.hour % 4 == 0) {
/* Delegate the meeting */
reply =
icalmessage_new_delegate_reply(
c,
this_user,
"*****@*****.**",
"Unfortunately, I have another commitment that conflicts "
"with this meeting. I am delegating my attendance to Bob.");
(void)icalset_add_component(out, reply);
} else if (dtstart.hour % 4 == 1) {
/* Counter propose to next available time */
icalcomponent *newc;
struct icalperiodtype next_time;
icalspanlist *spanl = icalspanlist_new(cal, dtstart,
icaltime_null_time());
next_time =
icalspanlist_next_free_time(spanl, icalcomponent_get_dtstart(c));
newc = icalcomponent_new_clone(c);
icalcomponent_set_dtstart(newc, next_time.start);
/* Hack, the duration of the counterproposed
meeting may be longer than the free time
available */
icalcomponent_set_duration(newc, icalcomponent_get_duration(c));
reply =
icalmessage_new_counterpropose_reply(
c,
newc,
this_user,
"Unfortunately, I have another commitment that conflicts with "
"this meeting. I am proposing a time that works better for me.");
(void)icalset_add_component(out, reply);
icalspanlist_free(spanl);
icalcomponent_free(newc);
} else {
/* Decline the meeting */
reply =
icalmessage_new_decline_reply(
c,
this_user,
"I can't make it to this meeting");
(void)icalset_add_component(out, reply);
}
}
icalcomponent_free(overlaps);
break;
}
case ICAL_XLICCLASS_PUBLISHFREEBUSY:{
/* Store the busy time information in a file named after
the sender */
break;
}
case ICAL_XLICCLASS_PUBLISHUPDATE:{
/* Only accept publish updates from self. If self, fall
through to ICAL_XLICCLASS_REQUESTUPDATE */
}
case ICAL_XLICCLASS_REQUESTUPDATE:{
/* always accept the changes */
break;
}
case ICAL_XLICCLASS_REQUESTRESCHEDULE:{
/* Use same rules as REQUEST_NEW */
(void)icalclassify_find_overlaps(cal, c);
break;
}
case ICAL_XLICCLASS_REQUESTDELEGATE:{
break;
}
case ICAL_XLICCLASS_REQUESTNEWORGANIZER:{
break;
}
case ICAL_XLICCLASS_REQUESTFORWARD:{
break;
}
case ICAL_XLICCLASS_REQUESTSTATUS:{
break;
}
case ICAL_XLICCLASS_REQUESTFREEBUSY:{
break;
}
case ICAL_XLICCLASS_REPLYACCEPT:{
/* Change the PARTSTAT of the sender */
break;
}
case ICAL_XLICCLASS_REPLYDECLINE:{
/* Change the PARTSTAT of the sender */
break;
}
case ICAL_XLICCLASS_REPLYCRASHERACCEPT:{
/* Add the crasher to the ATTENDEE list with the
appropriate PARTSTAT */
break;
}
case ICAL_XLICCLASS_REPLYCRASHERDECLINE:{
/* Add the crasher to the ATTENDEE list with the
appropriate PARTSTAT */
break;
}
case ICAL_XLICCLASS_ADDINSTANCE:{
break;
}
case ICAL_XLICCLASS_CANCELEVENT:{
/* Remove the component */
break;
}
case ICAL_XLICCLASS_CANCELINSTANCE:{
break;
}
case ICAL_XLICCLASS_CANCELALL:{
/* Remove the component */
break;
}
case ICAL_XLICCLASS_REFRESH:{
/* Resend the latest copy of the request */
break;
}
case ICAL_XLICCLASS_COUNTER:{
break;
}
case ICAL_XLICCLASS_DECLINECOUNTER:{
break;
}
case ICAL_XLICCLASS_MALFORMED:{
/* Send back an error */
break;
}
case ICAL_XLICCLASS_OBSOLETE:{
printf(" ** Got an obsolete component:\n%s", icalcomponent_as_ical_string(c));
/* Send back an error */
break;
}
case ICAL_XLICCLASS_MISSEQUENCED:{
printf(" ** Got a missequenced component:\n%s", icalcomponent_as_ical_string(c));
/* Send back an error */
break;
}
case ICAL_XLICCLASS_UNKNOWN:{
printf(" ** Don't know what to do with this component:\n%s",
icalcomponent_as_ical_string(c));
/* Send back an error */
break;
}
case ICAL_XLICCLASS_X:
case ICAL_XLICCLASS_REPLYDELEGATE:
default:{
}
}
#if 0
if (reply != 0) {
/* Don't send the reply if the RSVP parameter indicates not to */
icalcomponent *reply_inner;
icalproperty *attendee;
icalparameter *rsvp;
reply_inner = icalcomponent_get_first_real_component(reply);
attendee = icalcomponent_get_first_property(reply_inner, ICAL_ATTENDEE_PROPERTY);
rsvp = icalproperty_get_first_parameter(attendee, ICAL_RSVP_PARAMETER);
if (rsvp == 0 || icalparameter_get_rsvp(rsvp) == 1) {
icalrestriction_check(reply);
send_message(reply, this_user);
}
icalcomponent_free(reply);
}
#endif
if (reply != 0) {
printf("%s\n", icalcomponent_as_ical_string(reply));
}
next_c = icalset_get_next_component(f);
if (dont_remove == 0) {
/*icalset_remove_component(f,c);
icalset_add_component(trash,c); */
}
}
#if 0
for (c = icalset_get_first_component(out); c != 0; c = icalset_get_next_component(out)) {
printf("%s", icalcomponent_as_ical_string(c));
}
#endif
icalset_free(f);
icalset_free(trash);
icalset_free(cal);
icalset_free(out);
return 0;
}
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;
}
