Changeset 2118

Show
Ignore:
Timestamp:
06/09/07 19:39:29 (1 year ago)
Author:
dgollub
Message:

Updated the gnokii-event converter.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • plugins/gnokii-sync/src/gnokii_calendar.c

    r2116 r2118  
    367367                        break; 
    368368 
    369                 OSyncChange *change = osync_change_new(&error); 
    370  
    371369                // prepare UID with gnokii-calendar-<memory location> 
    372370                uid = g_strdup_printf ("gnokii-calendar-%i", calnote->location); 
    373371                osync_hashtable_report(sinkenv->hashtable, uid); 
    374372 
    375                 // get hash of calnote 
    376373                hash = gnokii_calendar_hash(calnote); 
    377  
     374                OSyncChangeType type = osync_hashtable_get_changetype(sinkenv->hashtable, uid, hash); 
     375 
     376                if (type == OSYNC_CHANGE_TYPE_UNMODIFIED) { 
     377                        g_free(hash); 
     378                        g_free(uid); 
     379                        g_free(calnote); 
     380                        continue; 
     381                } 
     382 
     383                osync_hashtable_update_hash(sinkenv->hashtable, type, uid, hash); 
     384 
     385                OSyncChange *change = osync_change_new(&error); 
     386 
     387                osync_change_set_uid(change, uid); 
    378388                osync_change_set_hash(change, hash);     
    379                 osync_change_set_uid(change, uid); 
    380  
     389                osync_change_set_changetype(change, type); 
    381390 
    382391                // set data 
    383                 OSyncData *data = osync_data_new((char *) calnote, sizeof(gn_calnote), sinkenv->objformat, &error); 
    384                 if (!data) { 
     392                osync_trace(TRACE_INTERNAL, "objformat: %p", sinkenv->objformat); 
     393                OSyncData *odata = osync_data_new((char *) calnote, sizeof(gn_calnote), sinkenv->objformat, &error); 
     394                if (!odata) { 
    385395                        osync_change_unref(change); 
    386396                        osync_context_report_osyncwarning(ctx, error); 
     
    388398                        g_free(hash); 
    389399                        g_free(uid); 
     400                        g_free(calnote); 
    390401                        continue; 
    391402                } 
    392403 
    393                 osync_data_set_objtype(data, osync_objtype_sink_get_name(sink)); 
    394                 osync_change_set_data(change, data); 
    395                 osync_data_unref(data); 
    396          
    397                 OSyncChangeType type = osync_hashtable_get_changetype(sinkenv->hashtable, uid, hash); 
    398                 if (type != OSYNC_CHANGE_TYPE_UNMODIFIED) { 
    399                         osync_trace(TRACE_INTERNAL, "Position: %i Needs to be reported (!= hash)", calnote->location); 
    400                         osync_context_report_change(ctx, change); 
    401                         osync_hashtable_update_hash(sinkenv->hashtable, type, uid, hash); 
    402                 }        
     404                osync_data_set_objtype(odata, osync_objtype_sink_get_name(sink)); 
     405                osync_change_set_data(change, odata); 
     406                osync_data_unref(odata); 
     407 
     408                osync_context_report_change(ctx, change); 
     409 
     410                osync_trace(TRACE_INTERNAL, "Change: %p", change); 
     411 
     412                osync_change_unref(change); 
    403413 
    404414                g_free(hash); 
  • plugins/gnokii-sync/src/gnokii_calendar_format.c

    r2097 r2118  
    5656 
    5757        // Type 
    58         xmlfield = osync_xmlfield_new(xmlformat, "Category", error); 
     58        xmlfield = osync_xmlfield_new(xmlformat, "Categories", error); 
    5959        switch (cal->type) { 
    6060                case GN_CALNOTE_MEETING: 
     
    289289} 
    290290 
     291static void _xmlfield_category(gn_calnote *calnote, OSyncXMLField *xmlfield) 
     292{ 
     293        int i; 
     294        int numnodes = osync_xmlfield_get_key_count(xmlfield); 
     295        for (i=0; i < numnodes; i++) { 
     296                const char *category = osync_xmlfield_get_nth_key_value(xmlfield, i); 
     297 
     298                if (!strcasecmp(category, "Meeting")) 
     299                        calnote->type = GN_CALNOTE_MEETING; 
     300                else if (!strcasecmp(category, "Calling")) 
     301                        calnote->type = GN_CALNOTE_CALL; 
     302                else if (!strcasecmp(category, "Birthday")) 
     303                        calnote->type = GN_CALNOTE_BIRTHDAY; 
     304                else if (!strcasecmp(category, "Reminder")) 
     305                        calnote->type = GN_CALNOTE_REMINDER; 
     306                else if (!strcasecmp(category, "Memo")) 
     307                        calnote->type = GN_CALNOTE_MEMO; 
     308 
     309                else 
     310                        // When no known type was found it will check later 
     311                        // for a valid type.  
     312                        calnote->type = 0; 
     313 
     314        } 
     315} 
     316 
     317static void _xmlfield_datestarted(gn_calnote *calnote, OSyncXMLField *xmlfield, int *alldayevent) 
     318{ 
     319 
     320        const char *dtstart = osync_xmlfield_get_key_value(xmlfield, "Content"); 
     321 
     322        struct tm *starttm = osync_time_vtime2tm(dtstart); 
     323        struct tm *tmptm = NULL; 
     324 
     325        if (!osync_time_isdate(dtstart) && osync_time_isutc(dtstart)) { 
     326                tmptm = starttm; 
     327                int offset = osync_time_timezone_diff(tmptm); 
     328                starttm = osync_time_tm2localtime(tmptm, offset); 
     329                g_free(tmptm); 
     330        } 
     331 
     332        calnote->time = gnokii_util_tm2timestamp(starttm); 
     333 
     334        g_free(starttm); 
     335 
     336        // Only 3 matches (=date) means all day event  
     337        if (osync_time_isdate(dtstart)) 
     338                *alldayevent = 1; 
     339 
     340        // Nokia cellphones cannot handle seconds in calendar - so set it to ZERO 
     341        calnote->time.second = 0; 
     342 
     343} 
     344 
     345void static _xmlfield_dateend(gn_calnote *calnote, OSyncXMLField *xmlfield) 
     346{ 
     347 
     348        const char *dtend = osync_xmlfield_get_key_value(xmlfield, "Content"); 
     349 
     350 
     351        struct tm *endtm = osync_time_vtime2tm(dtend); 
     352        struct tm *tmptm = NULL; 
     353        if (!osync_time_isdate(dtend) && osync_time_isutc(dtend)) { 
     354                tmptm = endtm; 
     355                int offset = osync_time_timezone_diff(tmptm); 
     356                endtm = osync_time_tm2localtime(tmptm, offset); 
     357                g_free(tmptm); 
     358        } 
     359 
     360        calnote->end_time = gnokii_util_tm2timestamp(endtm); 
     361        g_free(endtm); 
     362 
     363        // Nokia cellphones cannot handle seconds in calendar so set it to ZERO 
     364        calnote->end_time.second = 0; 
     365 
     366} 
     367 
    291368/*  
    292369 * Converts from XMLFormat-event to the gnokii event object type (gn_calnote). 
     
    297374                        output, outpsize, config, free_input, error); 
    298375 
    299         osync_trace(TRACE_SENSITIVE, "Input XML is:\n%s", osxml_write_to_string((xmlDoc *)input)); 
    300  
    301         char *tmp; 
    302         struct tm *starttm = NULL, *endtm = NULL, *tmptm = NULL; 
    303         int offset = 0; 
     376        OSyncXMLFormat *xmlformat = (OSyncXMLFormat *)input; 
     377        unsigned int size; 
     378        char *str; 
     379        osync_xmlformat_assemble(xmlformat, &str, &size); 
     380        osync_trace(TRACE_INTERNAL, "Input XMLFormat is:\n%s", str); 
     381        g_free(str); 
     382 
     383//      struct tm *starttm = NULL, *endtm = NULL, *tmptm = NULL; 
    304384        osync_bool alldayevent = 0; 
    305         xmlNode *cur = NULL; 
    306         xmlNode *root = xmlDocGetRootElement((xmlDoc *)input); 
    307  
    308         if (!root) { 
    309                 osync_error_set(error, OSYNC_ERROR_GENERIC, "Unable to get xml root element"); 
     385 
     386        if (strcmp("event", osync_xmlformat_get_objtype(xmlformat))) { 
     387                osync_error_set(error, OSYNC_ERROR_GENERIC, "Wrong xmlformat: %s",  osync_xmlformat_get_objtype(xmlformat)); 
    310388                goto error; 
    311389        } 
    312390 
    313         if (xmlStrcmp(root->name, (xmlChar *) "vcal")) { 
    314                 osync_error_set(error, OSYNC_ERROR_GENERIC, "Wrong (event) xml root element"); 
    315                 goto error; 
    316         } 
    317  
    318         // Event child 
    319         root = osxml_get_node(root, "Event"); 
    320  
    321391        // prepare calnote 
    322         gn_calnote *calnote = NULL; 
    323         calnote = (gn_calnote *) malloc(sizeof(gn_calnote)); 
    324  
    325         memset(calnote, 0, sizeof(gn_calnote)); 
    326  
    327         // Type 
    328         // TODO: handle more then one category - not only the first 
    329         cur = osxml_get_node(root, "Categories"); 
    330         if (cur) { 
    331  
    332                 tmp = (char *) xmlNodeGetContent(cur); 
    333  
    334                 if (!strcasecmp(tmp, "Meeting")) 
    335                         calnote->type = GN_CALNOTE_MEETING; 
    336                 else if (!strcasecmp(tmp, "Calling")) 
    337                         calnote->type = GN_CALNOTE_CALL; 
    338                 else if (!strcasecmp(tmp, "Birthday")) 
    339                         calnote->type = GN_CALNOTE_BIRTHDAY; 
    340                 else if (!strcasecmp(tmp, "Reminder")) 
    341                         calnote->type = GN_CALNOTE_REMINDER; 
    342                 else if (!strcasecmp(tmp, "Memo")) 
    343                         calnote->type = GN_CALNOTE_MEMO; 
    344  
    345                 else 
    346                         // When no known type was found it will check later 
    347                         // for a valid type.  
    348                         calnote->type = 0; 
    349  
    350                 g_free(tmp); 
    351         } 
    352  
    353         // DateStarted  
    354         cur = osxml_get_node(root, "DateStarted"); 
    355         if (cur) { 
    356  
    357                 tmp = osxml_find_node(cur, "Content"); 
    358  
    359                 /* 
    360                 ret = sscanf(tmp, "%04u%02u%02uT%02u%02u%02u", 
    361                                 &(calnote->time.year), 
    362                                 &(calnote->time.month), 
    363                                 &(calnote->time.day), 
    364                                 &(calnote->time.hour), 
    365                                 &(calnote->time.minute), 
    366                                 &(calnote->time.second)); 
    367                 */               
    368  
    369                 starttm = osync_time_vtime2tm(tmp); 
    370  
    371                 if (!osync_time_isdate(tmp) && osync_time_isutc(tmp)) { 
    372                         tmptm = starttm; 
    373                         offset = osync_time_timezone_diff(tmptm); 
    374                         starttm = osync_time_tm2localtime(tmptm, offset); 
    375                         g_free(tmptm); 
    376                 } 
    377  
    378                 calnote->time = gnokii_util_tm2timestamp(starttm); 
    379  
    380                 g_free(starttm); 
    381  
    382                 // Only 3 matches (=date) means all day event  
    383                 if (osync_time_isdate(tmp)) 
    384                         alldayevent = 1; 
    385  
    386                 g_free(tmp); 
    387                          
    388  
    389                 // Nokia cellphones cannot handle seconds in calendar - so set it to ZERO 
    390                 calnote->time.second = 0; 
    391         } 
     392        gn_calnote *calnote = osync_try_malloc0(sizeof(gn_calnote), error); 
     393 
     394        OSyncXMLField *xmlfield = osync_xmlformat_get_first_field(xmlformat); 
     395        for (; xmlfield; xmlfield = osync_xmlfield_get_next(xmlfield)) { 
     396                osync_trace(TRACE_INTERNAL, "Field: %s", osync_xmlfield_get_name(xmlfield)); 
     397 
     398                if (!strcmp("Categories", osync_xmlfield_get_name(xmlfield))) 
     399                        _xmlfield_category(calnote, xmlfield); 
     400                else if (!strcmp("DateStarted", osync_xmlfield_get_name(xmlfield))) 
     401                        _xmlfield_datestarted(calnote, xmlfield, &alldayevent); 
     402                else if (!strcmp("DateEnd", osync_xmlfield_get_name(xmlfield))) 
     403                        _xmlfield_dateend(calnote, xmlfield); 
     404 
     405 
     406        } 
     407 
    392408                 
    393  
    394         // DateEnd 
    395         cur = osxml_get_node(root, "DateEnd"); 
    396         if (cur) { 
    397  
    398                 tmp = osxml_find_node(cur, "Content"); 
    399  
    400                 endtm = osync_time_vtime2tm(tmp); 
    401                 if (!osync_time_isdate(tmp) && osync_time_isutc(tmp)) { 
    402                         tmptm = endtm; 
    403                         endtm = osync_time_tm2localtime(tmptm, offset); 
    404                         g_free(tmptm); 
    405                 } 
    406  
    407                 g_free(tmp); 
    408  
    409                 calnote->end_time = gnokii_util_tm2timestamp(endtm); 
    410  
    411                 g_free(endtm); 
    412  
    413                 // Nokia cellphones cannot handle seconds in calendar so set it to ZERO 
    414                 calnote->end_time.second = 0; 
    415         } 
    416409 
    417410        /* Alarm - TODO: is not fully supported 
     
    422415         *              # ... 
    423416         */ 
     417 
     418        /* TODO porting to new XMLFormat-even layout */ 
     419        /* 
    424420        cur = osxml_get_node(root, "Alarm"); 
    425421        if (cur && calnote->time.year) { 
     
    514510                        calnote->recurrence = GN_CALNOTE_2WEEKLY; 
    515511        } 
     512        */ 
    516513 
    517514        // check for type which fits for given data if no type was set