path: root/calendar/cal-util/icalendar-save.c

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */

#include <config.h>
#include <unistd.h>
#include <sys/stat.h>
#include "icalendar-save.h"


static void unparse_person (iCalPerson *person, icalproperty *person_prop);
static struct icaltimetype timet_to_icaltime (time_t tt);
static icalproperty *unparse_related (iCalRelation *rel);
static icalcomponent *unparse_alarm (CalendarAlarm *alarm);


icalcomponent*
icalcomponent_create_from_ical_object (iCalObject *ical)
{
    icalcomponent_kind kind;
    icalcomponent *comp;
    icalproperty *prop;

    switch (ical->type) {
    case ICAL_EVENT: kind = ICAL_VEVENT_COMPONENT; break;
    case ICAL_TODO: kind = ICAL_VTODO_COMPONENT; break;
    case ICAL_JOURNAL: kind = ICAL_VJOURNAL_COMPONENT; break;
    case ICAL_FBREQUEST: kind = ICAL_VFREEBUSY_COMPONENT; break;
    case ICAL_TIMEZONE: kind = ICAL_VTIMEZONE_COMPONENT; break;
    default:
        kind = ICAL_NO_COMPONENT; break;
    }

    comp = icalcomponent_new (kind);

    /*** calscale ***/
    prop = icalproperty_new_calscale ("GREGORIAN");
    icalcomponent_add_property (comp, prop);

    /*** catagories ***/
    if (ical->categories) {     
        /* ical->categories is a GList of (char *) */
        GList *cur;
        for (cur = ical->categories; cur; cur = cur->next) {
            prop = icalproperty_new_categories ((char *) cur);
            icalcomponent_add_property (comp, prop);
        }
    }

    /*** class ***/
    if (ical->class) {
        prop = icalproperty_new_class (ical->class);
        icalcomponent_add_property (comp, prop);
    }

    /*** comment ***/
    if (ical->comment) {
        prop = icalproperty_new_comment (ical->comment);
        icalcomponent_add_property (comp, prop);
    }

    /*** description ***/
    if (ical->desc) {
        prop = icalproperty_new_description (ical->desc);
        icalcomponent_add_property (comp, prop);
    }

    /*** geo ***/
    if (ical->geo.valid) {
        struct icalgeotype v;
        v.lat = ical->geo.latitude;
        v.lon = ical->geo.longitude;
        prop = icalproperty_new_geo (v);
        icalcomponent_add_property (comp, prop);
    }

    /*** location ***/
    if (ical->location) {
        prop = icalproperty_new_location (ical->location);
        icalcomponent_add_property (comp, prop);
    }

    /*** percentcomplete ***/
    prop = icalproperty_new_percentcomplete (ical->percent);
    icalcomponent_add_property (comp, prop);

    /*** priority ***/
    if (ical->priority) {
        prop = icalproperty_new_priority (ical->priority);
        icalcomponent_add_property (comp, prop);
    }

    /*** resources ***/
    if (ical->resources) {
        /* ical->resources is a GList of (char *) */
        GList *cur;
        for (cur = ical->resources; cur; cur = cur->next) {
            prop = icalproperty_new_resources ((char *) cur);
            icalcomponent_add_property (comp, prop);
        }
    }

    /*** status ***/
    if (ical->status) {
        prop = icalproperty_new_status (ical->status);
        icalcomponent_add_property (comp, prop);
    }

    /*** summary ***/
    if (ical->summary) {
        prop = icalproperty_new_summary (ical->summary);
        icalcomponent_add_property (comp, prop);
    }

    /*** completed ***/
    if (ical->completed) {
        struct icaltimetype ictime;
        ictime = timet_to_icaltime (ical->completed);
        prop = icalproperty_new_completed (ictime);
        icalcomponent_add_property (comp, prop);
    }

    /*** dtend ***/  /*** due ***/
    if (ical->dtend) {
        /* FIXME: We should handle timezone specifiers */
        struct icaltimetype ictime;
        ictime = timet_to_icaltime (ical->dtend);
        if (ical->type == ICAL_TODO)
            prop = icalproperty_new_due (ictime);
        else
            prop = icalproperty_new_dtend (ictime);
        if (ical->date_only) {
            icalparameter *param;
            param = icalparameter_new (ICAL_VALUE_PARAMETER);
            icalparameter_set_value (param, ICAL_VALUE_DATE);
            icalproperty_add_parameter (prop, param);
        }
        icalcomponent_add_property (comp, prop);
    }

    /*** dtstart ***/
    if (ical->dtstart) {
        /* FIXME: We should handle timezone specifiers */
        struct icaltimetype ictime;
        ictime = timet_to_icaltime (ical->dtstart);
        prop = icalproperty_new_dtstart (ictime);
        if (ical->date_only) {
            icalparameter *param;
            param = icalparameter_new (ICAL_VALUE_PARAMETER);
            icalparameter_set_value (param, ICAL_VALUE_DATE);
            icalproperty_add_parameter (prop, param);
        }
        icalcomponent_add_property (comp, prop);
    }

    /*** duration ***/
    {
        /* FIX ME */
    }

    /*** freebusy ***/
    {
        /* FIX ME */
    }

    /*** transp ***/
    {
        if (ical->transp == ICAL_TRANSP_PROPERTY)
            prop = icalproperty_new_transp ("TRANSPARENT");
        else
            prop = icalproperty_new_transp ("OPAQUE");
        icalcomponent_add_property (comp, prop);
    }

    /*
      ICAL_TZID_PROPERTY:
      ICAL_TZNAME_PROPERTY:
      ICAL_TZOFFSETFROM_PROPERTY:
      ICAL_TZOFFSETTO_PROPERTY:
      ICAL_TZURL_PROPERTY:
    */

    /*** attendee ***/
    if (ical->attendee) {
        /* a list of (iCalPerson *) */
        GList *cur;
        for (cur = ical->attendee; cur; cur = cur->next) {
            iCalPerson *person = (iCalPerson *) cur->data;
            prop = icalproperty_new_attendee (person->addr);
            unparse_person (person, prop);
            icalcomponent_add_property (comp, prop);
        }
    }

    /*** contact ***/
    if (ical->contact) {
        /* a list of (iCalPerson *) */
        GList *cur;
        for (cur = ical->contact; cur; cur = cur->next) {
            iCalPerson *person = (iCalPerson *) cur->data;
            prop = icalproperty_new_contact (person->addr);
            unparse_person (person, prop);
            icalcomponent_add_property (comp, prop);
        }
    }

    /*** organizer ***/
    if (ical->organizer) {
        prop = icalproperty_new_organizer (ical->organizer->addr);
        unparse_person (ical->organizer, prop);
        icalcomponent_add_property (comp, prop);
    }

    /*** recurrenceid ***/
    if (ical->recurid) {
        struct icaltimetype ictime;
        ictime = timet_to_icaltime (ical->recurid);
        prop = icalproperty_new_recurrenceid (ictime);
    }

    /*** relatedto ***/

    if (ical->related) {
        /* a list of (iCalPerson *) */
        GList *cur;
        for (cur = ical->related; cur; cur = cur->next) {
            iCalRelation *related = (iCalRelation *) cur->data;
            prop = unparse_related (related);
            icalcomponent_add_property (comp, prop);
        }
    }


    /*** url ***/
    if (ical->url) {
        prop = icalproperty_new_url (ical->url);
        icalcomponent_add_property (comp, prop);
    }

    /*** uid ***/
    if (ical->uid) {
        prop = icalproperty_new_uid (ical->uid);
        icalcomponent_add_property (comp, prop);
    }

    /*** exdate ***/
    if (ical->exdate) {
        struct icaltimetype v;
        GList *cur;
        for (cur = ical->exdate; cur; cur = cur->next) {
            time_t t = (time_t) cur->data;
            v = timet_to_icaltime (t);
            prop = icalproperty_new_exdate (v);
            icalcomponent_add_property (comp, prop);
        }
    }

    /*** created ***/
    if (ical->created) {
        struct icaltimetype v;
        v = timet_to_icaltime (ical->created);
        prop = icalproperty_new_created (v);
        icalcomponent_add_property (comp, prop);
    }

    /*** dtstamp ***/
    if (ical->dtstamp) {
        struct icaltimetype v;
        v = timet_to_icaltime (ical->dtstamp);
        prop = icalproperty_new_created (v);
        icalcomponent_add_property (comp, prop);
    }

    /*** lastmodified ***/
    if (ical->last_mod) {
        struct icaltimetype v;
        v = timet_to_icaltime (ical->last_mod);
        prop = icalproperty_new_created (v);
        icalcomponent_add_property (comp, prop);
    }

    /*** sequence ***/
    if (ical->seq) {
        prop = icalproperty_new_sequence (ical->seq);
        icalcomponent_add_property (comp, prop);
    }

    /*** requeststatus ***/
    if (ical->rstatus) {
        prop = icalproperty_new_requeststatus (ical->rstatus);
        icalcomponent_add_property (comp, prop);
    }

    /* if there is a VALARM subcomponent, add it here */

    if (ical->alarms) {
        GList *cur;
        for (cur = ical->alarms; cur; cur = cur->next) {
            CalendarAlarm *alarm = (CalendarAlarm *) cur->data;
            icalcomponent *subcomp = unparse_alarm (alarm);
            icalcomponent_add_component (comp, subcomp);
        }
    }

    return comp;
}


/* FIX ME -- same as icaltimetype_from_timet in icaltypes.c */
static
struct icaltimetype timet_to_icaltime (time_t tt)
{
    struct tm *t;
    struct icaltimetype i;

    t = gmtime (&tt);

    /*return tt - (i->is_utc ? timezone : 0); */
    i.is_utc = 0;

    i.year = t->tm_year + 1900;
    i.month = t->tm_mon + 1;
    i.day = t->tm_mday;

    if (t->tm_hour == 0 && t->tm_min == 0 && t->tm_sec == 0) {
        i.is_date = 1;
        i.hour = 0;
        i.minute = 0;
        i.second = 0;
    } else {
        i.is_date = 0;
        i.hour = t->tm_hour;
        i.minute = t->tm_min;
        i.second = t->tm_sec;
    }

    return i;
}


/* fills in "person_prop" with information from "person" */

static
void unparse_person (iCalPerson *person, icalproperty *person_prop)
{
    icalparameter *param;
    GList *cur;

    /* convert iCalPerson to an icalproperty */

    if (person->name) {
        param = icalparameter_new_cn (person->name);
        icalproperty_add_parameter (person_prop, param);
    }

    if (g_strcasecmp (person->role, "CHAIR") == 0)
        param = icalparameter_new_role (ICAL_ROLE_CHAIR);
    else if (g_strcasecmp (person->role, "REQPARTICIPANT") == 0)
        param = icalparameter_new_role (ICAL_ROLE_REQPARTICIPANT);
    else if (g_strcasecmp (person->role, "OPTPARTICIPANT") == 0)
        param = icalparameter_new_role (ICAL_ROLE_OPTPARTICIPANT);
    else if (g_strcasecmp (person->role, "NONPARTICIPANT") == 0)
        param = icalparameter_new_role (ICAL_ROLE_NONPARTICIPANT);
    else
        param = icalparameter_new_role (ICAL_ROLE_XNAME);
    icalproperty_add_parameter (person_prop, param);

    if (g_strcasecmp (person->partstat, "NEEDSACTION") == 0)
        param = icalparameter_new_partstat (ICAL_PARTSTAT_NEEDSACTION);
    else if (g_strcasecmp (person->partstat, "ACCEPTED") == 0)
        param = icalparameter_new_partstat (ICAL_PARTSTAT_ACCEPTED);
    else if (g_strcasecmp (person->partstat, "DECLINED") == 0)
        param = icalparameter_new_partstat (ICAL_PARTSTAT_DECLINED);
    else if (g_strcasecmp (person->partstat, "TENTATIVE") == 0)
        param = icalparameter_new_partstat (ICAL_PARTSTAT_TENTATIVE);
    else if (g_strcasecmp (person->partstat, "DELEGATED") == 0)
        param = icalparameter_new_partstat (ICAL_PARTSTAT_DELEGATED);
    else if (g_strcasecmp (person->partstat, "COMPLETED") == 0)
        param = icalparameter_new_partstat (ICAL_PARTSTAT_COMPLETED);
    else if (g_strcasecmp (person->partstat, "INPROCESS") == 0)
        param = icalparameter_new_partstat (ICAL_PARTSTAT_INPROCESS);
    else /* FIX ME, NEEDSACTION instead? */
        param = icalparameter_new_partstat (ICAL_PARTSTAT_XNAME);
    icalproperty_add_parameter (person_prop, param);

    if (person->rsvp != FALSE) {
        param = icalparameter_new_rsvp (TRUE);
        icalproperty_add_parameter (person_prop, param);
    }

    if (g_strcasecmp (person->cutype, "INDIVIDUAL") == 0)
        param = icalparameter_new_cutype (ICAL_CUTYPE_INDIVIDUAL);
    else if (g_strcasecmp (person->cutype, "GROUP") == 0)
        param = icalparameter_new_cutype (ICAL_CUTYPE_GROUP);
    else if (g_strcasecmp (person->cutype, "RESOURCE") == 0)
        param = icalparameter_new_cutype (ICAL_CUTYPE_RESOURCE);
    else if (g_strcasecmp (person->cutype, "ROOM") == 0)
        param = icalparameter_new_cutype (ICAL_CUTYPE_ROOM);
    else /* FIX ME, INDIVIDUAL instead? */
        param = icalparameter_new_cutype (ICAL_CUTYPE_UNKNOWN);
    icalproperty_add_parameter (person_prop, param);

    /* person->member is a list of ICAL_MEMBER_PARAMETER */
    for (cur = person->member; cur; cur = cur->next) {
        gchar *member = (gchar *) cur->data;
        param = icalparameter_new_member (member);
        icalproperty_add_parameter (person_prop, param);
    }

    /* person->deleg_to is a list of ICAL_DELEGATEDTO_PARAMETER */
    for (cur = person->deleg_to; cur; cur = cur->next) {
        gchar *deleg_to = (gchar *) cur->data;
        param = icalparameter_new_delegatedto (deleg_to);
        icalproperty_add_parameter (person_prop, param);
    }

    /* ret->deleg_from is a list of ICAL_DELEGATEDFROM_PARAMETER */
    for (cur = person->deleg_from; cur; cur = cur->next) {
        gchar *deleg_from = (gchar *) cur->data;
        param = icalparameter_new_delegatedfrom (deleg_from);
        icalproperty_add_parameter (person_prop, param);
    }

    if (person->sent_by) {
        param = icalparameter_new_sentby (person->sent_by);
        icalproperty_add_parameter (person_prop, param);
    }

    /* ret->deleg_to is a list of ICAL_DIR_PARAMETER */
    /* FIX ME ... */
}


static
icalproperty *unparse_related (iCalRelation *rel)
{
    icalproperty *prop;

    prop = icalproperty_new_relatedto (rel->reltype);

    icalproperty_set_relatedto (prop, rel->uid);

    /* FIX ME  RELTYPE_XNAME ? */
    
    return prop;
}


static
icalcomponent *unparse_alarm (CalendarAlarm *alarm)
{
    icalcomponent *comp = icalcomponent_new (ICAL_VALARM_COMPONENT);
    icalproperty *prop;

    prop = NULL;
    switch (alarm->type){
    case ALARM_AUDIO:
        prop = icalproperty_new_action ("AUDIO");
        break;
    case ALARM_DISPLAY:
        prop = icalproperty_new_action ("DISPLAY");
        break;
    case ALARM_MAIL:
        prop = icalproperty_new_action ("EMAIL");
        break;
    case ALARM_PROGRAM:
        prop = icalproperty_new_action ("PROCEDURE");
        break;
    default:
        g_warning ("Unsupported alarm type!");
        break;
    }
    if (prop)
        icalcomponent_add_property (comp, prop);

    if (alarm->snooze_repeat)
        prop = icalproperty_new_repeat (alarm->snooze_repeat);

    if (alarm->snooze_secs) {
        struct icaldurationtype dur;
        dur = icaldurationtype_from_timet (alarm->snooze_secs);
        prop = icalproperty_new_duration (dur);
        icalcomponent_add_property (comp, prop);
    }

    if (alarm->attach) {
        struct icalattachtype *attach;
        attach = icalattachtype_new ();
        icalattachtype_set_url (attach, alarm->attach);
        prop = icalproperty_new_attach (*attach);
        icalattachtype_free (attach);
        icalcomponent_add_property (comp, prop);
    }

    if (alarm->desc) {
        prop = icalproperty_new_description (alarm->desc);
        icalcomponent_add_property (comp, prop);
    }

    if (alarm->summary) {
        prop = icalproperty_new_summary (alarm->summary);
        icalcomponent_add_property (comp, prop);
    }

    if (alarm->attendee) {
        icalproperty_new_attendee (alarm->attendee);
        icalcomponent_add_property (comp, prop);
    }

    return comp;
}