path: root/calendar/gui/corba-cal.c

/*
 * corba-cal.c: Service that provides access to the calendar repository
 *
 * Author:
 *   Miguel de Icaza (miguel@gnu.org)
 */

#include <config.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
/*#include "calendar.h" DELETE */
#include "gnome-cal.h"
#include "alarm.h"
#include <cal-util/timeutil.h>
#include "libversit/vcc.h"
#include <libgnorba/gnome-factory.h>
#include "GnomeCal.h"
#include "corba-cal-factory.h"
#include "corba-cal.h"

static iCalObject *
calendar_object_find_by_pilot (GnomeCalendar *cal, int pilot_id);


typedef struct {
    POA_GNOME_Calendar_Repository servant;  
    GnomeCalendar *calendar;
} CalendarServant;

/*
 * Vectors
 */
static POA_GNOME_Calendar_Repository__epv  calendar_repository_epv;
static POA_GNOME_Calendar_Repository__vepv calendar_repository_vepv;

/*
 * Servant and Object Factory
 */
static POA_GNOME_Calendar_Repository calendar_repository_servant;

static inline GnomeCalendar *
gnomecal_from_servant (PortableServer_Servant servant)
{
    CalendarServant *cs = (CalendarServant *) servant;

    return cs->calendar;
}

static CORBA_char *
cal_repo_get_object (PortableServer_Servant servant,
             const CORBA_char  *uid,
             CORBA_Environment *ev)
{
    GnomeCalendar *gcal = gnomecal_from_servant (servant);
    iCalObject *obj;
    char *obj_string;
    char *buffer;
    CORBA_char *ret;
    
    /*obj = calendar_object_find_event (gcal->cal, uid); DELETE */
    obj_string = cal_client_get_object (gcal->calc, uid);
    obj = string_to_ical_object (obj_string);
    free (obj_string);

    if (obj == NULL){
            GNOME_Calendar_Repository_NotFound *exn;

        exn = GNOME_Calendar_Repository_NotFound__alloc();
        CORBA_exception_set (
            ev,
            CORBA_USER_EXCEPTION,
            ex_GNOME_Calendar_Repository_NotFound,
            exn);
        return NULL;
    }

    /* buffer = calendar_string_from_object (obj); DELETE */
    buffer = ical_object_to_string (obj);
    ret = CORBA_string_dup (buffer);
    free (buffer);

    return ret;
}



static CORBA_char *
cal_repo_get_object_by_pilot_id (PortableServer_Servant servant,
                 CORBA_long  pilot_id,
                 CORBA_Environment  *ev)
{
    GnomeCalendar *gcal = gnomecal_from_servant (servant);
    iCalObject *obj;
    char *buffer;
    CORBA_char *ret;

    obj = calendar_object_find_by_pilot (gcal, pilot_id);
    if (obj == NULL){
            GNOME_Calendar_Repository_NotFound *exn;

        exn = GNOME_Calendar_Repository_NotFound__alloc();
        CORBA_exception_set (ev,
                     CORBA_USER_EXCEPTION,
                     ex_GNOME_Calendar_Repository_NotFound, exn);
        return NULL;
    }

    /* buffer = calendar_string_from_object (obj); DELETE */
    buffer = ical_object_to_string (obj);
    ret = CORBA_string_dup (buffer);
    free (buffer);

    return ret;
    
}

/* where should this go? FIX ME */
static iCalObject *
calendar_object_find_by_pilot (GnomeCalendar *cal, int pilot_id)
{
    GList *l, *uids;
    
    g_return_val_if_fail (cal != NULL, NULL);

    uids = cal_client_get_uids (cal->calc, CALOBJ_TYPE_ANY);
    for (l = uids; l; l = l->next){
        char *obj_string = cal_client_get_object (cal->calc, l->data);
        iCalObject *obj = string_to_ical_object (obj_string);
        g_free (obj_string);

        if (obj->pilot_id == pilot_id)
            return obj;
    }

    /* DELETE
    for (l = cal->todo; l; l = l->next){
        iCalObject *obj = l->data;

        if (obj->pilot_id == pilot_id)
            return obj;
    }
    */

    return NULL;
}

static CORBA_char *
cal_repo_get_id_from_pilot_id (PortableServer_Servant servant,
                   CORBA_long  pilot_id,
                   CORBA_Environment  *ev)
{
    GnomeCalendar *gcal = gnomecal_from_servant (servant);
    iCalObject *obj;
    
    obj = calendar_object_find_by_pilot (gcal, pilot_id);
    if (obj == NULL){
            GNOME_Calendar_Repository_NotFound *exn;

        exn = GNOME_Calendar_Repository_NotFound__alloc();
        CORBA_exception_set (ev,
                     CORBA_USER_EXCEPTION,
                     ex_GNOME_Calendar_Repository_NotFound, exn);
        return NULL;
    }

    return CORBA_string_dup (obj->uid);
}

static void
cal_repo_delete_object (PortableServer_Servant servant,
            const CORBA_char  *uid,
            CORBA_Environment  *ev)
{
    GnomeCalendar *gcal = gnomecal_from_servant (servant);
    iCalObject *obj;
    char *obj_string;

    /* obj = calendar_object_find_event (gcal->cal, uid); */
    obj_string = cal_client_get_object (gcal->calc, uid);
    obj = string_to_ical_object (obj_string);
    free (obj_string);

    if (obj == NULL){
            GNOME_Calendar_Repository_NotFound *exn;

        exn = GNOME_Calendar_Repository_NotFound__alloc();
        CORBA_exception_set (ev,
                     CORBA_USER_EXCEPTION,
                     ex_GNOME_Calendar_Repository_NotFound,
                     exn);
        return;
    }

    gnome_calendar_remove_object (gcal, obj);
}

static void
cal_repo_update_object (PortableServer_Servant servant,
            const CORBA_char *uid,
            const CORBA_char *vcalendar_object,
            CORBA_Environment *ev)
{
    GnomeCalendar *gcal = gnomecal_from_servant (servant);
    /* iCalObject *obj; char *obj_string; */
    iCalObject *new_object;
    char *new_object_string;
    
    new_object = ical_object_new_from_string (vcalendar_object);

#if 0  /* it looks like this is taken care of in cal_client_update_object? */
    /* DELETE */
    /* obj = calendar_object_find_event (gcal->cal, uid); DELETE */
    obj_string = cal_client_get_object (gcal->calc, uid);
    obj = string_to_ical_object (obj_string);
    free (obj_string);

    if (obj != NULL){
        /* calendar_remove_object (gcal->cal, obj); DELETE */
        cal_client_remove_object (gcal->calc, uid);
    } 
#endif /* 0 */

    /* calendar_add_object (gcal->cal, new_object); DELETE */
    new_object_string = ical_object_to_string (new_object);
    cal_client_update_object (gcal->calc, uid, new_object_string);
    free (new_object_string);
}

static void
cal_repo_update_pilot_id (PortableServer_Servant servant,
              const CORBA_char *uid,
              const CORBA_long pilot_id,
              const CORBA_long pilot_status,
              CORBA_Environment *ev)
{
    GnomeCalendar *gcal = gnomecal_from_servant (servant);
    iCalObject *obj;
    char *obj_string;
    
    /* obj = calendar_object_find_event (gcal->cal, uid); DELETE */
    obj_string = cal_client_get_object (gcal->calc, uid);
    obj = string_to_ical_object (obj_string);
    free (obj_string);

    if (obj == NULL){
            GNOME_Calendar_Repository_NotFound *exn;

        exn = GNOME_Calendar_Repository_NotFound__alloc();
        CORBA_exception_set (
            ev,
            CORBA_USER_EXCEPTION,
            ex_GNOME_Calendar_Repository_NotFound,
            exn);
        return;
    }

    obj->pilot_id = pilot_id;
    obj->pilot_status = pilot_status;
}


static void list_free_string (gpointer data, gpointer user_data)
{
    free (data);
}


static CORBA_long
cal_repo_get_number_of_objects (PortableServer_Servant servant,
                GNOME_Calendar_Repository_RecordStatus record_status,
                CORBA_Environment *ev)
{
    GnomeCalendar *gcal = gnomecal_from_servant (servant);
    CORBA_long res;
    iCalPilotState real_record_status;
    GList *l, *uids;

    if (record_status == GNOME_Calendar_Repository_ANY) {
        /* return g_list_length(gcal->cal->events); DELETE */
                GList *uids = cal_client_get_uids (gcal->calc,
                           CALOBJ_TYPE_EVENT);
                res = g_list_length (uids);
                g_list_foreach (uids, list_free_string, NULL);
                g_list_free (uids);
                return res;
    }

    switch (record_status) {
    case GNOME_Calendar_Repository_NEW:
        real_record_status = ICAL_PILOT_SYNC_MOD;
        break;
    case GNOME_Calendar_Repository_MODIFIED:
        real_record_status = ICAL_PILOT_SYNC_MOD;
        break;
    case GNOME_Calendar_Repository_DELETED:
        real_record_status = ICAL_PILOT_SYNC_DEL;
        break;
    }

    res = 0;

    uids = cal_client_get_uids (gcal->calc, CALOBJ_TYPE_EVENT);
    for (l = uids; l; l = l->next){
        char *obj_string = cal_client_get_object (gcal->calc, l->data);
        iCalObject *obj = string_to_ical_object (obj_string);

        if (obj->pilot_status == real_record_status)
            res ++;
        g_free (l->data);
    }
    g_list_free (uids);

    return res;
}

static GNOME_Calendar_Repository_String_Sequence*
cal_repo_get_object_id_list(PortableServer_Servant servant,
                CORBA_Environment *ev)
{
    GnomeCalendar *gcal = gnomecal_from_servant (servant);
    GList *l, *uids;
    GNOME_Calendar_Repository_String_Sequence *result;
    int counter;

    uids = cal_client_get_uids (gcal->calc, CALOBJ_TYPE_EVENT);
    
    result = GNOME_Calendar_Repository_String_Sequence__alloc();
    result->_length = g_list_length (uids);
    result->_buffer =
      CORBA_sequence_CORBA_string_allocbuf(result->_length);

    counter = 0;
    for (l = uids; l; l = l->next){
        result->_buffer[counter] = CORBA_string_dup(l->data);
        counter++;
        g_free (l->data);
    }
    g_list_free (uids);

    return result;
}

static CORBA_char *
cal_repo_get_updated_objects (PortableServer_Servant servant,
                  CORBA_Environment *ev)
{
    /* FIX ME -- this might be wrong */
    GnomeCalendar *gcal = gnomecal_from_servant (servant);
    /* Calendar *dirty_cal; DELETE */
    VObject *vcalobj, *vobj;
    GList *l, *uids;
    CORBA_char *res;
    char *str;

    /* dirty_cal = calendar_new ("Temporal",CALENDAR_INIT_NIL); DELETE */
    vcalobj = newVObject (VCCalProp);
    
    uids = cal_client_get_uids (gcal->calc, CALOBJ_TYPE_EVENT);
    for (l = uids; l; l = l->next){
        char *obj_string = cal_client_get_object (gcal->calc, l->data);
        iCalObject *obj = string_to_ical_object (obj_string);

        if (obj->pilot_status != ICAL_PILOT_SYNC_MOD)
            continue;

        /* calendar_add_object (dirty_cal, obj); DELETE */
        vobj = ical_object_to_vobject (obj);
        addVObjectProp (vcalobj, vobj);
        g_free (l->data);
    }
    g_list_free (uids);

#       if 0
    /* DELETE */
    str = calendar_get_as_vcal_string (dirty_cal);
    res = CORBA_string_dup (str);
    free (str); /* calendar_get_as_vcal_string() uses writeMemVObject(), which uses realloc() */
    calendar_destroy (dirty_cal);
#       endif /* 0 */

    str = writeMemVObject (NULL, NULL, vcalobj);
    res = CORBA_string_dup (str);
    free (str); /* calendar_get_as_vcal_string() uses writeMemVObject(),
               which uses realloc() */
    cleanVObject (vcalobj);
    cleanStrTbl ();

    return res;
}

static void
cal_repo_done (PortableServer_Servant servant,
           CORBA_Environment *ev)
{
    /* GnomeCalendar *gcal = gnomecal_from_servant (servant); */

    /* calendar_save (gcal->cal, NULL); DELETE */
    /* FIX ME -- i dont know what to do here */
}

static void
init_calendar_repo_class (void)
{
    calendar_repository_epv.get_object = cal_repo_get_object;
    calendar_repository_epv.get_object_by_pilot_id = cal_repo_get_object_by_pilot_id;
    calendar_repository_epv.get_id_from_pilot_id = cal_repo_get_id_from_pilot_id;
    calendar_repository_epv.delete_object = cal_repo_delete_object;
    calendar_repository_epv.update_object = cal_repo_update_object;
    calendar_repository_epv.get_number_of_objects = cal_repo_get_number_of_objects;
    calendar_repository_epv.get_updated_objects = cal_repo_get_updated_objects;
    calendar_repository_epv.update_pilot_id = cal_repo_update_pilot_id;
    calendar_repository_epv.get_object_id_list = cal_repo_get_object_id_list;
    calendar_repository_epv.done = cal_repo_done;
    
    calendar_repository_vepv.GNOME_Calendar_Repository_epv =
        &calendar_repository_epv;

    calendar_repository_servant.vepv = &calendar_repository_vepv;
}

/*
 * Initializes the CORBA parts of the @calendar object
 */
void
gnome_calendar_create_corba_server (GnomeCalendar *calendar)
{
    static gboolean class_inited = FALSE;
    CalendarServant *calendar_servant;
    CORBA_Environment ev;
    
    if (!class_inited){
        init_calendar_repo_class ();
        class_inited = TRUE;
    }

    calendar_servant = g_new0 (CalendarServant, 1);
    calendar_servant->servant.vepv = &calendar_repository_vepv;
    calendar_servant->calendar = calendar;

    CORBA_exception_init (&ev);
    POA_GNOME_Calendar_Repository__init ((PortableServer_Servant) calendar_servant, &ev);
    CORBA_free (
        PortableServer_POA_activate_object (poa, calendar_servant, &ev));
    calendar->calc->corba_server =
      PortableServer_POA_servant_to_reference (poa, calendar_servant, &ev);

    CORBA_exception_free (&ev);
}