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                                                 while (*PauseMode == TRUE){
 433                                                         //nanosleep(&n1, &n2);
 434                                                         SleepFor(250000000);
 435                                                 }
 436
 437                                                 delete PauseMode;
 438                                                 PauseMode = NULL;
 439
 440                                                 //intResult = frmMainPtrGet->ShowConflictDialog(&Moo1, &Moo2);
 441
 442                                                 if (ConflictResult == 0){
 443
 444                                                         // Decide Later.
 445
 446                                                         iter->second = 4;
 447                                                         continue;
 448
 449                                                 } else if (ConflictResult == 1){
 450
 451                                                         // Decided to use client version.
 452
 453                                                         CardDAVIter->second->ProcessData();
 454                                                         //ETagServer = CardDAVIter->second.GetServerETagValueThread();
 455                                                         //ETagDBPtr->UpdateETag(ContactFilename, ETagServer, ETagServer);
 456
 457                                                         iter->second = 4;
 458
 459                                                 } else if (ConflictResult == 2){
 460
 461                                                         // Decided to use server version.
 462
 463                                                         // Write server version to file.
 464
 465                                                         ConvertedV4Data.WriteFile(FullFilename);
 466
 467                                                         iter->second = 4;
 468
 469                                                 }
 470
 471                                         } else {
 472
 473                                                 // Update the data to the server.
 474
 475                                                 CardDAVIter->second->ProcessData();
 476
 477                                         }
 478
 479                                 }*/
 480
 481                                 // Update the ETag DB.
 482
 483                                 CardDAVIter->second->GetServerETagValueThread();
 484                                 ETagServer = CardDAVIter->second->ETagValueResult();
 485                                 ETagDBPtr->UpdateETag(ContactFilename, ETagServer, ETagServer);
 486
 487                                 iter->second = 4;
 488                                 CardDAVIter->second = NULL;
 489
 490                         } else if (TypeIter->second == 2) {
 491
 492                                 // Delete the contact from the server and update the ETag DB.
 493
 494                                 AccountDir = StringAccountIter->second;
 495                                 ContactFilename = StringFilenameIter->second;
 496
 497                                 ETagDB *ETagDBPtr = ETagTmrPtr->GetPointer(AccountDir);
 498
 499                                 CardDAVIter->second->SetUploadMode(FALSE);
 500                                 CardDAVIter->second->SetupData(wxT("DELETE"), ContactFilename, wxT(""));
 501                                 //CardDAVIter->second.SetServerFilename();
 502                                 CardDAVIter->second->ProcessData();
 503                                 ETagDBPtr->RemoveETag(ContactFilename);
 504
 505                                 iter->second = 4;
 506                                 CardDAVIter->second = NULL;
 507
 508                         } else if (TypeIter->second == 3) {
 509
 510                                 frmMain *frmMainPtrGet = static_cast<frmMain*>(frmMainPtr);
 511
 512                                 wxString AccountNameFriendly;
 513                                 wxString PrefFilename = GetUserPrefDir();
 514
 515                                 XABPreferences PrefData(PrefFilename);
 516                                 int AccountID = 0;
 517
 518                                 for (int i = 0; i < PrefData.accounts.GetCount(); i++){
 519
 520                                         wxString AccountDirCheck = PrefData.accounts.GetAccountDirectory(i);
 521
 522                                         AccountDirCheck.Trim();
 523                                         AccountDirCheck.Append(wxT(".carddav"));
 524
 525                                         if (AccountDirCheck == StringAccountIter->second){
 526
 527                                                 AccountNameFriendly = PrefData.accounts.GetAccountName(i);
 528                                                 AccountID = i;
 529
 530                                         }
 531
 532                                 }
 533
 534                                 bool KeepUpdating = TRUE;
 535
 536                                 while (KeepUpdating == TRUE){
 537
 538                                         StringTaskDetailIter = ActivityListTaskDetail.find(iter->first);
 539
 540                                         AccountDir = StringAccountIter->second;
 541
 542                                         ETagDB *ETagDBPtr = ETagTmrPtr->GetPointer(AccountDir);
 543
 544                                         wxArrayString vCardAdd;
 545                                         wxArrayString vCardDelete;
 546                                         wxArrayString vCardList;
 547                                         wxArrayString vCardUpdateLocal;
 548                                         wxArrayString vCardUpdateRemote;
 549                                         wxArrayString vCardUpdateLog;
 550                                         std::map<wxString,wxString> vCardETag;
 551                                         ContactListData ServerContactList;
 552
 553                                         std::map<wxString,vCardDownloadDataFileClass> vCardDownloadData;
 554                                         //wxArrayString vCardDownload;
 555                                         //std::map<wxString,wxString> vCardDownloadData;
 556
 557                                         // Get the list of vCard files locally.
 558
 559                                         wxString AccountDirFinal;
 560                                         wxString AccountSyncTokenFilename;
 561                                         wxString SyncTokenLoad;
 562
 563 #if defined(__HAIKU__)
 564
 565                                             //preffilename = wxT("noo");
 566
 567 #elif defined(__WIN32__)
 568
 569                                         AccountDirFinal = GetAccountDir(AccountDir, FALSE);
 570                                         AccountSyncTokenFilename = AccountDirFinal;
 571                                         AccountSyncTokenFilename.Append(wxT("synctoken"));
 572
 573 #else
 574
 575                                         AccountDirFinal = GetAccountDir(AccountDir, FALSE);
 576                                         AccountSyncTokenFilename = AccountDirFinal;
 577                                         AccountSyncTokenFilename.Append(wxT("synctoken"));
 578
 579 #endif
 580
 581                                         // Suppress Error Messages.
 582
 583                                         wxLogNull PleaseDoNotDisturb;
 584
 585                                         wxFFile SyncLoad;
 586                                         SyncLoad.Open(AccountSyncTokenFilename, wxT("r"));
 587
 588                                         if (SyncLoad.IsOpened()){
 589
 590                                                 SyncLoad.ReadAll(&SyncTokenLoad, wxMBConvUTF8());
 591                                                 SyncLoad.Close();
 592
 593                                         }
 594
 595                                         // Get a list of vCard files from the server.
 596
 597                                         // Get the list of vCard files from the ETagDB.
 598
 599                                         std::map<wxString,ETagData> ETagDBData = ETagDBPtr->GetETagData();
 600
 601                                         bool ExitLoop = FALSE;
 602
 603                                         std::map<wxString,FileSyncData> *SCListData = NULL;
 604
 605                                         while (ExitLoop == FALSE){
 606
 607                                                 ServerContactList = CardDAVIter->second->GetContactList(SyncTokenLoad.ToUTF8());
 608                                                 SSLCertCollection certcol = CardDAVIter->second->GetCertificateData();
 609
 610                                                 // Create a pointer for the std::map<wxString,FileSyncData>.
 611
 612                                                 SCListData = &ServerContactList.ListData;
 613
 614                                                 // Check if any errors have occured whilst getting the data.
 615
 616                                                 int ErrorCode = CardDAVIter->second->GetResultCode();
 617
 618                                                 if (ErrorCode != 0){
 619
 620                                                         if (ErrorCode == 60 || ErrorCode == 51){
 621
 622                                                                 // Invalid SSL certificate so bring up a dialog to the user
 623                                                                 // explaining what has happened and the options available.
 624
 625                                                                 // Stop all the timers.
 626
 627                                                                 frmMainPtrGet->PauseAllTimers();
 628
 629                                                                 // Setup the data to be sent in the wxPostEvent command.
 630
 631                                                                 SSLInvalidCertNotifObj SSLICNProcData;
 632
 633                                                                 bool *PauseMode = new bool;
 634                                                                 int SSLResult;
 635                                                                 QRNotif qrn;
 636
 637                                                                 *PauseMode = TRUE;
 638                                                                 qrn.QResponse = &SSLResult;
 639                                                                 qrn.PausePtr = PauseMode;
 640
 641                                                                 SSLICNProcData.CertCollection = certcol;
 642                                                                 SSLICNProcData.QRNotifData = &qrn;
 643                                                                 SSLICNProcData.AccountName = AccountNameFriendly;
 644
 645                                                                 wxCommandEvent event(INVALIDSSLCERT);
 646                                                                 event.SetClientData(&SSLICNProcData);
 647                                                                 wxPostEvent(frmMainPtrGet, event);
 648
 649                                                                 /*timespec n1, n2;
 650
 651                                                                 // Fall asleep until we get an response.
 652
 653                                                                 n1.tv_sec = 0;
 654                                                                 n1.tv_nsec = 250000000L;*/
 655
 656                                                                 while (*PauseMode == TRUE){
 657                                                                         //nanosleep(&n1, &n2);
 658                                                                         SleepFor(250000000);
 659                                                                 }
 660
 661                                                                 // Process the response from the user.
 662
 663                                                                 if (SSLResult == 1){
 664
 665                                                                         // Accept the certificate. Write the certificate into the account
 666                                                                         // directory (as server.crt) - will overwrite old certificate.
 667
 668                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, CardDAVIter->second->GetCertificateData());
 669                                                                         WriteServerCertificate(AccountDir, CardDAVIter->second->GetCertificateData());
 670
 671                                                                 } else if (SSLResult == 2){
 672
 673                                                                         // Reject the certificate, abort the task and mark as failed.
 674
 675                                                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 1, CardDAVIter->second->GetCertificateData());
 676                                                                         iter->second = 2;
 677                                                                         break;
 678
 679                                                                 }
 680
 681                                                                 // Resume all the timers.
 682
 683                                                                 frmMainPtrGet->ResumeAllTimers();
 684
 685                                                         } else {
 686
 687                                                                 iter->second = 4;
 688                                                                 break;
 689
 690                                                         }
 691
 692                                                 } else {
 693
 694                                                         ExitLoop = TRUE;
 695
 696                                                 }
 697
 698                                         }
 699
 700                                         if (iter->second == 2 || iter->second == 3 || iter->second == 4){
 701                                                 break;
 702                                         }
 703
 704                                         frmMainPtrGet->UpdateSSLAccountStatus(AccountID, 0, CardDAVIter->second->GetCertificateData());
 705
 706                                         // Look in directory and see which vCards to add and delete
 707
 708                                         // In short:
 709                                         // vCard exists but not in ETagDB - Add (and upload).
 710                                         // vCard missing but in ETagDB - Delete (from server).
 711
 712                                         // Start by looking for vCards that are not in the ETagDB.
 713
 714                                         wxDir AccDir(AccountDirFinal);
 715                                         wxString AccDirFilename;
 716
 717                                         bool ContinueProcess = AccDir.GetFirst(&AccDirFilename, wxEmptyString, wxDIR_DEFAULT);
 718
 719                                         // Process the server data.
 720
 721                                         if (SCListData != NULL){
 722
 723                                                 for (std::map<wxString, FileSyncData>::iterator fsiter = SCListData->begin();
 724                                                         fsiter != SCListData->end(); fsiter++){
 725
 726                                                         // Check the mode of the file before adding.
 727
 728                                                         // Get the HTTP status of the file from the list.
 729
 730                                                         FileSyncData fsd = fsiter->second;
 731
 732                                                         if (fsd.DataFlag == 1){
 733
 734                                                                 // Added or modified contact.
 735
 736                                                                 //vCardAdd.Add(fsiter->first, 1);
 737
 738                                                                 vCardDownloadDataFileClass vCardNewData;
 739                                                                 vCardNewData.DataType = 0;
 740                                                                 vCardDownloadData.insert(std::make_pair(fsiter->first, vCardNewData));
 741
 742                                                                 //} else if (fsd.DataFlag == 1){
 743
 744                                                                 // Contact has been modified on the server.
 745
 746                                                                 //      vCardUpdateLocal.Add(fsiter->first, 1);
 747
 748                                                         }
 749                                                         else if (fsd.DataFlag == 2){
 750
 751                                                                 // Contact has been deleted.
 752
 753                                                                 vCardDelete.Add(fsiter->first, 1);
 754
 755                                                         }
 756
 757                                                 }
 758
 759                                         }
 760
 761                                         // Look for vCards that are missing but in the ETagDB.
 762
 763                                         for (std::map<wxString,ETagData>::iterator etagiter = ETagDBData.begin();
 764                                                 etagiter != ETagDBData.end(); etagiter++){
 765
 766                                                 // Check if the vCard exists.
 767
 768                                                 if (!wxFileExists(AccountDirFinal + etagiter->first)){
 769
 770                                                         // vCard doesn't exist so mark for deleting.
 771
 772                                                         vCardDelete.Add(etagiter->first, 1);
 773
 774                                                 }
 775
 776                                         }
 777
 778                                         // Compare Server with the ETag DB. Work out which
 779                                         // needs to updated remotely and which needs to be
 780                                         // updated locally.
 781
 782                                         for (std::map<wxString,FileSyncData>::iterator srviter = SCListData->begin();
 783                                                 srviter != SCListData->end(); srviter++){
 784
 785                                                 if (ETagDBData.find(srviter->first) == ETagDBData.end()){
 786                                                         continue;
 787                                                 }
 788
 789                                                 std::map<wxString,ETagData>::iterator lociter = ETagDBData.find(srviter->first);
 790
 791                                                 ETagData etd = lociter->second;
 792                                                 FileSyncData fsd = srviter->second;
 793
 794                                                 wxString ETagSrv = fsd.ETagData;
 795
 796                                                 // Compare local ETag with original local ETag.
 797                                                 // If different, update to server is required.
 798
 799                                                 if (etd.ETagValue != etd.ETagOrigValue){
 800
 801                                                         // Check if local original ETag is different from server ETag.
 802                                                         // If it is then throw up a conflict resolution dialog.
 803
 804                                                         if (etd.ETagOrigValue != ETagSrv){
 805
 806                                                                 vCard34Conv vCard34Obj;
 807
 808                                                                 wxString ServerContactData;
 809                                                                 wxString FullFilename;
 810                                                                 vCard ClientData;
 811                                                                 vCard ConvertedV4Data;
 812
 813                                                                 // Conflict. Bring up conflict resolution dialog.
 814
 815                                                                 // Get the server contact data for comparison.
 816
 817                                                                 CardDAVIter->second->SetServerFilename(srviter->first);
 818                                                                 CardDAVIter->second->GetServerContactData();
 819                                                                 ServerContactData = CardDAVIter->second->GetPageData();
 820
 821                                                                 FullFilename = CreateFilenamePath(AccountDirFinal, srviter->first);
 822
 823                                                                 // Convert it to v4.
 824
 825                                                                 vCard34Obj.ConvertToV4(&ServerContactData, &ConvertedV4Data);
 826
 827                                                                 vCardConflictObj vCardProcData;
 828
 829                                                                 vCardProcData.vCardLocalData = &ClientData;
 830                                                                 vCardProcData.vCardServerData = &ConvertedV4Data;
 831
 832                                                                 // Load the client data from the filename given.
 833
 834                                                                 ClientData.LoadFile(FullFilename);
 835
 836                                                                 // Show dialog.
 837
 838                                                                 bool *PauseMode = new bool;
 839                                                                 int ConflictResult;
 840                                                                 QRNotif qrn;
 841                                                                 frmMain *frmMainPtrGet = static_cast<frmMain*>(frmMainPtr);
 842
 843                                                                 *PauseMode = TRUE;
 844                                                                 qrn.QResponse = &ConflictResult;
 845                                                                 qrn.PausePtr = PauseMode;
 846
 847                                                                 vCardProcData.QRNotifData = &qrn;
 848
 849                                                                 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED);
 850                                                                 event.SetClientData(&vCardProcData);
 851                                                                 wxPostEvent(frmMainPtrGet, event);
 852
 853                                                                 /*timespec n1, n2;
 854
 855                                                                 n1.tv_sec = 0;
 856                                                                 n1.tv_nsec = 250000000L;*/
 857
 858                                                                 while (*PauseMode == TRUE){
 859                                                                         //nanosleep(&n1, &n2);
 860                                                                         SleepFor(250000000);
 861                                                                 }
 862
 863                                                                 delete PauseMode;
 864                                                                 PauseMode = NULL;
 865
 866                                                                 // If replacing local version, store copy for now.
 867                                                                 // Otherwise upload to server.
 868
 869                                                                 if (ConflictResult == 0){
 870
 871                                                                         // Decide Later.
 872
 873                                                                         continue;
 874
 875                                                                 } else if (ConflictResult == 1){
 876
 877                                                                         // Decided to use client version.
 878
 879                                                                         vCardUpdateLocal.Remove(srviter->first);
 880                                                                         vCardUpdateRemote.Add(srviter->first, 1);
 881
 882                                                                 } else if (ConflictResult == 2){
 883
 884                                                                         // Decided to use server version.
 885                                                                         // Store the converted downloaded copy for
 886                                                                         // processing later.
 887
 888                                                                         //vCardUpdateLocal.Add(srviter->first, 1);
 889
 890                                                                         vCardDownloadDataFileClass vCardNewData;
 891                                                                         vCardNewData.DataType = 1;
 892                                                                         vCardNewData.FileData = ConvertedV4Data.WriteString();
 893
 894                                                                         ConvertedV4Data.WriteFile(FullFilename);
 895
 896                                                                         vCardDownloadData.insert(std::make_pair(srviter->first, vCardNewData));
 897
 898
 899
 900                                                                 }
 901
 902                                                         } else {
 903
 904                                                                 // Send vCard to the server.
 905
 906                                                                 vCardUpdateRemote.Add(srviter->first, 1);
 907
 908                                                         }
 909
 910                                                 } else {
 911
 912                                                         // Check if local ETag is different from server ETag.
 913                                                         // If different, obtain the vCard from the server.
 914
 915                                                         if (etd.ETagOrigValue != ETagSrv){
 916
 917                                                                 vCardUpdateLocal.Add(srviter->first, 1);
 918
 919                                                         }
 920
 921                                                 }
 922
 923                                         }
 924
 925                                         // Process the vCards that need to be downloaded and added/overwritten.
 926
 927                                         wxString vCardFilenameFinal;
 928                                         wxString vCardOutputData;
 929                                         wxString vCardInputData;
 930                                         wxString ETagFileData;
 931                                         wxFFile vCardFile;
 932
 933                                         for (std::map<wxString,vCardDownloadDataFileClass>::iterator additer = vCardDownloadData.begin();
 934                                                 additer != vCardDownloadData.end(); additer++){
 935
 936                                                 vCardFilenameFinal.Clear();
 937                                                 vCardInputData.Clear();
 938                                                 vCardOutputData.Clear();
 939                                                 ETagFileData.Clear();
 940
 941                                                 vCardFilenameFinal = CreateFilenamePath(AccountDirFinal, additer->first);
 942
 943                                                 ETagDB *ETagDBPtr = ETagTmrPtr->GetPointer(AccountDir);
 944
 945                                                 if (additer->second.DataType == 0){
 946
 947                                                         vCard ConvertedV4Data;
 948
 949                                                         // Grab the file from the server and write the contact out.
 950
 951                                                         vCard34Conv vCard34Obj;
 952
 953                                                         CardDAVIter->second->SetServerFilename(additer->first);
 954                                                         CardDAVIter->second->GetServerContactData();
 955                                                         vCardInputData = CardDAVIter->second->GetPageData();
 956
 957                                                         vCard34Obj.ConvertToV4(&vCardInputData, &ConvertedV4Data);
 958
 959                                                         ConvertedV4Data.WriteFile(vCardFilenameFinal);
 960
 961                                                         // Update the ETagDB.
 962
 963                                                         //vCardFile.Open(vCardFilenameFinal, wxT("w"));
 964
 965                                                         //if (vCardFile.IsOpened()){
 966
 967                                                         //      vCardFile.Write(vCardOutputData, wxConvAuto());
 968                                                         //      vCardFile.Close();
 969
 970                                                         //}
 971
 972                                                         // Get the server ETag.
 973
 974                                                         wxString ServerETag;
 975                                                         CardDAVIter->second->GetServerETagValueThread();
 976                                                         ServerETag = CardDAVIter->second->ETagValueResult();
 977
 978                                                         // Add to the ETag Database.
 979
 980                                                         ETagDBPtr->AddETag(additer->first, ServerETag, ServerETag);
 981
 982                                                 } else if (additer->second.DataType == 1){
 983
 984                                                         // Write out the contact to the account directory.
 985
 986                                                         vCardFilenameFinal = CreateFilenamePath(AccountDirFinal, additer->first);
 987                                                         vCardOutputData = additer->second.FileData;
 988
 989                                                         vCardFile.Open(vCardFilenameFinal, wxT("w"));
 990
 991                                                         if (vCardFile.IsOpened()){
 992
 993                                                                 vCardFile.Write(vCardOutputData, wxConvAuto());
 994                                                                 vCardFile.Close();
 995
 996                                                         }
 997
 998                                                         // Update the ETagDB.
 999
1000                                                         wxString ServerETag;
1001                                                         CardDAVIter->second->GetServerETagValueThread();
1002                                                         ServerETag = CardDAVIter->second->ETagValueResult();
1003
1004                                                         // Add to the ETag Database.
1005
1006                                                         ETagDBPtr->AddETag(additer->first, ServerETag, ServerETag);
1007
1008                                                 }
1009                                         }
1010
1011                                         // Look for vCard files which aren't in the ETagDB.
1012
1013                                         while(ContinueProcess){
1014
1015                                                 // Check and make sure that the filename ends in .vcf/.vcard
1016                                                 // Skip any file that beings with a dot.
1017
1018                                                 if (AccDirFilename.Left(1) == wxT(".")){
1019
1020                                                         ContinueProcess = AccDir.GetNext(&AccDirFilename);
1021                                                         continue;
1022
1023                                                 }
1024
1025                                                 if (AccDirFilename.Right(4) != wxT(".vcf") &&
1026                                                 AccDirFilename.Right(6) != wxT(".vcard")){
1027
1028                                                         ContinueProcess = AccDir.GetNext(&AccDirFilename);
1029                                                         continue;
1030
1031                                                 }
1032
1033                                                 // Look in the ETagDB for the file.
1034
1035                                                 bool ETagExists = ETagDBPtr->CheckETagExists(AccDirFilename);
1036
1037                                                 if (ETagExists == FALSE){
1038
1039                                                         // Add the vCard to the list to be added.
1040
1041                                                         vCardAdd.Add(AccDirFilename, 1);
1042
1043                                                 }
1044
1045                                                 ContinueProcess = AccDir.GetNext(&AccDirFilename);
1046
1047                                         }
1048
1049                                         // Process the vCards to add/update to the server.
1050
1051                                         for (int vi = 0; vi < vCardAdd.GetCount(); vi++){
1052
1053                                                 ETagDB *ETagDBPtr = ETagTmrPtr->GetPointer(AccountDir);
1054                                                 ETag = ETagDBPtr->GetETag(vCardAdd[vi]);
1055                                                 ETagOriginal = ETagDBPtr->GetETagOriginal(vCardAdd[vi]);
1056
1057                                                 ContactFilename = vCardAdd[vi];
1058                                                 FullFilename = CreateFilenamePath(AccountDirFinal, vCardAdd[vi]);
1059
1060                                                 ContactFilename.Trim();
1061
1062                                                 if (ETag == ETagOriginal && ETagDBPtr->ETagExists(vCardAdd[vi])){
1063
1064                                                         // Compare the ETag with the Server ETag.
1065
1066                                                         CardDAVIter->second->SetServerFilename(vCardAdd[vi]);
1067                                                         CardDAVIter->second->GetServerETagValueThread();
1068                                                         ETagServer = CardDAVIter->second->ETagValueResult();
1069
1070                                                         if (ETagOriginal != ETagServer){
1071
1072                                                                 // Server ETag is different from original ETag.
1073                                                                 // This is a conflict which the user will now
1074                                                                 // need to resolve.
1075
1076                                                                 frmMain *frmMainPtrGet = static_cast<frmMain*>(frmMainPtr);
1077
1078                                                                 vCard34Conv vCard34Obj;
1079
1080                                                                 wxString ServerContactData;
1081                                                                 vCard ClientData;
1082                                                                 vCard ConvertedV4Data;
1083
1084                                                                 // Load the client data from the filename given.
1085
1086                                                                 CardDAVIter->second->GetServerContactData();
1087                                                                 ServerContactData = CardDAVIter->second->GetPageData();
1088
1089                                                                 // Process v3 version into v4 version.
1090
1091                                                                 vCard34Obj.ConvertToV4(&ServerContactData, &ConvertedV4Data);
1092
1093                                                                 vCardConflictObj vCardProcData;
1094
1095                                                                 vCardProcData.vCardLocalData = &ClientData;
1096                                                                 vCardProcData.vCardServerData = &ConvertedV4Data;
1097                                                                 ClientData.LoadFile(FullFilename);
1098
1099                                                                 //ContactConflictEvent event(ContactConflictCmdEnv);
1100                                                                 //event.SetData(ContactFilename, Moo1, Moo2);
1101
1102                                                                 //wxPostEvent(frmMainPtrGet, event);
1103
1104                                                                 // Setup Conflict Resolution Dialog.
1105
1106                                                                 // Fetch Data from Server and convert.
1107
1108                                                                 bool *PauseMode = new bool;
1109                                                                 int ConflictResult;
1110                                                                 QRNotif qrn;
1111
1112                                                                 *PauseMode = TRUE;
1113                                                                 qrn.QResponse = &ConflictResult;
1114                                                                 qrn.PausePtr = PauseMode;
1115
1116                                                                 vCardProcData.QRNotifData = &qrn;
1117
1118                                                                 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED);
1119                                                                 event.SetClientData(&vCardProcData);
1120                                                                 wxPostEvent(frmMainPtrGet, event);
1121
1122                                                                 /*timespec n1, n2;
1123
1124                                                                 n1.tv_sec = 0;
1125                                                                 n1.tv_nsec = 250000000L;*/
1126
1127                                                                 while (*PauseMode == TRUE){
1128                                                                         //nanosleep(&n1, &n2);
1129                                                                         SleepFor(250000000);
1130                                                                 }
1131
1132                                                                 delete PauseMode;
1133                                                                 PauseMode = NULL;
1134
1135                                                                 //intResult = frmMainPtrGet->ShowConflictDialog(&Moo1, &Moo2);
1136
1137                                                                 if (ConflictResult == 0){
1138
1139                                                                         // Decide Later.
1140
1141                                                                         iter->second = 4;
1142                                                                         continue;
1143
1144                                                                 } else if (ConflictResult == 1){
1145
1146                                                                         // Decided to use client version.
1147
1148                                                                         CardDAVIter->second->ProcessData();
1149
1150                                                                         iter->second = 4;
1151
1152                                                                 } else if (ConflictResult == 2){
1153
1154                                                                         // Decided to use server version.
1155
1156                                                                         // Download server version.
1157
1158                                                                         ConvertedV4Data.WriteFile(CreateFilenamePath(AccountDirFinal, vCardAdd[vi]));
1159
1160                                                                         iter->second = 4;
1161
1162                                                                 }
1163
1164                                                         } else {
1165
1166                                                                 // Setup the filename for the contact being added.
1167
1168                                                                 wxString wxSFilename = CreateFilenamePath(AccountDirFinal, vCardAdd[vi]);
1169                                                                 wxString wxSCardData;
1170                                                                 wxString TaskData;
1171                                                                 //wxString TaskURL;
1172
1173                                                                 // Load the data from the file.
1174
1175                                                                 wxFFile wxFCard;
1176                                                                 wxFCard.Open(wxSFilename, wxT("r"));
1177
1178                                                                 if (wxFCard.IsOpened()){
1179
1180                                                                         wxFCard.ReadAll(&wxSCardData, wxConvAuto());
1181                                                                         wxFCard.Close();
1182
1183                                                                 }
1184
1185                                                                 // Convert the data to v3.
1186
1187                                                                 vCard34Conv vCard34Obj;
1188
1189                                                                 vCard34Obj.ConvertToV3(wxSFilename, &TaskData);
1190
1191                                                                 // Setup the URL address.
1192
1193                                                                 //TaskURL = StringTaskDetailIter->second + wxT("/") + vCardAdd[vi];
1194
1195                                                                 // Upload the data to the server.
1196
1197                                                                 CardDAVIter->second->SetUploadMode(TRUE);
1198                                                                 CardDAVIter->second->SetupData(wxT("PUT"), vCardAdd[vi], TaskData);
1199                                                                 CardDAVIter->second->ProcessData();
1200
1201                                                                 // Get the Server ETag and put it in the ETag database.
1202
1203                                                                 CardDAVIter->second->SetServerFilename(vCardAdd[vi]);
1204                                                                 CardDAVIter->second->GetServerETagValueThread();
1205                                                                 ETagServer = CardDAVIter->second->ETagValueResult();
1206
1207                                                                 ETagDBPtr->AddETag(vCardAdd[vi], ETagServer, ETagServer);
1208
1209                                                         }
1210
1211                                                 } else {
1212
1213                                                         if (ETagOriginal != ETagServer){
1214
1215                                                                 // Server ETag is different from original ETag.
1216                                                                 // This is a conflict which the user will now
1217                                                                 // need to resolve.
1218
1219                                                                 frmMain *frmMainPtrGet = (frmMain *)frmMainPtr;
1220
1221                                                                 //ContactConflictEvent event(ContactConflictCmdEnv);
1222                                                                 //event.SetData(ContactFilename, Moo1, Moo2);
1223
1224                                                                 vCard34Conv vCard34Obj;
1225
1226                                                                 wxString ServerContactData;
1227                                                                 vCard ClientData;
1228                                                                 vCard ConvertedV4Data;
1229
1230                                                                 // Load the client data from the filename given.
1231
1232                                                                 CardDAVIter->second->GetServerContactData();
1233                                                                 ServerContactData = CardDAVIter->second->GetPageData();
1234                                                                 ClientData.LoadFile(FullFilename);
1235
1236                                                                 // Process v3 version into v4 version.
1237
1238                                                                 vCard34Obj.ConvertToV4(&ServerContactData, &ConvertedV4Data);
1239
1240                                                                 vCardConflictObj vCardProcData;
1241
1242                                                                 vCardProcData.vCardLocalData = &ClientData;
1243                                                                 vCardProcData.vCardServerData = &ConvertedV4Data;
1244
1245                                                                 bool *PauseMode = new bool;
1246                                                                 int ConflictResult;
1247                                                                 QRNotif qrn;
1248
1249                                                                 *PauseMode = TRUE;
1250                                                                 qrn.QResponse = &ConflictResult;
1251                                                                 qrn.PausePtr = PauseMode;
1252
1253                                                                 vCardProcData.QRNotifData = &qrn;
1254
1255                                                                 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED);
1256                                                                 event.SetClientData(&vCardProcData);
1257                                                                 wxPostEvent(frmMainPtrGet, event);
1258
1259                                                                 /*timespec n1, n2;
1260
1261                                                                 n1.tv_sec = 0;
1262                                                                 n1.tv_nsec = 250000000L;*/
1263
1264                                                                 while (*PauseMode == TRUE){
1265                                                                         //nanosleep(&n1, &n2);
1266                                                                         SleepFor(250000000);
1267                                                                 }
1268
1269                                                                 delete PauseMode;
1270                                                                 PauseMode = NULL;
1271
1272                                                                 //intResult = frmMainPtrGet->ShowConflictDialog(&Moo1, &Moo2);
1273
1274                                                                 if (ConflictResult == 0){
1275
1276                                                                         // Decide Later.
1277
1278                                                                         iter->second = 4;
1279                                                                         continue;
1280
1281                                                                 } else if (ConflictResult == 1){
1282
1283                                                                         // Decided to use client version.
1284
1285                                                                         CardDAVIter->second->ProcessData();
1286                                                                         //ETagServer = CardDAVIter->second.GetServerETagValueThread();
1287                                                                         //ETagDBPtr->UpdateETag(ContactFilename, ETagServer, ETagServer);
1288
1289                                                                         iter->second = 4;
1290
1291                                                                 } else if (ConflictResult == 2){
1292
1293                                                                         // Decided to use server version.
1294
1295                                                                         // Write server version to file.
1296
1297                                                                         ConvertedV4Data.WriteFile(CreateFilenamePath(AccountDirFinal, vCardAdd[vi]));
1298
1299                                                                         iter->second = 4;
1300
1301                                                                 }
1302
1303                                                         } else {
1304
1305                                                                 // Setup the filename for the contact being added.
1306
1307                                                                 wxString wxSFilename = CreateFilenamePath(AccountDirFinal, vCardAdd[vi]);
1308                                                                 wxString wxSCardData;
1309                                                                 wxString TaskData;
1310                                                                 //wxString TaskURL;
1311
1312                                                                 // Load the data from the file.
1313
1314                                                                 wxFFile wxFCard;
1315                                                                 wxFCard.Open(wxSFilename, wxT("r"));
1316
1317                                                                 if (wxFCard.IsOpened()){
1318
1319                                                                         wxFCard.ReadAll(&wxSCardData, wxConvAuto());
1320                                                                         wxFCard.Close();
1321
1322                                                                 }
1323
1324                                                                 // Convert the data to v3.
1325
1326                                                                 vCard34Conv vCard34Obj;
1327
1328                                                                 vCard34Obj.ConvertToV3(wxSFilename, &TaskData);
1329
1330                                                                 // Setup the URL address.
1331
1332                                                                 //TaskURL = StringTaskDetailIter->second + wxT("/") + vCardAdd[vi];
1333
1334                                                                 // Upload the data to the server.
1335
1336                                                                 CardDAVIter->second->SetUploadMode(TRUE);
1337                                                                 CardDAVIter->second->SetupData(wxT("PUT"), vCardAdd[vi], TaskData);
1338                                                                 CardDAVIter->second->ProcessData();
1339
1340                                                                 // Get the Server ETag and put it in the ETag database.
1341
1342                                                                 CardDAVIter->second->SetServerFilename(vCardAdd[vi]);
1343                                                                 CardDAVIter->second->GetServerETagValueThread();
1344                                                                 ETagServer = CardDAVIter->second->ETagValueResult();
1345
1346
1347                                                                 ETagDBPtr->AddETag(vCardAdd[vi], ETagServer, ETagServer);
1348
1349                                                         }
1350
1351                                                 }
1352
1353                                         }
1354
1355                                         // Process the vCards to delete locally.
1356
1357                                         for (int vi = 0; vi < vCardDelete.GetCount(); vi++){
1358
1359                                                 if (!wxRemoveFile(CreateFilenamePath(AccountDirFinal, vCardDelete[vi]))){
1360
1361                                                 } else {
1362
1363                                                         ETagDBPtr->RemoveETag(vCardDelete[vi]);
1364
1365                                                 }
1366
1367                                         }
1368
1369                                         // Process the vCards to delete from the server.
1370
1371                                         std::map<wxString,wxString> *ETagFilenameMap = ETagDBPtr->GetFilenamePointer();
1372
1373
1374                                         for (std::map<wxString,wxString>::iterator deliter = ETagFilenameMap->begin();
1375                                                 deliter != ETagFilenameMap->end(); deliter++){
1376
1377                                                 // Look through the ETagDB and find contacts which are marked as DELETED.
1378
1379                                                 if (deliter->second == wxT("DELETED")){
1380
1381                                                         CardDAVIter->second->SetUploadMode(FALSE);
1382                                                         CardDAVIter->second->SetupData(wxT("DELETE"), deliter->first, wxT(""));
1383                                                         CardDAVIter->second->ProcessData();
1384
1385                                                         // Delete the ETag as the file has now been deleted.
1386
1387                                                         ETagDBPtr->RemoveETag(deliter->first);
1388
1389                                                 }
1390
1391                                         }
1392
1393                                         // Write out the update server sync token.
1394
1395                                         wxString ServerSyncToken = ServerContactList.SyncToken;
1396
1397                                         ServerSyncToken.Trim();
1398
1399                                         if (!ServerSyncToken.IsEmpty()){
1400
1401                                                 wxFFile SyncWrite;
1402                                                 SyncWrite.Open(AccountSyncTokenFilename, wxT("w"));
1403
1404                                                 if (SyncWrite.IsOpened()){
1405
1406                                                         SyncWrite.Write(ServerSyncToken, wxConvAuto());
1407                                                         SyncWrite.Close();
1408
1409                                                 }
1410
1411                                         }
1412
1413                                         // Check for another sync token. If there is another
1414                                         // sync token then repeat this. If token matches then stop processing.
1415
1416                                         if (SyncTokenLoad == ServerSyncToken){
1417
1418                                                 KeepUpdating = FALSE;
1419
1420                                         }
1421
1422                                 }
1423
1424                                 // Mark as completed.
1425
1426                                 wxString AccountNameFinal;
1427                                 AccountNameFinal = PrefData.accounts.GetAccountDirectory(AccountID);
1428                                 AccountNameFinal.Append(wxT(".carddav"));
1429
1430                                 wxCommandEvent reloadevent(RELOADCONTACTLIST);
1431                                 reloadevent.SetString(AccountNameFinal);
1432                                 wxPostEvent(this->GetParent(), reloadevent);
1433
1434                                 iter->second = 4;
1435                                 continue;
1436
1437                         } else {
1438
1439                                 // Update the data to the server.
1440
1441                                 CardDAVIter->second->ProcessData();
1442                                 iter->second = 4;
1443                                 continue;
1444
1445                         }
1446
1447                         /*timespec n1, n2;
1448
1449                         n1.tv_sec = 0;
1450                         n1.tv_nsec = 250000000L;*/
1451
1452                         while (iter->second == 1){
1453
1454                                 SleepFor(250000000);
1455                                 //nanosleep(&n1, &n2);
1456
1457                         }
1458
1459                         if ((iter->second == 4 && TypeIter->second == 0) ||
1460                         (iter->second == 8 && TypeIter->second == 0)){
1461
1462                                 AccountDir = StringAccountIter->second;
1463                                 ETagDB *ETagDBPtr = ETagTmrPtr->GetPointer(AccountDir);
1464
1465                                 CardDAVIter->second->GetServerETagValueThread();
1466                                 ETagServer = CardDAVIter->second->ETagValueResult();
1467                                 ETagDBPtr->UpdateETag(ContactFilename, ETagServer, ETagServer);
1468
1469                         }
1470
1471                         if ((iter->second == 4 && TypeIter->second == 1) ||
1472                         (iter->second == 8 && TypeIter->second == 1)){
1473
1474                                 AccountDir = StringAccountIter->second;
1475                                 ETagDB *ETagDBPtr = ETagTmrPtr->GetPointer(AccountDir);
1476
1477                                 CardDAVIter->second->GetServerETagValueThread();
1478                                 ETagServer = CardDAVIter->second->ETagValueResult();
1479                                 ETagDBPtr->UpdateETag(ContactFilename, ETagServer, ETagServer);
1480
1481                         }
1482
1483                         break;
1484
1485                 }
1486
1487         }
1488
1489         if (TasksFoundProc == FALSE){
1490
1491                 TasksActive = FALSE;
1492                 ProcessTasksData = FALSE;
1493
1494         } else {
1495
1496                 wxCommandEvent eventp(ACTMGR_STARTTIMER);
1497                 wxPostEvent(this, eventp);
1498
1499                 //AnimationTimer.StartAnimation();
1500                 //ActListProcTimer.Start();
1501
1502         }
1503
1504         wxCommandEvent event(ACTMGR_STARTPROCESSTIMER);
1505         wxPostEvent(this, event);
1506
1507         //ActProcessTimer.Start();
1508
1509 }
1510
1511 void frmActivityMgr::ProcessTasks()
1512 {
1513
1514         std::thread ProcessThread(&frmActivityMgr::ProcessTasksThread, this);
1515         ProcessThread.detach();
1516
1517 }
1518
1519 void frmActivityMgr::SetupPointers(wxETagProcessTimer *ETagTmrPtrInc, void *frmMainPtrInc)
1520 {
1521
1522         ETagTmrPtr = ETagTmrPtrInc;
1523
1524         frmMainPtr = frmMainPtrInc;
1525
1526 }
1527
1528 void frmActivityMgr::ResumeProcessing(wxCommandEvent &event){
1529
1530         QRNotif *qrn = (QRNotif *)event.GetClientData();
1531
1532         int *QRes = qrn->QResponse;
1533
1534         *qrn->PausePtr = FALSE;
1535
1536         *QRes = event.GetInt();
1537
1538 }
1539
1540 void frmActivityMgr::ToggleConnectionStatus( wxCommandEvent &event ){
1541
1542         wxCommandEvent connevent(CONNSTAT_UPDATE);
1543
1544         if (SleepMode == FALSE){
1545
1546                 connevent.SetInt(1);
1547                 SleepMode = TRUE;
1548
1549         } else {
1550
1551                 connevent.SetInt(0);
1552                 SleepMode = FALSE;
1553
1554         }
1555
1556         wxPostEvent(GetParent(), connevent);
1557
1558 }
1559
1560 void frmActivityMgr::WriteServerCertificate(wxString AccountName, SSLCertCollection SSLCertInc){
1561
1562         wxString ServerCertFinal;
1563
1564         // Get the Cert section of the certificate and write it to the file.
1565
1566         ServerCertFinal = GetAccountDir(AccountName, TRUE);
1567
1568         wxFile CertFile;
1569
1570         std::map<int, SSLCertData>::iterator SSLCDIter = SSLCertInc.SSLCollection.find(0);
1571         std::multimap<wxString,wxString>::iterator SSLDataIter = SSLCDIter->second.CertData.find(wxT("Cert"));
1572
1573         CertFile.Open(ServerCertFinal, wxFile::write);
1574
1575         CertFile.Write(SSLDataIter->second, wxConvUTF8);
1576         CertFile.Close();
1577
1578 }
1579
1580 void frmActivityMgr::StartTimer(wxCommandEvent& event){
1581
1582         ActListProcTimer.Start(1000, FALSE);
1583
1584 }
1585
1586 void frmActivityMgr::StopTimer(wxCommandEvent& event){
1587
1588         ActListProcTimer.Stop();
1589
1590 }
1591
1592 void frmActivityMgr::StartProcessTimer(wxCommandEvent& event){
1593
1594         ActProcessTimer.Start(1000, FALSE);
1595
1596 }
1597
1598 void frmActivityMgr::StopProcessTimer(wxCommandEvent& event){
1599
1600         ActProcessTimer.Stop();
1601
1602 }
1603
1604 void frmActivityMgr::UpdateStatusLabel(wxCommandEvent& event){
1605
1606         ActivityMgrLabelUpdate *actmgrudata = (ActivityMgrLabelUpdate*)event.GetClientData();
1607
1608         if (actmgrudata != NULL){
1609
1610                 lstActivity->SetItem(actmgrudata->ItemIndex, 2, actmgrudata->ItemLabel);
1611
1612                 /*if (!actmgrudata->ItemDes.IsEmpty()){
1613                 lstActivity->SetItem(actmgrudata->ItemIndex, 0, actmgrudata->ItemDes);
1614                 }*/
1615
1616                 delete actmgrudata;
1617                 actmgrudata = NULL;
1618
1619         }
1620
1621 }
1622
1623 #endif