Sync fixes

2 files changed, 12 insertions, 4 deletions

diff --git a/korganizer/calendarview.cpp b/korganizer/calendarview.cpp
index 94cc97d..ce41fbd 100644
--- a/korganizer/calendarview.cpp
+++ b/korganizer/calendarview.cpp
@@ -992,74 +992,82 @@ bool  CalendarView::synchronizeCalendar( Calendar* local,  Calendar* remote, int
     Incidence* inL;
     QProgressBar bar( er.count(),0 );
     bar.setCaption (i18n("Syncing - close to abort!") );
     
     int w = 300;
     if ( QApplication::desktop()->width() < 320 )
         w = 220;
     int h = bar.sizeHint().height() ;
     int dw = QApplication::desktop()->width();
     int dh = QApplication::desktop()->height();
     bar.setGeometry( (dw-w)/2, (dh - h )/2 ,w,h );
     bar.show();
     int modulo = (er.count()/10)+1;
     int incCounter = 0;
     while ( inR ) {
         if ( ! bar.isVisible() )
             return false;
         if ( incCounter % modulo == 0 )
             bar.setProgress( incCounter );
         ++incCounter;
         uid = inR->uid(); 
         bool skipIncidence = false;
         if ( uid.left(15) == QString("last-syncEvent-") )
             skipIncidence = true;
-       
+        QString idS;
         qApp->processEvents();
         if ( !skipIncidence ) {
             inL = local->incidence( uid );
             if ( inL ) { // maybe conflict - same uid in both calendars
                 int maxrev = inL->revision();
                 if ( maxrev < inR->revision() )
                     maxrev = inR->revision();
                 if ( (take = takeEvent( inL, inR, mode, fullDateRange )) > 0 ) {
                     //qDebug("take %d %s ", take, inL->summary().latin1());
                     if ( take == 3 )
                         return false;
                     if ( take == 1  ) {// take local
-                        inL->setCsum( mCurrentSyncDevice, inR->getCsum(mCurrentSyncDevice) );
+                        if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL )
+                            inL->setCsum( mCurrentSyncDevice, inR->getCsum(mCurrentSyncDevice) );
+                        else
+                            idS = inR->IDStr();
                         remote->deleteIncidence( inR );
                         if ( inL->revision() < maxrev )
                             inL->setRevision( maxrev );
                         inR = inL->clone();
                         inR->setTempSyncStat( SYNC_TEMPSTATE_INITIAL );
+                        if ( mGlobalSyncMode != SYNC_MODE_EXTERNAL )
+                            inR->setIDStr( idS );
                         remote->addIncidence(  inR );
                         ++changedRemote;
                     } else {
                         if ( inR->revision() < maxrev )
                             inR->setRevision( maxrev );
+                        idS = inL->IDStr();
                         local->deleteIncidence( inL );
-                        local->addIncidence(  inR->clone()  );
+                        inL = inR->clone();
+                        inL->setIDStr( idS );
+                        local->addIncidence(  inL  );
                         ++changedLocal;
                     }
                 }
             } else { //  no conflict
                 if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
                     QString des = eventLSync->description(); 
                     QString pref = "e";
                     if ( inR->type() == "Todo" )
                         pref = "t";
                     if ( des.find(pref+ inR->getID(mCurrentSyncDevice)  +"," ) >= 0 && mode != 5) { // delete it
                         inR->setTempSyncStat( SYNC_TEMPSTATE_DELETE );
                         //remote->deleteIncidence( inR );
                         ++deletedEventR; 
                     } else {
                         inR->setLastModified( modifiedCalendar );
                         inL = inR->clone();
                         local->addIncidence( inL );
                         ++addedEvent;
                     }
                 } else {
                     if ( inR->lastModified() > mLastCalendarSync || mode == 5 ) {
                         inR->setLastModified( modifiedCalendar );
                         local->addIncidence( inR->clone() );
                         ++addedEvent;
@@ -1079,48 +1087,49 @@ bool  CalendarView::synchronizeCalendar( Calendar* local,  Calendar* remote, int
     bar.setCaption (i18n("Add / remove events") ); 
     bar.setTotalSteps (  el.count()  ) ;
     bar.show();
     incCounter = 0;
    
     while ( inL ) {
            
         qApp->processEvents();
         if ( ! bar.isVisible() )
             return false;
         if ( incCounter % modulo == 0 )
             bar.setProgress( incCounter );
         ++incCounter;
         uid = inL->uid();
         bool skipIncidence = false;
         if ( uid.left(15) == QString("last-syncEvent-") )
             skipIncidence = true;
         if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL && inL->type() == "Journal" )
             skipIncidence = true;
         if ( !skipIncidence )  {
             inR = remote->incidence( uid );
             if ( ! inR ) { 
                 if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
                     if ( !inL->getID(mCurrentSyncDevice).isEmpty() && mode != 4 ) {
+                        checkExternSyncEvent(eventLSyncSharp, inL);
                         local->deleteIncidence( inL );
                         ++deletedEventL; 
                     } else {
                         if ( ! KOPrefs::instance()->mWriteBackExistingOnly ) {
                             inL->removeID(mCurrentSyncDevice );
                             ++addedEventR; 
                             qDebug("remote added Incidence %s ", inL->summary().latin1());
                             inL->setLastModified( modifiedCalendar );
                             inR = inL->clone();
                             inR->setTempSyncStat( SYNC_TEMPSTATE_INITIAL );
                             remote->addIncidence(  inR );
                         }
                     }
                 } else {
                     if ( inL->lastModified() < mLastCalendarSync && mode != 4 ) {
                         checkExternSyncEvent(eventLSyncSharp, inL);
                         local->deleteIncidence( inL );
                         ++deletedEventL; 
                     } else {
                         if ( ! KOPrefs::instance()->mWriteBackExistingOnly ) {
                             ++addedEventR; 
                             inL->setLastModified( modifiedCalendar );
                             remote->addIncidence(  inL->clone() );
                         }
diff --git a/libkcal/event.cpp b/libkcal/event.cpp
index dd67252..dfa265b 100644
--- a/libkcal/event.cpp
+++ b/libkcal/event.cpp
@@ -23,49 +23,48 @@
 #include <kdebug.h>
 
 #include "event.h"
 
 using namespace KCal;
 
 Event::Event() :
   mHasEndDate( false ), mTransparency( Opaque )
 {
 }
 
 Event::Event(const Event &e) : Incidence(e)
 {
   mDtEnd = e.mDtEnd;
   mHasEndDate = e.mHasEndDate;
   mTransparency = e.mTransparency;
 }
 
 Event::~Event()
 {
 }
 
 Incidence *Event::clone()
 {
-  kdDebug(5800) << "Event::clone()" << endl;
   return new Event(*this);
 }
 
 bool KCal::operator==( const Event& e1, const Event& e2 )
 {
     return operator==( (const Incidence&)e1, (const Incidence&)e2 ) &&
         e1.dtEnd() == e2.dtEnd() &&
         e1.hasEndDate() == e2.hasEndDate() &&
         e1.transparency() == e2.transparency();
 }
 
 
 
 void Event::setDtEnd(const QDateTime &dtEnd)
 {
   if (mReadOnly) return;
 
   mDtEnd = getEvenTime( dtEnd );
 
   setHasEndDate(true);
   setHasDuration(false);
 
   updated();
 }