source/libraries/CalendarDataStorage/CalendarDataStorage.cpp

   1 #include "CalendarDataStorage.h"
   2
   3 #include <iostream>
   4
   5 using namespace std;
   6
   7 static int callback(void *NotUsed, int argc, char **argv, char **azColName){
   8    return 0;
   9 }
  10
  11 CalendarDataStorage::CalendarDataStorage(){
  12
  13         // Initialise the SQLite database.
  14
  15         sqlite3_open_v2(":memory:", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_FULLMUTEX, nullptr);
  16         SetupTables();
  17
  18 }
  19
  20 CalendarDataStorage::~CalendarDataStorage(){
  21
  22         // Destory the SQLite database.
  23
  24         sqlite3_close(db);
  25
  26 }
  27
  28 void CalendarDataStorage::SetupTables(){
  29
  30         // Setup the tables for the Calendar Data Storage.
  31
  32         char *setupTablesErrMsg = nullptr;
  33         int resultCode;
  34
  35         // Setup the accounts table.
  36
  37         const char *accountsTableString;
  38         accountsTableString = "CREATE TABLE accounts(id INTEGER PRIMARY KEY "
  39                 ", name TEXT"
  40                 ");";
  41
  42         resultCode = sqlite3_exec(db, accountsTableString, callback, nullptr, &setupTablesErrMsg);
  43
  44         if (resultCode != 0){
  45                 DataStorageInitOK = false;
  46                 return;
  47         }
  48
  49         // Setup the calendars table.
  50
  51         const char *calendarTableString;
  52         calendarTableString = "CREATE TABLE calendars(id INTEGER PRIMARY KEY "
  53                 ", accountid INTEGER"
  54                 ", name TEXT"
  55                 ", calendarid TEXT"
  56                 ", colour TEXT"
  57                 ");";
  58
  59         resultCode = sqlite3_exec(db, calendarTableString, callback, nullptr, &setupTablesErrMsg);
  60
  61         if (resultCode != 0){
  62                 DataStorageInitOK = false;
  63                 return;
  64         }
  65
  66         // Setup the calendar entries table.
  67
  68         const char *calendarentriesTableString;
  69         calendarentriesTableString = "CREATE TABLE calendarentries(id INTEGER PRIMARY KEY "
  70                 ", calendarid INTEGER"
  71                 ", entryname TEXT"
  72                 ", entrydescription TEXT"
  73                 ", entrystartyear INTEGER"
  74                 ", entrystartmonth INTEGER"
  75                 ", entrystartday INTEGER"
  76                 ", entrystarthour INTEGER"
  77                 ", entrystartminute INTEGER"
  78                 ", entrystartsecond INTEGER"
  79                 ", entryendyear INTEGER"
  80                 ", entryendmonth INTEGER"
  81                 ", entryendday INTEGER"
  82                 ", entryendhour INTEGER"
  83                 ", entryendminute INTEGER"
  84                 ", entryendsecond INTEGER"
  85                 ", entrydurationweek INTEGER"
  86                 ", entrydurationday INTEGER"
  87                 ", entrydurationhour INTEGER"
  88                 ", entrydurationminute INTEGER"
  89                 ", entrydurationsecond INTEGER"
  90                 ");";
  91
  92         resultCode = sqlite3_exec(db, calendarentriesTableString, callback, nullptr, &setupTablesErrMsg);
  93
  94         if (resultCode != 0){
  95                 DataStorageInitOK = false;
  96                 return;
  97         }
  98
  99         // Setup the checksums table.
 100
 101         const char *checksumsTableString;
 102         checksumsTableString = "CREATE TABLE checksums(hashname TEXT PRIMARY KEY "
 103                 ", hashvalue TEXT);";
 104
 105         resultCode = sqlite3_exec(db, checksumsTableString, callback, nullptr, &setupTablesErrMsg);
 106
 107         if (resultCode != 0){
 108                 DataStorageInitOK = false;
 109                 return;
 110         }
 111
 112         DataStorageInitOK = true;
 113
 114 }
 115
 116 bool CalendarDataStorage::DidInitOK()
 117 {
 118
 119         return DataStorageInitOK;
 120
 121 }
 122
 123 CDSAccountResult CalendarDataStorage::AddAccount(string accountName)
 124 {
 125
 126         CDSAccountResult addResult = CDSACCOUNT_UNITTESTFAIL;
 127         int resultCode;
 128
 129         sqlite3_stmt *statementHandle;
 130
 131         resultCode = sqlite3_prepare_v2(db, "INSERT INTO accounts (name) VALUES(?1);", -1, &statementHandle, nullptr);
 132
 133         if (resultCode != 0){
 134                 return CDSACCOUNT_FAILED;
 135         }
 136
 137         resultCode = sqlite3_bind_text(statementHandle, 1, accountName.c_str(), -1, SQLITE_STATIC);
 138
 139         if (resultCode != 0){
 140                 return CDSACCOUNT_FAILED;
 141         }
 142
 143         resultCode = sqlite3_step(statementHandle);
 144
 145         if (resultCode != SQLITE_DONE){
 146                 return CDSACCOUNT_FAILED;
 147         }
 148
 149         addResult = CDSACCOUNT_OK;
 150
 151         return addResult;
 152
 153 }
 154
 155 CDSAccountList CalendarDataStorage::GetAccountList()
 156 {
 157
 158         CDSAccountList accountList;
 159
 160         // Check if calendar exists first.
 161
 162         int resultCode = 0;
 163
 164         sqlite3_stmt *statementHandle;
 165
 166         resultCode = sqlite3_prepare_v2(db, "SELECT id, name from accounts;", -1, &statementHandle, nullptr);
 167
 168         if (resultCode != 0){
 169                 accountList.getAccountListResult = CDSACCOUNT_FAILED;
 170                 return accountList;
 171         }
 172
 173         if (resultCode != 0){
 174                 accountList.getAccountListResult = CDSACCOUNT_FAILED;
 175                 return accountList;
 176         }
 177
 178         resultCode = sqlite3_step(statementHandle);
 179
 180         if (resultCode == SQLITE_ROW){
 181
 182         } else if (resultCode == SQLITE_DONE) {
 183                 accountList.getAccountListResult = CDSACCOUNT_NOACCOUNT;
 184                 return accountList;
 185         } else {
 186                 accountList.getAccountListResult = CDSACCOUNT_FAILED;
 187                 return accountList;
 188         }
 189
 190         while (resultCode == SQLITE_ROW){
 191
 192                 CDSGetAccountInfo accountInfo;
 193
 194                 accountInfo.accountID = sqlite3_column_int(statementHandle, 0);
 195
 196                 stringstream calendarStream;
 197
 198                 calendarStream << sqlite3_column_text(statementHandle, 1);
 199
 200                 accountInfo.accountName = calendarStream.str();
 201                 accountInfo.accountInfoResult = CDSACCOUNT_OK;
 202
 203                 accountList.accountList.push_back(accountInfo);
 204
 205                 resultCode = sqlite3_step(statementHandle);
 206
 207         }
 208
 209         accountList.getAccountListResult = CDSACCOUNT_OK;
 210
 211         return accountList;
 212
 213 }
 214
 215 CDSGetAccountInfo CalendarDataStorage::GetAccount(string accountName)
 216 {
 217
 218         CDSGetAccountInfo accountInfo;
 219         accountInfo.accountInfoResult = CDSACCOUNT_UNITTESTFAIL;
 220         int resultCode;
 221
 222         sqlite3_stmt *statementHandle;
 223
 224         resultCode = sqlite3_prepare_v2(db, "SELECT name, id FROM accounts WHERE name=(?1);", -1, &statementHandle, nullptr);
 225
 226         if (resultCode != 0){
 227                 accountInfo.accountInfoResult = CDSACCOUNT_FAILED;
 228                 return accountInfo;
 229         }
 230
 231         resultCode = sqlite3_bind_text(statementHandle, 1, accountName.c_str(), -1, SQLITE_STATIC);
 232
 233         if (resultCode != 0){
 234                 accountInfo.accountInfoResult = CDSACCOUNT_FAILED;
 235                 return accountInfo;
 236         }
 237
 238         resultCode = sqlite3_step(statementHandle);
 239
 240         if (resultCode == SQLITE_DONE){
 241
 242                 accountInfo.accountInfoResult = CDSACCOUNT_NOACCOUNT;
 243                 return accountInfo;
 244
 245         } else if (resultCode == SQLITE_ROW){
 246
 247                 // Get the result data.
 248
 249                 stringstream accountNameStream;
 250
 251                 accountNameStream << sqlite3_column_text(statementHandle, 0);
 252
 253                 accountInfo.accountName = accountNameStream.str();
 254                 accountInfo.accountID = sqlite3_column_int(statementHandle, 1);
 255
 256                 accountInfo.accountInfoResult = CDSACCOUNT_OK;
 257                 return accountInfo;
 258
 259         } else {
 260
 261                 accountInfo.accountInfoResult = CDSACCOUNT_FAILED;
 262                 return accountInfo;
 263
 264         }
 265
 266         return accountInfo;
 267
 268 }
 269
 270 CDSAccountResult CalendarDataStorage::UpdateAccount(int accountID, string accountName)
 271 {
 272
 273         CDSAccountResult updateResult = CDSACCOUNT_UNITTESTFAIL;
 274         int resultCode;
 275
 276         sqlite3_stmt *findHandle;
 277         sqlite3_stmt *statementHandle;
 278
 279         // Check if account exists first.
 280
 281         resultCode = sqlite3_prepare_v2(db, "SELECT id from accounts WHERE id=(?1);", -1, &findHandle, nullptr);
 282
 283         if (resultCode != 0){
 284                 return CDSACCOUNT_FAILED;
 285         }
 286
 287         resultCode = sqlite3_bind_int(findHandle, 1, accountID);
 288
 289         if (resultCode != 0){
 290                 return CDSACCOUNT_FAILED;
 291         }
 292
 293         resultCode = sqlite3_step(findHandle);
 294
 295         if (resultCode == SQLITE_ROW){
 296
 297         } else if (resultCode == SQLITE_DONE) {
 298                 return CDSACCOUNT_NOACCOUNT;
 299         } else {
 300                 return CDSACCOUNT_FAILED;
 301         }
 302
 303         // Update the account.
 304
 305         resultCode = sqlite3_prepare_v2(db, "UPDATE accounts SET name=(?1) WHERE id=(?2);", -1, &statementHandle, nullptr);
 306
 307         if (resultCode != 0){
 308                 return CDSACCOUNT_FAILED;
 309         }
 310
 311         resultCode = sqlite3_bind_text(statementHandle, 1, accountName.c_str(), -1, SQLITE_STATIC);
 312
 313         if (resultCode != 0){
 314                 return CDSACCOUNT_FAILED;
 315         }
 316
 317         resultCode = sqlite3_bind_int(statementHandle, 2, accountID);
 318
 319         if (resultCode != 0){
 320                 return CDSACCOUNT_FAILED;
 321         }
 322
 323         resultCode = sqlite3_step(statementHandle);
 324
 325         if (resultCode != SQLITE_DONE){
 326                 return CDSACCOUNT_FAILED;
 327         }
 328
 329         updateResult = CDSACCOUNT_OK;
 330
 331         return updateResult;
 332
 333 }
 334
 335 CDSAccountResult CalendarDataStorage::DeleteAccount(int accountID)
 336 {
 337
 338         CDSAccountResult deleteResult = CDSACCOUNT_UNITTESTFAIL;
 339
 340         // Check if account exists first.
 341
 342         sqlite3_stmt *findHandle;
 343         sqlite3_stmt *statementHandle;
 344         sqlite3_stmt *calendarHandle;
 345         int resultCode;
 346
 347         resultCode = sqlite3_prepare_v2(db, "SELECT id from accounts WHERE id=(?1);", -1, &findHandle, nullptr);
 348
 349         if (resultCode != 0){
 350                 return CDSACCOUNT_FAILED;
 351         }
 352
 353         resultCode = sqlite3_bind_int(findHandle, 1, accountID);
 354
 355         if (resultCode != 0){
 356                 return CDSACCOUNT_FAILED;
 357         }
 358
 359         resultCode = sqlite3_step(findHandle);
 360
 361         if (resultCode == SQLITE_ROW){
 362
 363         } else if (resultCode == SQLITE_DONE) {
 364                 return CDSACCOUNT_NOACCOUNT;
 365         } else {
 366                 return CDSACCOUNT_FAILED;
 367         }
 368
 369         // Delete the account.
 370
 371         resultCode = sqlite3_prepare_v2(db, "DELETE FROM accounts WHERE id=(?1);", -1, &statementHandle, nullptr);
 372
 373         if (resultCode != 0){
 374                 return CDSACCOUNT_FAILED;
 375         }
 376
 377         resultCode = sqlite3_bind_int(statementHandle, 1, accountID);
 378
 379         if (resultCode != 0){
 380                 return CDSACCOUNT_FAILED;
 381         }
 382
 383         resultCode = sqlite3_step(statementHandle);
 384
 385         if (resultCode == SQLITE_DONE){
 386                 //deleteResult = CDSACCOUNT_OK;
 387         } else {
 388                 return CDSACCOUNT_FAILED;
 389         }
 390
 391         // Get the calendar IDs and delete each calendar (and associated entries).
 392
 393         resultCode = sqlite3_prepare_v2(db, "SELECT id FROM calendars WHERE accountid=(?1);", -1, &calendarHandle, nullptr);
 394
 395         if (resultCode != 0){
 396                 return CDSACCOUNT_FAILED;
 397         }
 398
 399         resultCode = sqlite3_bind_int(calendarHandle, 1, accountID);
 400
 401         if (resultCode != 0){
 402                 return CDSACCOUNT_FAILED;
 403         }
 404
 405         resultCode = sqlite3_step(calendarHandle);
 406
 407         if (resultCode == SQLITE_DONE || resultCode == SQLITE_ROW){
 408                 deleteResult = CDSACCOUNT_OK;
 409         } else {
 410                 return CDSACCOUNT_FAILED;
 411         }
 412
 413         while (resultCode == SQLITE_ROW){
 414
 415                 int calendarDeleteID = sqlite3_column_int(calendarHandle, 0);
 416
 417                 DeleteCalendar(calendarDeleteID);
 418
 419                 resultCode = sqlite3_step(calendarHandle);
 420
 421         }
 422
 423         deleteResult = CDSACCOUNT_OK;
 424
 425         return deleteResult;
 426
 427
 428 }
 429
 430 CDSCalendarResult CalendarDataStorage::AddCalendar(int accountID, string calendarName, string calendarID, Colour calendarColour)
 431 {
 432
 433         CDSCalendarResult addResult = CDSCALENDAR_UNITTESTFAIL;
 434         int resultCode;
 435
 436         sqlite3_stmt *statementHandle;
 437
 438         resultCode = sqlite3_prepare_v2(db, "INSERT INTO calendars (name, calendarid, accountid, colour) VALUES(?1, ?2, ?3, ?4);", -1, &statementHandle, nullptr);
 439
 440         if (resultCode != 0){
 441                 return CDSCALENDAR_FAILED;
 442         }
 443
 444         resultCode = sqlite3_bind_text(statementHandle, 1, calendarName.c_str(), -1, SQLITE_STATIC);
 445
 446         if (resultCode != 0){
 447                 return CDSCALENDAR_FAILED;
 448         }
 449
 450         resultCode = sqlite3_bind_text(statementHandle, 2, calendarID.c_str(), -1, SQLITE_STATIC);
 451
 452         if (resultCode != 0){
 453                 return CDSCALENDAR_FAILED;
 454         }
 455
 456         resultCode = sqlite3_bind_int(statementHandle, 3, accountID);
 457
 458         if (resultCode != 0){
 459                 return CDSCALENDAR_FAILED;
 460         }
 461
 462         resultCode = sqlite3_bind_text(statementHandle, 4, ((string)calendarColour).c_str(), -1, SQLITE_STATIC);
 463
 464         if (resultCode != 0){
 465                 return CDSCALENDAR_FAILED;
 466         }
 467
 468         resultCode = sqlite3_step(statementHandle);
 469
 470         if (resultCode != SQLITE_DONE){
 471                 return CDSCALENDAR_FAILED;
 472         }
 473
 474         addResult = CDSCALENDAR_OK;
 475
 476         return addResult;
 477
 478 }
 479
 480 CDSGetCalendarInfo CalendarDataStorage::GetCalendar(std::string accountName, std::string calendarTextID)
 481 {
 482
 483         CDSGetAccountInfo accountResult;
 484         CDSGetCalendarInfo calendarResult;
 485         sqlite3_stmt *statementHandle;
 486         int resultCode;
 487
 488         // Check if the account exists.
 489
 490         accountResult = GetAccount(accountName);
 491
 492         switch (accountResult.accountInfoResult){
 493
 494                 case CDSACCOUNT_OK:
 495                         calendarResult.accountName = accountResult.accountName;
 496                         calendarResult.accountInfoResult = CDSACCOUNT_OK;
 497                         break;
 498                 case CDSACCOUNT_FAILED:
 499                         calendarResult.accountInfoResult = CDSACCOUNT_FAILED;
 500                         calendarResult.calendarInfoResult = CDSCALENDAR_FAILED;
 501                         return calendarResult;
 502                 case CDSACCOUNT_NOACCOUNT:
 503                         calendarResult.accountInfoResult = CDSACCOUNT_NOACCOUNT;
 504                         calendarResult.calendarInfoResult = CDSCALENDAR_NOCALENDAR;
 505                         return calendarResult;
 506
 507         }
 508
 509         // Check if the calendar exists.
 510
 511         resultCode = sqlite3_prepare_v2(db, "SELECT id, accountid, name, calendarid, colour FROM calendars WHERE accountid=(?1) AND calendarid=(?2);", -1, &statementHandle, nullptr);
 512
 513         if (resultCode != 0){
 514                 calendarResult.calendarInfoResult = CDSCALENDAR_FAILED;
 515                 return calendarResult;
 516         }
 517
 518         resultCode = sqlite3_bind_int(statementHandle, 1, accountResult.accountID);
 519
 520         if (resultCode != 0){
 521                 calendarResult.calendarInfoResult = CDSCALENDAR_FAILED;
 522                 return calendarResult;
 523         }
 524
 525         resultCode = sqlite3_bind_text(statementHandle, 2, calendarTextID.c_str(), -1, SQLITE_STATIC);
 526
 527         if (resultCode != 0){
 528                 calendarResult.calendarInfoResult = CDSCALENDAR_FAILED;
 529                 return calendarResult;
 530         }
 531
 532         resultCode = sqlite3_step(statementHandle);
 533
 534         if (resultCode == SQLITE_DONE){
 535
 536                 calendarResult.calendarInfoResult = CDSCALENDAR_NOCALENDAR;
 537                 return calendarResult;
 538
 539         } else if (resultCode == SQLITE_ROW){
 540
 541                 // Get the calendar name.
 542
 543                 stringstream calendarStream;
 544
 545                 calendarStream << sqlite3_column_text(statementHandle, 2);
 546                 calendarResult.calendarName = calendarStream.str();
 547
 548                 calendarStream.str("");
 549                 calendarStream << sqlite3_column_text(statementHandle, 3);
 550                 calendarResult.calendarTextID = calendarStream.str();
 551
 552                 calendarStream.str("");
 553                 calendarStream << sqlite3_column_text(statementHandle, 4);
 554                 calendarResult.calendarColour = calendarStream.str();
 555
 556                 calendarResult.calendarID = sqlite3_column_int(statementHandle, 0);
 557                 calendarResult.accountID = sqlite3_column_int(statementHandle, 1);
 558                 calendarResult.calendarInfoResult = CDSCALENDAR_OK;
 559                 return calendarResult;
 560
 561         } else {
 562
 563                 calendarResult.calendarInfoResult = CDSCALENDAR_FAILED;
 564                 return calendarResult;
 565
 566         }
 567
 568         return calendarResult;
 569
 570 }
 571
 572 CDSCalendarResult CalendarDataStorage::UpdateCalendar(int calendarID, string calendarName)
 573 {
 574
 575         CDSCalendarResult updateResult = CDSCALENDAR_UNITTESTFAIL;
 576         int resultCode;
 577
 578         sqlite3_stmt *findHandle;
 579         sqlite3_stmt *statementHandle;
 580
 581         // Check if calendar exists first.
 582
 583         resultCode = sqlite3_prepare_v2(db, "SELECT id from calendars WHERE id=(?1);", -1, &findHandle, nullptr);
 584
 585         if (resultCode != 0){
 586                 return CDSCALENDAR_FAILED;
 587         }
 588
 589         resultCode = sqlite3_bind_int(findHandle, 1, calendarID);
 590
 591         if (resultCode != 0){
 592                 return CDSCALENDAR_FAILED;
 593         }
 594
 595         resultCode = sqlite3_step(findHandle);
 596
 597         if (resultCode == SQLITE_ROW){
 598
 599         } else if (resultCode == SQLITE_DONE) {
 600                 return CDSCALENDAR_NOCALENDAR;
 601         } else {
 602                 return CDSCALENDAR_FAILED;
 603         }
 604
 605         // Update the account.
 606
 607         resultCode = sqlite3_prepare_v2(db, "UPDATE calendars SET name=(?1) WHERE id=(?2);", -1, &statementHandle, nullptr);
 608
 609         if (resultCode != 0){
 610                 return CDSCALENDAR_FAILED;
 611         }
 612
 613         resultCode = sqlite3_bind_text(statementHandle, 1, calendarName.c_str(), -1, SQLITE_STATIC);
 614
 615         if (resultCode != 0){
 616                 return CDSCALENDAR_FAILED;
 617         }
 618
 619         resultCode = sqlite3_bind_int(statementHandle, 2, calendarID);
 620
 621         if (resultCode != 0){
 622                 return CDSCALENDAR_FAILED;
 623         }
 624
 625         resultCode = sqlite3_step(statementHandle);
 626
 627         if (resultCode != SQLITE_DONE){
 628                 return CDSCALENDAR_FAILED;
 629         }
 630
 631         updateResult = CDSCALENDAR_OK;
 632
 633         return updateResult;
 634
 635 }
 636
 637 CDSCalendarResult CalendarDataStorage::DeleteCalendar(int calendarID)
 638 {
 639
 640         CDSCalendarResult deleteResult = CDSCALENDAR_UNITTESTFAIL;
 641
 642         // Check if account exists first.
 643
 644         sqlite3_stmt *findHandle;
 645         sqlite3_stmt *statementHandle;
 646         sqlite3_stmt *entriesHandle;
 647         int resultCode;
 648
 649         resultCode = sqlite3_prepare_v2(db, "SELECT id from calendars WHERE id=(?1);", -1, &findHandle, nullptr);
 650
 651         if (resultCode != 0){
 652                 return CDSCALENDAR_FAILED;
 653         }
 654
 655         resultCode = sqlite3_bind_int(findHandle, 1, calendarID);
 656
 657         if (resultCode != 0){
 658                 return CDSCALENDAR_FAILED;
 659         }
 660
 661         resultCode = sqlite3_step(findHandle);
 662
 663         if (resultCode == SQLITE_ROW){
 664
 665         } else if (resultCode == SQLITE_DONE) {
 666                 return CDSCALENDAR_NOCALENDAR;
 667         } else {
 668                 return CDSCALENDAR_FAILED;
 669         }
 670
 671         // Delete the calendar.
 672
 673         resultCode = sqlite3_prepare_v2(db, "DELETE FROM calendars WHERE id=(?1);", -1, &statementHandle, nullptr);
 674
 675         if (resultCode != 0){
 676                 return CDSCALENDAR_FAILED;
 677         }
 678
 679         resultCode = sqlite3_bind_int(statementHandle, 1, calendarID);
 680
 681         if (resultCode != 0){
 682                 return CDSCALENDAR_FAILED;
 683         }
 684
 685         resultCode = sqlite3_step(statementHandle);
 686
 687         if (resultCode != SQLITE_DONE){
 688                 return CDSCALENDAR_FAILED;
 689         }
 690
 691         // Delete the calendar entries.
 692
 693         resultCode = sqlite3_prepare_v2(db, "DELETE FROM calendarentries WHERE calendarid=(?1);", -1, &entriesHandle, nullptr);
 694
 695         if (resultCode != 0){
 696                 return CDSCALENDAR_FAILED;
 697         }
 698
 699         resultCode = sqlite3_bind_int(entriesHandle, 1, calendarID);
 700
 701         if (resultCode != 0){
 702                 return CDSCALENDAR_FAILED;
 703         }
 704
 705         resultCode = sqlite3_step(entriesHandle);
 706
 707         if (resultCode == SQLITE_DONE){
 708                 deleteResult = CDSCALENDAR_OK;
 709         } else {
 710                 return CDSCALENDAR_FAILED;
 711         }
 712
 713         return deleteResult;
 714
 715 }
 716
 717 CDSAddEntryResult CalendarDataStorage::AddEvent(int calendarID, std::string filename)
 718 {
 719
 720         CDSAddEntryResult addResult;
 721         addResult.addEventResult = CDSENTRY_UNITTESTFAIL;
 722
 723         // Load the event file.
 724
 725         CalendarEventObject eventData;
 726         CalendarObjectLoadResult eventLoadResult = eventData.LoadFile(filename);
 727
 728         // Check the result of the event file load.
 729
 730         switch (eventLoadResult){
 731
 732                 case CALENDAROBJECTLOAD_OK:
 733                         break;
 734                 case CALENDAROBJECTLOAD_MISSING:
 735                         addResult.addEventResult = CDSENTRY_MISSINGFILE;
 736                         return addResult;
 737                 case CALENDAROBJECTLOAD_INVALIDFORMAT:
 738                         addResult.addEventResult = CDSENTRY_INVALIDFILE;
 739                         return addResult;
 740                 case CALENDAROBJECTLOAD_CANNOTOPEN:
 741                         addResult.addEventResult = CDSENTRY_CANNOTOPENFILE;
 742                         return addResult;
 743
 744         }
 745
 746         // Check if calendar exists first.
 747
 748         int resultCode;
 749
 750         sqlite3_stmt *findHandle;
 751         sqlite3_stmt *statementHandle;
 752
 753         resultCode = sqlite3_prepare_v2(db, "SELECT id from calendars WHERE id=(?1);", -1, &findHandle, nullptr);
 754
 755         if (resultCode != 0){
 756                 addResult.addEventResult = CDSENTRY_FAILED;
 757                 return addResult;
 758         }
 759
 760         resultCode = sqlite3_bind_int(findHandle, 1, calendarID);
 761
 762         if (resultCode != 0){
 763                 addResult.addEventResult = CDSENTRY_FAILED;
 764                 return addResult;
 765         }
 766
 767         resultCode = sqlite3_step(findHandle);
 768
 769         if (resultCode == SQLITE_ROW){
 770
 771         } else if (resultCode == SQLITE_DONE) {
 772                 addResult.addEventResult = CDSENTRY_NOCALENDAR;
 773                 return addResult;
 774         } else {
 775                 addResult.addEventResult = CDSENTRY_FAILED;
 776                 return addResult;
 777         }
 778
 779         // Get the required values from the event object.
 780
 781         int eventStartYear = 0;
 782         int eventStartMonth = 0;
 783         int eventStartDay = 0;
 784         int eventStartHour = 0;
 785         int eventStartMinute = 0;
 786         int eventStartSecond = 0;
 787         int eventStartDuration = 0;
 788         std::string eventString = "";
 789
 790         // Start Date.
 791
 792         if (eventData.DateTimeStartData.size() < 16){
 793
 794                 addResult.addEventResult = CDSENTRY_INVALIDFILE;
 795                 return addResult;
 796
 797         }
 798
 799         eventString = eventData.DateTimeStartData.substr(0,4);
 800
 801         if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
 802
 803                 eventStartYear = atoi(eventString.c_str());
 804
 805         } else {
 806
 807                 addResult.addEventResult = CDSENTRY_INVALIDFILE;
 808                 return addResult;
 809
 810         }
 811
 812         eventString = eventData.DateTimeStartData.substr(4,2);
 813
 814         if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
 815
 816                 eventStartMonth = atoi(eventString.c_str());
 817
 818         } else {
 819
 820                 addResult.addEventResult = CDSENTRY_INVALIDFILE;
 821                 return addResult;
 822
 823         }
 824
 825         eventString = eventData.DateTimeStartData.substr(6,2);
 826
 827         if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
 828
 829                 eventStartDay = atoi(eventString.c_str());
 830
 831         } else {
 832
 833                 addResult.addEventResult = CDSENTRY_INVALIDFILE;
 834                 return addResult;
 835
 836         }
 837
 838         eventString = eventData.DateTimeStartData.substr(9,2);
 839
 840         if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
 841
 842                 eventStartHour = atoi(eventString.c_str());
 843
 844         } else {
 845
 846                 addResult.addEventResult = CDSENTRY_INVALIDFILE;
 847                 return addResult;
 848
 849         }
 850
 851         eventString = eventData.DateTimeStartData.substr(11,2);
 852
 853         if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
 854
 855                 eventStartMinute = atoi(eventString.c_str());
 856
 857         } else {
 858
 859                 addResult.addEventResult = CDSENTRY_INVALIDFILE;
 860                 return addResult;
 861
 862         }
 863
 864         eventString = eventData.DateTimeStartData.substr(13,2);
 865
 866         if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
 867
 868                 eventStartSecond = atoi(eventString.c_str());
 869
 870         } else {
 871
 872                 addResult.addEventResult = CDSENTRY_INVALIDFILE;
 873                 return addResult;
 874
 875         }
 876
 877         //eventYear = eventStartDate.substr(0, 4);
 878
 879         // End Date.
 880
 881         int eventEndYear = 0;
 882         int eventEndMonth = 0;
 883         int eventEndDay = 0;
 884         int eventEndHour = 0;
 885         int eventEndMinute = 0;
 886         int eventEndSecond = 0;
 887         int eventEndDuration = 0;
 888
 889         if (eventData.DateTimeEndData != ""){
 890
 891                 if (eventData.DateTimeEndData.size() < 16){
 892
 893                         addResult.addEventResult = CDSENTRY_INVALIDFILE;
 894                         return addResult;
 895
 896                 }
 897
 898                 eventString = eventData.DateTimeEndData.substr(0,4);
 899
 900                 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
 901
 902                         eventEndYear = atoi(eventString.c_str());
 903
 904                 } else {
 905
 906                         addResult.addEventResult = CDSENTRY_INVALIDFILE;
 907                         return addResult;
 908
 909                 }
 910
 911                 eventString = eventData.DateTimeEndData.substr(4,2);
 912
 913                 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
 914
 915                         eventEndMonth = atoi(eventString.c_str());
 916
 917                 } else {
 918
 919                         addResult.addEventResult = CDSENTRY_INVALIDFILE;
 920                         return addResult;
 921
 922                 }
 923
 924                 eventString = eventData.DateTimeEndData.substr(6,2);
 925
 926                 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
 927
 928                         eventEndDay = atoi(eventString.c_str());
 929
 930                 } else {
 931
 932                         addResult.addEventResult = CDSENTRY_INVALIDFILE;
 933                         return addResult;
 934
 935                 }
 936
 937                 eventString = eventData.DateTimeEndData.substr(9,2);
 938
 939                 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
 940
 941                         eventEndHour = atoi(eventString.c_str());
 942
 943                 } else {
 944
 945                         addResult.addEventResult = CDSENTRY_INVALIDFILE;
 946                         return addResult;
 947
 948                 }
 949
 950                 eventString = eventData.DateTimeEndData.substr(11,2);
 951
 952                 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
 953
 954                         eventEndMinute = atoi(eventString.c_str());
 955
 956                 } else {
 957
 958                         addResult.addEventResult = CDSENTRY_INVALIDFILE;
 959                         return addResult;
 960
 961                 }
 962
 963                 eventString = eventData.DateTimeEndData.substr(13,2);
 964
 965                 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
 966
 967                         eventEndSecond = atoi(eventString.c_str());
 968
 969                 } else {
 970
 971                         addResult.addEventResult = CDSENTRY_INVALIDFILE;
 972                         return addResult;
 973
 974                 }
 975
 976         }
 977
 978         eventString = eventData.DurationData;
 979
 980         // Process the duration data.
 981
 982         int eventDurationWeeks = 0;
 983         int eventDurationDays = 0;
 984         int eventDurationHours = 0;
 985         int eventDurationMinutes = 0;
 986         int eventDurationSeconds = 0;
 987
 988         // Get the duration (if DTEND hasn't been specified).
 989
 990         if (eventData.DurationData.size() > 0){
 991
 992                 bool FoundP = false;
 993                 bool FoundW = false;
 994                 bool DateTimeMode = false;
 995
 996                 std::string::iterator eventDataChar = eventData.DurationData.begin();
 997                 std::string currentValue = "";
 998
 999                 if (*eventDataChar != 'P'){
1000
1001                         eventDataChar = eventData.DurationData.end();
1002
1003                 }
1004
1005                 for(eventDataChar; eventDataChar != eventData.DurationData.end(); eventDataChar++){
1006
1007                         // Check if value is a digit.
1008
1009                         if (isdigit(*eventDataChar)){
1010
1011                                 currentValue += *eventDataChar;
1012
1013                         } else {
1014
1015                                 // Check that the value matches one of the letters.
1016
1017                                 if (*eventDataChar == 'W' && DateTimeMode == false){
1018
1019                                         eventDurationWeeks = atoi(currentValue.c_str());
1020
1021                                 } else if (*eventDataChar == 'D' && DateTimeMode == false){
1022
1023                                         eventDurationDays = atoi(currentValue.c_str());
1024
1025                                 } else if (*eventDataChar == 'T' && DateTimeMode == false){
1026
1027                                         DateTimeMode = true;
1028
1029                                 } else if (*eventDataChar == 'H'){
1030
1031                                         eventDurationHours = atoi(currentValue.c_str());
1032
1033                                 } else if (*eventDataChar == 'M'){
1034
1035                                         eventDurationMinutes = atoi(currentValue.c_str());
1036
1037                                 } else if (*eventDataChar == 'S'){
1038
1039                                         eventDurationSeconds = atoi(currentValue.c_str());
1040
1041                                 }
1042
1043                                 // Reset the current value.
1044
1045                                 currentValue = "";
1046
1047                         }
1048
1049                 }
1050
1051         }
1052
1053         // Add the calendar entry.
1054
1055         std::string sqlParameter = "INSERT INTO calendarentries (calendarid, entryname, entrydescription,"
1056         " entrystartyear, entrystartmonth, entrystartday, entrystarthour, entrystartminute, entrystartsecond,"
1057         " entryendyear, entryendmonth, entryendday, entryendhour, entryendminute, entryendsecond, "
1058         " entrydurationweek, entrydurationday, entrydurationhour, entrydurationminute, entrydurationsecond)"
1059         " VALUES ((?1), (?2), (?3), (?4), (?5), (?6), (?7), (?8), (?9), (?10), "
1060         " (?11), (?12), (?13), (?14), (?15), (?16), (?17), (?18), (?19), (?20))";
1061
1062         resultCode = sqlite3_prepare_v2(db, sqlParameter.c_str(), -1, &statementHandle, nullptr);
1063
1064         resultCode = sqlite3_bind_int(statementHandle, 1, calendarID);
1065
1066         if (resultCode != 0){
1067                 addResult.addEventResult = CDSENTRY_FAILED;
1068                 return addResult;
1069         }
1070
1071         // Process Entry Name.
1072
1073         resultCode = sqlite3_bind_text(statementHandle, 2, eventData.SummaryData.c_str(), -1, SQLITE_STATIC);
1074
1075         if (resultCode != 0){
1076                 addResult.addEventResult = CDSENTRY_FAILED;
1077                 return addResult;
1078         }
1079
1080         // Process Entry Description.
1081
1082         string eventDescription;
1083
1084         try {
1085                 eventDescription = eventData.DescriptionList.at(0);
1086         }
1087
1088         catch (out_of_range &err){
1089                 eventDescription = "";
1090         }
1091
1092         resultCode = sqlite3_bind_text(statementHandle, 3, eventDescription.c_str(), -1, SQLITE_STATIC);
1093
1094         if (resultCode != 0){
1095                 addResult.addEventResult = CDSENTRY_FAILED;
1096                 return addResult;
1097         }
1098
1099         // Process Entry Start Date information.
1100
1101         resultCode = sqlite3_bind_int(statementHandle, 4, eventStartYear);
1102
1103         if (resultCode != 0){
1104                 addResult.addEventResult = CDSENTRY_FAILED;
1105                 return addResult;
1106         }
1107
1108         resultCode = sqlite3_bind_int(statementHandle, 5, eventStartMonth);
1109
1110         if (resultCode != 0){
1111                 addResult.addEventResult = CDSENTRY_FAILED;
1112                 return addResult;
1113         }
1114
1115         resultCode = sqlite3_bind_int(statementHandle, 6, eventStartDay);
1116
1117         if (resultCode != 0){
1118                 addResult.addEventResult = CDSENTRY_FAILED;
1119                 return addResult;
1120         }
1121
1122         resultCode = sqlite3_bind_int(statementHandle, 7, eventStartHour);
1123
1124         if (resultCode != 0){
1125                 addResult.addEventResult = CDSENTRY_FAILED;
1126                 return addResult;
1127         }
1128
1129         resultCode = sqlite3_bind_int(statementHandle, 8, eventStartMinute);
1130
1131         if (resultCode != 0){
1132                 addResult.addEventResult = CDSENTRY_FAILED;
1133                 return addResult;
1134         }
1135
1136         resultCode = sqlite3_bind_int(statementHandle, 9, eventStartSecond);
1137
1138         if (resultCode != 0){
1139                 addResult.addEventResult = CDSENTRY_FAILED;
1140                 return addResult;
1141         }
1142
1143         // Process Entry Start End information.
1144
1145         resultCode = sqlite3_bind_int(statementHandle, 10, eventEndYear);
1146
1147         if (resultCode != 0){
1148                 addResult.addEventResult = CDSENTRY_FAILED;
1149                 return addResult;
1150         }
1151
1152         resultCode = sqlite3_bind_int(statementHandle, 11, eventEndMonth);
1153
1154         if (resultCode != 0){
1155                 addResult.addEventResult = CDSENTRY_FAILED;
1156                 return addResult;
1157         }
1158
1159         resultCode = sqlite3_bind_int(statementHandle, 12, eventEndDay);
1160
1161         if (resultCode != 0){
1162                 addResult.addEventResult = CDSENTRY_FAILED;
1163                 return addResult;
1164         }
1165
1166         resultCode = sqlite3_bind_int(statementHandle, 13, eventEndHour);
1167
1168         if (resultCode != 0){
1169                 addResult.addEventResult = CDSENTRY_FAILED;
1170                 return addResult;
1171         }
1172
1173         resultCode = sqlite3_bind_int(statementHandle, 14, eventEndMinute);
1174
1175         if (resultCode != 0){
1176                 addResult.addEventResult = CDSENTRY_FAILED;
1177                 return addResult;
1178         }
1179
1180         resultCode = sqlite3_bind_int(statementHandle, 15, eventEndSecond);
1181
1182         if (resultCode != 0){
1183                 addResult.addEventResult = CDSENTRY_FAILED;
1184                 return addResult;
1185         }
1186
1187         resultCode = sqlite3_bind_int(statementHandle, 16, eventDurationWeeks);
1188
1189         if (resultCode != 0){
1190                 addResult.addEventResult = CDSENTRY_FAILED;
1191                 return addResult;
1192         }
1193
1194         resultCode = sqlite3_bind_int(statementHandle, 17, eventDurationDays);
1195
1196         if (resultCode != 0){
1197                 addResult.addEventResult = CDSENTRY_FAILED;
1198                 return addResult;
1199         }
1200
1201         resultCode = sqlite3_bind_int(statementHandle, 18, eventDurationHours);
1202
1203         if (resultCode != 0){
1204                 addResult.addEventResult = CDSENTRY_FAILED;
1205                 return addResult;
1206         }
1207
1208         resultCode = sqlite3_bind_int(statementHandle, 19, eventDurationMinutes);
1209
1210         if (resultCode != 0){
1211                 addResult.addEventResult = CDSENTRY_FAILED;
1212                 return addResult;
1213         }
1214
1215         resultCode = sqlite3_bind_int(statementHandle, 20, eventDurationSeconds);
1216
1217         if (resultCode != 0){
1218                 addResult.addEventResult = CDSENTRY_FAILED;
1219                 return addResult;
1220         }
1221
1222         resultCode = sqlite3_step(statementHandle);
1223
1224         if (resultCode != SQLITE_DONE){
1225                 addResult.addEventResult = CDSENTRY_FAILED;
1226                 return addResult;
1227         }
1228
1229         addResult.calendarEntryID = sqlite3_last_insert_rowid(db);
1230         addResult.addEventResult = CDSENTRY_OK;
1231
1232         return addResult;
1233
1234 }
1235
1236 CDSGetCalendarEntryInfo CalendarDataStorage::GetEvent(int calendarEntryID)
1237 {
1238
1239         CDSGetCalendarEntryInfo entryResult;
1240
1241         // Check if the calendar entry exists.
1242
1243         int resultCode;
1244
1245         sqlite3_stmt *findHandle;
1246         sqlite3_stmt *statementHandle;
1247
1248         resultCode = sqlite3_prepare_v2(db, "SELECT id FROM calendarentries WHERE id=(?1);", -1, &findHandle, nullptr);
1249
1250         if (resultCode != 0){
1251                 entryResult.getEventResult = CDSENTRY_FAILED;
1252                 return entryResult;
1253         }
1254
1255         resultCode = sqlite3_bind_int(findHandle, 1, calendarEntryID);
1256
1257         if (resultCode != 0){
1258                 entryResult.getEventResult = CDSENTRY_FAILED;
1259                 return entryResult;
1260         }
1261
1262         resultCode = sqlite3_step(findHandle);
1263
1264         if (resultCode == SQLITE_ROW){
1265
1266         } else if (resultCode == SQLITE_DONE) {
1267                 entryResult.getEventResult = CDSENTRY_NOENTRY;
1268                 return entryResult;
1269         } else {
1270                 entryResult.getEventResult = CDSENTRY_FAILED;
1271                 return entryResult;
1272         }
1273
1274         // Get the calendar entry data.
1275
1276         std::string sqlParameter = "SELECT entryname, entrydescription,"
1277         " entrystartyear, entrystartmonth, entrystartday, entrystarthour, entrystartminute, entrystartsecond,"
1278         " entryendyear, entryendmonth, entryendday, entryendhour, entryendminute, entryendsecond, "
1279         " entrydurationweek, entrydurationday, entrydurationhour, entrydurationminute, entrydurationsecond "
1280         " FROM calendarentries WHERE id=(?1)";
1281
1282         resultCode = sqlite3_prepare_v2(db, sqlParameter.c_str(), -1, &statementHandle, nullptr);
1283
1284         if (resultCode != 0){
1285                 entryResult.getEventResult = CDSENTRY_FAILED;
1286                 return entryResult;
1287         }
1288
1289         resultCode = sqlite3_bind_int(statementHandle, 1, calendarEntryID);
1290
1291         if (resultCode != 0){
1292                 entryResult.getEventResult = CDSENTRY_FAILED;
1293                 return entryResult;
1294         }
1295
1296         resultCode = sqlite3_step(statementHandle);
1297
1298         if (resultCode == SQLITE_ROW){
1299
1300                 // Get the calendar entry name,
1301
1302                 stringstream entryStream;
1303
1304                 entryStream << sqlite3_column_text(statementHandle, 0);
1305                 entryResult.entryName = entryStream.str();
1306
1307                 entryStream.str("");
1308
1309                 // Get the calendar entry description.
1310
1311                 entryStream << sqlite3_column_text(statementHandle, 1);
1312                 entryResult.entryDescription = entryStream.str();
1313
1314                 entryStream.str("");
1315
1316                 entryResult.entryStartYear = sqlite3_column_int(statementHandle, 2);
1317                 entryResult.entryStartMonth = sqlite3_column_int(statementHandle, 3);
1318                 entryResult.entryStartDay = sqlite3_column_int(statementHandle, 4);
1319                 entryResult.entryStartHour = sqlite3_column_int(statementHandle, 5);
1320                 entryResult.entryStartMinute = sqlite3_column_int(statementHandle, 6);
1321                 entryResult.entryStartSecond = sqlite3_column_int(statementHandle, 7);
1322                 entryResult.entryEndYear = sqlite3_column_int(statementHandle, 8);
1323                 entryResult.entryEndMonth = sqlite3_column_int(statementHandle, 9);
1324                 entryResult.entryEndDay = sqlite3_column_int(statementHandle, 10);
1325                 entryResult.entryEndHour = sqlite3_column_int(statementHandle, 11);
1326                 entryResult.entryEndMinute = sqlite3_column_int(statementHandle, 12);
1327                 entryResult.entryEndSecond = sqlite3_column_int(statementHandle, 13);
1328                 entryResult.entryDurationWeeks = sqlite3_column_int(statementHandle, 14);
1329                 entryResult.entryDurationDays = sqlite3_column_int(statementHandle, 15);
1330                 entryResult.entryDurationHours = sqlite3_column_int(statementHandle, 16);
1331                 entryResult.entryDurationMinutes = sqlite3_column_int(statementHandle, 17);
1332                 entryResult.entryDurationSeconds = sqlite3_column_int(statementHandle, 18);
1333
1334         } else if (resultCode == SQLITE_DONE) {
1335                 entryResult.getEventResult = CDSENTRY_NOCALENDAR;
1336                 return entryResult;
1337         } else {
1338                 entryResult.getEventResult = CDSENTRY_FAILED;
1339                 return entryResult;
1340         }
1341
1342         entryResult.getEventResult = CDSENTRY_OK;
1343
1344         return entryResult;
1345
1346 }
1347
1348 CDSEntryResult CalendarDataStorage::DeleteEvent(int calendarEntryID)
1349 {
1350
1351         CDSEntryResult deleteResult = CDSENTRY_UNITTESTFAIL;
1352
1353         // Check if the calendar entry exists.
1354
1355         int resultCode;
1356
1357         sqlite3_stmt *findHandle;
1358         sqlite3_stmt *statementHandle;
1359
1360         resultCode = sqlite3_prepare_v2(db, "SELECT id FROM calendarentries WHERE id=(?1);", -1, &findHandle, nullptr);
1361
1362         if (resultCode != 0){
1363                 return CDSENTRY_FAILED;
1364         }
1365
1366         resultCode = sqlite3_bind_int(findHandle, 1, calendarEntryID);
1367
1368         if (resultCode != 0){
1369                 return CDSENTRY_FAILED;
1370         }
1371
1372         resultCode = sqlite3_step(findHandle);
1373
1374         if (resultCode == SQLITE_ROW){
1375
1376         } else if (resultCode == SQLITE_DONE) {
1377                 return CDSENTRY_NOENTRY;
1378         } else {
1379                 return CDSENTRY_FAILED;
1380         }
1381
1382         // Delete the account.
1383
1384         resultCode = sqlite3_prepare_v2(db, "DELETE FROM calendarentries WHERE id=(?1);", -1, &statementHandle, nullptr);
1385
1386         if (resultCode != 0){
1387                 return CDSENTRY_FAILED;
1388         }
1389
1390         resultCode = sqlite3_bind_int(statementHandle, 1, calendarEntryID);
1391
1392         if (resultCode != 0){
1393                 return CDSENTRY_FAILED;
1394         }
1395
1396         resultCode = sqlite3_step(statementHandle);
1397
1398         if (resultCode == SQLITE_DONE){
1399                 deleteResult = CDSENTRY_OK;
1400         } else {
1401                 return CDSENTRY_FAILED;
1402         }
1403
1404         return deleteResult;
1405
1406 }
1407
1408 CDSEntryList CalendarDataStorage::GetEventList(int calendarID){
1409
1410         CDSEntryList entryList;
1411         entryList.getEventListResult = CDSENTRY_UNITTESTFAIL;
1412
1413         // Check if calendar exists first.
1414
1415         int resultCode;
1416
1417         sqlite3_stmt *findHandle;
1418         sqlite3_stmt *calendarHandle;
1419
1420         resultCode = sqlite3_prepare_v2(db, "SELECT id from calendars WHERE id=(?1);", -1, &findHandle, nullptr);
1421
1422         if (resultCode != 0){
1423                 entryList.getEventListResult = CDSENTRY_FAILED;
1424                 return entryList;
1425         }
1426
1427         resultCode = sqlite3_bind_int(findHandle, 1, calendarID);
1428
1429         if (resultCode != 0){
1430                 entryList.getEventListResult = CDSENTRY_FAILED;
1431                 return entryList;
1432         }
1433
1434         resultCode = sqlite3_step(findHandle);
1435
1436         if (resultCode == SQLITE_ROW){
1437
1438         } else if (resultCode == SQLITE_DONE) {
1439                 entryList.getEventListResult = CDSENTRY_NOCALENDAR;
1440                 return entryList;
1441         } else {
1442                 entryList.getEventListResult = CDSENTRY_FAILED;
1443                 return entryList;
1444         }
1445
1446         // Get the list of entry IDs.
1447
1448         resultCode = sqlite3_prepare_v2(db, "SELECT id FROM calendarentries WHERE calendarid=(?1);", -1, &calendarHandle, nullptr);
1449
1450         if (resultCode != 0){
1451                 entryList.getEventListResult = CDSENTRY_FAILED;
1452                 return entryList;
1453         }
1454
1455         resultCode = sqlite3_bind_int(calendarHandle, 1, calendarID);
1456
1457         if (resultCode != 0){
1458                 entryList.getEventListResult = CDSENTRY_FAILED;
1459                 return entryList;
1460         }
1461
1462         resultCode = sqlite3_step(calendarHandle);
1463
1464         if (resultCode == SQLITE_DONE || resultCode == SQLITE_ROW){
1465         } else {
1466                 entryList.getEventListResult = CDSENTRY_FAILED;
1467                 return entryList;
1468         }
1469
1470         while (resultCode == SQLITE_ROW){
1471
1472                 int calendarID = sqlite3_column_int(calendarHandle, 0);
1473
1474                 entryList.entryList.push_back(calendarID);
1475
1476                 resultCode = sqlite3_step(calendarHandle);
1477
1478         }
1479
1480         entryList.getEventListResult = CDSENTRY_OK;
1481
1482         return entryList;
1483
1484 }
1485
1486 CDSCalendarList CalendarDataStorage::GetCalendarList(int accountID){
1487
1488         CDSCalendarList calendarList;
1489         calendarList.getCalendarListResult = CDSCALENDAR_UNITTESTFAIL;
1490
1491         // Check if calendar exists first.
1492
1493         int resultCode;
1494
1495         sqlite3_stmt *findHandle;
1496         sqlite3_stmt *calendarHandle;
1497
1498         resultCode = sqlite3_prepare_v2(db, "SELECT id from accounts WHERE id=(?1);", -1, &findHandle, nullptr);
1499
1500         if (resultCode != 0){
1501                 calendarList.getCalendarListResult = CDSCALENDAR_FAILED;
1502                 return calendarList;
1503         }
1504
1505         resultCode = sqlite3_bind_int(findHandle, 1, accountID);
1506
1507         if (resultCode != 0){
1508                 calendarList.getCalendarListResult = CDSCALENDAR_FAILED;
1509                 return calendarList;
1510         }
1511
1512         resultCode = sqlite3_step(findHandle);
1513
1514         if (resultCode == SQLITE_ROW){
1515
1516         } else if (resultCode == SQLITE_DONE) {
1517                 calendarList.getCalendarListResult = CDSCALENDAR_NOCALENDAR;
1518                 return calendarList;
1519         } else {
1520                 calendarList.getCalendarListResult = CDSCALENDAR_FAILED;
1521                 return calendarList;
1522         }
1523
1524         // Get the list of entry IDs.
1525
1526         resultCode = sqlite3_prepare_v2(db, "SELECT id, calendarid FROM calendars WHERE accountid=(?1);", -1, &calendarHandle, nullptr);
1527
1528         if (resultCode != 0){
1529                 calendarList.getCalendarListResult = CDSCALENDAR_FAILED;
1530                 return calendarList;
1531         }
1532
1533         resultCode = sqlite3_bind_int(calendarHandle, 1, accountID);
1534
1535         if (resultCode != 0){
1536                 calendarList.getCalendarListResult = CDSCALENDAR_FAILED;
1537                 return calendarList;
1538         }
1539
1540         resultCode = sqlite3_step(calendarHandle);
1541
1542         if (resultCode == SQLITE_DONE || resultCode == SQLITE_ROW){
1543         } else {
1544                 calendarList.getCalendarListResult = CDSCALENDAR_FAILED;
1545                 return calendarList;
1546         }
1547
1548         while (resultCode == SQLITE_ROW){
1549
1550                 int calendarID = sqlite3_column_int(calendarHandle, 0);
1551
1552                 stringstream calendarStream;
1553
1554                 calendarStream << sqlite3_column_text(calendarHandle, 1);
1555
1556                 calendarList.calendarList.push_back(calendarID);
1557                 calendarList.calendarListTextID.push_back(calendarStream.str());
1558
1559                 calendarStream.str("");
1560
1561                 resultCode = sqlite3_step(calendarHandle);
1562
1563         }
1564
1565         calendarList.getCalendarListResult = CDSCALENDAR_OK;
1566
1567         return calendarList;
1568
1569 }