void
scalix_appointment_unset (ScalixAppointment * comp, const char *key)
{
icalcomponent *icomp;
icalproperty *icalprop;
const char *x_val;
GSList *list, *iter;
list = NULL;
icomp = e_cal_component_get_icalcomponent (E_CAL_COMPONENT (comp));
icalprop = icalcomponent_get_first_property (icomp, ICAL_X_PROPERTY);
while (icalprop) {
const char *x_name;
x_name = icalproperty_get_x_name (icalprop);
x_val = icalproperty_get_x (icalprop);
if (!strcmp (x_name, key)) {
list = g_slist_prepend (list, icalprop);
}
icalprop = icalcomponent_get_next_property (icomp, ICAL_X_PROPERTY);
}
for (iter = list; iter; iter = iter->next) {
icalprop = iter->data;
icalcomponent_remove_property (icomp, icalprop);
icalproperty_free (icalprop);
}
return;
}
gboolean
scalix_appointment_get (ScalixAppointment * comp, const char *key, char **value)
{
icalcomponent *icomp;
icalproperty *icalprop;
const char *x_val;
icomp = e_cal_component_get_icalcomponent (E_CAL_COMPONENT (comp));
icalprop = icalcomponent_get_first_property (icomp, ICAL_X_PROPERTY);
while (icalprop) {
const char *x_name;
x_name = icalproperty_get_x_name (icalprop);
x_val = icalproperty_get_x (icalprop);
if (!strcmp (x_name, key)) {
break;
}
icalprop = icalcomponent_get_next_property (icomp, ICAL_X_PROPERTY);
}
if (icalprop) {
*value = g_strdup (x_val);
return TRUE;
}
*value = NULL;
return FALSE;
}
/** Gets the LOCATION or X-LIC-LOCATION property from a VTIMEZONE. */
static char*
icaltimezone_get_location_from_vtimezone (icalcomponent *component)
{
icalproperty *prop;
const char *location;
const char *name;
prop = icalcomponent_get_first_property (component,
ICAL_LOCATION_PROPERTY);
if (prop) {
location = icalproperty_get_location (prop);
if (location)
return strdup (location);
}
prop = icalcomponent_get_first_property (component, ICAL_X_PROPERTY);
while (prop) {
name = icalproperty_get_x_name (prop);
if (name && !strcasecmp (name, "X-LIC-LOCATION")) {
location = icalproperty_get_x (prop);
if (location)
return strdup (location);
}
prop = icalcomponent_get_next_property (component,
ICAL_X_PROPERTY);
}
return NULL;
}
static const char *get_expect(icalcomponent *c)
{
icalproperty *p;
const char *note = 0;
if (c != 0) {
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-EXPECT") == 0) {
note = icalproperty_get_x(p);
}
}
}
if (note == 0) {
note = "None";
}
return note;
}
static int get_expected_numevents(icalcomponent *c)
{
icalproperty *p;
const char* note = 0;
int num_events = 0;
if(c != 0){
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-EXPECT-NUMEVENTS")==0){
note = icalproperty_get_x(p);
}
}
}
if(note != 0){
num_events = atoi(note);
}
return num_events;
}
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;
}
//Order swapped from 7cterm.cpp due to dependencies
icalcomponent* find_event(icalcomponent* calendar)
{
int num_matches = 0;
//Display possible fields and prompt for which ones(!) to use
//FIXME Doesn't display possible properties for readability
cout << "Enter all properties you want to use in all caps, delimited by semicolons" << endl;
string properties;
cin >> properties;
char* c_properties = new char[properties.size()+1];
strcpy(c_properties, properties.c_str());
char* sel_props_c = strtok(c_properties, ";");
vector<string> sel_props;
vector<int> sel_props_pos;
while (sel_props_c != NULL)
{
sel_props.push_back(sel_props_c);
sel_props_pos.push_back(0);
sel_props_c = strtok(c_properties, ";");
}
string all_props[] = {"ATTACH", "ATTENDEE", "CATEGORIES", "CLASS", "COMMENT", "CONTACT", "CREATED", "DESCRIPTION", "DTEND", "DTSTAMP", "DTSTART", "DURATION", "EXDATE", "EXRULE", "GEO", "LAST-MOD", "LOCATION", "ORGANIZER", "PRIORITY", "RDATE", "RECURID", "RELATED", "RESOURCES", "RRULE", "RSTATUS", "SEQ", "STATUS", "SUMMARY", "TRANSP", "UID", "URL"};
for (int i = 0; i < sel_props.size() && i < 31; i++)
{
for (int j = 0; j < 31; j++)
{
if (sel_props[i] == all_props[j])
{
sel_props_pos[i] = j;
break;
}
}
if (sel_props[i] == "X-CLASS")
{
sel_props_pos[i] = 32; //beyond the end of all_props
}
}
vector<string> values;
cout << "Enter values for: " << endl;
for (int i = 0; i < sel_props.size(); i++)
{
cout << sel_props[i] << ": ";
flush(cout);
string value;
cin >> value; //FIXME error check for type
values.push_back(value);
}
//Iterate through class events and non-class events to match properties
icalcomponent *c;
vector<icalcomponent*> matching_events;
for (c = icalcomponent_get_first_component(calendar,ICAL_VEVENT_COMPONENT); c != 0; c = icalcomponent_get_next_component(calendar,ICAL_VEVENT_COMPONENT))
{
bool is_match = true;
//Check each of the properties
for (int i = 0; i < sel_props.size(); i++)
{
if (sel_props_pos[i] == 32)
{
icalproperty* p = icalcomponent_get_first_property(c, ICAL_X_PROPERTY);
char* class_name;
strcpy(class_name, icalproperty_get_x(p));
for (int j = 0; class_name != 0 && j < values[i].size(); j++)
{
if (class_name[j] != values[i][j])
{
is_match = false;
break;
}
}
}else
{
//FIXME Iterate through all properties
icalproperty* p = icalcomponent_get_first_property(c,ICAL_ANY_PROPERTY);
char* prop_value;
strcpy(prop_value, icalproperty_get_comment(p));
for (int j = 0; prop_value != 0 && j < values[i].size(); j++)
{
if (prop_value[j] != values[i][j])
{
is_match = false;
break;
}
}
}
}
if (is_match)
{
matching_events.push_back(c);
num_matches++;
}
}
if (num_matches == 0)
{
cout << "No matches found" << endl;
return NULL;
}
cout << "Which event do you want?" << endl;
int user_choice;
while (true)
{
cin >> user_choice;
if ((user_choice >= 1) && (user_choice <= num_matches))
{
break;
}
cout << "Invalid selection (Not between 1 and "<< num_matches <<" inclusive)" << endl;
}
//Return the user_choice-th event from the results
return matching_events[user_choice];
}
