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

   1 //
   2 // \file        vtodo.cc
   3 //              Conversion routines for vtodos (VCALENDAR, etc)
   4 //
   5
   6 /*
   7     Copyright (C) 2008-2009, Nicolas VIVIEN
   8     Copyright (C) 2006-2010, Net Direct Inc. (http://www.netdirect.ca/)
   9
  10     This program is free software; you can redistribute it and/or modify
  11     it under the terms of the GNU General Public License as published by
  12     the Free Software Foundation; either version 2 of the License, or
  13     (at your option) any later version.
  14
  15     This program is distributed in the hope that it will be useful,
  16     but WITHOUT ANY WARRANTY; without even the implied warranty of
  17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  18
  19     See the GNU General Public License in the COPYING file at the
  20     root directory of this project for more details.
  21 */
  22
  23 #include <opensync/opensync.h>
  24 #include <opensync/opensync-time.h>
  25
  26 #include "vtodo.h"
  27 #include "environment.h"
  28 #include "trace.h"
  29 #include "tosserror.h"
  30 #include <stdint.h>
  31 #include <glib.h>
  32 #include <string.h>
  33 #include <sstream>
  34
  35 using namespace Barry::Sync;
  36
  37 //////////////////////////////////////////////////////////////////////////////
  38 //
  39
  40 VTodoConverter::VTodoConverter()
  41         : m_Data(0)
  42 {
  43 }
  44
  45 VTodoConverter::VTodoConverter(uint32_t newRecordId)
  46         : m_Data(0),
  47         m_RecordId(newRecordId)
  48 {
  49 }
  50
  51 VTodoConverter::~VTodoConverter()
  52 {
  53         if( m_Data )
  54                 g_free(m_Data);
  55 }
  56
  57 // Transfers ownership of m_Data to the caller
  58 char* VTodoConverter::ExtractData()
  59 {
  60         Trace trace("VTodoConverter::ExtractData");
  61         char *ret = m_Data;
  62         m_Data = 0;
  63         return ret;
  64 }
  65
  66 bool VTodoConverter::ParseData(const char *data)
  67 {
  68         Trace trace("VTodoConverter::ParseData");
  69
  70         try {
  71
  72                 vTimeConverter vtc;
  73                 vTodo vtodo(vtc);
  74                 m_Task = vtodo.ToBarry(data, m_RecordId);
  75
  76         }
  77         catch( Barry::ConvertError &ce ) {
  78                 trace.logf("ERROR: vtodo:Barry::ConvertError exception: %s", ce.what());
  79                 return false;
  80         }
  81
  82         return true;
  83 }
  84
  85 // Barry storage operator
  86 void VTodoConverter::operator()(const Barry::Task &rec)
  87 {
  88         Trace trace("VTodoConverter::operator()");
  89
  90         // Delete data if some already exists
  91         if( m_Data ) {
  92                 g_free(m_Data);
  93                 m_Data = 0;
  94         }
  95
  96         try {
  97
  98                 vTimeConverter vtc;
  99                 vTodo vtodo(vtc);
 100                 vtodo.ToTask(rec);
 101                 m_Data = vtodo.ExtractVTodo();
 102
 103         }
 104         catch( Barry::ConvertError &ce ) {
 105                 trace.logf("ERROR: vtodo:Barry::ConvertError exception: %s", ce.what());
 106         }
 107 }
 108
 109 // Barry builder operator
 110 bool VTodoConverter::operator()(Barry::Task &rec, unsigned int dbId)
 111 {
 112         Trace trace("VTodoConverter::builder operator()");
 113
 114         rec = m_Task;
 115         return true;
 116 }
 117
 118 // Handles calling of the Barry::Controller to fetch a specific
 119 // record, indicated by index (into the RecordStateTable).
 120 // Returns a g_malloc'd string of data containing the vevent20
 121 // data.  It is the responsibility of the caller to free it.
 122 // This is intended to be passed into the GetChanges() function.
 123 char* VTodoConverter::GetRecordData(BarryEnvironment *env, unsigned int dbId,
 124                                 Barry::RecordStateTable::IndexType index)
 125 {
 126         Trace trace("VTodoConverter::GetRecordData()");
 127
 128         using namespace Barry;
 129
 130         VTodoConverter task2todo;
 131         RecordParser<Task, VTodoConverter> parser(task2todo);
 132         env->m_pDesktop->GetRecord(dbId, index, parser);
 133         return task2todo.ExtractData();
 134 }
 135
 136 bool VTodoConverter::CommitRecordData(BarryEnvironment *env, unsigned int dbId,
 137         Barry::RecordStateTable::IndexType StateIndex, uint32_t recordId,
 138         const char *data, bool add, std::string &errmsg)
 139 {
 140         Trace trace("VTodoConverter::CommitRecordData()");
 141
 142         uint32_t newRecordId;
 143         if( add ) {
 144                 // use given id if possible
 145                 if( recordId && !env->m_TodoSync.m_Table.GetIndex(recordId) ) {
 146                         // recordId is unique and non-zero
 147                         newRecordId = recordId;
 148                 }
 149                 else {
 150                         trace.log("Can't use recommended recordId, generating new one.");
 151                         newRecordId = env->m_TodoSync.m_Table.MakeNewRecordId();
 152                 }
 153         }
 154         else {
 155                 newRecordId = env->m_TodoSync.m_Table.StateMap[StateIndex].RecordId;
 156         }
 157         trace.logf("newRecordId: %u", newRecordId);
 158
 159         VTodoConverter convert(newRecordId);
 160         if( !convert.ParseData(data) ) {
 161                 std::ostringstream oss;
 162                 oss << "unable to parse change data for new RecordId: "
 163                     << newRecordId << " data: " << data;
 164                 errmsg = oss.str();
 165                 trace.log(errmsg.c_str());
 166                 return false;
 167         }
 168
 169         Barry::RecordBuilder<Barry::Task, VTodoConverter> builder(convert);
 170
 171         if( add ) {
 172                 trace.log("adding record");
 173                 env->m_pDesktop->AddRecord(dbId, builder);
 174         }
 175         else {
 176                 trace.log("setting record");
 177                 env->m_pDesktop->SetRecord(dbId, StateIndex, builder);
 178                 trace.log("clearing dirty flag");
 179                 env->m_pDesktop->ClearDirty(dbId, StateIndex);
 180         }
 181
 182         return true;
 183 }
 184