opensync-plugin-0.4x/src/vevent.cc

   1 //
   2 // \file        vevent.cc
   3 //              Conversion routines for vevents (VCALENDAR, etc)
   4 //
   5
   6 /*
   7     Copyright (C) 2006-2012, Net Direct Inc. (http://www.netdirect.ca/)
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17
  18     See the GNU General Public License in the COPYING file at the
  19     root directory of this project for more details.
  20 */
  21
  22 #include <opensync/opensync.h>
  23 #include <opensync/opensync-time.h>
  24
  25 #include "vevent.h"
  26 #include "environment.h"
  27 #include "trace.h"
  28 #include "tosserror.h"
  29 #include <stdint.h>
  30 #include <glib.h>
  31 #include <strings.h>
  32 #include <sstream>
  33 #include <vector>
  34
  35 using namespace Barry::Sync;
  36
  37 //////////////////////////////////////////////////////////////////////////////
  38 //
  39
  40 VEventConverter::VEventConverter()
  41         : m_Data(0)
  42 {
  43 }
  44
  45 VEventConverter::VEventConverter(uint32_t newRecordId)
  46         : m_Data(0),
  47         m_RecordId(newRecordId)
  48 {
  49 }
  50
  51 VEventConverter::~VEventConverter()
  52 {
  53         if( m_Data )
  54                 g_free(m_Data);
  55 }
  56
  57 // Transfers ownership of m_Data to the caller
  58 char* VEventConverter::ExtractData()
  59 {
  60         Trace trace("VEventConverter::ExtractData");
  61         char *ret = m_Data;
  62         m_Data = 0;
  63         return ret;
  64 }
  65
  66 bool VEventConverter::ParseData(const char *data)
  67 {
  68         Trace trace("VEventConverter::ParseData");
  69
  70         try {
  71
  72                 vTimeConverter vtc;
  73                 vCalendar vcal(vtc);
  74                 m_Cal = vcal.ToBarry(data, m_RecordId);
  75
  76         }
  77         catch( Barry::ConvertError &ce ) {
  78                 trace.logf("ERROR: vevent:Barry::ConvertError exception: %s", ce.what());
  79                 m_last_errmsg = ce.what();
  80                 return false;
  81         }
  82
  83         return true;
  84 }
  85
  86 bool VEventConverter::MergeData(const Barry::Calendar &origin)
  87 {
  88         // Save CalendarID value
  89         // CalendarID field is used to link an entry event to an account mail
  90         if (origin.CalendarID != m_Cal.CalendarID)
  91                 m_Cal.CalendarID = origin.CalendarID;
  92
  93         return true;
  94 }
  95
  96 // Barry storage operator
  97 void VEventConverter::operator()(const Barry::Calendar &rec)
  98 {
  99         Trace trace("VEventConverter::operator()");
 100
 101         // Delete data if some already exists
 102         if( m_Data ) {
 103                 g_free(m_Data);
 104                 m_Data = 0;
 105         }
 106
 107         // Keep a trace of Calendar object (need to merge with the new event)
 108         m_Cal = rec;
 109
 110         try {
 111                 vTimeConverter vtc;
 112                 vCalendar vcal(vtc);
 113                 vcal.ToVCal(rec);
 114                 m_Data = vcal.ExtractVCal();
 115
 116         }
 117         catch( Barry::ConvertError &ce ) {
 118                 trace.logf("ERROR: vevent:Barry::ConvertError exception: %s", ce.what());
 119                 m_last_errmsg = ce.what();
 120         }
 121 }
 122
 123 // Barry builder operator
 124 bool VEventConverter::operator()(Barry::Calendar &rec, Barry::Builder &)
 125 {
 126         Trace trace("VEventConverter::builder operator()");
 127
 128         rec = m_Cal;
 129         return true;
 130 }
 131
 132 // Handles calling of the Barry::Controller to fetch a specific
 133 // record, indicated by index (into the RecordStateTable).
 134 // Returns a g_malloc'd string of data containing the vevent20
 135 // data.  It is the responsibility of the caller to free it.
 136 // This is intended to be passed into the GetChanges() function.
 137 char* VEventConverter::GetRecordData(BarryEnvironment *env, unsigned int dbId,
 138                                 Barry::RecordStateTable::IndexType index)
 139 {
 140         Trace trace("VEventConverter::GetRecordData()");
 141
 142         using namespace Barry;
 143
 144         VEventConverter cal2event;
 145         RecordParser<Calendar, VEventConverter> parser(cal2event);
 146         env->GetDesktop()->GetRecord(dbId, index, parser);
 147         return cal2event.ExtractData();
 148 }
 149
 150 bool VEventConverter::CommitRecordData(BarryEnvironment *env, unsigned int dbId,
 151         Barry::RecordStateTable::IndexType StateIndex, uint32_t recordId,
 152         const char *data, bool add, std::string &errmsg)
 153 {
 154         Trace trace("VEventConverter::CommitRecordData()");
 155
 156         uint32_t newRecordId;
 157         if( add ) {
 158                 // use given id if possible
 159                 if( recordId && !env->m_CalendarSync.m_Table.GetIndex(recordId) ) {
 160                         // recordId is unique and non-zero
 161                         newRecordId = recordId;
 162                 }
 163                 else {
 164                         trace.log("Can't use recommended recordId, generating new one.");
 165                         newRecordId = env->m_CalendarSync.m_Table.MakeNewRecordId();
 166                 }
 167         }
 168         else {
 169                 newRecordId = env->m_CalendarSync.m_Table.StateMap[StateIndex].RecordId;
 170         }
 171         trace.logf("newRecordId: %u", newRecordId);
 172
 173         VEventConverter convert(newRecordId);
 174         if( !convert.ParseData(data) ) {
 175                 std::ostringstream oss;
 176                 oss << "unable to parse change data for new RecordId: "
 177                     << newRecordId
 178                     << " (" << convert.GetLastError() << ") data: " << data;
 179                 errmsg = oss.str();
 180                 trace.log(errmsg.c_str());
 181                 return false;
 182         }
 183
 184         // If we modify a data, we read at first its current value
 185         // then we merge with the parsed value from the other opensync member
 186         // Merge function is important because, we have to save some BlackBerry fields.
 187         // Fix an issue with the new OS release who supports several calendar.
 188         if( !add ) {
 189                 using namespace Barry;
 190
 191                 VEventConverter cal2event;
 192                 RecordParser<Calendar, VEventConverter> parser(cal2event);
 193                 env->GetDesktop()->GetRecord(dbId, StateIndex, parser);
 194
 195                 convert.MergeData(cal2event.GetCalendar());
 196         }
 197
 198         Barry::RecordBuilder<Barry::Calendar, VEventConverter> builder(convert);
 199
 200         if( add ) {
 201                 trace.log("adding record");
 202                 env->GetDesktop()->AddRecord(dbId, builder);
 203         }
 204         else {
 205                 trace.log("setting record");
 206                 env->GetDesktop()->SetRecord(dbId, StateIndex, builder);
 207                 trace.log("clearing dirty flag");
 208                 env->GetDesktop()->ClearDirty(dbId, StateIndex);
 209         }
 210
 211         return true;
 212 }
 213