3 files changed, 149 insertions, 41 deletions

diff --git a/libopie2/opiepim/backend/otodoaccesssql.cpp b/libopie2/opiepim/backend/otodoaccesssql.cpp
index ebd03bb..3913661 100644
--- a/libopie2/opiepim/backend/otodoaccesssql.cpp
+++ b/libopie2/opiepim/backend/otodoaccesssql.cpp
@@ -94,128 +94,138 @@ namespace {
         int m_uid;
     };
 
     /**
      * overdue query
      */
     class OverDueQuery : public OSQLQuery {
     public:
         OverDueQuery();
         ~OverDueQuery();
         QString query()const;
     };
     class EffQuery : public OSQLQuery {
     public:
         EffQuery( const QDate&, const QDate&, bool inc );
         ~EffQuery();
         QString query()const;
     private:
         QString with()const;
         QString out()const;
         QDate m_start;
         QDate m_end;
         bool m_inc :1;
     };
 
 
     CreateQuery::CreateQuery() : OSQLQuery() {}
     CreateQuery::~CreateQuery() {}
     QString CreateQuery::query()const {
         QString qu;
         qu += "create table todolist( uid PRIMARY KEY, categories, completed, ";
         qu += "description, summary, priority, DueDate, progress ,  state, ";
-        qu += "Recurrence, reminders, alarms, maintainer, startdate, completeddate);";
+        // This is the recurrance-stuff .. Exceptions are currently not supported (see ORecur.cpp) ! (eilers)
+        qu += "RType, RWeekdays, RPosition, RFreq, RHasEndDate, EndDate, Created, Exceptions, "; 
+        qu += "reminders, alarms, maintainer, startdate, completeddate);";
         qu += "create table custom_data( uid INTEGER, id INTEGER, type VARCHAR(10), value VARCHAR(10), PRIMARY KEY /* identifier */ (uid, id) );";
         return qu;
     }
 
     LoadQuery::LoadQuery() : OSQLQuery() {}
     LoadQuery::~LoadQuery() {}
     QString LoadQuery::query()const {
         QString qu;
         // We do not need "distinct" here. The primary key is always unique..
         //qu += "select distinct uid from todolist";
         qu += "select uid from todolist";
 
         return qu;
     }
 
     InsertQuery::InsertQuery( const OTodo& todo )
         : OSQLQuery(), m_todo( todo ) {
     }
     InsertQuery::~InsertQuery() {
     }
     /*
      * converts from a OTodo to a query
      * we leave out X-Ref + Alarms
      */
     QString InsertQuery::query()const{
 
         int year, month, day;
         year = month = day = 0;
         if (m_todo.hasDueDate() ) {
             QDate date = m_todo.dueDate();
             year = date.year();
             month = date.month();
             day = date.day();
         }
         int sYear = 0, sMonth = 0, sDay = 0;
         if( m_todo.hasStartDate() ){
                 QDate sDate = m_todo.startDate();
                 sYear = sDate.year();
                 sMonth= sDate.month();
                 sDay  = sDate.day();
         } 
 
         int eYear = 0, eMonth = 0, eDay = 0;
         if( m_todo.hasCompletedDate() ){
                 QDate eDate = m_todo.completedDate();
                 eYear = eDate.year();
                 eMonth= eDate.month();
                 eDay  = eDate.day();
         } 
         QString qu;
+        QMap<int, QString> recMap = m_todo.recurrence().toMap();
         qu  = "insert into todolist VALUES(" 
                 +  QString::number( m_todo.uid() ) + "," 
                 + "'" + m_todo.idsToString( m_todo.categories() ) + "'" + ","
                 +       QString::number( m_todo.isCompleted() )         + ","  
                 + "'" + m_todo.description()                      + "'" + ","
                 + "'" + m_todo.summary()                          + "'" + "," 
                 +       QString::number(m_todo.priority() )             + ","
                 + "'" + QString::number(year) + "-" 
                 +       QString::number(month)
                 +       "-" + QString::number( day )              + "'" + ","
                 +       QString::number( m_todo.progress() )            + ","
                 +       QString::number( m_todo.state().state() )       + ","
-                + "'" + m_todo.recurrence().toString()            + "'"+ ",";
+                + "'" + recMap[ ORecur::RType ]                   + "'" + ","
+                + "'" + recMap[ ORecur::RWeekdays ]               + "'" + ","
+                + "'" + recMap[ ORecur::RPosition ]               + "'" + ","
+                + "'" + recMap[ ORecur::RFreq ]                   + "'" + ","
+                + "'" + recMap[ ORecur::RHasEndDate ]             + "'" + ","
+                + "'" + recMap[ ORecur::EndDate ]                 + "'" + ","
+                + "'" + recMap[ ORecur::Created ]                 + "'" + ","
+                + "'" + recMap[ ORecur::Exceptions ]              + "'" + ",";
         
         if ( m_todo.hasNotifiers() ) {
                 OPimNotifyManager manager = m_todo.notifiers();
                         qu += "'" + manager.remindersToString()           + "'" + ","   
                         + "'" + manager.alarmsToString()          + "'" + ",";
         }
         else{
                 qu += QString( "''" )                                   + ","
                         + "''"                                          + ",";
         }
 
         qu +=   QString( "''" )                             + QString( "," ) // Maintainers (cur. not supported !)
                 + "'" + QString::number(sYear) + "-" 
                 + QString::number(sMonth)
                 + "-" + QString::number(sDay)                     + "'" + ","
                 + "'" + QString::number(eYear) + "-"
                 +       QString::number(eMonth)
                 +       "-"+QString::number(eDay)                 + "'"
                 + ")";
 
         qWarning("add %s", qu.latin1() );
         return qu;
     }
 
     RemoveQuery::RemoveQuery(int uid )
         : OSQLQuery(), m_uid( uid ) {}
     RemoveQuery::~RemoveQuery() {}
     QString RemoveQuery::query()const {
         QString qu = "DELETE from todolist where uid = " + QString::number(m_uid);
         return qu;
     }
 
@@ -495,94 +505,107 @@ bool OTodoAccessBackendSQL::date( QDate& da, const QString& str ) const{
         year = list[0].toInt();
         month = list[1].toInt();
         day = list[2].toInt();
         da.setYMD( year, month, day );
         return true;
     }
 }
 OTodo OTodoAccessBackendSQL::todo( const OSQLResult& res) const{
     if ( res.state() == OSQLResult::Failure ) {
         OTodo to;
         return to;
     }
 
     OSQLResultItem::ValueList list = res.results();
     OSQLResultItem::ValueList::Iterator it = list.begin();
     qWarning("todo1");
     OTodo to = todo( (*it) );
     cache( to );
     ++it;
 
     for ( ; it != list.end(); ++it ) {
         qWarning("caching");
         cache( todo( (*it) ) );
     }
     return to;
 }
 OTodo OTodoAccessBackendSQL::todo( OSQLResultItem& item )const {
     qWarning("todo");
     bool hasDueDate = false; QDate dueDate = QDate::currentDate();
     hasDueDate = date( dueDate, item.data("DueDate") );
     QStringList cats = QStringList::split(";", item.data("categories") );
 
+    qWarning("Item is completed: %d", item.data("completed").toInt() );
+
     OTodo to( (bool)item.data("completed").toInt(), item.data("priority").toInt(),
               cats, item.data("summary"), item.data("description"),
               item.data("progress").toUShort(), hasDueDate, dueDate,
               item.data("uid").toInt() );
 
     bool isOk;
     int prioInt = QString( item.data("priority") ).toInt( &isOk );
     if ( isOk )
             to.setPriority( prioInt );
 
     bool hasStartDate = false; QDate startDate = QDate::currentDate();
     hasStartDate = date( startDate, item.data("startdate") );
     bool hasCompletedDate = false; QDate completedDate = QDate::currentDate();
     hasCompletedDate = date( completedDate, item.data("completeddate") );
 
     if ( hasStartDate )
             to.setStartDate( startDate );
     if ( hasCompletedDate )
             to.setCompletedDate( completedDate );
     
     OPimNotifyManager& manager = to.notifiers();
     manager.alarmsFromString( item.data("alarms") );
     manager.remindersFromString( item.data("reminders") );
 
     OPimState pimState;
     pimState.setState( QString( item.data("state") ).toInt() );
     to.setState( pimState );
 
-    // Recurrence not supported yet
-    // to.setRecurrence( 
+    QMap<int, QString> recMap;
+    recMap.insert( ORecur::RType      , item.data("RType") );
+    recMap.insert( ORecur::RWeekdays  , item.data("RWeekdays") );
+    recMap.insert( ORecur::RPosition  , item.data("RPosition") );
+    recMap.insert( ORecur::RFreq      , item.data("RFreq") );
+    recMap.insert( ORecur::RHasEndDate, item.data("RHasEndDate") );
+    recMap.insert( ORecur::EndDate    , item.data("EndDate") );
+    recMap.insert( ORecur::Created    , item.data("Created") );
+    recMap.insert( ORecur::Exceptions , item.data("Exceptions") );
+    
+    ORecur recur;
+    recur.fromMap( recMap );
+    to.setRecurrence( recur );
 
     return to;
 }
 OTodo OTodoAccessBackendSQL::todo( int uid )const {
     FindQuery find( uid );
     return todo( m_driver->query(&find) );
 }
 /*
  * update the dict
  */
 void OTodoAccessBackendSQL::fillDict() {
     /* initialize dict */
     /*
      * UPDATE dict if you change anything!!!
      * FIXME: Isn't this dict obsolete ? (eilers)
      */
     m_dict.setAutoDelete( TRUE );
     m_dict.insert("Categories" ,     new int(OTodo::Category)         );
     m_dict.insert("Uid" ,            new int(OTodo::Uid)              );
     m_dict.insert("HasDate" ,        new int(OTodo::HasDate)          );
     m_dict.insert("Completed" ,      new int(OTodo::Completed)        );
     m_dict.insert("Description" ,    new int(OTodo::Description)      );
     m_dict.insert("Summary" ,        new int(OTodo::Summary)          );
     m_dict.insert("Priority" ,       new int(OTodo::Priority)         );
     m_dict.insert("DateDay" ,        new int(OTodo::DateDay)          );
     m_dict.insert("DateMonth" ,      new int(OTodo::DateMonth)        );
     m_dict.insert("DateYear" ,       new int(OTodo::DateYear)         );
     m_dict.insert("Progress" ,       new int(OTodo::Progress)         );
     m_dict.insert("Completed",       new int(OTodo::Completed)        ); // Why twice ? (eilers)
     m_dict.insert("CrossReference",  new int(OTodo::CrossReference)   );
 //    m_dict.insert("HasAlarmDateTime",new int(OTodo::HasAlarmDateTime) ); // old stuff (eilers)
 //    m_dict.insert("AlarmDateTime",   new int(OTodo::AlarmDateTime)    ); // old stuff (eilers)
diff --git a/libopie2/opiepim/core/orecur.cpp b/libopie2/opiepim/core/orecur.cpp
index eae1fdc..8c9ad46 100644
--- a/libopie2/opiepim/core/orecur.cpp
+++ b/libopie2/opiepim/core/orecur.cpp
@@ -427,84 +427,159 @@ void ORecur::setHasEndDate( bool b) {
 void ORecur::setRepitition( int rep ) {
     checkOrModify();
     data->rep = rep;
 }
 void ORecur::setService( const QString& app ) {
     checkOrModify();
     data->app = app;
 }
 void ORecur::setStart( const QDate& dt ) {
     checkOrModify();
     data->start = dt;
 }
 void ORecur::checkOrModify() {
     if ( data->count !=  1 ) {
         data->deref();
         Data* d2 = new Data;
         d2->days = data->days;
         d2->type = data->type;
         d2->freq = data->freq;
         d2->pos  = data->pos;
         d2->hasEnd = data->hasEnd;
         d2->end  = data->end;
         d2->create = data->create;
         d2->rep = data->rep;
         d2->app = data->app;
         d2->list = data->list;
         d2->start = data->start;
         data = d2;
     }
 }
 QString ORecur::toString()const {
     QString buf;
+    QMap<int, QString> recMap = toMap();
 
     buf += " rtype=\"";
-    switch ( data->type ) {
-    case ORecur::Daily:
-        buf += "Daily";
-        break;
-    case ORecur::Weekly:
-        buf += "Weekly";
-        break;
-    case ORecur::MonthlyDay:
-        buf += "MonthlyDay";
-        break;
-    case ORecur::MonthlyDate:
-        buf += "MonthlyDate";
-        break;
-    case ORecur::Yearly:
-        buf += "Yearly";
-        break;
-    default:
-        buf += "NoRepeat";
-        break;
-    }
+    buf += recMap[ORecur::RType];
     buf += "\"";
     if (data->days > 0 )
-        buf += " rweekdays=\"" + QString::number( static_cast<int>( data->days ) ) + "\"";
+        buf += " rweekdays=\"" + recMap[ORecur::RWeekdays] + "\"";
     if ( data->pos != 0 )
-        buf += " rposition=\"" + QString::number(data->pos ) + "\"";
+        buf += " rposition=\"" + recMap[ORecur::RPosition] + "\"";
 
-    buf += " rfreq=\"" + QString::number( data->freq ) + "\"";
-    buf += " rhasenddate=\"" + QString::number( static_cast<int>( data->hasEnd ) ) + "\"";
+    buf += " rfreq=\"" + recMap[ORecur::RFreq] + "\"";
+    buf += " rhasenddate=\"" + recMap[ORecur::RHasEndDate]+ "\"";
     if ( data->hasEnd )
         buf += " enddt=\""
-               + QString::number( OTimeZone::utc().fromUTCDateTime( QDateTime( data->end, QTime(12,0,0) ) ) )
+               + recMap[ORecur::EndDate]
                + "\"";
-    buf += " created=\"" + QString::number( OTimeZone::utc().fromUTCDateTime( data->create ) ) + "\"";
+    buf += " created=\"" + recMap[ORecur::Created] + "\"";
 
     if ( data->list.isEmpty() ) return buf;
-    // save exceptions list here!!
-    ExceptionList::ConstIterator it;
-    ExceptionList list = data->list;
     buf += " exceptions=\"";
-    QDate date;
-    for ( it = list.begin(); it != list.end(); ++it ) {
-        date = (*it);
-        if ( it != list.begin() ) buf += " ";
-
-        buf += QCString().sprintf("%04d%02d%02d", date.year(), date.month(), date.day() );
-    }
+    buf += recMap[ORecur::Exceptions];
     buf += "\" ";
 
     return buf;
 }
+
+QString ORecur::rTypeString() const
+{
+        QString retString;
+        switch ( data->type ) {
+        case ORecur::Daily:
+                retString = "Daily";
+                break;
+        case ORecur::Weekly:
+                retString = "Weekly";
+                break;
+        case ORecur::MonthlyDay:
+                retString = "MonthlyDay";
+                break;
+        case ORecur::MonthlyDate:
+                retString = "MonthlyDate";
+                break;
+        case ORecur::Yearly:
+                retString = "Yearly";
+                break;
+        default:
+                retString = "NoRepeat";
+                break;
+
+        }
+
+        return retString;
+}
+
+QMap<QString, ORecur::RepeatType> ORecur::rTypeValueConvertMap() const
+{
+        QMap<QString, RepeatType> convertMap;
+
+        convertMap.insert( QString( "Daily" ), ORecur::Daily );
+        convertMap.insert( QString( "Weekly" ), ORecur::Weekly );
+        convertMap.insert( QString( "MonthlyDay" ), ORecur::MonthlyDay );
+        convertMap.insert( QString( "MonthlyDate" ), ORecur::MonthlyDate );
+        convertMap.insert( QString( "Yearly" ), ORecur::Yearly );
+        convertMap.insert( QString( "NoRepeat" ), ORecur::NoRepeat );
+
+        return convertMap;
+}
+
+
+QMap<int, QString> ORecur::toMap() const
+{
+        QMap<int, QString> retMap;
+        
+        retMap.insert( ORecur::RType, rTypeString() );
+        retMap.insert( ORecur::RWeekdays, QString::number( static_cast<int>( data->days ) ) );
+        retMap.insert( ORecur::RPosition, QString::number(data->pos ) );
+        retMap.insert( ORecur::RFreq, QString::number( data->freq ) );
+        retMap.insert( ORecur::RHasEndDate, QString::number( static_cast<int>( data->hasEnd ) ) );
+        if( data -> hasEnd )
+                retMap.insert( ORecur::EndDate, QString::number( OTimeZone::utc().fromUTCDateTime( QDateTime( data->end, QTime(12,0,0) ) ) ) );
+        retMap.insert( ORecur::Created, QString::number( OTimeZone::utc().fromUTCDateTime( data->create ) ) );
+        
+        if ( data->list.isEmpty() ) return retMap;
+
+        // save exceptions list here!!
+        ExceptionList::ConstIterator it;
+        ExceptionList list = data->list;
+        QString exceptBuf;
+        QDate date;
+        for ( it = list.begin(); it != list.end(); ++it ) {
+                date = (*it);
+                if ( it != list.begin() ) exceptBuf += " ";
+                
+                exceptBuf += QCString().sprintf("%04d%02d%02d", date.year(), date.month(), date.day() );
+        }
+
+        retMap.insert( ORecur::Exceptions, exceptBuf );
+
+        return retMap;
+}
+
+void ORecur::fromMap( const QMap<int, QString>& map )
+{
+        QMap<QString, RepeatType> repTypeMap = rTypeValueConvertMap(); 
+
+        data -> type  = repTypeMap[ map [ORecur::RType] ];
+        data -> days  = (char) map[ ORecur::RWeekdays ].toInt();
+        data -> pos   = map[ ORecur::RPosition ].toInt();
+        data -> freq = map[ ORecur::RFreq ].toInt();
+        data -> hasEnd= map[ ORecur::RHasEndDate ].toInt() ? true : false;
+        OTimeZone utc = OTimeZone::utc();
+        if ( data -> hasEnd ){
+                data -> end = utc.fromUTCDateTime( (time_t) map[ ORecur::EndDate ].toLong() ).date();
+        }
+        data -> create = utc.fromUTCDateTime( (time_t) map[ ORecur::Created ].toLong() ).date();
+
+#if 0
+        // FIXME: Exceptions currently not supported...
+        // Convert the list of exceptions from QString into ExceptionList
+        data -> list.clear();
+        QString exceptStr = map[ ORecur::Exceptions ];
+        QStringList exceptList = QStringList::split( " ", exceptStr );
+        ...
+#endif
+        
+        
+}
diff --git a/libopie2/opiepim/core/orecur.h b/libopie2/opiepim/core/orecur.h
index b214b3f..47901b0 100644
--- a/libopie2/opiepim/core/orecur.h
+++ b/libopie2/opiepim/core/orecur.h
@@ -1,91 +1,101 @@
 /*
  * GPL from TT
  */
 
 #ifndef OPIE_RECUR_H
 #define OPIE_RECUR_H
 
 #include <sys/types.h>
 
 #include <qdatetime.h>
 #include <qvaluelist.h>
-
+#include <qmap.h>
 
 class ORecur {
 public:
     typedef QValueList<QDate> ExceptionList;
     enum RepeatType{ NoRepeat = -1, Daily, Weekly, MonthlyDay,
                      MonthlyDate, Yearly };
     enum Days { MON = 0x01, TUE = 0x02, WED = 0x04, THU = 0x08,
                 FRI = 0x10, SAT = 0x20, SUN = 0x40 };
+    enum Fields{ RType = 0, RWeekdays, RPosition, RFreq, RHasEndDate, 
+                 EndDate, Created, Exceptions };
+
     ORecur();
     ORecur( const ORecur& );
     ~ORecur();
 
     ORecur &operator=( const ORecur& );
     bool operator==(const ORecur& )const;
 
     bool doesRecur()const;
     /* if it recurrs on that day */
     bool doesRecur( const QDate& );
     RepeatType type()const;
     int frequency()const;
     int position()const;
     char days()const;
     bool hasEndDate()const;
     QDate start()const;
     QDate endDate()const;
     QDateTime createdDateTime()const;
     /**
      * starting on monday=0, sunday=6
      * for convience
      */
     bool repeatOnWeekDay( int day )const;
 
     /**
      * FromWhereToStart is not included!!!
      */
     bool nextOcurrence( const QDate& FromWhereToStart, QDate &recurDate );
 
     /**
      * The module this ORecur belongs to
      */
     QString service()const;
 
     /*
      * reference to the exception list
      */
     ExceptionList &exceptions();
 
     /**
      * the current repetition
      */
     int repetition()const;
 
     void setType( const RepeatType& );
     void setFrequency( int freq );
     void setPosition( int pos );
     void setDays( char c);
     void setEndDate( const QDate& dt );
     void setStart( const QDate& dt );
     void setCreatedDateTime( const QDateTime& );
     void setHasEndDate( bool b );
     void setRepitition(int );
 
     void setService( const QString& ser );
+    
+    QMap<int, QString> toMap() const;
+    void fromMap( const QMap<int, QString>& map );
 
     /* almost internal */
     QString toString()const;
 private:
     bool p_nextOccurrence( const QDate& from, QDate& next );
     void deref();
     inline void checkOrModify();
 
+    /* Converts rType to String */
+    QString rTypeString() const;
+    /* Returns a map to convert Stringname for RType to RepeatType */
+    QMap<QString, RepeatType> rTypeValueConvertMap() const;
 
     class Data;
     Data* data;
     class ORecurPrivate;
     ORecurPrivate *d;
 };
 
 #endif