HEAD: an extra unit test for wvbase64 that I forgot to check in a while ago.

[wvapps.git] / evolution / calendaradaptor.cc

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* 
 * Authors : Patrick Patterson <ppatters@nit.ca>
 *           Peter Colijn <pcolijn@nit.ca>
 *           Scott MacLean <scott@nit.ca>
 *           William Lachance <wlach@nit.ca>
 *
 * Copyright 2003-2004, Net Integration Technologies, Inc.
 *
 * This program is free software; you can redistribute it and/or 
 * modify it under the terms of version 2 of the GNU General Public 
 * License as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 * USA
 */


extern "C" 
{
#include <bonobo/bonobo-main.h>
}


#include "wvtnefconv.h"
#include "wvfile.h"

#include "calendaradaptor.h"
#include "localstorage.h"
#include "eituniconfkeys.h"


// Called when the client is connected to the calendar
static void cal_open_cb(CalClient *client,
                        CalClientOpenStatus status,
                        gpointer data)
{
    CalendarAdaptor *adaptor = static_cast<CalendarAdaptor *>(data);

    WvLog log(adaptor->log);
    
    if (NULL == adaptor)
        return;

    // Notify the element that it's ready for updates
    if (CAL_CLIENT_OPEN_SUCCESS == status) 
    {
        log("cal_open_cb. status: ready!\n");
        adaptor->set_ready(true);
    }
}

// Called when the client is disconnected from the calendar
static void cal_destroy_cb(GObject *object, gpointer data)
{
    g_message("Disconnected from a calendar");

    // Do we really want to quit?? If one calendar dies
    // maybe we should keep going with the others?
    // Yeah, but they usually all die at the same time (pcolijn)
    bonobo_main_quit();
}

void CalendarAdaptor::merge_vcal2tnef(CalComponent *component, WvTnef &tnef,
                                      WvString type, bool task)
{
    WvString vcal("");

    icalcomponent *icalevent = cal_component_get_icalcomponent(component);
    int prop_count = 0;
    icalproperty *prop = icalcomponent_get_first_property(icalevent,
                                                          ICAL_ANY_PROPERTY);

    while (prop != NULL) 
    {
        prop_count++;
        WvString prop_name = icalproperty_get_name(prop);
        WvString prop_value = icalproperty_get_value_as_string(prop);
        log(WvLog::Debug5,
            "Property Number: %s - Property kind: %s Property value: %s\n",
            prop_count, prop_name, prop_value);

        if (!!prop_name && !!prop_value)
            vcal.append("%s:%s\n", prop_name, prop_value);

        prop = icalcomponent_get_next_property(icalevent,
                                               ICAL_ANY_PROPERTY);            
    }
    
    // This code is not in WvMAPI because it relies heavily
    // on Evolution CalComponent stuff...
    if (cal_component_has_alarms(component))
    {
        GList *list = cal_component_get_alarm_uids(component);
        const char *auid = NULL;
        bool chosen = false;
        int relative = 0;
        time_t dtend = 0;
        time_t dtstart = 0;
        time_t alarmtime = 0;
        uint32_t rel_min = 0;
        CalAlarmAction action;
        CalAlarmTrigger trigger;
        CalComponentText caltext;
        CalComponentAlarm *alarm = NULL;
        string *s;

        for (GList *l = list; l; l = l->next)
        {
            auid = (const char *)l->data;
            alarm = cal_component_get_alarm(component, auid);
            cal_component_alarm_get_action(alarm, &action);
            dtstart = icaltime_as_timet(icalcomponent_get_dtstart(icalevent));
            dtend = icaltime_as_timet(icalcomponent_get_dtend(icalevent));

            // Use the first suitable DISPLAY alarm for the alarm
            // in Outlook; Outlook only supports one
            if (action == CAL_ALARM_DISPLAY)
            {
                cal_component_alarm_get_trigger(alarm, &trigger);

                if (CAL_ALARM_TRIGGER_RELATIVE_START == trigger.type)
                {
                    relative = icaldurationtype_as_int(trigger.u.rel_duration);
                    alarmtime = dtstart + relative;
                }
                else if (CAL_ALARM_TRIGGER_RELATIVE_END == trigger.type)
                {
                    relative = icaldurationtype_as_int(trigger.u.rel_duration);
                    alarmtime = dtend + relative;
                }
                else if (CAL_ALARM_TRIGGER_ABSOLUTE == trigger.type)
                    alarmtime = icaltime_as_timet(trigger.u.abs_time);
                else
                    alarmtime = dtstart;

                // Outlook only supports alarms before the start time
                if (alarmtime < dtstart)
                {
                    chosen = true;
                    rel_min = (dtstart - alarmtime) / 60;
                    rel_min = swap4(rel_min);

                    // Set the alarm time
                    s = new string((const char *)&rel_min, 4);
                    tnef.set_property(str2guid(GUID_3), ALARM_TRIGGER,
                                      s, PT_LONG);

                    // Enable the alarm
                    rel_min = 1;
                    rel_min = swap4(rel_min);
                    s = new string((const char *)&rel_min, 4);
                    tnef.set_property(str2guid(GUID_3), IS_ALARM_ENABLED,
                                      s, PT_BOOLEAN);

                    // Set the alarm description
                    cal_component_alarm_get_description(alarm, &caltext);
                    s = new string(caltext.value);
                    tnef.set_property(str2guid(GUID_2),
                                      str2ustr("EvoAlarmTxt"),
                                      s, PT_STRING8);

                    log("I set an alarm: %s", caltext.value);
                }
            }

            cal_component_alarm_free(alarm);
            alarm = NULL;

            if (chosen)
                break;
        }

        cal_obj_uid_list_free(list);
    }

    tnef_set_type(tnef, type);

    char *vcal_fooenc = utf8_to_barenc(vcal, get_codepage(tnef));
    vcal2tnef(vcal_fooenc, tnef, task);

    log("After merging, the TNEF VCal now looks like this:\n%s\n",
        get_vcal(tnef, task));
}


// FIXME: Do we need this? This looks suspiciously like the crappy
// "duplicate detection" code that was in the server, and was intended
// for the "fix stuff after a crash" code
#if 0
static bool is_prop_in_cal(WvStringParm _prop_name, WvStringParm _prop_value,
                          icalcomponent *ical)
{
    WvLog log("is_prop_in_cal", WvLog::Debug5);
    // this should work unless ical is horribly broken. assuming it isn't
    icalproperty *prop = icalcomponent_get_first_property(ical,
                                                          ICAL_ANY_PROPERTY);
    while (prop != NULL) 
    {
        WvString prop_name = icalproperty_get_name(prop);
        WvString prop_value = icalproperty_get_value_as_string(prop);

        log("(%s, %s):  prop name: %s, prop value: %s\n", 
            _prop_name.cstr(), _prop_value.cstr(), 
            prop_name.cstr(), prop_value.cstr());

        if (strcmp(prop_name, _prop_name) == 0)
        {
            // evolution appends a "Z" to the last modified
            // time stamp to indicate timezone-- for better or worse,
            // we don't add this in the icals we generate in wvtnef,
            // so we have to do the comparison like this.
            if (strncmp(prop_value, _prop_value, strlen(prop_value)) == 0)
                return true;

            if (strcmp(prop_name, "EXDATE") != 0)
                return false;
        }

        prop = icalcomponent_get_next_property(ical, ICAL_ANY_PROPERTY);
    }

    return false;
}

static bool vcal_has_changed(CalComponent *component, const WvTnef &tnef,
                             bool task)
{
    WvLog log("vcal_has_changed", WvLog::Debug1);

    if (is_vcal(tnef))
    {
        icalcomponent *tnef_ical =
            icalcomponent_new_from_string(get_vcal(tnef, task).edit());
        icalcomponent *new_ical =
            cal_component_get_icalcomponent(component);

        icalproperty *prop =
            icalcomponent_get_first_property(new_ical, ICAL_ANY_PROPERTY);
        
        while (prop != NULL) 
        {
            WvString prop_name = icalproperty_get_name(prop);
            WvString prop_value = icalproperty_get_value_as_string(prop);
        
            // NOTE: UID is not a property that appears in a CalComponent..
            // Use strncmp here because property names sometimes get
            // extra values appended to them with ';'s and (RFC for details)
            if (!strncmp(prop_name, "SUMMARY", 7) ||
                !strncmp(prop_name, "DTSTART", 7) ||
                !strncmp(prop_name, "DTEND", 5) || 
                !strncmp(prop_name, "LOCATION", 8) ||
                !strncmp(prop_name, "DESCRIPTION", 11) ||
                !strncmp(prop_name, "LAST-MODIFIED", 13) || 
                !strncmp(prop_name, "RRULE", 5) ||
                !strncmp(prop_name, "EXDATE", 6) ||
                !strncmp(prop_name, "TRANSP", 6) ||
                !strncmp(prop_name, "CLASS", 5) ||
                !strncmp(prop_name, "CATEGORIES", 10))
            {
                if (!is_prop_in_cal(prop_name, prop_value, tnef_ical)) 
                {
                    log("Property: %s not found in calendar for item:\n%s\n",
                        prop_name, get_vcal(tnef, task));
                    return true;
                }
            }        

            prop = icalcomponent_get_next_property(new_ical,
                                                   ICAL_ANY_PROPERTY);
        }    
    }

    return false;
}
#endif

// This gets called back whenever evolution changes/updates something in
// the calendar. It just marshals the uid to a callback in CalendarAdaptor
static void update_cb(CalClient *client, const char *uid, gpointer data)
{
    assert(data);
    assert(uid != NULL);
    
    CalendarAdaptor *adaptor = static_cast<CalendarAdaptor *>(data);
    adaptor->item_updated(uid);
}

// This gets called back whenever the user deletes something in their
// evolution calendar (or we delete something manually). In the former
// case, it adds a key to the todelete list in the gconf keyspace. In the
// latter case, this function does nothing.
static void remove_cb(CalClient *client, const char *uid, gpointer data)
{
    assert(data);
    assert(uid != NULL);
    
    CalendarAdaptor *adaptor = static_cast<CalendarAdaptor *>(data);
    adaptor->item_removed(uid);
}

CalendarAdaptor::CalendarAdaptor(WvStringParm _key,
                                 WvStringParm _path,
                                 const UniConf parent) :
    ExchangeItAdaptor(_key, _path, true, parent),
    log("CalendarAdaptor",
    WvLog::Debug3),
    is_task(false)
{
    _initCalClient(_path, "/calendar.ics");
}

CalendarAdaptor::CalendarAdaptor(WvStringParm _key,
                                 WvStringParm _path,
                                 const UniConf parent,
                                 WvStringParm _file,
                                 bool task) :
    ExchangeItAdaptor(_key, _path, true, parent), 
    log("CalendarAdaptor", WvLog::Debug3), is_task(task)
{
    _initCalClient(_path, _file);
}

CalendarAdaptor::~CalendarAdaptor()
{
    g_object_unref(client);
}

void CalendarAdaptor::_initCalClient(WvStringParm path, WvStringParm file)
{
    log("CalendarAdaptor::_initCalClient\n");
    WvString calendar_filename = path;
    calendar_filename.append(file);
    log("Calendar filename: %s\n", calendar_filename);

    client = cal_client_new();
    if (!client)
    {
        log("Calendar Client Initialization failed\n");
        return;
    }

    g_signal_connect(client, "backend_died", G_CALLBACK(cal_destroy_cb), this);
    g_signal_connect(client, "cal_opened", G_CALLBACK(cal_open_cb), this);
    g_signal_connect(client, "obj_updated", G_CALLBACK(update_cb), this);
    g_signal_connect(client, "obj_removed", G_CALLBACK(remove_cb), this);

    if (!cal_client_open_calendar(client, calendar_filename.cstr(), FALSE))
    {
        log("Cannot open calendar %s\n", calendar_filename);
        return;
    }
}

/** Call this to update or add an item to the server
 */
const bool CalendarAdaptor::update_item(WvTnef &tnef, WvStringParm uid)
{
    log(WvLog::Debug1, "Told to update item: %s\n", uid);

    if (is_vcal(tnef))
    {
        // Set the UID so we don't duplicate stuff
        tnef_set_uid(tnef, uid);
        
        WvString vcal = get_vcal(tnef, is_task);
        char *vcal_utf8 = fooenc_to_utf8(vcal, get_codepage(tnef));

        log(" %s\n\n\n", vcal);
        CalComponent *calcomp = cal_component_new();
        icalcomponent *icalcomp = icalparser_parse_string(vcal_utf8);
        cal_component_set_icalcomponent(calcomp, icalcomp);
        cal_component_rescan(calcomp);

        // icalparser_parse_string takes const char *
        g_free(vcal_utf8);

        if (has_alarm(tnef))
        {
            log(WvLog::Debug1, "Item has an alarm. Creating Evo alarm.\n");
            bool do_alarm = true;
            uint32_t rel_min = 0;
            const WvMapiPart *p = NULL;
            CalComponent *itemcomp = NULL;
            CalComponentText text;
            CalAlarmTrigger trigger;
            CalAlarmAction action = CAL_ALARM_DISPLAY;
            CalComponentAlarm *alarm = NULL;

            cal_client_get_object(client, uid, &itemcomp);
            if (itemcomp)
            {
                cal_component_remove_all_alarms(itemcomp);
                cal_component_rescan(itemcomp);

                // If we were unable to remove the alarms,
                // it's unsafe to add new ones
                if (cal_client_update_object(client, itemcomp) !=
                    CAL_CLIENT_RESULT_SUCCESS)
                    do_alarm = false;
            }

            if (do_alarm)
            {
                alarm = cal_component_alarm_new();
                p = tnef.get_property(str2guid(GUID_3),
                                      ALARM_TRIGGER);
                rel_min = *(const uint32_t *)p->get_string()->c_str();
                rel_min = swap4(rel_min);

                trigger.type = CAL_ALARM_TRIGGER_RELATIVE_START;
                trigger.u.rel_duration =
                    icaldurationtype_from_int(-1*rel_min*60);

                cal_component_alarm_set_action(alarm, action);
                cal_component_alarm_set_trigger(alarm, trigger);

                p = tnef.get_property(str2guid(GUID_2),
                                      str2ustr("EvoAlarmTxt"));
                if (p && strlen(p->get_string()->c_str()))
                    text.value = p->get_string()->c_str();
                else
                    cal_component_get_summary(calcomp, &text);

                text.altrep = NULL;
                cal_component_alarm_set_description(alarm, &text);
                cal_component_add_alarm(calcomp, alarm);
                cal_component_rescan(calcomp);
                cal_component_alarm_free(alarm);
            }
        }

        // FIXME: check if calendar is "available" first somehow
        
        // asking the cal client to update the object will send an
        // update signal, but we don't want to add the item we just added
        // to the tosend list..
        state[NOSEND_KEY][uid].setmeint(1);
        log("adding nosend key: %s\n", state[NOSEND_KEY][uid].getme());

        // So we know if we're successful
        if (cal_client_update_object(client, calcomp) == 
            CAL_CLIENT_RESULT_SUCCESS)
            return true;
    }    

    return false;
}

const bool CalendarAdaptor::delete_item(WvStringParm uid)
{
    log(WvLog::Debug1, "Told to delete item %s\n", uid);
    bool success = false;
    
    // don't want to send a delete command when we're
    // responding to a server event
    state[NOSEND_KEY][uid].setmeint(1);
    log("adding nosend key: %s\n", state[NOSEND_KEY][uid].getme());
    
    if (cal_client_remove_object (client, uid.cstr()) ==
        CAL_CLIENT_RESULT_SUCCESS)
    {
        // FIXME: should remove the TNEF as well..
        // if/when we do, we need to update DELETE to use the item sent
        // back from the server on denial (pcolijn)
        success = true;
    }
    
    return success;
}

// This gets called by update_cb, which in turn gets called when the user
// changes something in Evolution
// it should take the item pointed to by uid, modify its associated TNEF,
// and enqueue it to be sent
void CalendarAdaptor::item_updated(WvStringParm uid)
{
    log(WvLog::Debug1, "Got an update for %s\n", uid);

    // Check whether we're expecting this update
    // (i.e. if we just added/updated the item b/c we just synced w/the server)
    // if so, remove from the nosend list but don't send it out
    if (state[NOSEND_KEY][uid].getmeint())
    {
            log("Action: It's in our nosend list, do nothing\n");
            state[NOSEND_KEY][uid].remove();
            return;
    }

    // Otherwise we want to update our local TNEF, and enqueue it to send to
    // the server at a later time..
    log("Action: converting ical to tnef, and enqueing it to be sent\n");

    CalComponent *component = NULL;

    if (cal_client_get_object(client, uid, &component) ==
        CAL_CLIENT_GET_SUCCESS) 
    {
        // Open up our TNEF for modification
        WvStream *istream = NULL;
        WvString tnef_path("%s/%s", get_storage_path(), uid);
        WvFile file(tnef_path, O_RDONLY);

        if (file.isok())
            istream = &file;

        WvTnef tnef(istream);
        file.close();
        tnef_set_uid(tnef, uid);

        WvString item_type = get_item_type();
        merge_vcal2tnef(component, tnef, item_type, is_task);

        // FIXME: should check for failure of this operation
        if (!tnef.rewrite(tnef_path))
            log(WvLog::Debug1,
                "YOU CARE ABOUT THIS: TNEF rewrite failure!\n");

        log("Converted vcal looks like this:\n%s\n",
            get_vcal(tnef, is_task));

        state[TOSEND_KEY][uid].setmeint(1);
        // FIXMEFIXME: Should we also delete the calcomponent?
    }
}

void CalendarAdaptor::item_removed(WvStringParm uid)
{
    log(WvLog::Debug1, "Got a remove for %s\n", uid);
    
    // Check whether we're expecting this update
    // (i.e.: if we just removed the item b/c we just synced w/ the server)
    // if so, do nothing
    if (state[NOSEND_KEY][uid].getmeint())
    {
            log("Action: It's in our nosend list, do nothing\n");
            state[NOSEND_KEY][uid].remove();
            return;
    }

    state[TODELETE_KEY][uid].setmeint(1);

    log("Action: enqueing it to be deleted", uid);
}

static int uidcount = 0;

static void add_uid_to_strlist(gpointer data, gpointer userdata)
{
    const char *uid = (const char *)data;
    WvStringList *string_list = (WvStringList *)userdata;
    uidcount++;

    string_list->append(uid);        
}

WvStringList *CalendarAdaptor::get_all_uids()
{
    WvStringList *uid_list = new WvStringList();
    GList *evo_uid_list = cal_client_get_uids(client, CALOBJ_TYPE_ANY);
    g_list_foreach(evo_uid_list, &add_uid_to_strlist, uid_list);
    cal_obj_uid_list_free(evo_uid_list);

    return uid_list;
}

// FIXME: Do we need this? This is the "try to recover after a crash code"
// Ideally, we want the plugin to be solid enough that this isn't necessary
# if 0
const bool CalendarAdaptor::_sync_local_items()
{
    WvStringList uid_list;

    log(WvLog::Debug1,
        "Checking to see if we have any out-of-sync local items\n");

    // FIXMEFIXME: have to check if the cal_client is loaded.. I'm not sure
    // what to do if it isn't.. maybe it should be a precondition for calling
    // this function
    GList *evo_uid_list = cal_client_get_uids(client, CALOBJ_TYPE_ANY);
    g_list_foreach(evo_uid_list, &add_uid_to_strlist, &uid_list);
    uidcount = 0;
    cal_obj_uid_list_free(evo_uid_list);
    
    WvStringList::Iter i(uid_list);
    for(i.rewind(); i.next();)
    {     
        CalComponent *component = NULL;
        if (cal_client_get_object(client, i().cstr(), &component) ==
            CAL_CLIENT_GET_SUCCESS) 
        {
            WvString tnef_path("%s/%s", get_storage_path(), i());
            struct stat statbuf;
            bool needs_update = false;

            if(stat(tnef_path.cstr(), &statbuf) == 0) 
            {
                // FIXME: should check for failure of this operation
                WvFile file(tnef_path, O_RDONLY);
                WvTnef tnef(&file);
                file.close();
                if (vcal_has_changed(component, tnef, is_task))
                {
                    WvString item_type = get_item_type();
                    merge_vcal2tnef(component, tnef, item_type, is_task);
                    // FIXME: should check for failure of this operation
                    if (!tnef.rewrite(tnef_path))
                        log(WvLog::Debug1,
                            "YOU CARE ABOUT THIS: TNEF rewrite failure!\n");

                    needs_update = true;
                }
            }
            else
            {
                WvTnef tnef;
                WvString item_type = get_item_type();
                merge_vcal2tnef(component, tnef, item_type, is_task);
                // FIXME: should check for failure of this operation
                if (!tnef.rewrite(tnef_path))
                    log(WvLog::Debug1,
                        "YOU CARE ABOUT THIS: TNEF rewrite failure!\n");

                needs_update = true;
            }
            if (needs_update) 
            {
                state[TOSEND_KEY][i()].setmeint(1);
                log("Syncing local item %s in folder %s to be sent, "
                    "as it has changed\n", i(), this->key);
            }
            else
            {
                log(WvLog::Debug3,
                    "Item %s in folder %s is in sync, no need to resend\n", 
                    i(), this->key);
            }
            // FIXMEFIXME: Should we delete the calcomponent?
        }
        else
        {
            // we're screwed
        }
    }
    return true;
}

#endif

const bool CalendarAdaptor::_sync_local_items()
{
    return true;
}


/** Merge CalClient into the calendar associated to the adpator
 *
 * @param local_client the CalClient to pull the data from
 * @note should be called by the open callback set for the 
 * given CalClient
 */
void CalendarAdaptor::merge_into_calendar(CalClient *local_client)
{
    WvLog log("migrate_local_calendar", WvLog::Debug1);
    
    GList *list = cal_client_get_uids(local_client, CALOBJ_TYPE_ANY);
    GList *current = list;
    CalComponent *component = NULL;
    char *uid;
    while(current)
    {
        uid = (char*)current->data;
        if (cal_client_get_object(local_client, uid, &component) ==
            CAL_CLIENT_GET_SUCCESS)
        {
            log("Got 1 %s item to migrate !\n",(is_task?"task":"calendar"));
            if (cal_client_update_object(client, component) != CAL_CLIENT_RESULT_SUCCESS)
            {
                log("Error updating client!\n");
            }
        }
        else 
        {
            log("cal_client_get_object() failed.\n");
        }
        g_object_unref(component);
        current = g_list_next(current);
    }
    cal_obj_uid_list_free(list);
// not sure about this one, looks like it makes wombat crash
// how else can I get rid of this. -- hub
//    g_object_unref(local_client); // we are done with the client
    if (!is_task) 
    {
        state.root()[CALENDAR_LOCAL_IMPORTED_KEY].setmeint(1);
    }
    else
    {
        state.root()[TASKS_LOCAL_IMPORTED_KEY].setmeint(1);
    }
    state.root().commit();
}