source/actmgr/frmActivityMgr.cpp

   1 // frmActivityMgr.cpp - Activity Manager form.
   2 //
   3 // (c) 2012-2015 Xestia Software Development.
   4 //
   5 // This file is part of Xestia Address Book.
   6 //
   7 // Xestia Address Book is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU General Public License as published by the
   9 // Free Software Foundation, version 3 of the license.
  10 //
  11 // Xestia Address Book is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License along
  17 // with Xestia Address Book. If not, see <http://www.gnu.org/licenses/>
  18
  19 #include "frmActivityMgr.h"
  20 #include <wx/mstream.h>
  21 #include <wx/file.h>
  22 #include <wx/ffile.h>
  23 #include <wx/tokenzr.h>
  24 #include <wx/dir.h>
  25 #include <wx/filefn.h>
  26 #include <thread>
  27 #include <curl/curl.h>
  28
  29 #include "../bitmaps.h"
  30 #include "../enums.h"
  31 #include "../common/preferences.h"
  32 #include "../frmConflictResolution.h"
  33 #include "../frmInvalidSSLCertificate.h"
  34 #include "../frmMain.h"
  35 #include "../common/events.h"
  36 #include "../common/filename.h"
  37 #include "../vcard/vcard34conv.h"
  38 #include "../vcard/vcard.h"
  39
  40 #ifndef FRMACTIVITYMGR_H
  41 #define FRMACTIVITYMGR_H
  42
  43 DEFINE_EVENT_TYPE(ACTMGR_RESUMEPROC);
  44 DEFINE_EVENT_TYPE(ACTMGR_TOGGLECONN);
  45 DEFINE_EVENT_TYPE(ACTMGR_STARTTIMER);
  46 DEFINE_EVENT_TYPE(ACTMGR_STOPTIMER);
  47 DEFINE_EVENT_TYPE(ACTMGR_STARTPROCESSTIMER);
  48 DEFINE_EVENT_TYPE(ACTMGR_STOPPROCESSTIMER);
  49 DEFINE_EVENT_TYPE(ACTMGR_UPDATESTATUSLABEL);
  50
  51 BEGIN_EVENT_TABLE(frmActivityMgr, wxWindow)
  52   EVT_COMMAND(wxID_ANY, ACTMGR_RESUMEPROC, frmActivityMgr::ResumeProcessing)
  53   EVT_COMMAND(wxID_ANY, ACTMGR_TOGGLECONN, frmActivityMgr::ToggleConnectionStatus)
  54   EVT_COMMAND(wxID_ANY, ACTMGR_STARTTIMER, frmActivityMgr::StartTimer)
  55   EVT_COMMAND(wxID_ANY, ACTMGR_STOPTIMER, frmActivityMgr::StopTimer)
  56   EVT_COMMAND(wxID_ANY, ACTMGR_STARTPROCESSTIMER, frmActivityMgr::StartProcessTimer)
  57   EVT_COMMAND(wxID_ANY, ACTMGR_STOPPROCESSTIMER, frmActivityMgr::StopProcessTimer)
  58   EVT_COMMAND(wxID_ANY, ACTMGR_UPDATESTATUSLABEL, frmActivityMgr::UpdateStatusLabel)
  59 END_EVENT_TABLE()
  60
  61 frmActivityMgr::frmActivityMgr( wxWindow* parent )
  62 :
  63 frmActivityMgrADT( parent )
  64 {
  65
  66         wxMemoryInputStream istream(icons_activitywindow_png, sizeof(icons_activitywindow_png));
  67         wxImage icons_activitywindow_pngi(istream, wxBITMAP_TYPE_PNG);
  68         wxBitmap activityiconbmp(icons_activitywindow_pngi, -1);
  69         wxIcon activityicon;
  70         activityicon.CopyFromBitmap(activityiconbmp);
  71         this->SetIcon(activityicon);
  72
  73         wxMemoryInputStream istream2(misc_activitysleep_png, sizeof(misc_activitysleep_png));
  74         wxImage misc_activitysleep_pngi(istream2, wxBITMAP_TYPE_PNG);
  75         wxBitmap sleepiconbmp(misc_activitysleep_pngi, -1);
  76         SleepBitmap = sleepiconbmp;
  77         bmpActivity->SetBitmap(SleepBitmap);
  78         ActProcessTimer.SetupPointers(this);
  79         lblDetails->SetLabel(_("No activity."));
  80
  81         ActListProcTimer.SetupPointers(&ActivityList, &ActivityListIndex, &ActivityListTaskDetail,
  82                                         &TasksActive, lstActivity, lblDetails, GauProgress, this, &AnimationTimer,
  83                                         &ActProcessTimer, &ActivityListFinDate, &ActivityListConn);
  84
  85         AnimationTimer.SetBitmap(bmpActivity);
  86         AnimationTimer.SetSleepBitmap(&SleepBitmap);
  87         AnimationTimer.SetupPointer(this->GetParent());
  88
  89         wxListItem ColumnData;
  90         ColumnData.SetId(0);
  91         ColumnData.SetText(_("Activity"));
  92         ColumnData.SetWidth(175);
  93         lstActivity->InsertColumn(0, ColumnData);
  94
  95         wxListItem ColumnData2;
  96         ColumnData2.SetId(1);
  97         ColumnData2.SetText(_("Account"));
  98         ColumnData2.SetWidth(100);
  99         lstActivity->InsertColumn(1, ColumnData2);
 100
 101         wxListItem ColumnData3;
 102         ColumnData3.SetId(2);
 103         ColumnData3.SetText(_("Status"));
 104         ColumnData3.SetWidth(100);
 105         lstActivity->InsertColumn(2, ColumnData3);
 106
 107         //AnimationTimer.StartAnimation();
 108
 109         // Create recovery database if it doesn't exist.
 110
 111         wxString RecoveryFilename = GetRecoveryDB();
 112
 113         wxFile RecoveryDB;
 114
 115         if (wxFile::Exists(RecoveryFilename) == FALSE){
 116
 117                 // Create the recovery database.
 118
 119                 RecoveryDB.Open(RecoveryFilename.c_str(), wxFile::write);
 120
 121                 RecoveryDB.Write(wxT("BEGIN:XAB-RECOVERYDB\r\n"), wxConvUTF8);
 122                 RecoveryDB.Write(wxT("VERSION:1.0\r\n"), wxConvUTF8);
 123                 RecoveryDB.Write(wxT("COMMENT:Please do not alter or delete this file. DATA LOSS IS POSSIBLE!\r\n"), wxConvUTF8);
 124                 RecoveryDB.Write(wxT("END:XAB-RECOVERYDB\r\n"), wxConvUTF8);
 125                 RecoveryDB.Close();
 126
 127         }
 128
 129         wxFFile RecoveryDBF;
 130
 131 #if wxABI_VERSION < 20900
 132         RecoveryDBF.Open(RecoveryFilename.c_str(), wxT("r"));
 133 #else
 134         RecoveryDBF.Open(RecoveryFilename, wxT("r"));
 135 #endif
 136
 137         // Load the recovery database for tasks not done.
 138
 139         if (RecoveryDBF.IsOpened() == TRUE){
 140
 141                 wxString wxSRecoveryDB;
 142                 wxString RecoveryLine;
 143
 144                 // Check if we are using wxWidgets version 2.8 or less and
 145                 // execute the required command accordingly.
 146
 147                 RecoveryDBF.ReadAll(&wxSRecoveryDB, wxConvAuto());
 148
 149                 // Split the lines.
 150
 151                 std::map<int, wxString> RecoveryFileLines;
 152                 std::map<int, wxString>::iterator striter;
 153
 154                 wxStringTokenizer wSTRecoveryDBLines(wxSRecoveryDB, wxT("\r\n"));
 155
 156                 int RecoveryLineSeek = 0;
 157
 158                 while (wSTRecoveryDBLines.HasMoreTokens() == TRUE){
 159
 160                         RecoveryLine = wSTRecoveryDBLines.GetNextToken();
 161                         RecoveryFileLines.insert(std::make_pair(RecoveryLineSeek, RecoveryLine));
 162                         RecoveryLineSeek++;
 163
 164                 }
 165
 166         }
 167
 168
 169
 170         //TestTimer.Start(50, FALSE);
 171 }
 172
 173 void frmActivityMgr::OpenWindow()
 174 {
 175         WindowOpen = TRUE;
 176 }
 177
 178 void frmActivityMgr::CloseWindow( wxCommandEvent& event )
 179 {
 180         WindowOpen = FALSE;
 181         this->Hide();
 182 }
 183
 184 void frmActivityMgr::CloseWindow( wxCloseEvent& event )
 185 {
 186         WindowOpen = FALSE;
 187         this->Hide();
 188 }
 189
 190 void frmActivityMgr::ProcessTasksThread()
 191 {
 192
 193         if (ProcessTasksData == FALSE){
 194
 195                 return;
 196
 197         }
 198
 199         std::map<int,int>::iterator TypeIter;
 200         std::map<int,wxString>::iterator StringIter;
 201         std::map<int,wxString>::iterator StringDetailIter;
 202         std::map<int,wxString>::iterator StringAccountIter;
 203         std::map<int,wxString>::iterator StringFilenameIter;
 204         std::map<int,wxString>::iterator StringFullFilenameIter;
 205         std::map<int,wxString>::iterator StringTaskDetailIter;
 206         std::map<int,wxString>::iterator StringETagIter;
 207         std::map<int,wxString>::iterator StringETagOrigIter;
 208         std::map<int,CardDAV*>::iterator CardDAVIter;
 209         std::map<int,long>::iterator LongIter;
 210         bool TasksFoundProc = FALSE;
 211         wxString TaskDetail;
 212
 213         for (std::map<int,int>::iterator iter = ActivityList.begin();
 214          iter != ActivityList.end(); ++iter){
 215
 216                 // Check for any queued tasks and start one.
 217
 218                 if (iter->second > 4){
 219                         continue;
 220                 }
 221
 222                 CardDAVIter = ActivityListConn.find(iter->first);
 223                 TypeIter = ActivityListType.find(iter->first);
 224                 StringETagIter = ActivityListETag.find(iter->first);
 225                 StringETagOrigIter = ActivityListETagOriginal.find(iter->first);
 226                 StringAccountIter = ActivityListAccount.find(iter->first);
 227                 StringFilenameIter = ActivityListFilename.find(iter->first);
 228                 StringFullFilenameIter = ActivityListFullFilename.find(iter->first);
 229
 230                 // 0 = Queued.
 231                 // 1 = Processing.
 232                 // 2 = Failed.
 233                 // 3 = Stopped.
 234                 // 4 = Completed.
 235                 // 5 = Failed (UI Updated).
 236                 // 6 = Stopped (UI Updated).
 237                 // 7 = (Reserved) (UI Updated).
 238                 // 8 = Completed. (UI Updated).
 239
 240                 if (iter->second == 0){
 241
 242                         //CardDAVIter->second.
 243
 244                         // Wait for process to finish.
 245
 246                         TasksActive = TRUE;
 247                         TasksFoundProc = TRUE;
 248                         wxString ETag;
 249                         wxString ETagOriginal;
 250                         wxString ETagServer;
 251                         wxString AccountDir;
 252                         wxString ContactFilename;
 253                         wxString FullFilename;
 254                         wxString ETagResult;
 255
 256                         iter->second = 1;
 257
 258                         if (TypeIter->second == 1){
 259                                 CardDAVIter->second->GetServerETagValueThread();
 260                                 ETagServer = CardDAVIter->second->ETagValueResult();
 261                         }
 262
 263                         // Compare the ETags and work out if a conflict has occured.
 264
 265                         if (TypeIter->second == 1){
 266
 267                                 ETag = StringETagIter->second;
 268                                 ETagOriginal = StringETagOrigIter->second;
 269                                 AccountDir = StringAccountIter->second;
 270                                 ContactFilename = StringFilenameIter->second;
 271                                 FullFilename = StringFullFilenameIter->second;
 272
 273                                 ETagDB *ETagDBPtr = ETagTmrPtr->GetPointer(AccountDir);
 274
 275                                 if (ETag == ETagOriginal){
 276
 277                                         // Compare the ETag with the Server ETag.
 278
 279                                         if (ETagOriginal != ETagServer){
 280
 281                                                 // Server ETag is different from original ETag.
 282                                                 // This is a conflict which the user will now
 283                                                 // need to resolve.
 284
 285                                                 vCard Moo1;
 286                                                 vCard Moo2;
 287
 288                                                 frmMain *frmMainPtrGet = static_cast<frmMain*>(frmMainPtr);
 289
 290                                                 vCard34Conv vCard34Obj;
 291
 292                                                 wxString ServerContactData;
 293                                                 vCard ClientData;
 294                                                 vCard ConvertedV4Data;
 295
 296                                                 // Load the client data from the filename given.
 297
 298                                                 CardDAVIter->second->GetServerContactData();
 299                                                 ServerContactData = CardDAVIter->second->GetPageData();
 300
 301                                                 // Process v3 version into v4 version.
 302
 303                                                 vCard34Obj.ConvertToV4(&ServerContactData, &ConvertedV4Data);
 304
 305                                                 vCardConflictObj vCardProcData;
 306
 307                                                 vCardProcData.vCardLocalData = &ClientData;
 308                                                 vCardProcData.vCardServerData = &ConvertedV4Data;
 309                                                 ClientData.LoadFile(FullFilename);
 310
 311                                                 //ContactConflictEvent event(ContactConflictCmdEnv);
 312                                                 //event.SetData(ContactFilename, Moo1, Moo2);
 313
 314                                                 //wxPostEvent(frmMainPtrGet, event);
 315
 316                                                 // Setup Conflict Resolution Dialog.
 317
 318                                                 // Fetch Data from Server and convert.
 319
 320                                                 bool *PauseMode = new bool;
 321                                                 int ConflictResult;
 322                                                 QRNotif qrn;
 323
 324                                                 *PauseMode = TRUE;
 325                                                 qrn.QResponse = &ConflictResult;
 326                                                 qrn.PausePtr = PauseMode;
 327
 328                                                 vCardProcData.QRNotifData = &qrn;
 329
 330                                                 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED);
 331                                                 event.SetClientData(&vCardProcData);
 332                                                 wxPostEvent(frmMainPtrGet, event);
 333
 334                                                 /*timespec n1, n2;
 335
 336                                                 n1.tv_sec = 0;
 337                                                 n1.tv_nsec = 250000000L;*/
 338
 339                                                 while (*PauseMode == TRUE){
 340                                                         //nanosleep(&n1, &n2);
 341                                                         SleepFor(250000000);
 342                                                 }
 343
 344                                                 delete PauseMode;
 345                                                 PauseMode = NULL;
 346
 347                                                 //intResult = frmMainPtrGet->ShowConflictDialog(&Moo1, &Moo2);
 348
 349                                                 if (ConflictResult == 0){
 350
 351                                                         // Decide Later.
 352
 353                                                         iter->second = 4;
 354                                                         continue;
 355
 356                                                 } else if (ConflictResult == 1){
 357
 358                                                         // Decided to use client version.
 359
 360                                                         CardDAVIter->second->ProcessData();
 361
 362                                                         iter->second = 4;
 363
 364                                                 } else if (ConflictResult == 2){
 365
 366                                                         // Decided to use server version.
 367
 368                                                         // Download server version.
 369
 370                                                         ConvertedV4Data.WriteFile(FullFilename);
 371
 372                                                         iter->second = 4;
 373
 374                                                 }
 375
 376                                         } else {
 377
 378                                                 // Update the data to the server.
 379
 380                                                 CardDAVIter->second->ProcessData();
 381
 382                                         }
 383
 384                                 } else {
 385
 386                                         if (ETagOriginal != ETagServer){
 387
 388                                                 // Server ETag is different from original ETag.
 389                                                 // This is a conflict which the user will now
 390                                                 // need to resolve.
 391
 392                                                 frmMain *frmMainPtrGet = (frmMain *)frmMainPtr;
 393
 394                                                 //ContactConflictEvent event(ContactConflictCmdEnv);
 395                                                 //event.SetData(ContactFilename, Moo1, Moo2);
 396
 397                                                 vCard34Conv vCard34Obj;
 398
 399                                                 wxString ServerContactData;
 400                                                 vCard ClientData;
 401                                                 vCard ConvertedV4Data;
 402
 403                                                 // Load the client data from the filename given.
 404
 405                                                 CardDAVIter->second->GetServerContactData();
 406                                                 ServerContactData = CardDAVIter->second->GetPageData();
 407                                                 ClientData.LoadFile(FullFilename);
 408
 409                                                 // Process v3 version into v4 version.
 410
 411                                                 vCard34Obj.ConvertToV4(&ServerContactData, &ConvertedV4Data);
 412
 413                                                 vCardConflictObj vCardProcData;
 414
 415                                                 vCardProcData.vCardLocalData = &ClientData;
 416                                                 vCardProcData.vCardServerData = &ConvertedV4Data;
 417
 418                                                 bool *PauseMode = new bool;
 419                                                 int ConflictResult;
 420                                                 QRNotif qrn;
 421
 422                                                 *PauseMode = TRUE;
 423                                                 qrn.QResponse = &ConflictResult;
 424                                                 qrn.PausePtr = PauseMode;
 425
 426                                                 vCardProcData.QRNotifData = &qrn;
 427
 428                                                 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED);
 429                                                 event.SetClientData(&vCardProcData);
 430                                                 wxPostEvent(frmMainPtrGet, event);
 431
 432                                                 /*timespec n1, n2;
 433
 434                                                 n1.tv_sec = 0;
 435                                                 n1.tv_nsec = 250000000L;*/
 436
 437                                                 while (*PauseMode == TRUE){
 438                                                         //nanosleep(&n1, &n2);
 439                                                         SleepFor(250000000);
 440                                                 }
 441
 442                                                 delete PauseMode;
 443                                                 PauseMode = NULL;
 444
 445                                                 //intResult = frmMainPtrGet->ShowConflictDialog(&Moo1, &Moo2);
 446
 447                                                 if (ConflictResult == 0){
 448
 449                                                         // Decide Later.
 450
 451                                                         iter->second = 4;
 452                                                         continue;
 453
 454                                                 } else if (ConflictResult == 1){
 455
 456                                                         // Decided to use client version.
 457
 458                                                         CardDAVIter->second->ProcessData();
 459                                                         //ETagServer = CardDAVIter->second.GetServerETagValueThread();
 460                                                         //ETagDBPtr->UpdateETag(ContactFilename, ETagServer, ETagServer);
 461
 462                                                         iter->second = 4;
 463
 464                                                 } else if (ConflictResult == 2){
 465
 466                                                         // Decided to use server version.
 467
 468                                                         // Write server version to file.
 469
 470                                                         ConvertedV4Data.WriteFile(FullFilename);
 471
 472                                                         iter->second = 4;
 473
 474                                                 }
 475
 476                                         } else {
 477
 478                                                 // Update the data to the server.
 479
 480                                                 CardDAVIter->second->ProcessData();
 481
 482                                         }
 483
 484                                 }
 485
 486                                 // Update the ETag DB.
 487
 488                                 CardDAVIter->second->GetServerETagValueThread();
 489                                 ETagServer = CardDAVIter->second->ETagValueResult();
 490                                 ETagDBPtr->UpdateETag(ContactFilename, ETagServer, ETagServer);
 491
 492                                 iter->second = 4;
 493                                 CardDAVIter->second = NULL;
 494
 495                         } else if (TypeIter->second == 2) {
 496
 497                                 // Delete the contact from the server and update the ETag DB.
 498
 499                                 AccountDir = StringAccountIter->second;
 500                                 ContactFilename = StringFilenameIter->second;
 501
 502                                 ETagDB *ETagDBPtr = ETagTmrPtr->GetPointer(AccountDir);
 503
 504                                 CardDAVIter->second->SetUploadMode(FALSE);
 505                                 CardDAVIter->second->SetupData(wxT("DELETE"), ContactFilename, wxT(""));
 506                                 //CardDAVIter->second.SetServerFilename();
 507                                 CardDAVIter->second->ProcessData();
 508                                 ETagDBPtr->RemoveETag(ContactFilename);
 509
 510                                 iter->second = 4;
 511                                 CardDAVIter->second = NULL;
 512
 513                         } else if (TypeIter->second == 3) {
 514
 515                                 frmMain *frmMainPtrGet = static_cast<frmMain*>(frmMainPtr);
 516
 517                                 wxString AccountNameFriendly;
 518                                 wxString PrefFilename = GetUserPrefDir();
 519
 520                                 XABPreferences PrefData(PrefFilename);
 521                                 int AccountID = 0;
 522
 523                                 for (int i = 0; i < PrefData.accounts.GetCount(); i++){
 524
 525                                         wxString AccountDirCheck = PrefData.accounts.GetAccountDirectory(i);
 526
 527                                         AccountDirCheck.Trim();
 528                                         AccountDirCheck.Append(wxT(".carddav"));
 529
 530                                         if (AccountDirCheck == StringAccountIter->second){
 531
 532                                                 AccountNameFriendly = PrefData.accounts.GetAccountName(i);
 533                                                 AccountID = i;
 534
 535                                         }
 536
 537                                 }
 538
 539                                 bool KeepUpdating = TRUE;
 540
 541                                 while (KeepUpdating == TRUE){
 542
 543                                         StringTaskDetailIter = ActivityListTaskDetail.find(iter->first);
 544
 545                                         AccountDir = StringAccountIter->second;
 546
 547                                         ETagDB *ETagDBPtr = ETagTmrPtr->GetPointer(AccountDir);
 548
 549                                         wxArrayString vCardAdd;
 550                                         wxArrayString vCardDelete;
 551                                         wxArrayString vCardList;
 552                                         wxArrayString vCardUpdateLocal;
 553                                         wxArrayString vCardUpdateRemote;
 554                                         wxArrayString vCardUpdateLog;
 555                                         std::map<wxString,wxString> vCardETag;
 556                                         ContactListData ServerContactList;
 557
 558                                         std::map<wxString,vCardDownloadDataFileClass> vCardDownloadData;
 559                                         //wxArrayString vCardDownload;
 560                                         //std::map<wxString,wxString> vCardDownloadData;
 561
 562                                         // Get the list of vCard files locally.
 563
 564                                         wxString AccountDirFinal;
 565                                         wxString AccountSyncTokenFilename;
 566                                         wxString SyncTokenLoad;
 567
 568 #if defined(__HAIKU__)
 569
 570                                             //preffilename = wxT("noo");
 571
 572 #elif defined(__WIN32__)
 573
 574                                         AccountDirFinal = GetAccountDir(AccountDir, FALSE);
 575                                         AccountSyncTokenFilename = AccountDirFinal;
 576                                         AccountSyncTokenFilename.Append(wxT("synctoken"));
 577
 578 #else
 579
 580                                         AccountDirFinal = GetAccountDir(AccountDir, FALSE);
 581                                         AccountSyncTokenFilename = AccountDirFinal;
 582                                         AccountSyncTokenFilename.Append(wxT("synctoken"));
 583
 584 #endif
 585
 586                                         // Suppress Error Messages.
 587
 588                                         wxLogNull PleaseDoNotDisturb;
 589
 590                                         wxFFile SyncLoad;
 591                                         SyncLoad.Open(AccountSyncTokenFilename, wxT("r"));
 592
 593                                         if (SyncLoad.IsOpened()){
 594
 595                                                 SyncLoad.ReadAll(&SyncTokenLoad, wxMBConvUTF8());
 596                                                 SyncLoad.Close();
 597
 598                                         }
 599
 600                                         // Get a list of vCard files from the server.
 601
 602                                         // Get the list of vCard files from the ETagDB.
 603
 604                                         std::map<wxString,ETagData> ETagDBData = ETagDBPtr->GetETagData();
 605
 606                                         bool ExitLoop = FALSE;
 607
 608                                         std::map<wxString,FileSyncData> *SCListData = NULL;
 609
 610                                         while (ExitLoop == FALSE){
 611
 612                                                 ServerContactList = CardDAVIter->second->GetContactList(SyncTokenLoad.ToUTF8());
 613                                                 SSLCertCollection certcol = CardDAVIter->second->GetCertificateData();
 614
 615                                                 // Create a pointer for the std::map<wxString,FileSyncData>.
 616
 617                                                 SCListData = &ServerContactList.ListData;
 618
 619                                                 // Check if any errors have occured whilst getting the data.
 620
 621                                                 int ErrorCode = CardDAVIter->second->GetResultCode();
 622
 623                                                 if (ErrorCode != 0){
 624
 625                                                         if (ErrorCode == 60 || ErrorCode == 51){
 626
 627                                                                 // Invalid SSL certificate so bring up a dialog to the user
 628                                                                 // explaining what has happened and the options available.
 629
 630                                                                 // Stop all the timers.
 631
 632                                                                 frmMainPtrGet->PauseAllTimers();
 633
 634                                                                 // Setup the data to be sent in the wxPostEvent command.
 635
 636                                                                 SSLInvalidCertNotifObj SSLICNProcData;
 637
 638                                                                 bool *PauseMode = new bool;
 639                                                                 int SSLResult;
 640                                                                 QRNotif qrn;
 641
 642                                                                 *PauseMode = TRUE;
 643                                                                 qrn.QResponse = &SSLResult;
 644                                                                 qrn.PausePtr = PauseMode;
 645
 646                                                                 SSLICNProcData.CertCollection = certcol;
 647                                                                 SSLICNProcData.QRNotifData = &qrn;
 648                                                                 SSLICNProcData.AccountName = AccountNameFriendly;
 649
 650                                                                 wxCommandEvent event(INVALIDSSLCERT);
 651                                                                 event.SetClientData(&SSLICNProcData);
 652                                                                 wxPostEvent(frmMainPtrGet, event);
 653
 654                                                                 /*timespec n1, n2;
 655
 656                                                                 // Fall asleep until we get an response.
 657
 658                                                                 n1.tv_sec = 0;
 659                                                                 n1.tv_nsec = 250000000L;*/
 660
 661                                                                 while (*PauseMode == TRUE){
 662                                                                         //nanosleep(&n1, &n2);
 663                                                                         SleepFor(250000000);
 664                                                                 }
 665
 666                                                                 // Process the response from the user.
 667
 668                                                                 if (SSLResult == 1){
 669
 670                                                                         // Accept the certificate. Write the certificate into the account
 671                                                                         // directory (as server.crt) - will overwrite old certificate.
 672
 673                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, CardDAVIter->second->GetCertificateData());
 674                                                                         WriteServerCertificate(AccountDir, CardDAVIter->second->GetCertificateData());
 675
 676                                                                 } else if (SSLResult == 2){
 677
 678                                                                         // Reject the certificate, abort the task and mark as failed.
 679
 680                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 1, CardDAVIter->second->GetCertificateData());
 681                                                                         iter->second = 2;
 682                                                                         break;
 683
 684                                                                 }
 685
 686                                                                 // Resume all the timers.
 687
 688                                                                 frmMainPtrGet->ResumeAllTimers();
 689
 690                                                         } else {
 691
 692                                                                 iter->second = 4;
 693                                                                 break;
 694
 695                                                         }
 696
 697                                                 } else {
 698
 699                                                         ExitLoop = TRUE;
 700
 701                                                 }
 702
 703                                         }
 704
 705                                         if (iter->second == 2 || iter->second == 3 || iter->second == 4){
 706                                                 break;
 707                                         }
 708
 709                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, CardDAVIter->second->GetCertificateData());
 710
 711                                         // Look in directory and see which vCards to add and delete
 712
 713                                         // In short:
 714                                         // vCard exists but not in ETagDB - Add (and upload).
 715                                         // vCard missing but in ETagDB - Delete (from server).
 716
 717                                         // Start by looking for vCards that are not in the ETagDB.
 718
 719                                         wxDir AccDir(AccountDirFinal);
 720                                         wxString AccDirFilename;
 721
 722                                         bool ContinueProcess = AccDir.GetFirst(&AccDirFilename, wxEmptyString, wxDIR_DEFAULT);
 723
 724                                         // Process the server data.
 725
 726                                         if (SCListData != NULL){
 727
 728                                                 for (std::map<wxString, FileSyncData>::iterator fsiter = SCListData->begin();
 729                                                         fsiter != SCListData->end(); fsiter++){
 730
 731                                                         // Check the mode of the file before adding.
 732
 733                                                         // Get the HTTP status of the file from the list.
 734
 735                                                         FileSyncData fsd = fsiter->second;
 736
 737                                                         if (fsd.DataFlag == 1){
 738
 739                                                                 // Added or modified contact.
 740
 741                                                                 //vCardAdd.Add(fsiter->first, 1);
 742
 743                                                                 vCardDownloadDataFileClass vCardNewData;
 744                                                                 vCardNewData.DataType = 0;
 745                                                                 vCardDownloadData.insert(std::make_pair(fsiter->first, vCardNewData));
 746
 747                                                                 //} else if (fsd.DataFlag == 1){
 748
 749                                                                 // Contact has been modified on the server.
 750
 751                                                                 //      vCardUpdateLocal.Add(fsiter->first, 1);
 752
 753                                                         }
 754                                                         else if (fsd.DataFlag == 2){
 755
 756                                                                 // Contact has been deleted.
 757
 758                                                                 vCardDelete.Add(fsiter->first, 1);
 759
 760                                                         }
 761
 762                                                 }
 763
 764                                         }
 765
 766                                         // Look for vCards that are missing but in the ETagDB.
 767
 768                                         for (std::map<wxString,ETagData>::iterator etagiter = ETagDBData.begin();
 769                                                 etagiter != ETagDBData.end(); etagiter++){
 770
 771                                                 // Check if the vCard exists.
 772
 773                                                 if (!wxFileExists(AccountDirFinal + etagiter->first)){
 774
 775                                                         // vCard doesn't exist so mark for deleting.
 776
 777                                                         vCardDelete.Add(etagiter->first, 1);
 778
 779                                                 }
 780
 781                                         }
 782
 783                                         // Compare Server with the ETag DB. Work out which
 784                                         // needs to updated remotely and which needs to be
 785                                         // updated locally.
 786
 787                                         for (std::map<wxString,FileSyncData>::iterator srviter = SCListData->begin();
 788                                                 srviter != SCListData->end(); srviter++){
 789
 790                                                 if (ETagDBData.find(srviter->first) == ETagDBData.end()){
 791                                                         continue;
 792                                                 }
 793
 794                                                 std::map<wxString,ETagData>::iterator lociter = ETagDBData.find(srviter->first);
 795
 796                                                 ETagData etd = lociter->second;
 797                                                 FileSyncData fsd = srviter->second;
 798
 799                                                 wxString ETagSrv = fsd.ETagData;
 800
 801                                                 // Compare local ETag with original local ETag.
 802                                                 // If different, update to server is required.
 803
 804                                                 if (etd.ETagValue != etd.ETagOrigValue){
 805
 806                                                         // Check if local original ETag is different from server ETag.
 807                                                         // If it is then throw up a conflict resolution dialog.
 808
 809                                                         if (etd.ETagOrigValue != ETagSrv){
 810
 811                                                                 vCard34Conv vCard34Obj;
 812
 813                                                                 wxString ServerContactData;
 814                                                                 wxString FullFilename;
 815                                                                 vCard ClientData;
 816                                                                 vCard ConvertedV4Data;
 817
 818                                                                 // Conflict. Bring up conflict resolution dialog.
 819
 820                                                                 // Get the server contact data for comparison.
 821
 822                                                                 CardDAVIter->second->SetServerFilename(srviter->first);
 823                                                                 CardDAVIter->second->GetServerContactData();
 824                                                                 ServerContactData = CardDAVIter->second->GetPageData();
 825
 826                                                                 FullFilename = CreateFilenamePath(AccountDirFinal, srviter->first);
 827
 828                                                                 // Convert it to v4.
 829
 830                                                                 vCard34Obj.ConvertToV4(&ServerContactData, &ConvertedV4Data);
 831
 832                                                                 vCardConflictObj vCardProcData;
 833
 834                                                                 vCardProcData.vCardLocalData = &ClientData;
 835                                                                 vCardProcData.vCardServerData = &ConvertedV4Data;
 836
 837                                                                 // Load the client data from the filename given.
 838
 839                                                                 ClientData.LoadFile(FullFilename);
 840
 841                                                                 // Show dialog.
 842
 843                                                                 bool *PauseMode = new bool;
 844                                                                 int ConflictResult;
 845                                                                 QRNotif qrn;
 846                                                                 frmMain *frmMainPtrGet = static_cast<frmMain*>(frmMainPtr);
 847
 848                                                                 *PauseMode = TRUE;
 849                                                                 qrn.QResponse = &ConflictResult;
 850                                                                 qrn.PausePtr = PauseMode;
 851
 852                                                                 vCardProcData.QRNotifData = &qrn;
 853
 854                                                                 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED);
 855                                                                 event.SetClientData(&vCardProcData);
 856                                                                 wxPostEvent(frmMainPtrGet, event);
 857
 858                                                                 /*timespec n1, n2;
 859
 860                                                                 n1.tv_sec = 0;
 861                                                                 n1.tv_nsec = 250000000L;*/
 862
 863                                                                 while (*PauseMode == TRUE){
 864                                                                         //nanosleep(&n1, &n2);
 865                                                                         SleepFor(250000000);
 866                                                                 }
 867
 868                                                                 delete PauseMode;
 869                                                                 PauseMode = NULL;
 870
 871                                                                 // If replacing local version, store copy for now.
 872                                                                 // Otherwise upload to server.
 873
 874                                                                 if (ConflictResult == 0){
 875
 876                                                                         // Decide Later.
 877
 878                                                                         continue;
 879
 880                                                                 } else if (ConflictResult == 1){
 881
 882                                                                         // Decided to use client version.
 883
 884                                                                         vCardUpdateLocal.Remove(srviter->first);
 885                                                                         vCardUpdateRemote.Add(srviter->first, 1);
 886
 887                                                                 } else if (ConflictResult == 2){
 888
 889                                                                         // Decided to use server version.
 890                                                                         // Store the converted downloaded copy for
 891                                                                         // processing later.
 892
 893                                                                         //vCardUpdateLocal.Add(srviter->first, 1);
 894
 895                                                                         vCardDownloadDataFileClass vCardNewData;
 896                                                                         vCardNewData.DataType = 1;
 897                                                                         vCardNewData.FileData = ConvertedV4Data.WriteString();
 898
 899                                                                         ConvertedV4Data.WriteFile(FullFilename);
 900
 901                                                                         vCardDownloadData.insert(std::make_pair(srviter->first, vCardNewData));
 902
 903
 904
 905                                                                 }
 906
 907                                                         } else {
 908
 909                                                                 // Send vCard to the server.
 910
 911                                                                 vCardUpdateRemote.Add(srviter->first, 1);
 912
 913                                                         }
 914
 915                                                 } else {
 916
 917                                                         // Check if local ETag is different from server ETag.
 918                                                         // If different, obtain the vCard from the server.
 919
 920                                                         if (etd.ETagOrigValue != ETagSrv){
 921
 922                                                                 vCardUpdateLocal.Add(srviter->first, 1);
 923
 924                                                         }
 925
 926                                                 }
 927
 928                                         }
 929
 930                                         // Process the vCards that need to be downloaded and added/overwritten.
 931
 932                                         wxString vCardFilenameFinal;
 933                                         wxString vCardOutputData;
 934                                         wxString vCardInputData;
 935                                         wxString ETagFileData;
 936                                         wxFFile vCardFile;
 937
 938                                         for (std::map<wxString,vCardDownloadDataFileClass>::iterator additer = vCardDownloadData.begin();
 939                                                 additer != vCardDownloadData.end(); additer++){
 940
 941                                                 vCardFilenameFinal.Clear();
 942                                                 vCardInputData.Clear();
 943                                                 vCardOutputData.Clear();
 944                                                 ETagFileData.Clear();
 945
 946                                                 vCardFilenameFinal = CreateFilenamePath(AccountDirFinal, additer->first);
 947
 948                                                 ETagDB *ETagDBPtr = ETagTmrPtr->GetPointer(AccountDir);
 949
 950                                                 if (additer->second.DataType == 0){
 951
 952                                                         vCard ConvertedV4Data;
 953
 954                                                         // Grab the file from the server and write the contact out.
 955
 956                                                         vCard34Conv vCard34Obj;
 957
 958                                                         CardDAVIter->second->SetServerFilename(additer->first);
 959                                                         CardDAVIter->second->GetServerContactData();
 960                                                         vCardInputData = CardDAVIter->second->GetPageData();
 961
 962                                                         vCard34Obj.ConvertToV4(&vCardInputData, &ConvertedV4Data);
 963
 964                                                         ConvertedV4Data.WriteFile(vCardFilenameFinal);
 965
 966                                                         // Update the ETagDB.
 967
 968                                                         //vCardFile.Open(vCardFilenameFinal, wxT("w"));
 969
 970                                                         //if (vCardFile.IsOpened()){
 971
 972                                                         //      vCardFile.Write(vCardOutputData, wxConvAuto());
 973                                                         //      vCardFile.Close();
 974
 975                                                         //}
 976
 977                                                         // Get the server ETag.
 978
 979                                                         wxString ServerETag;
 980                                                         CardDAVIter->second->GetServerETagValueThread();
 981                                                         ServerETag = CardDAVIter->second->ETagValueResult();
 982
 983                                                         // Add to the ETag Database.
 984
 985                                                         ETagDBPtr->AddETag(additer->first, ServerETag, ServerETag);
 986
 987                                                 } else if (additer->second.DataType == 1){
 988
 989                                                         // Write out the contact to the account directory.
 990
 991                                                         vCardFilenameFinal = CreateFilenamePath(AccountDirFinal, additer->first);
 992                                                         vCardOutputData = additer->second.FileData;
 993
 994                                                         vCardFile.Open(vCardFilenameFinal, wxT("w"));
 995
 996                                                         if (vCardFile.IsOpened()){
 997
 998                                                                 vCardFile.Write(vCardOutputData, wxConvAuto());
 999                                                                 vCardFile.Close();
1000
1001                                                         }
1002
1003                                                         // Update the ETagDB.
1004
1005                                                         wxString ServerETag;
1006                                                         CardDAVIter->second->GetServerETagValueThread();
1007                                                         ServerETag = CardDAVIter->second->ETagValueResult();
1008
1009                                                         // Add to the ETag Database.
1010
1011                                                         ETagDBPtr->AddETag(additer->first, ServerETag, ServerETag);
1012
1013                                                 }
1014                                         }
1015
1016                                         // Look for vCard files which aren't in the ETagDB.
1017
1018                                         while(ContinueProcess){
1019
1020                                                 // Check and make sure that the filename ends in .vcf/.vcard
1021                                                 // Skip any file that beings with a dot.
1022
1023                                                 if (AccDirFilename.Left(1) == wxT(".")){
1024
1025                                                         ContinueProcess = AccDir.GetNext(&AccDirFilename);
1026                                                         continue;
1027
1028                                                 }
1029
1030                                                 if (AccDirFilename.Right(4) != wxT(".vcf") &&
1031                                                 AccDirFilename.Right(6) != wxT(".vcard")){
1032
1033                                                         ContinueProcess = AccDir.GetNext(&AccDirFilename);
1034                                                         continue;
1035
1036                                                 }
1037
1038                                                 // Look in the ETagDB for the file.
1039
1040                                                 bool ETagExists = ETagDBPtr->CheckETagExists(AccDirFilename);
1041
1042                                                 if (ETagExists == FALSE){
1043
1044                                                         // Add the vCard to the list to be added.
1045
1046                                                         vCardAdd.Add(AccDirFilename, 1);
1047
1048                                                 }
1049
1050                                                 ContinueProcess = AccDir.GetNext(&AccDirFilename);
1051
1052                                         }
1053
1054                                         // Process the vCards to add/update to the server.
1055
1056                                         for (int vi = 0; vi < vCardAdd.GetCount(); vi++){
1057
1058                                                 ETagDB *ETagDBPtr = ETagTmrPtr->GetPointer(AccountDir);
1059                                                 ETag = ETagDBPtr->GetETag(vCardAdd[vi]);
1060                                                 ETagOriginal = ETagDBPtr->GetETagOriginal(vCardAdd[vi]);
1061
1062                                                 ContactFilename = vCardAdd[vi];
1063                                                 FullFilename = CreateFilenamePath(AccountDirFinal, vCardAdd[vi]);
1064
1065                                                 ContactFilename.Trim();
1066
1067                                                 if (ETag == ETagOriginal && ETagDBPtr->ETagExists(vCardAdd[vi])){
1068
1069                                                         // Compare the ETag with the Server ETag.
1070
1071                                                         CardDAVIter->second->SetServerFilename(vCardAdd[vi]);
1072                                                         CardDAVIter->second->GetServerETagValueThread();
1073                                                         ETagServer = CardDAVIter->second->ETagValueResult();
1074
1075                                                         if (ETagOriginal != ETagServer){
1076
1077                                                                 // Server ETag is different from original ETag.
1078                                                                 // This is a conflict which the user will now
1079                                                                 // need to resolve.
1080
1081                                                                 frmMain *frmMainPtrGet = static_cast<frmMain*>(frmMainPtr);
1082
1083                                                                 vCard34Conv vCard34Obj;
1084
1085                                                                 wxString ServerContactData;
1086                                                                 vCard ClientData;
1087                                                                 vCard ConvertedV4Data;
1088
1089                                                                 // Load the client data from the filename given.
1090
1091                                                                 CardDAVIter->second->GetServerContactData();
1092                                                                 ServerContactData = CardDAVIter->second->GetPageData();
1093
1094                                                                 // Process v3 version into v4 version.
1095
1096                                                                 vCard34Obj.ConvertToV4(&ServerContactData, &ConvertedV4Data);
1097
1098                                                                 vCardConflictObj vCardProcData;
1099
1100                                                                 vCardProcData.vCardLocalData = &ClientData;
1101                                                                 vCardProcData.vCardServerData = &ConvertedV4Data;
1102                                                                 ClientData.LoadFile(FullFilename);
1103
1104                                                                 //ContactConflictEvent event(ContactConflictCmdEnv);
1105                                                                 //event.SetData(ContactFilename, Moo1, Moo2);
1106
1107                                                                 //wxPostEvent(frmMainPtrGet, event);
1108
1109                                                                 // Setup Conflict Resolution Dialog.
1110
1111                                                                 // Fetch Data from Server and convert.
1112
1113                                                                 bool *PauseMode = new bool;
1114                                                                 int ConflictResult;
1115                                                                 QRNotif qrn;
1116
1117                                                                 *PauseMode = TRUE;
1118                                                                 qrn.QResponse = &ConflictResult;
1119                                                                 qrn.PausePtr = PauseMode;
1120
1121                                                                 vCardProcData.QRNotifData = &qrn;
1122
1123                                                                 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED);
1124                                                                 event.SetClientData(&vCardProcData);
1125                                                                 wxPostEvent(frmMainPtrGet, event);
1126
1127                                                                 /*timespec n1, n2;
1128
1129                                                                 n1.tv_sec = 0;
1130                                                                 n1.tv_nsec = 250000000L;*/
1131
1132                                                                 while (*PauseMode == TRUE){
1133                                                                         //nanosleep(&n1, &n2);
1134                                                                         SleepFor(250000000);
1135                                                                 }
1136
1137                                                                 delete PauseMode;
1138                                                                 PauseMode = NULL;
1139
1140                                                                 //intResult = frmMainPtrGet->ShowConflictDialog(&Moo1, &Moo2);
1141
1142                                                                 if (ConflictResult == 0){
1143
1144                                                                         // Decide Later.
1145
1146                                                                         iter->second = 4;
1147                                                                         continue;
1148
1149                                                                 } else if (ConflictResult == 1){
1150
1151                                                                         // Decided to use client version.
1152
1153                                                                         CardDAVIter->second->ProcessData();
1154
1155                                                                         iter->second = 4;
1156
1157                                                                 } else if (ConflictResult == 2){
1158
1159                                                                         // Decided to use server version.
1160
1161                                                                         // Download server version.
1162
1163                                                                         ConvertedV4Data.WriteFile(CreateFilenamePath(AccountDirFinal, vCardAdd[vi]));
1164
1165                                                                         iter->second = 4;
1166
1167                                                                 }
1168
1169                                                         } else {
1170
1171                                                                 // Setup the filename for the contact being added.
1172
1173                                                                 wxString wxSFilename = CreateFilenamePath(AccountDirFinal, vCardAdd[vi]);
1174                                                                 wxString wxSCardData;
1175                                                                 wxString TaskData;
1176                                                                 //wxString TaskURL;
1177
1178                                                                 // Load the data from the file.
1179
1180                                                                 wxFFile wxFCard;
1181                                                                 wxFCard.Open(wxSFilename, wxT("r"));
1182
1183                                                                 if (wxFCard.IsOpened()){
1184
1185                                                                         wxFCard.ReadAll(&wxSCardData, wxConvAuto());
1186                                                                         wxFCard.Close();
1187
1188                                                                 }
1189
1190                                                                 // Convert the data to v3.
1191
1192                                                                 vCard34Conv vCard34Obj;
1193
1194                                                                 vCard34Obj.ConvertToV3(wxSFilename, &TaskData);
1195
1196                                                                 // Setup the URL address.
1197
1198                                                                 //TaskURL = StringTaskDetailIter->second + wxT("/") + vCardAdd[vi];
1199
1200                                                                 // Upload the data to the server.
1201
1202                                                                 CardDAVIter->second->SetUploadMode(TRUE);
1203                                                                 CardDAVIter->second->SetupData(wxT("PUT"), vCardAdd[vi], TaskData);
1204                                                                 CardDAVIter->second->ProcessData();
1205
1206                                                                 // Get the Server ETag and put it in the ETag database.
1207
1208                                                                 CardDAVIter->second->SetServerFilename(vCardAdd[vi]);
1209                                                                 CardDAVIter->second->GetServerETagValueThread();
1210                                                                 ETagServer = CardDAVIter->second->ETagValueResult();
1211
1212                                                                 ETagDBPtr->AddETag(vCardAdd[vi], ETagServer, ETagServer);
1213
1214                                                         }
1215
1216                                                 } else {
1217
1218                                                         if (ETagOriginal != ETagServer){
1219
1220                                                                 // Server ETag is different from original ETag.
1221                                                                 // This is a conflict which the user will now
1222                                                                 // need to resolve.
1223
1224                                                                 frmMain *frmMainPtrGet = (frmMain *)frmMainPtr;
1225
1226                                                                 //ContactConflictEvent event(ContactConflictCmdEnv);
1227                                                                 //event.SetData(ContactFilename, Moo1, Moo2);
1228
1229                                                                 vCard34Conv vCard34Obj;
1230
1231                                                                 wxString ServerContactData;
1232                                                                 vCard ClientData;
1233                                                                 vCard ConvertedV4Data;
1234
1235                                                                 // Load the client data from the filename given.
1236
1237                                                                 CardDAVIter->second->GetServerContactData();
1238                                                                 ServerContactData = CardDAVIter->second->GetPageData();
1239                                                                 ClientData.LoadFile(FullFilename);
1240
1241                                                                 // Process v3 version into v4 version.
1242
1243                                                                 vCard34Obj.ConvertToV4(&ServerContactData, &ConvertedV4Data);
1244
1245                                                                 vCardConflictObj vCardProcData;
1246
1247                                                                 vCardProcData.vCardLocalData = &ClientData;
1248                                                                 vCardProcData.vCardServerData = &ConvertedV4Data;
1249
1250                                                                 bool *PauseMode = new bool;
1251                                                                 int ConflictResult;
1252                                                                 QRNotif qrn;
1253
1254                                                                 *PauseMode = TRUE;
1255                                                                 qrn.QResponse = &ConflictResult;
1256                                                                 qrn.PausePtr = PauseMode;
1257
1258                                                                 vCardProcData.QRNotifData = &qrn;
1259
1260                                                                 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED);
1261                                                                 event.SetClientData(&vCardProcData);
1262                                                                 wxPostEvent(frmMainPtrGet, event);
1263
1264                                                                 /*timespec n1, n2;
1265
1266                                                                 n1.tv_sec = 0;
1267                                                                 n1.tv_nsec = 250000000L;*/
1268
1269                                                                 while (*PauseMode == TRUE){
1270                                                                         //nanosleep(&n1, &n2);
1271                                                                         SleepFor(250000000);
1272                                                                 }
1273
1274                                                                 delete PauseMode;
1275                                                                 PauseMode = NULL;
1276
1277                                                                 //intResult = frmMainPtrGet->ShowConflictDialog(&Moo1, &Moo2);
1278
1279                                                                 if (ConflictResult == 0){
1280
1281                                                                         // Decide Later.
1282
1283                                                                         iter->second = 4;
1284                                                                         continue;
1285
1286                                                                 } else if (ConflictResult == 1){
1287
1288                                                                         // Decided to use client version.
1289
1290                                                                         CardDAVIter->second->ProcessData();
1291                                                                         //ETagServer = CardDAVIter->second.GetServerETagValueThread();
1292                                                                         //ETagDBPtr->UpdateETag(ContactFilename, ETagServer, ETagServer);
1293
1294                                                                         iter->second = 4;
1295
1296                                                                 } else if (ConflictResult == 2){
1297
1298                                                                         // Decided to use server version.
1299
1300                                                                         // Write server version to file.
1301
1302                                                                         ConvertedV4Data.WriteFile(CreateFilenamePath(AccountDirFinal, vCardAdd[vi]));
1303
1304                                                                         iter->second = 4;
1305
1306                                                                 }
1307
1308                                                         } else {
1309
1310                                                                 // Setup the filename for the contact being added.
1311
1312                                                                 wxString wxSFilename = CreateFilenamePath(AccountDirFinal, vCardAdd[vi]);
1313                                                                 wxString wxSCardData;
1314                                                                 wxString TaskData;
1315                                                                 //wxString TaskURL;
1316
1317                                                                 // Load the data from the file.
1318
1319                                                                 wxFFile wxFCard;
1320                                                                 wxFCard.Open(wxSFilename, wxT("r"));
1321
1322                                                                 if (wxFCard.IsOpened()){
1323
1324                                                                         wxFCard.ReadAll(&wxSCardData, wxConvAuto());
1325                                                                         wxFCard.Close();
1326
1327                                                                 }
1328
1329                                                                 // Convert the data to v3.
1330
1331                                                                 vCard34Conv vCard34Obj;
1332
1333                                                                 vCard34Obj.ConvertToV3(wxSFilename, &TaskData);
1334
1335                                                                 // Setup the URL address.
1336
1337                                                                 //TaskURL = StringTaskDetailIter->second + wxT("/") + vCardAdd[vi];
1338
1339                                                                 // Upload the data to the server.
1340
1341                                                                 CardDAVIter->second->SetUploadMode(TRUE);
1342                                                                 CardDAVIter->second->SetupData(wxT("PUT"), vCardAdd[vi], TaskData);
1343                                                                 CardDAVIter->second->ProcessData();
1344
1345                                                                 // Get the Server ETag and put it in the ETag database.
1346
1347                                                                 CardDAVIter->second->SetServerFilename(vCardAdd[vi]);
1348                                                                 CardDAVIter->second->GetServerETagValueThread();
1349                                                                 ETagServer = CardDAVIter->second->ETagValueResult();
1350
1351
1352                                                                 ETagDBPtr->AddETag(vCardAdd[vi], ETagServer, ETagServer);
1353
1354                                                         }
1355
1356                                                 }
1357
1358                                         }
1359
1360                                         // Process the vCards to delete locally.
1361
1362                                         for (int vi = 0; vi < vCardDelete.GetCount(); vi++){
1363
1364                                                 if (!wxRemoveFile(CreateFilenamePath(AccountDirFinal, vCardDelete[vi]))){
1365
1366                                                 } else {
1367
1368                                                         ETagDBPtr->RemoveETag(vCardDelete[vi]);
1369
1370                                                 }
1371
1372                                         }
1373
1374                                         // Process the vCards to delete from the server.
1375
1376                                         std::map<wxString,wxString> *ETagFilenameMap = ETagDBPtr->GetFilenamePointer();
1377
1378
1379                                         for (std::map<wxString,wxString>::iterator deliter = ETagFilenameMap->begin();
1380                                                 deliter != ETagFilenameMap->end(); deliter++){
1381
1382                                                 // Look through the ETagDB and find contacts which are marked as DELETED.
1383
1384                                                 if (deliter->second == wxT("DELETED")){
1385
1386                                                         CardDAVIter->second->SetUploadMode(FALSE);
1387                                                         CardDAVIter->second->SetupData(wxT("DELETE"), deliter->first, wxT(""));
1388                                                         CardDAVIter->second->ProcessData();
1389
1390                                                         // Delete the ETag as the file has now been deleted.
1391
1392                                                         ETagDBPtr->RemoveETag(deliter->first);
1393
1394                                                 }
1395
1396                                         }
1397
1398                                         // Write out the update server sync token.
1399
1400                                         wxString ServerSyncToken = ServerContactList.SyncToken;
1401
1402                                         ServerSyncToken.Trim();
1403
1404                                         if (!ServerSyncToken.IsEmpty()){
1405
1406                                                 wxFFile SyncWrite;
1407                                                 SyncWrite.Open(AccountSyncTokenFilename, wxT("w"));
1408
1409                                                 if (SyncWrite.IsOpened()){
1410
1411                                                         SyncWrite.Write(ServerSyncToken, wxConvAuto());
1412                                                         SyncWrite.Close();
1413
1414                                                 }
1415
1416                                         }
1417
1418                                         // Check for another sync token. If there is another
1419                                         // sync token then repeat this. If token matches then stop processing.
1420
1421                                         if (SyncTokenLoad == ServerSyncToken){
1422
1423                                                 KeepUpdating = FALSE;
1424
1425                                         }
1426
1427                                 }
1428
1429                                 // Mark as completed.
1430
1431                                 wxString AccountNameFinal;
1432                                 AccountNameFinal = PrefData.accounts.GetAccountDirectory(AccountID);
1433                                 AccountNameFinal.Append(wxT(".carddav"));
1434
1435                                 wxCommandEvent reloadevent(RELOADCONTACTLIST);
1436                                 reloadevent.SetString(AccountNameFinal);
1437                                 wxPostEvent(this->GetParent(), reloadevent);
1438
1439                                 iter->second = 4;
1440                                 continue;
1441
1442                         } else {
1443
1444                                 // Update the data to the server.
1445
1446                                 CardDAVIter->second->ProcessData();
1447                                 iter->second = 4;
1448                                 continue;
1449
1450                         }
1451
1452                         /*timespec n1, n2;
1453
1454                         n1.tv_sec = 0;
1455                         n1.tv_nsec = 250000000L;*/
1456
1457                         while (iter->second == 1){
1458
1459                                 SleepFor(250000000);
1460                                 //nanosleep(&n1, &n2);
1461
1462                         }
1463
1464                         if ((iter->second == 4 && TypeIter->second == 0) ||
1465                         (iter->second == 8 && TypeIter->second == 0)){
1466
1467                                 AccountDir = StringAccountIter->second;
1468                                 ETagDB *ETagDBPtr = ETagTmrPtr->GetPointer(AccountDir);
1469
1470                                 CardDAVIter->second->GetServerETagValueThread();
1471                                 ETagServer = CardDAVIter->second->ETagValueResult();
1472                                 ETagDBPtr->UpdateETag(ContactFilename, ETagServer, ETagServer);
1473
1474                         }
1475
1476                         if ((iter->second == 4 && TypeIter->second == 1) ||
1477                         (iter->second == 8 && TypeIter->second == 1)){
1478
1479                                 AccountDir = StringAccountIter->second;
1480                                 ETagDB *ETagDBPtr = ETagTmrPtr->GetPointer(AccountDir);
1481
1482                                 CardDAVIter->second->GetServerETagValueThread();
1483                                 ETagServer = CardDAVIter->second->ETagValueResult();
1484                                 ETagDBPtr->UpdateETag(ContactFilename, ETagServer, ETagServer);
1485
1486                         }
1487
1488                         break;
1489
1490                 }
1491
1492         }
1493
1494         if (TasksFoundProc == FALSE){
1495
1496                 TasksActive = FALSE;
1497                 ProcessTasksData = FALSE;
1498
1499         } else {
1500
1501                 wxCommandEvent eventp(ACTMGR_STARTTIMER);
1502                 wxPostEvent(this, eventp);
1503
1504                 //AnimationTimer.StartAnimation();
1505                 //ActListProcTimer.Start();
1506
1507         }
1508
1509         wxCommandEvent event(ACTMGR_STARTPROCESSTIMER);
1510         wxPostEvent(this, event);
1511
1512         //ActProcessTimer.Start();
1513
1514 }
1515
1516 void frmActivityMgr::ProcessTasks()
1517 {
1518
1519         std::thread ProcessThread(&frmActivityMgr::ProcessTasksThread, this);
1520         ProcessThread.detach();
1521
1522 }
1523
1524 void frmActivityMgr::SetupPointers(wxETagProcessTimer *ETagTmrPtrInc, void *frmMainPtrInc)
1525 {
1526
1527         ETagTmrPtr = ETagTmrPtrInc;
1528
1529         frmMainPtr = frmMainPtrInc;
1530
1531 }
1532
1533 void frmActivityMgr::ResumeProcessing(wxCommandEvent &event){
1534
1535         QRNotif *qrn = (QRNotif *)event.GetClientData();
1536
1537         int *QRes = qrn->QResponse;
1538
1539         *qrn->PausePtr = FALSE;
1540
1541         *QRes = event.GetInt();
1542
1543 }
1544
1545 void frmActivityMgr::ToggleConnectionStatus( wxCommandEvent &event ){
1546
1547         wxCommandEvent connevent(CONNSTAT_UPDATE);
1548
1549         if (SleepMode == FALSE){
1550
1551                 connevent.SetInt(1);
1552                 SleepMode = TRUE;
1553
1554         } else {
1555
1556                 connevent.SetInt(0);
1557                 SleepMode = FALSE;
1558
1559         }
1560
1561         wxPostEvent(GetParent(), connevent);
1562
1563 }
1564
1565 void frmActivityMgr::WriteServerCertificate(wxString AccountName, SSLCertCollection SSLCertInc){
1566
1567         wxString ServerCertFinal;
1568
1569         // Get the Cert section of the certificate and write it to the file.
1570
1571         ServerCertFinal = GetAccountDir(AccountName, TRUE);
1572
1573         wxFile CertFile;
1574
1575         std::map<int, SSLCertData>::iterator SSLCDIter = SSLCertInc.SSLCollection.find(0);
1576         std::multimap<wxString,wxString>::iterator SSLDataIter = SSLCDIter->second.CertData.find(wxT("Cert"));
1577
1578         CertFile.Open(ServerCertFinal, wxFile::write);
1579
1580         CertFile.Write(SSLDataIter->second, wxConvUTF8);
1581         CertFile.Close();
1582
1583 }
1584
1585 void frmActivityMgr::StartTimer(wxCommandEvent& event){
1586
1587         ActListProcTimer.Start(1000, FALSE);
1588
1589 }
1590
1591 void frmActivityMgr::StopTimer(wxCommandEvent& event){
1592
1593         ActListProcTimer.Stop();
1594
1595 }
1596
1597 void frmActivityMgr::StartProcessTimer(wxCommandEvent& event){
1598
1599         ActProcessTimer.Start(1000, FALSE);
1600
1601 }
1602
1603 void frmActivityMgr::StopProcessTimer(wxCommandEvent& event){
1604
1605         ActProcessTimer.Stop();
1606
1607 }
1608
1609 void frmActivityMgr::UpdateStatusLabel(wxCommandEvent& event){
1610
1611         ActivityMgrLabelUpdate *actmgrudata = (ActivityMgrLabelUpdate*)event.GetClientData();
1612
1613         if (actmgrudata != NULL){
1614
1615                 lstActivity->SetItem(actmgrudata->ItemIndex, 2, actmgrudata->ItemLabel);
1616
1617                 /*if (!actmgrudata->ItemDes.IsEmpty()){
1618                 lstActivity->SetItem(actmgrudata->ItemIndex, 0, actmgrudata->ItemDes);
1619                 }*/
1620
1621                 delete actmgrudata;
1622                 actmgrudata = NULL;
1623
1624         }
1625
1626 }
1627
1628 #endif