1 // CalendarDataStorage.cpp - CalendarDataStorage class
3 // (c) 2016-2017 Xestia Software Development.
5 // This file is part of Xestia Calendar.
7 // Xestia Calendar 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.
11 // Xestia Calendar 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.
16 // You should have received a copy of the GNU General Public License along
17 // with Xestia Calendar. If not, see <http://www.gnu.org/licenses/>
19 #include "CalendarDataStorage.h"
21 #define CDS_RANDOMPOW 24
25 static int callback(void *NotUsed, int argc, char **argv, char **azColName){
29 CalendarDataStorage::CalendarDataStorage(){
31 // Initialise the SQLite database.
33 sqlite3_open_v2(":memory:", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_FULLMUTEX, nullptr);
38 CalendarDataStorage::~CalendarDataStorage(){
40 // Destory the SQLite database.
46 void CalendarDataStorage::SetupTables(){
48 // Setup the tables for the Calendar Data Storage.
50 char *setupTablesErrMsg = nullptr;
53 // Setup the accounts table.
55 const char *accountsTableString;
56 accountsTableString = "CREATE TABLE accounts(id INTEGER PRIMARY KEY AUTOINCREMENT"
57 ", preferencesid INTEGER"
61 resultCode = sqlite3_exec(db, accountsTableString, callback, nullptr, &setupTablesErrMsg);
64 DataStorageInitOK = false;
68 // Setup the calendars table.
70 const char *calendarTableString;
71 calendarTableString = "CREATE TABLE calendars(id INTEGER PRIMARY KEY AUTOINCREMENT"
79 resultCode = sqlite3_exec(db, calendarTableString, callback, nullptr, &setupTablesErrMsg);
82 DataStorageInitOK = false;
86 // Setup the calendar entries table.
88 const char *calendarentriesTableString;
89 calendarentriesTableString = "CREATE TABLE calendarentries(id INTEGER PRIMARY KEY AUTOINCREMENT"
90 ", calendarid INTEGER"
92 ", entrydescription TEXT"
93 ", entrystartyear INTEGER"
94 ", entrystartmonth INTEGER"
95 ", entrystartday INTEGER"
96 ", entrystarthour INTEGER"
97 ", entrystartminute INTEGER"
98 ", entrystartsecond INTEGER"
99 ", entryendyear INTEGER"
100 ", entryendmonth INTEGER"
101 ", entryendday INTEGER"
102 ", entryendhour INTEGER"
103 ", entryendminute INTEGER"
104 ", entryendsecond INTEGER"
105 ", entrydurationweek INTEGER"
106 ", entrydurationday INTEGER"
107 ", entrydurationhour INTEGER"
108 ", entrydurationminute INTEGER"
109 ", entrydurationsecond INTEGER"
113 resultCode = sqlite3_exec(db, calendarentriesTableString, callback, nullptr, &setupTablesErrMsg);
115 if (resultCode != 0){
116 DataStorageInitOK = false;
120 // Setup the checksums table.
122 const char *checksumsTableString;
123 checksumsTableString = "CREATE TABLE checksums(checksumname TEXT PRIMARY KEY "
124 ", checksumvalue TEXT);";
126 resultCode = sqlite3_exec(db, checksumsTableString, callback, nullptr, &setupTablesErrMsg);
128 if (resultCode != 0){
129 DataStorageInitOK = false;
133 // Setup internal checksums.
135 CDSChecksumResult addChecksum = AddChecksum("internal_updatedata", "");
137 if (addChecksum != CDSCHECKSUM_OK){
138 DataStorageInitOK = false;
142 DataStorageInitOK = true;
146 bool CalendarDataStorage::DidInitOK()
149 return DataStorageInitOK;
153 CDSAccountResult CalendarDataStorage::AddAccount(string accountName, int accountPreferencesID)
156 CDSAccountResult addResult = CDSACCOUNT_UNITTESTFAIL;
159 sqlite3_stmt *statementHandle;
160 sqlite3_stmt *findHandle;
162 if (accountName == ""){
163 return CDSACCOUNT_NONAME;
166 // Check if the account name already exsits.
168 resultCode = sqlite3_prepare_v2(db, "SELECT name FROM accounts WHERE name=(?1);", -1, &findHandle, nullptr);
170 if (resultCode != 0){
171 return CDSACCOUNT_FAILED;
174 resultCode = sqlite3_bind_text(findHandle, 1, accountName.c_str(), -1, SQLITE_STATIC);
176 if (resultCode != 0){
177 return CDSACCOUNT_FAILED;
180 resultCode = sqlite3_step(findHandle);
182 if (resultCode != SQLITE_DONE){
183 return CDSACCOUNT_FAILED;
184 } else if (resultCode == SQLITE_ROW){
185 return CDSACCOUNT_FAILED;
188 resultCode = sqlite3_prepare_v2(db, "INSERT INTO accounts (name, preferencesid) VALUES(?1, ?2);", -1, &statementHandle, nullptr);
190 if (resultCode != 0){
191 return CDSACCOUNT_FAILED;
194 resultCode = sqlite3_bind_text(statementHandle, 1, accountName.c_str(), -1, SQLITE_STATIC);
196 if (resultCode != 0){
197 return CDSACCOUNT_FAILED;
200 resultCode = sqlite3_bind_int(statementHandle, 2, accountPreferencesID);
202 if (resultCode != 0){
203 return CDSACCOUNT_FAILED;
206 resultCode = sqlite3_step(statementHandle);
208 if (resultCode != SQLITE_DONE){
209 return CDSACCOUNT_FAILED;
212 // Update the checksum.
214 UpdateChecksum("internal_updatedata", to_string(GenerateRandomNumber(CDS_RANDOMPOW)));
216 addResult = CDSACCOUNT_OK;
222 CDSAccountList CalendarDataStorage::GetAccountList()
225 CDSAccountList accountList;
227 // Check if calendar exists first.
231 sqlite3_stmt *statementHandle;
233 resultCode = sqlite3_prepare_v2(db, "SELECT id, name, preferencesid from accounts;", -1, &statementHandle, nullptr);
235 if (resultCode != 0){
236 accountList.getAccountListResult = CDSACCOUNT_FAILED;
240 if (resultCode != 0){
241 accountList.getAccountListResult = CDSACCOUNT_FAILED;
245 resultCode = sqlite3_step(statementHandle);
247 if (resultCode == SQLITE_ROW){
249 } else if (resultCode == SQLITE_DONE) {
250 accountList.getAccountListResult = CDSACCOUNT_NOACCOUNT;
253 accountList.getAccountListResult = CDSACCOUNT_FAILED;
257 while (resultCode == SQLITE_ROW){
259 CDSGetAccountInfo accountInfo;
261 accountInfo.accountID = sqlite3_column_int(statementHandle, 0);
262 accountInfo.accountPreferencesID = sqlite3_column_int(statementHandle, 2);
264 stringstream calendarStream;
266 calendarStream << sqlite3_column_text(statementHandle, 1);
268 accountInfo.accountName = calendarStream.str();
269 accountInfo.accountInfoResult = CDSACCOUNT_OK;
271 accountList.accountList.push_back(accountInfo);
273 resultCode = sqlite3_step(statementHandle);
277 accountList.getAccountListResult = CDSACCOUNT_OK;
283 CDSGetAccountInfo CalendarDataStorage::GetAccount(string accountName)
286 CDSGetAccountInfo accountInfo;
287 accountInfo.accountInfoResult = CDSACCOUNT_UNITTESTFAIL;
290 sqlite3_stmt *statementHandle;
292 resultCode = sqlite3_prepare_v2(db, "SELECT name, id, preferencesid FROM accounts WHERE name=(?1);", -1, &statementHandle, nullptr);
294 if (resultCode != 0){
295 accountInfo.accountInfoResult = CDSACCOUNT_FAILED;
299 resultCode = sqlite3_bind_text(statementHandle, 1, accountName.c_str(), -1, SQLITE_STATIC);
301 if (resultCode != 0){
302 accountInfo.accountInfoResult = CDSACCOUNT_FAILED;
306 resultCode = sqlite3_step(statementHandle);
308 if (resultCode == SQLITE_DONE){
310 accountInfo.accountInfoResult = CDSACCOUNT_NOACCOUNT;
313 } else if (resultCode == SQLITE_ROW){
315 // Get the result data.
317 stringstream accountNameStream;
319 accountNameStream << sqlite3_column_text(statementHandle, 0);
321 accountInfo.accountName = accountNameStream.str();
322 accountInfo.accountID = sqlite3_column_int(statementHandle, 1);
323 accountInfo.accountPreferencesID = sqlite3_column_int(statementHandle, 2);
325 accountInfo.accountInfoResult = CDSACCOUNT_OK;
330 accountInfo.accountInfoResult = CDSACCOUNT_FAILED;
339 CDSAccountResult CalendarDataStorage::UpdateAccount(int accountID, string accountName)
342 CDSAccountResult updateResult = CDSACCOUNT_UNITTESTFAIL;
345 sqlite3_stmt *findHandle;
346 sqlite3_stmt *existingHandle;
347 sqlite3_stmt *statementHandle;
349 if (accountName == ""){
350 return CDSACCOUNT_NONAME;
353 // Check if account exists first.
355 resultCode = sqlite3_prepare_v2(db, "SELECT id from accounts WHERE id=(?1);", -1, &findHandle, nullptr);
357 if (resultCode != 0){
358 return CDSACCOUNT_FAILED;
361 resultCode = sqlite3_bind_int(findHandle, 1, accountID);
363 if (resultCode != 0){
364 return CDSACCOUNT_FAILED;
367 resultCode = sqlite3_step(findHandle);
369 if (resultCode == SQLITE_ROW){
371 } else if (resultCode == SQLITE_DONE) {
372 return CDSACCOUNT_NOACCOUNT;
374 return CDSACCOUNT_FAILED;
377 // Check if account with the name given already exists before renaming.
379 resultCode = sqlite3_prepare_v2(db, "SELECT name from accounts WHERE name=(?1);", -1, &existingHandle, nullptr);
381 if (resultCode != 0){
382 return CDSACCOUNT_FAILED;
385 resultCode = sqlite3_bind_text(existingHandle, 1, accountName.c_str(), -1, SQLITE_STATIC);
387 if (resultCode != 0){
388 return CDSACCOUNT_FAILED;
391 resultCode = sqlite3_step(existingHandle);
393 if (resultCode == SQLITE_ROW){
394 return CDSACCOUNT_FAILED;
395 } else if (resultCode == SQLITE_DONE) {
398 return CDSACCOUNT_FAILED;
401 // Update the account.
403 resultCode = sqlite3_prepare_v2(db, "UPDATE accounts SET name=(?1) WHERE id=(?2);", -1, &statementHandle, nullptr);
405 if (resultCode != 0){
406 return CDSACCOUNT_FAILED;
409 resultCode = sqlite3_bind_text(statementHandle, 1, accountName.c_str(), -1, SQLITE_STATIC);
411 if (resultCode != 0){
412 return CDSACCOUNT_FAILED;
415 resultCode = sqlite3_bind_int(statementHandle, 2, accountID);
417 if (resultCode != 0){
418 return CDSACCOUNT_FAILED;
421 resultCode = sqlite3_step(statementHandle);
423 if (resultCode != SQLITE_DONE){
424 return CDSACCOUNT_FAILED;
427 // Update the checksum.
429 UpdateChecksum("internal_updatedata", to_string(GenerateRandomNumber(CDS_RANDOMPOW)));
431 updateResult = CDSACCOUNT_OK;
437 CDSAccountResult CalendarDataStorage::DeleteAccount(int accountID)
440 CDSAccountResult deleteResult = CDSACCOUNT_UNITTESTFAIL;
442 // Check if account exists first.
444 sqlite3_stmt *findHandle;
445 sqlite3_stmt *statementHandle;
446 sqlite3_stmt *calendarHandle;
449 resultCode = sqlite3_prepare_v2(db, "SELECT id from accounts WHERE id=(?1);", -1, &findHandle, nullptr);
451 if (resultCode != 0){
452 return CDSACCOUNT_FAILED;
455 resultCode = sqlite3_bind_int(findHandle, 1, accountID);
457 if (resultCode != 0){
458 return CDSACCOUNT_FAILED;
461 resultCode = sqlite3_step(findHandle);
463 if (resultCode == SQLITE_ROW){
465 } else if (resultCode == SQLITE_DONE) {
466 return CDSACCOUNT_NOACCOUNT;
471 // Delete the account.
473 resultCode = sqlite3_prepare_v2(db, "DELETE FROM accounts WHERE id=(?1);", -1, &statementHandle, nullptr);
475 if (resultCode != 0){
476 return CDSACCOUNT_FAILED;
479 resultCode = sqlite3_bind_int(statementHandle, 1, accountID);
481 if (resultCode != 0){
482 return CDSACCOUNT_FAILED;
485 resultCode = sqlite3_step(statementHandle);
487 if (resultCode == SQLITE_DONE){
488 //deleteResult = CDSACCOUNT_OK;
490 return CDSACCOUNT_FAILED;
493 // Get the calendar IDs and delete each calendar (and associated entries).
495 resultCode = sqlite3_prepare_v2(db, "SELECT id FROM calendars WHERE accountid=(?1);", -1, &calendarHandle, nullptr);
497 if (resultCode != 0){
498 return CDSACCOUNT_FAILED;
501 resultCode = sqlite3_bind_int(calendarHandle, 1, accountID);
503 if (resultCode != 0){
504 return CDSACCOUNT_FAILED;
507 resultCode = sqlite3_step(calendarHandle);
509 if (resultCode == SQLITE_DONE || resultCode == SQLITE_ROW){
510 deleteResult = CDSACCOUNT_OK;
512 return CDSACCOUNT_FAILED;
515 while (resultCode == SQLITE_ROW){
517 int calendarDeleteID = sqlite3_column_int(calendarHandle, 0);
519 DeleteCalendar(calendarDeleteID);
521 resultCode = sqlite3_step(calendarHandle);
525 // Update the checksum.
527 UpdateChecksum("internal_updatedata", to_string(GenerateRandomNumber(CDS_RANDOMPOW)));
529 deleteResult = CDSACCOUNT_OK;
536 CDSCalendarResult CalendarDataStorage::AddCalendar(int accountID, string calendarName, string calendarID, Colour calendarColour, string calendarDescription)
539 CDSCalendarResult addResult = CDSCALENDAR_UNITTESTFAIL;
542 sqlite3_stmt *findHandle;
543 sqlite3_stmt *statementHandle;
545 // Check if the account exists first.
547 resultCode = sqlite3_prepare_v2(db, "SELECT id FROM accounts WHERE id=(?1);", -1, &findHandle, nullptr);
549 if (resultCode != 0){
550 return CDSCALENDAR_FAILED;
553 resultCode = sqlite3_bind_int(findHandle, 1, accountID);
555 if (resultCode != 0){
556 return CDSCALENDAR_FAILED;
559 resultCode = sqlite3_step(findHandle);
561 if (resultCode != SQLITE_ROW){
562 return CDSCALENDAR_NOACCOUNT;
565 resultCode = sqlite3_prepare_v2(db, "INSERT INTO calendars (name, calendarid, accountid, colour, description) VALUES(?1, ?2, ?3, ?4, ?5);", -1, &statementHandle, nullptr);
567 if (resultCode != 0){
568 return CDSCALENDAR_FAILED;
571 resultCode = sqlite3_bind_text(statementHandle, 1, calendarName.c_str(), -1, SQLITE_STATIC);
573 if (resultCode != 0){
574 return CDSCALENDAR_FAILED;
577 resultCode = sqlite3_bind_text(statementHandle, 2, calendarID.c_str(), -1, SQLITE_STATIC);
579 if (resultCode != 0){
580 return CDSCALENDAR_FAILED;
583 resultCode = sqlite3_bind_int(statementHandle, 3, accountID);
585 if (resultCode != 0){
586 return CDSCALENDAR_FAILED;
589 string calendarColourString = (string)calendarColour;
590 resultCode = sqlite3_bind_text(statementHandle, 4, calendarColourString.c_str(), -1, SQLITE_STATIC);
592 if (resultCode != 0){
593 return CDSCALENDAR_FAILED;
596 resultCode = sqlite3_bind_text(statementHandle, 5, calendarDescription.c_str(), -1, SQLITE_STATIC);
598 if (resultCode != 0){
599 return CDSCALENDAR_FAILED;
602 resultCode = sqlite3_step(statementHandle);
604 if (resultCode != SQLITE_DONE){
605 return CDSCALENDAR_FAILED;
608 // Update the checksum.
610 UpdateChecksum("internal_updatedata", to_string(GenerateRandomNumber(CDS_RANDOMPOW)));
612 addResult = CDSCALENDAR_OK;
618 CDSGetCalendarInfo CalendarDataStorage::GetCalendar(std::string accountName, std::string calendarTextID)
621 CDSGetAccountInfo accountResult;
622 CDSGetCalendarInfo calendarResult;
623 sqlite3_stmt *statementHandle;
626 // Check if the account exists.
628 accountResult = GetAccount(accountName);
630 switch (accountResult.accountInfoResult){
633 calendarResult.accountName = accountResult.accountName;
634 calendarResult.accountInfoResult = CDSACCOUNT_OK;
636 case CDSACCOUNT_FAILED:
637 calendarResult.accountInfoResult = CDSACCOUNT_FAILED;
638 calendarResult.calendarInfoResult = CDSCALENDAR_FAILED;
639 return calendarResult;
640 case CDSACCOUNT_NOACCOUNT:
641 calendarResult.accountInfoResult = CDSACCOUNT_NOACCOUNT;
642 calendarResult.calendarInfoResult = CDSCALENDAR_NOCALENDAR;
643 return calendarResult;
647 // Check if the calendar exists.
649 resultCode = sqlite3_prepare_v2(db, "SELECT id, accountid, name, calendarid, colour, description FROM calendars WHERE accountid=(?1) AND calendarid=(?2);", -1, &statementHandle, nullptr);
651 if (resultCode != 0){
652 calendarResult.calendarInfoResult = CDSCALENDAR_FAILED;
653 return calendarResult;
656 resultCode = sqlite3_bind_int(statementHandle, 1, accountResult.accountID);
658 if (resultCode != 0){
659 calendarResult.calendarInfoResult = CDSCALENDAR_FAILED;
660 return calendarResult;
663 resultCode = sqlite3_bind_text(statementHandle, 2, calendarTextID.c_str(), -1, SQLITE_STATIC);
665 if (resultCode != 0){
666 calendarResult.calendarInfoResult = CDSCALENDAR_FAILED;
667 return calendarResult;
670 resultCode = sqlite3_step(statementHandle);
672 if (resultCode == SQLITE_DONE){
674 calendarResult.calendarInfoResult = CDSCALENDAR_NOCALENDAR;
675 return calendarResult;
677 } else if (resultCode == SQLITE_ROW){
679 // Get the calendar name.
681 stringstream calendarStream;
683 calendarStream << sqlite3_column_text(statementHandle, 2);
684 calendarResult.calendarName = calendarStream.str();
686 calendarStream.str("");
687 calendarStream << sqlite3_column_text(statementHandle, 3);
688 calendarResult.calendarTextID = calendarStream.str();
690 calendarStream.str("");
691 calendarStream << sqlite3_column_text(statementHandle, 4);
692 calendarResult.calendarColour = calendarStream.str();
694 calendarStream.str("");
695 calendarStream << sqlite3_column_text(statementHandle, 5);
696 calendarResult.calendarDescription = calendarStream.str();
698 calendarResult.calendarID = sqlite3_column_int(statementHandle, 0);
699 calendarResult.accountID = sqlite3_column_int(statementHandle, 1);
700 calendarResult.calendarInfoResult = CDSCALENDAR_OK;
701 return calendarResult;
705 calendarResult.calendarInfoResult = CDSCALENDAR_FAILED;
706 return calendarResult;
710 return calendarResult;
714 CDSGetCalendarInfo CalendarDataStorage::GetCalendar(int calendarID)
717 CDSGetCalendarInfo calendarResult;
718 sqlite3_stmt *statementHandle;
719 sqlite3_stmt *accountHandle;
722 // Check if the calendar exists.
724 resultCode = sqlite3_prepare_v2(db, "SELECT id, accountid, name, calendarid, colour, description FROM calendars WHERE id=(?1);", -1, &statementHandle, nullptr);
726 if (resultCode != 0){
727 calendarResult.calendarInfoResult = CDSCALENDAR_FAILED;
728 return calendarResult;
731 resultCode = sqlite3_bind_int(statementHandle, 1, calendarID);
733 if (resultCode != 0){
734 calendarResult.calendarInfoResult = CDSCALENDAR_FAILED;
735 return calendarResult;
738 resultCode = sqlite3_step(statementHandle);
740 if (resultCode == SQLITE_DONE){
742 calendarResult.calendarInfoResult = CDSCALENDAR_NOCALENDAR;
743 return calendarResult;
745 } else if (resultCode == SQLITE_ROW){
747 // Get the calendar data.
749 stringstream calendarStream;
751 calendarStream << sqlite3_column_text(statementHandle, 2);
752 calendarResult.calendarName = calendarStream.str();
754 calendarStream.str("");
755 calendarStream << sqlite3_column_text(statementHandle, 3);
756 calendarResult.calendarTextID = calendarStream.str();
758 calendarStream.str("");
759 calendarStream << sqlite3_column_text(statementHandle, 4);
760 calendarResult.calendarColour = calendarStream.str();
762 calendarStream.str("");
763 calendarStream << sqlite3_column_text(statementHandle, 5);
764 calendarResult.calendarDescription = calendarStream.str();
766 calendarResult.calendarID = sqlite3_column_int(statementHandle, 0);
767 calendarResult.accountID = sqlite3_column_int(statementHandle, 1);
769 // Get the account name.
771 resultCode = sqlite3_prepare_v2(db, "SELECT name FROM accounts WHERE id=(?1);", -1, &accountHandle, nullptr);
773 if (resultCode != 0){
774 calendarResult.calendarInfoResult = CDSCALENDAR_FAILED;
775 return calendarResult;
778 resultCode = sqlite3_bind_int(accountHandle, 1, calendarResult.accountID);
780 if (resultCode != 0){
781 calendarResult.calendarInfoResult = CDSCALENDAR_FAILED;
782 return calendarResult;
785 resultCode = sqlite3_step(accountHandle);
787 if (resultCode == SQLITE_ROW){
789 stringstream accountStream;
790 accountStream << sqlite3_column_text(accountHandle, 0);
791 calendarResult.accountName = accountStream.str();
792 calendarResult.accountInfoResult = CDSACCOUNT_OK;
796 calendarResult.accountInfoResult = CDSACCOUNT_FAILED;
800 calendarResult.calendarInfoResult = CDSCALENDAR_OK;
801 return calendarResult;
805 calendarResult.calendarInfoResult = CDSCALENDAR_FAILED;
806 return calendarResult;
810 return calendarResult;
815 CDSCalendarResult CalendarDataStorage::UpdateCalendar(int calendarID, string calendarName, Colour calendarColour, std::string calendarDescription)
818 CDSCalendarResult updateResult = CDSCALENDAR_UNITTESTFAIL;
821 sqlite3_stmt *findHandle;
822 sqlite3_stmt *statementHandle;
824 // Check if calendar exists first.
826 resultCode = sqlite3_prepare_v2(db, "SELECT id from calendars WHERE id=(?1);", -1, &findHandle, nullptr);
828 if (resultCode != 0){
829 return CDSCALENDAR_FAILED;
832 resultCode = sqlite3_bind_int(findHandle, 1, calendarID);
834 if (resultCode != 0){
835 return CDSCALENDAR_FAILED;
838 resultCode = sqlite3_step(findHandle);
840 if (resultCode == SQLITE_ROW){
842 } else if (resultCode == SQLITE_DONE) {
843 return CDSCALENDAR_NOCALENDAR;
845 return CDSCALENDAR_FAILED;
848 // Update the account.
850 resultCode = sqlite3_prepare_v2(db, "UPDATE calendars SET name=(?1), colour=(?2), description=(?3) WHERE id=(?4);", -1, &statementHandle, nullptr);
852 if (resultCode != 0){
853 return CDSCALENDAR_FAILED;
856 resultCode = sqlite3_bind_text(statementHandle, 1, calendarName.c_str(), -1, SQLITE_STATIC);
858 if (resultCode != 0){
859 return CDSCALENDAR_FAILED;
862 string calendarColourString = calendarColour;
863 resultCode = sqlite3_bind_text(statementHandle, 2, calendarColourString.c_str(), -1, SQLITE_STATIC);
865 if (resultCode != 0){
866 return CDSCALENDAR_FAILED;
869 resultCode = sqlite3_bind_text(statementHandle, 3, calendarDescription.c_str(), -1, SQLITE_STATIC);
871 if (resultCode != 0){
872 return CDSCALENDAR_FAILED;
875 resultCode = sqlite3_bind_int(statementHandle, 4, calendarID);
877 if (resultCode != 0){
878 return CDSCALENDAR_FAILED;
881 resultCode = sqlite3_step(statementHandle);
883 if (resultCode != SQLITE_DONE){
884 return CDSCALENDAR_FAILED;
887 // Update the checksum.
889 UpdateChecksum("internal_updatedata", to_string(GenerateRandomNumber(CDS_RANDOMPOW)));
891 updateResult = CDSCALENDAR_OK;
897 CDSCalendarResult CalendarDataStorage::DeleteCalendar(int calendarID)
900 CDSCalendarResult deleteResult = CDSCALENDAR_UNITTESTFAIL;
902 // Check if account exists first.
904 sqlite3_stmt *findHandle;
905 sqlite3_stmt *statementHandle;
906 sqlite3_stmt *entriesHandle;
909 resultCode = sqlite3_prepare_v2(db, "SELECT id from calendars WHERE id=(?1);", -1, &findHandle, nullptr);
911 if (resultCode != 0){
912 return CDSCALENDAR_FAILED;
915 resultCode = sqlite3_bind_int(findHandle, 1, calendarID);
917 if (resultCode != 0){
918 return CDSCALENDAR_FAILED;
921 resultCode = sqlite3_step(findHandle);
923 if (resultCode == SQLITE_ROW){
925 } else if (resultCode == SQLITE_DONE) {
926 return CDSCALENDAR_NOCALENDAR;
928 return CDSCALENDAR_FAILED;
931 // Delete the calendar.
933 resultCode = sqlite3_prepare_v2(db, "DELETE FROM calendars WHERE id=(?1);", -1, &statementHandle, nullptr);
935 if (resultCode != 0){
936 return CDSCALENDAR_FAILED;
939 resultCode = sqlite3_bind_int(statementHandle, 1, calendarID);
941 if (resultCode != 0){
942 return CDSCALENDAR_FAILED;
945 resultCode = sqlite3_step(statementHandle);
947 if (resultCode != SQLITE_DONE){
948 return CDSCALENDAR_FAILED;
951 // Delete the calendar entries.
953 resultCode = sqlite3_prepare_v2(db, "DELETE FROM calendarentries WHERE calendarid=(?1);", -1, &entriesHandle, nullptr);
955 if (resultCode != 0){
956 return CDSCALENDAR_FAILED;
959 resultCode = sqlite3_bind_int(entriesHandle, 1, calendarID);
961 if (resultCode != 0){
962 return CDSCALENDAR_FAILED;
965 resultCode = sqlite3_step(entriesHandle);
967 if (resultCode == SQLITE_DONE){
968 deleteResult = CDSCALENDAR_OK;
970 return CDSCALENDAR_FAILED;
973 // Update the checksum.
975 UpdateChecksum("internal_updatedata", to_string(GenerateRandomNumber(CDS_RANDOMPOW)));
981 CDSAddEntryResult CalendarDataStorage::AddEvent(int calendarID, std::string filename)
984 CDSAddEntryResult addResult;
985 addResult.addEventResult = CDSENTRY_UNITTESTFAIL;
987 // Load the event file.
989 CalendarEventObject eventData;
990 CalendarObjectLoadResult eventLoadResult = eventData.LoadFile(filename);
992 // Check the result of the event file load.
994 switch (eventLoadResult){
996 case CALENDAROBJECTLOAD_OK:
998 case CALENDAROBJECTLOAD_MISSING:
999 addResult.addEventResult = CDSENTRY_MISSINGFILE;
1001 case CALENDAROBJECTLOAD_INVALIDFORMAT:
1002 addResult.addEventResult = CDSENTRY_INVALIDFILE;
1004 case CALENDAROBJECTLOAD_CANNOTOPEN:
1005 addResult.addEventResult = CDSENTRY_CANNOTOPENFILE;
1010 // Check if calendar exists first.
1014 sqlite3_stmt *findHandle;
1015 sqlite3_stmt *statementHandle;
1017 resultCode = sqlite3_prepare_v2(db, "SELECT id from calendars WHERE id=(?1);", -1, &findHandle, nullptr);
1019 if (resultCode != 0){
1020 addResult.addEventResult = CDSENTRY_FAILED;
1024 resultCode = sqlite3_bind_int(findHandle, 1, calendarID);
1026 if (resultCode != 0){
1027 addResult.addEventResult = CDSENTRY_FAILED;
1031 resultCode = sqlite3_step(findHandle);
1033 if (resultCode == SQLITE_ROW){
1035 } else if (resultCode == SQLITE_DONE) {
1036 addResult.addEventResult = CDSENTRY_NOCALENDAR;
1039 addResult.addEventResult = CDSENTRY_FAILED;
1043 // Get the required values from the event object.
1045 int eventStartYear = 0;
1046 int eventStartMonth = 0;
1047 int eventStartDay = 0;
1048 int eventStartHour = 0;
1049 int eventStartMinute = 0;
1050 int eventStartSecond = 0;
1051 int eventStartDuration = 0;
1052 std::string eventString = "";
1056 if (eventData.dateTimeStartData.size() < 16){
1058 addResult.addEventResult = CDSENTRY_INVALIDFILE;
1063 eventString = eventData.dateTimeStartData.substr(0,4);
1065 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
1067 eventStartYear = atoi(eventString.c_str());
1071 addResult.addEventResult = CDSENTRY_INVALIDFILE;
1076 eventString = eventData.dateTimeStartData.substr(4,2);
1078 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
1080 eventStartMonth = atoi(eventString.c_str());
1084 addResult.addEventResult = CDSENTRY_INVALIDFILE;
1089 eventString = eventData.dateTimeStartData.substr(6,2);
1091 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
1093 eventStartDay = atoi(eventString.c_str());
1097 addResult.addEventResult = CDSENTRY_INVALIDFILE;
1102 eventString = eventData.dateTimeStartData.substr(9,2);
1104 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
1106 eventStartHour = atoi(eventString.c_str());
1110 addResult.addEventResult = CDSENTRY_INVALIDFILE;
1115 eventString = eventData.dateTimeStartData.substr(11,2);
1117 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
1119 eventStartMinute = atoi(eventString.c_str());
1123 addResult.addEventResult = CDSENTRY_INVALIDFILE;
1128 eventString = eventData.dateTimeStartData.substr(13,2);
1130 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
1132 eventStartSecond = atoi(eventString.c_str());
1136 addResult.addEventResult = CDSENTRY_INVALIDFILE;
1141 //eventYear = eventStartDate.substr(0, 4);
1145 int eventEndYear = 0;
1146 int eventEndMonth = 0;
1147 int eventEndDay = 0;
1148 int eventEndHour = 0;
1149 int eventEndMinute = 0;
1150 int eventEndSecond = 0;
1151 int eventEndDuration = 0;
1153 if (eventData.dateTimeEndData != ""){
1155 if (eventData.dateTimeEndData.size() < 16){
1157 addResult.addEventResult = CDSENTRY_INVALIDFILE;
1162 eventString = eventData.dateTimeEndData.substr(0,4);
1164 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
1166 eventEndYear = atoi(eventString.c_str());
1170 addResult.addEventResult = CDSENTRY_INVALIDFILE;
1175 eventString = eventData.dateTimeEndData.substr(4,2);
1177 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
1179 eventEndMonth = atoi(eventString.c_str());
1183 addResult.addEventResult = CDSENTRY_INVALIDFILE;
1188 eventString = eventData.dateTimeEndData.substr(6,2);
1190 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
1192 eventEndDay = atoi(eventString.c_str());
1196 addResult.addEventResult = CDSENTRY_INVALIDFILE;
1201 eventString = eventData.dateTimeEndData.substr(9,2);
1203 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
1205 eventEndHour = atoi(eventString.c_str());
1209 addResult.addEventResult = CDSENTRY_INVALIDFILE;
1214 eventString = eventData.dateTimeEndData.substr(11,2);
1216 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
1218 eventEndMinute = atoi(eventString.c_str());
1222 addResult.addEventResult = CDSENTRY_INVALIDFILE;
1227 eventString = eventData.dateTimeEndData.substr(13,2);
1229 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
1231 eventEndSecond = atoi(eventString.c_str());
1235 addResult.addEventResult = CDSENTRY_INVALIDFILE;
1242 eventString = eventData.durationData;
1244 // Process the duration data.
1246 int eventDurationWeeks = 0;
1247 int eventDurationDays = 0;
1248 int eventDurationHours = 0;
1249 int eventDurationMinutes = 0;
1250 int eventDurationSeconds = 0;
1252 // Get the duration (if DTEND hasn't been specified).
1254 if (eventData.durationData.size() > 0){
1256 bool FoundP = false;
1257 bool FoundW = false;
1258 bool DateTimeMode = false;
1260 std::string::iterator eventDataChar = eventData.durationData.begin();
1261 std::string currentValue = "";
1263 if (*eventDataChar != 'P'){
1265 eventDataChar = eventData.durationData.end();
1269 for(eventDataChar; eventDataChar != eventData.durationData.end(); eventDataChar++){
1271 // Check if value is a digit.
1273 if (isdigit(*eventDataChar)){
1275 currentValue += *eventDataChar;
1279 // Check that the value matches one of the letters.
1281 if (*eventDataChar == 'W' && DateTimeMode == false){
1283 eventDurationWeeks = atoi(currentValue.c_str());
1285 } else if (*eventDataChar == 'D' && DateTimeMode == false){
1287 eventDurationDays = atoi(currentValue.c_str());
1289 } else if (*eventDataChar == 'T' && DateTimeMode == false){
1291 DateTimeMode = true;
1293 } else if (*eventDataChar == 'H'){
1295 eventDurationHours = atoi(currentValue.c_str());
1297 } else if (*eventDataChar == 'M'){
1299 eventDurationMinutes = atoi(currentValue.c_str());
1301 } else if (*eventDataChar == 'S'){
1303 eventDurationSeconds = atoi(currentValue.c_str());
1307 // Reset the current value.
1317 // Add the calendar entry.
1319 std::string sqlParameter = "INSERT INTO calendarentries (calendarid, entryname, entrydescription,"
1320 " entrystartyear, entrystartmonth, entrystartday, entrystarthour, entrystartminute, entrystartsecond,"
1321 " entryendyear, entryendmonth, entryendday, entryendhour, entryendminute, entryendsecond, "
1322 " entrydurationweek, entrydurationday, entrydurationhour, entrydurationminute, entrydurationsecond, "
1324 " VALUES ((?1), (?2), (?3), (?4), (?5), (?6), (?7), (?8), (?9), (?10), "
1325 " (?11), (?12), (?13), (?14), (?15), (?16), (?17), (?18), (?19), (?20), (?21))";
1327 resultCode = sqlite3_prepare_v2(db, sqlParameter.c_str(), -1, &statementHandle, nullptr);
1329 resultCode = sqlite3_bind_int(statementHandle, 1, calendarID);
1331 if (resultCode != 0){
1332 addResult.addEventResult = CDSENTRY_FAILED;
1336 // Process Entry Name.
1338 resultCode = sqlite3_bind_text(statementHandle, 2, eventData.summaryData.c_str(), -1, SQLITE_STATIC);
1340 if (resultCode != 0){
1341 addResult.addEventResult = CDSENTRY_FAILED;
1345 // Process Entry Description.
1347 string eventDescription;
1350 eventDescription = eventData.descriptionList.at(0);
1353 catch (out_of_range &err){
1354 eventDescription = "";
1357 resultCode = sqlite3_bind_text(statementHandle, 3, eventDescription.c_str(), -1, SQLITE_STATIC);
1359 if (resultCode != 0){
1360 addResult.addEventResult = CDSENTRY_FAILED;
1364 // Process Entry Start Date information.
1366 resultCode = sqlite3_bind_int(statementHandle, 4, eventStartYear);
1368 if (resultCode != 0){
1369 addResult.addEventResult = CDSENTRY_FAILED;
1373 resultCode = sqlite3_bind_int(statementHandle, 5, eventStartMonth);
1375 if (resultCode != 0){
1376 addResult.addEventResult = CDSENTRY_FAILED;
1380 resultCode = sqlite3_bind_int(statementHandle, 6, eventStartDay);
1382 if (resultCode != 0){
1383 addResult.addEventResult = CDSENTRY_FAILED;
1387 resultCode = sqlite3_bind_int(statementHandle, 7, eventStartHour);
1389 if (resultCode != 0){
1390 addResult.addEventResult = CDSENTRY_FAILED;
1394 resultCode = sqlite3_bind_int(statementHandle, 8, eventStartMinute);
1396 if (resultCode != 0){
1397 addResult.addEventResult = CDSENTRY_FAILED;
1401 resultCode = sqlite3_bind_int(statementHandle, 9, eventStartSecond);
1403 if (resultCode != 0){
1404 addResult.addEventResult = CDSENTRY_FAILED;
1408 // Process Entry Start End information.
1410 resultCode = sqlite3_bind_int(statementHandle, 10, eventEndYear);
1412 if (resultCode != 0){
1413 addResult.addEventResult = CDSENTRY_FAILED;
1417 resultCode = sqlite3_bind_int(statementHandle, 11, eventEndMonth);
1419 if (resultCode != 0){
1420 addResult.addEventResult = CDSENTRY_FAILED;
1424 resultCode = sqlite3_bind_int(statementHandle, 12, eventEndDay);
1426 if (resultCode != 0){
1427 addResult.addEventResult = CDSENTRY_FAILED;
1431 resultCode = sqlite3_bind_int(statementHandle, 13, eventEndHour);
1433 if (resultCode != 0){
1434 addResult.addEventResult = CDSENTRY_FAILED;
1438 resultCode = sqlite3_bind_int(statementHandle, 14, eventEndMinute);
1440 if (resultCode != 0){
1441 addResult.addEventResult = CDSENTRY_FAILED;
1445 resultCode = sqlite3_bind_int(statementHandle, 15, eventEndSecond);
1447 if (resultCode != 0){
1448 addResult.addEventResult = CDSENTRY_FAILED;
1452 resultCode = sqlite3_bind_int(statementHandle, 16, eventDurationWeeks);
1454 if (resultCode != 0){
1455 addResult.addEventResult = CDSENTRY_FAILED;
1459 resultCode = sqlite3_bind_int(statementHandle, 17, eventDurationDays);
1461 if (resultCode != 0){
1462 addResult.addEventResult = CDSENTRY_FAILED;
1466 resultCode = sqlite3_bind_int(statementHandle, 18, eventDurationHours);
1468 if (resultCode != 0){
1469 addResult.addEventResult = CDSENTRY_FAILED;
1473 resultCode = sqlite3_bind_int(statementHandle, 19, eventDurationMinutes);
1475 if (resultCode != 0){
1476 addResult.addEventResult = CDSENTRY_FAILED;
1480 resultCode = sqlite3_bind_int(statementHandle, 20, eventDurationSeconds);
1482 if (resultCode != 0){
1483 addResult.addEventResult = CDSENTRY_FAILED;
1487 resultCode = sqlite3_bind_text(statementHandle, 21, filename.c_str(), -1, SQLITE_STATIC);
1489 if (resultCode != 0){
1490 addResult.addEventResult = CDSENTRY_FAILED;
1494 resultCode = sqlite3_step(statementHandle);
1496 if (resultCode != SQLITE_DONE){
1497 addResult.addEventResult = CDSENTRY_FAILED;
1501 addResult.calendarEntryID = sqlite3_last_insert_rowid(db);
1502 addResult.addEventResult = CDSENTRY_OK;
1504 // Update the checksum.
1506 UpdateChecksum("internal_updatedata", to_string(GenerateRandomNumber(CDS_RANDOMPOW)));
1512 CDSEditEntryResult CalendarDataStorage::UpdateEvent(int eventID, std::string filename)
1515 CDSEditEntryResult editResult;
1516 editResult.editEventResult = CDSENTRY_UNITTESTFAIL;
1518 // Load the event file.
1520 CalendarEventObject eventData;
1521 CalendarObjectLoadResult eventLoadResult = eventData.LoadFile(filename);
1523 // Check the result of the event file load.
1525 switch (eventLoadResult){
1527 case CALENDAROBJECTLOAD_OK:
1529 case CALENDAROBJECTLOAD_MISSING:
1530 editResult.editEventResult = CDSENTRY_MISSINGFILE;
1532 case CALENDAROBJECTLOAD_INVALIDFORMAT:
1533 editResult.editEventResult = CDSENTRY_INVALIDFILE;
1535 case CALENDAROBJECTLOAD_CANNOTOPEN:
1536 editResult.editEventResult = CDSENTRY_CANNOTOPENFILE;
1541 // Check if event exists first.
1545 sqlite3_stmt *findHandle;
1546 sqlite3_stmt *statementHandle;
1548 resultCode = sqlite3_prepare_v2(db, "SELECT id from calendarentries WHERE id=(?1);", -1, &findHandle, nullptr);
1550 if (resultCode != 0){
1551 editResult.editEventResult = CDSENTRY_FAILED;
1555 resultCode = sqlite3_bind_int(findHandle, 1, eventID);
1557 if (resultCode != 0){
1558 editResult.editEventResult = CDSENTRY_FAILED;
1562 resultCode = sqlite3_step(findHandle);
1564 if (resultCode == SQLITE_ROW){
1566 } else if (resultCode == SQLITE_DONE) {
1567 editResult.editEventResult = CDSENTRY_NOENTRY;
1570 editResult.editEventResult = CDSENTRY_FAILED;
1574 // Get the required values from the event object.
1576 int eventStartYear = 0;
1577 int eventStartMonth = 0;
1578 int eventStartDay = 0;
1579 int eventStartHour = 0;
1580 int eventStartMinute = 0;
1581 int eventStartSecond = 0;
1582 int eventStartDuration = 0;
1583 std::string eventString = "";
1587 if (eventData.dateTimeStartData.size() < 16){
1589 editResult.editEventResult = CDSENTRY_INVALIDFILE;
1594 eventString = eventData.dateTimeStartData.substr(0,4);
1596 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
1598 eventStartYear = atoi(eventString.c_str());
1602 editResult.editEventResult = CDSENTRY_INVALIDFILE;
1607 eventString = eventData.dateTimeStartData.substr(4,2);
1609 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
1611 eventStartMonth = atoi(eventString.c_str());
1615 editResult.editEventResult = CDSENTRY_INVALIDFILE;
1620 eventString = eventData.dateTimeStartData.substr(6,2);
1622 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
1624 eventStartDay = atoi(eventString.c_str());
1628 editResult.editEventResult = CDSENTRY_INVALIDFILE;
1633 eventString = eventData.dateTimeStartData.substr(9,2);
1635 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
1637 eventStartHour = atoi(eventString.c_str());
1641 editResult.editEventResult = CDSENTRY_INVALIDFILE;
1646 eventString = eventData.dateTimeStartData.substr(11,2);
1648 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
1650 eventStartMinute = atoi(eventString.c_str());
1654 editResult.editEventResult = CDSENTRY_INVALIDFILE;
1659 eventString = eventData.dateTimeStartData.substr(13,2);
1661 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
1663 eventStartSecond = atoi(eventString.c_str());
1667 editResult.editEventResult = CDSENTRY_INVALIDFILE;
1672 //eventYear = eventStartDate.substr(0, 4);
1676 int eventEndYear = 0;
1677 int eventEndMonth = 0;
1678 int eventEndDay = 0;
1679 int eventEndHour = 0;
1680 int eventEndMinute = 0;
1681 int eventEndSecond = 0;
1682 int eventEndDuration = 0;
1684 if (eventData.dateTimeEndData != ""){
1686 if (eventData.dateTimeEndData.size() < 16){
1688 editResult.editEventResult = CDSENTRY_INVALIDFILE;
1693 eventString = eventData.dateTimeEndData.substr(0,4);
1695 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
1697 eventEndYear = atoi(eventString.c_str());
1701 editResult.editEventResult = CDSENTRY_INVALIDFILE;
1706 eventString = eventData.dateTimeEndData.substr(4,2);
1708 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
1710 eventEndMonth = atoi(eventString.c_str());
1714 editResult.editEventResult = CDSENTRY_INVALIDFILE;
1719 eventString = eventData.dateTimeEndData.substr(6,2);
1721 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
1723 eventEndDay = atoi(eventString.c_str());
1727 editResult.editEventResult = CDSENTRY_INVALIDFILE;
1732 eventString = eventData.dateTimeEndData.substr(9,2);
1734 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
1736 eventEndHour = atoi(eventString.c_str());
1740 editResult.editEventResult = CDSENTRY_INVALIDFILE;
1745 eventString = eventData.dateTimeEndData.substr(11,2);
1747 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
1749 eventEndMinute = atoi(eventString.c_str());
1753 editResult.editEventResult = CDSENTRY_INVALIDFILE;
1758 eventString = eventData.dateTimeEndData.substr(13,2);
1760 if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
1762 eventEndSecond = atoi(eventString.c_str());
1766 editResult.editEventResult = CDSENTRY_INVALIDFILE;
1773 eventString = eventData.durationData;
1775 // Process the duration data.
1777 int eventDurationWeeks = 0;
1778 int eventDurationDays = 0;
1779 int eventDurationHours = 0;
1780 int eventDurationMinutes = 0;
1781 int eventDurationSeconds = 0;
1783 // Get the duration (if DTEND hasn't been specified).
1785 if (eventData.durationData.size() > 0){
1787 bool FoundP = false;
1788 bool FoundW = false;
1789 bool DateTimeMode = false;
1791 std::string::iterator eventDataChar = eventData.durationData.begin();
1792 std::string currentValue = "";
1794 if (*eventDataChar != 'P'){
1796 eventDataChar = eventData.durationData.end();
1800 for(eventDataChar; eventDataChar != eventData.durationData.end(); eventDataChar++){
1802 // Check if value is a digit.
1804 if (isdigit(*eventDataChar)){
1806 currentValue += *eventDataChar;
1810 // Check that the value matches one of the letters.
1812 if (*eventDataChar == 'W' && DateTimeMode == false){
1814 eventDurationWeeks = atoi(currentValue.c_str());
1816 } else if (*eventDataChar == 'D' && DateTimeMode == false){
1818 eventDurationDays = atoi(currentValue.c_str());
1820 } else if (*eventDataChar == 'T' && DateTimeMode == false){
1822 DateTimeMode = true;
1824 } else if (*eventDataChar == 'H'){
1826 eventDurationHours = atoi(currentValue.c_str());
1828 } else if (*eventDataChar == 'M'){
1830 eventDurationMinutes = atoi(currentValue.c_str());
1832 } else if (*eventDataChar == 'S'){
1834 eventDurationSeconds = atoi(currentValue.c_str());
1838 // Reset the current value.
1848 // Add the calendar entry.
1850 std::string sqlParameter = "UPDATE calendarentries SET entryname=(?2), entrydescription=(?3),"
1851 " entrystartyear=(?4), entrystartmonth=(?5), entrystartday=(?6), entrystarthour=(?7), entrystartminute=(?8), entrystartsecond=(?9),"
1852 " entryendyear=(?10), entryendmonth=(?11), entryendday=(?12), entryendhour=(?13), entryendminute=(?14), entryendsecond=(?15), "
1853 " entrydurationweek=(?16), entrydurationday=(?17), entrydurationhour=(?18), entrydurationminute=(?19), entrydurationsecond=(?20) "
1856 resultCode = sqlite3_prepare_v2(db, sqlParameter.c_str(), -1, &statementHandle, nullptr);
1858 resultCode = sqlite3_bind_int(statementHandle, 1, eventID);
1860 if (resultCode != 0){
1861 editResult.editEventResult = CDSENTRY_FAILED;
1865 // Process Entry Name.
1867 resultCode = sqlite3_bind_text(statementHandle, 2, eventData.summaryData.c_str(), -1, SQLITE_STATIC);
1869 if (resultCode != 0){
1870 editResult.editEventResult = CDSENTRY_FAILED;
1874 // Process Entry Description.
1876 string eventDescription;
1879 eventDescription = eventData.descriptionList.at(0);
1882 catch (out_of_range &err){
1883 eventDescription = "";
1886 resultCode = sqlite3_bind_text(statementHandle, 3, eventDescription.c_str(), -1, SQLITE_STATIC);
1888 if (resultCode != 0){
1889 editResult.editEventResult = CDSENTRY_FAILED;
1893 // Process Entry Start Date information.
1895 resultCode = sqlite3_bind_int(statementHandle, 4, eventStartYear);
1897 if (resultCode != 0){
1898 editResult.editEventResult = CDSENTRY_FAILED;
1902 resultCode = sqlite3_bind_int(statementHandle, 5, eventStartMonth);
1904 if (resultCode != 0){
1905 editResult.editEventResult = CDSENTRY_FAILED;
1909 resultCode = sqlite3_bind_int(statementHandle, 6, eventStartDay);
1911 if (resultCode != 0){
1912 editResult.editEventResult = CDSENTRY_FAILED;
1916 resultCode = sqlite3_bind_int(statementHandle, 7, eventStartHour);
1918 if (resultCode != 0){
1919 editResult.editEventResult = CDSENTRY_FAILED;
1923 resultCode = sqlite3_bind_int(statementHandle, 8, eventStartMinute);
1925 if (resultCode != 0){
1926 editResult.editEventResult = CDSENTRY_FAILED;
1930 resultCode = sqlite3_bind_int(statementHandle, 9, eventStartSecond);
1932 if (resultCode != 0){
1933 editResult.editEventResult = CDSENTRY_FAILED;
1937 // Process Entry Start End information.
1939 resultCode = sqlite3_bind_int(statementHandle, 10, eventEndYear);
1941 if (resultCode != 0){
1942 editResult.editEventResult = CDSENTRY_FAILED;
1946 resultCode = sqlite3_bind_int(statementHandle, 11, eventEndMonth);
1948 if (resultCode != 0){
1949 editResult.editEventResult = CDSENTRY_FAILED;
1953 resultCode = sqlite3_bind_int(statementHandle, 12, eventEndDay);
1955 if (resultCode != 0){
1956 editResult.editEventResult = CDSENTRY_FAILED;
1960 resultCode = sqlite3_bind_int(statementHandle, 13, eventEndHour);
1962 if (resultCode != 0){
1963 editResult.editEventResult = CDSENTRY_FAILED;
1967 resultCode = sqlite3_bind_int(statementHandle, 14, eventEndMinute);
1969 if (resultCode != 0){
1970 editResult.editEventResult = CDSENTRY_FAILED;
1974 resultCode = sqlite3_bind_int(statementHandle, 15, eventEndSecond);
1976 if (resultCode != 0){
1977 editResult.editEventResult = CDSENTRY_FAILED;
1981 resultCode = sqlite3_bind_int(statementHandle, 16, eventDurationWeeks);
1983 if (resultCode != 0){
1984 editResult.editEventResult = CDSENTRY_FAILED;
1988 resultCode = sqlite3_bind_int(statementHandle, 17, eventDurationDays);
1990 if (resultCode != 0){
1991 editResult.editEventResult = CDSENTRY_FAILED;
1995 resultCode = sqlite3_bind_int(statementHandle, 18, eventDurationHours);
1997 if (resultCode != 0){
1998 editResult.editEventResult = CDSENTRY_FAILED;
2002 resultCode = sqlite3_bind_int(statementHandle, 19, eventDurationMinutes);
2004 if (resultCode != 0){
2005 editResult.editEventResult = CDSENTRY_FAILED;
2009 resultCode = sqlite3_bind_int(statementHandle, 20, eventDurationSeconds);
2011 if (resultCode != 0){
2012 editResult.editEventResult = CDSENTRY_FAILED;
2016 resultCode = sqlite3_step(statementHandle);
2018 if (resultCode != SQLITE_DONE){
2019 editResult.editEventResult = CDSENTRY_FAILED;
2023 editResult.calendarEntryID = sqlite3_last_insert_rowid(db);
2024 editResult.editEventResult = CDSENTRY_OK;
2026 // Update the checksum.
2028 UpdateChecksum("internal_updatedata", to_string(GenerateRandomNumber(CDS_RANDOMPOW)));
2034 CDSGetCalendarEntryInfo CalendarDataStorage::GetEvent(int calendarEntryID)
2037 CDSGetCalendarEntryInfo entryResult;
2039 // Check if the calendar entry exists.
2043 sqlite3_stmt *findHandle;
2044 sqlite3_stmt *statementHandle;
2046 resultCode = sqlite3_prepare_v2(db, "SELECT id FROM calendarentries WHERE id=(?1);", -1, &findHandle, nullptr);
2048 if (resultCode != 0){
2049 entryResult.getEventResult = CDSENTRY_FAILED;
2053 resultCode = sqlite3_bind_int(findHandle, 1, calendarEntryID);
2055 if (resultCode != 0){
2056 entryResult.getEventResult = CDSENTRY_FAILED;
2060 resultCode = sqlite3_step(findHandle);
2062 if (resultCode == SQLITE_ROW){
2064 } else if (resultCode == SQLITE_DONE) {
2065 entryResult.getEventResult = CDSENTRY_NOENTRY;
2068 entryResult.getEventResult = CDSENTRY_FAILED;
2072 // Get the calendar entry data.
2074 std::string sqlParameter = "SELECT entryname, entrydescription,"
2075 " entrystartyear, entrystartmonth, entrystartday, entrystarthour, entrystartminute, entrystartsecond,"
2076 " entryendyear, entryendmonth, entryendday, entryendhour, entryendminute, entryendsecond, "
2077 " entrydurationweek, entrydurationday, entrydurationhour, entrydurationminute, entrydurationsecond, "
2078 " calendarid, id, filename"
2079 " FROM calendarentries WHERE id=(?1)";
2081 resultCode = sqlite3_prepare_v2(db, sqlParameter.c_str(), -1, &statementHandle, nullptr);
2083 if (resultCode != 0){
2084 entryResult.getEventResult = CDSENTRY_FAILED;
2088 resultCode = sqlite3_bind_int(statementHandle, 1, calendarEntryID);
2090 if (resultCode != 0){
2091 entryResult.getEventResult = CDSENTRY_FAILED;
2095 resultCode = sqlite3_step(statementHandle);
2097 if (resultCode == SQLITE_ROW){
2099 // Get the calendar entry name,
2101 stringstream entryStream;
2103 entryStream << sqlite3_column_text(statementHandle, 0);
2104 entryResult.entryName = entryStream.str();
2106 entryStream.str("");
2108 // Get the calendar entry description.
2110 entryStream << sqlite3_column_text(statementHandle, 1);
2111 entryResult.entryDescription = entryStream.str();
2113 entryStream.str("");
2115 // Get the calendar entry filename.
2117 entryStream << sqlite3_column_text(statementHandle, 21);
2118 entryResult.entryFilename = entryStream.str();
2120 entryStream.str("");
2122 entryResult.entryStartYear = sqlite3_column_int(statementHandle, 2);
2123 entryResult.entryStartMonth = sqlite3_column_int(statementHandle, 3);
2124 entryResult.entryStartDay = sqlite3_column_int(statementHandle, 4);
2125 entryResult.entryStartHour = sqlite3_column_int(statementHandle, 5);
2126 entryResult.entryStartMinute = sqlite3_column_int(statementHandle, 6);
2127 entryResult.entryStartSecond = sqlite3_column_int(statementHandle, 7);
2128 entryResult.entryEndYear = sqlite3_column_int(statementHandle, 8);
2129 entryResult.entryEndMonth = sqlite3_column_int(statementHandle, 9);
2130 entryResult.entryEndDay = sqlite3_column_int(statementHandle, 10);
2131 entryResult.entryEndHour = sqlite3_column_int(statementHandle, 11);
2132 entryResult.entryEndMinute = sqlite3_column_int(statementHandle, 12);
2133 entryResult.entryEndSecond = sqlite3_column_int(statementHandle, 13);
2134 entryResult.entryDurationWeeks = sqlite3_column_int(statementHandle, 14);
2135 entryResult.entryDurationDays = sqlite3_column_int(statementHandle, 15);
2136 entryResult.entryDurationHours = sqlite3_column_int(statementHandle, 16);
2137 entryResult.entryDurationMinutes = sqlite3_column_int(statementHandle, 17);
2138 entryResult.entryDurationSeconds = sqlite3_column_int(statementHandle, 18);
2139 entryResult.calendarID = sqlite3_column_int(statementHandle, 19);
2140 entryResult.calendarEntryID = sqlite3_column_int(statementHandle, 20);
2142 } else if (resultCode == SQLITE_DONE) {
2143 entryResult.getEventResult = CDSENTRY_NOCALENDAR;
2146 entryResult.getEventResult = CDSENTRY_FAILED;
2150 entryResult.getEventResult = CDSENTRY_OK;
2156 CDSEntryResult CalendarDataStorage::DeleteEvent(int calendarEntryID)
2159 CDSEntryResult deleteResult = CDSENTRY_UNITTESTFAIL;
2161 // Check if the calendar entry exists.
2165 sqlite3_stmt *findHandle;
2166 sqlite3_stmt *statementHandle;
2168 resultCode = sqlite3_prepare_v2(db, "SELECT id FROM calendarentries WHERE id=(?1);", -1, &findHandle, nullptr);
2170 if (resultCode != 0){
2171 return CDSENTRY_FAILED;
2174 resultCode = sqlite3_bind_int(findHandle, 1, calendarEntryID);
2176 if (resultCode != 0){
2177 return CDSENTRY_FAILED;
2180 resultCode = sqlite3_step(findHandle);
2182 if (resultCode == SQLITE_ROW){
2184 } else if (resultCode == SQLITE_DONE) {
2185 return CDSENTRY_NOENTRY;
2187 return CDSENTRY_FAILED;
2190 // Delete the account.
2192 resultCode = sqlite3_prepare_v2(db, "DELETE FROM calendarentries WHERE id=(?1);", -1, &statementHandle, nullptr);
2194 if (resultCode != 0){
2195 return CDSENTRY_FAILED;
2198 resultCode = sqlite3_bind_int(statementHandle, 1, calendarEntryID);
2200 if (resultCode != 0){
2201 return CDSENTRY_FAILED;
2204 resultCode = sqlite3_step(statementHandle);
2206 if (resultCode == SQLITE_DONE){
2207 deleteResult = CDSENTRY_OK;
2209 return CDSENTRY_FAILED;
2212 // Update the checksum.
2214 UpdateChecksum("internal_updatedata", to_string(GenerateRandomNumber(CDS_RANDOMPOW)));
2216 return deleteResult;
2220 CDSEntryList CalendarDataStorage::GetEventList(int calendarID){
2222 CDSEntryList entryList;
2223 entryList.getEventListResult = CDSENTRY_UNITTESTFAIL;
2225 // Check if calendar exists first.
2229 sqlite3_stmt *findHandle;
2230 sqlite3_stmt *calendarHandle;
2232 resultCode = sqlite3_prepare_v2(db, "SELECT id from calendars WHERE id=(?1);", -1, &findHandle, nullptr);
2234 if (resultCode != 0){
2235 entryList.getEventListResult = CDSENTRY_FAILED;
2239 resultCode = sqlite3_bind_int(findHandle, 1, calendarID);
2241 if (resultCode != 0){
2242 entryList.getEventListResult = CDSENTRY_FAILED;
2246 resultCode = sqlite3_step(findHandle);
2248 if (resultCode == SQLITE_ROW){
2250 } else if (resultCode == SQLITE_DONE) {
2251 entryList.getEventListResult = CDSENTRY_NOCALENDAR;
2254 entryList.getEventListResult = CDSENTRY_FAILED;
2258 // Get the list of entry IDs.
2260 resultCode = sqlite3_prepare_v2(db, "SELECT id FROM calendarentries WHERE calendarid=(?1);", -1, &calendarHandle, nullptr);
2262 if (resultCode != 0){
2263 entryList.getEventListResult = CDSENTRY_FAILED;
2267 resultCode = sqlite3_bind_int(calendarHandle, 1, calendarID);
2269 if (resultCode != 0){
2270 entryList.getEventListResult = CDSENTRY_FAILED;
2274 resultCode = sqlite3_step(calendarHandle);
2276 if (resultCode == SQLITE_DONE || resultCode == SQLITE_ROW){
2278 entryList.getEventListResult = CDSENTRY_FAILED;
2282 while (resultCode == SQLITE_ROW){
2284 int calendarID = sqlite3_column_int(calendarHandle, 0);
2286 entryList.entryList.push_back(calendarID);
2288 resultCode = sqlite3_step(calendarHandle);
2292 entryList.getEventListResult = CDSENTRY_OK;
2298 CDSEntryList CalendarDataStorage::GetEventListByDate(int calendarYear, int calendarMonth, int calendarDay){
2300 CDSEntryList entryList;
2301 entryList.getEventListResult = CDSENTRY_UNITTESTFAIL;
2303 // Check if calendar exists first.
2307 sqlite3_stmt *calendarHandle;
2309 // Get the list of entry IDs.
2311 resultCode = sqlite3_prepare_v2(db, "SELECT id FROM calendarentries WHERE entrystartyear=(?1) AND entrystartmonth=(?2) AND entrystartday=(?3);", -1, &calendarHandle, nullptr);
2313 if (resultCode != 0){
2314 entryList.getEventListResult = CDSENTRY_FAILED;
2318 resultCode = sqlite3_bind_int(calendarHandle, 1, calendarYear);
2320 if (resultCode != 0){
2321 entryList.getEventListResult = CDSENTRY_FAILED;
2325 resultCode = sqlite3_bind_int(calendarHandle, 2, calendarMonth);
2327 if (resultCode != 0){
2328 entryList.getEventListResult = CDSENTRY_FAILED;
2332 resultCode = sqlite3_bind_int(calendarHandle, 3, calendarDay);
2334 if (resultCode != 0){
2335 entryList.getEventListResult = CDSENTRY_FAILED;
2339 resultCode = sqlite3_step(calendarHandle);
2341 if (resultCode == SQLITE_DONE || resultCode == SQLITE_ROW){
2343 entryList.getEventListResult = CDSENTRY_FAILED;
2347 while (resultCode == SQLITE_ROW){
2349 int calendarID = sqlite3_column_int(calendarHandle, 0);
2351 entryList.entryList.push_back(calendarID);
2353 resultCode = sqlite3_step(calendarHandle);
2357 entryList.getEventListResult = CDSENTRY_OK;
2363 CDSCalendarList CalendarDataStorage::GetCalendarList(int accountID){
2365 CDSCalendarList calendarList;
2366 calendarList.getCalendarListResult = CDSCALENDAR_UNITTESTFAIL;
2368 // Check if calendar exists first.
2372 sqlite3_stmt *findHandle;
2373 sqlite3_stmt *calendarHandle;
2375 resultCode = sqlite3_prepare_v2(db, "SELECT id from accounts WHERE id=(?1);", -1, &findHandle, nullptr);
2377 if (resultCode != 0){
2378 calendarList.getCalendarListResult = CDSCALENDAR_FAILED;
2379 return calendarList;
2382 resultCode = sqlite3_bind_int(findHandle, 1, accountID);
2384 if (resultCode != 0){
2385 calendarList.getCalendarListResult = CDSCALENDAR_FAILED;
2386 return calendarList;
2389 resultCode = sqlite3_step(findHandle);
2391 if (resultCode == SQLITE_ROW){
2393 } else if (resultCode == SQLITE_DONE) {
2394 calendarList.getCalendarListResult = CDSCALENDAR_NOCALENDAR;
2395 return calendarList;
2397 calendarList.getCalendarListResult = CDSCALENDAR_FAILED;
2398 return calendarList;
2401 // Get the list of entry IDs.
2403 resultCode = sqlite3_prepare_v2(db, "SELECT id, calendarid FROM calendars WHERE accountid=(?1);", -1, &calendarHandle, nullptr);
2405 if (resultCode != 0){
2406 calendarList.getCalendarListResult = CDSCALENDAR_FAILED;
2407 return calendarList;
2410 resultCode = sqlite3_bind_int(calendarHandle, 1, accountID);
2412 if (resultCode != 0){
2413 calendarList.getCalendarListResult = CDSCALENDAR_FAILED;
2414 return calendarList;
2417 resultCode = sqlite3_step(calendarHandle);
2419 if (resultCode == SQLITE_DONE || resultCode == SQLITE_ROW){
2421 calendarList.getCalendarListResult = CDSCALENDAR_FAILED;
2422 return calendarList;
2425 while (resultCode == SQLITE_ROW){
2427 int calendarID = sqlite3_column_int(calendarHandle, 0);
2429 stringstream calendarStream;
2431 calendarStream << sqlite3_column_text(calendarHandle, 1);
2433 calendarList.calendarList.push_back(calendarID);
2434 calendarList.calendarListTextID.push_back(calendarStream.str());
2436 calendarStream.str("");
2438 resultCode = sqlite3_step(calendarHandle);
2442 calendarList.getCalendarListResult = CDSCALENDAR_OK;
2444 return calendarList;
2448 CDSChecksumResult CalendarDataStorage::AddChecksum(string checksumName, string checksumValue){
2452 // Check if the checksum already exists.
2454 sqlite3_stmt *findHandle;
2455 sqlite3_stmt *checksumHandle;
2457 resultCode = sqlite3_prepare_v2(db, "SELECT checksumvalue from checksums WHERE checksumname=(?1);", -1, &findHandle, nullptr);
2459 if (resultCode != 0){
2460 return CDSCHECKSUM_FAILED;
2463 resultCode = sqlite3_bind_text(findHandle, 1, checksumName.c_str(), -1, SQLITE_STATIC);
2465 if (resultCode != 0){
2466 return CDSCHECKSUM_FAILED;
2469 resultCode = sqlite3_step(findHandle);
2471 if (resultCode == SQLITE_ROW){
2472 return CDSCHECKSUM_CHECKSUMALREADYEXISTS;
2473 } else if (resultCode == SQLITE_DONE) {
2476 return CDSCHECKSUM_FAILED;
2479 // Add the checksum to the checksum table.
2481 resultCode = sqlite3_prepare_v2(db, "INSERT INTO checksums (checksumname, checksumvalue) VALUES(?1, ?2);", -1, &checksumHandle, nullptr);
2483 if (resultCode != 0){
2484 return CDSCHECKSUM_FAILED;
2487 resultCode = sqlite3_bind_text(checksumHandle, 1, checksumName.c_str(), -1, SQLITE_STATIC);
2489 if (resultCode != 0){
2490 return CDSCHECKSUM_FAILED;
2493 resultCode = sqlite3_bind_text(checksumHandle, 2, checksumValue.c_str(), -1, SQLITE_STATIC);
2495 if (resultCode != 0){
2496 return CDSCHECKSUM_FAILED;
2499 resultCode = sqlite3_step(checksumHandle);
2501 if (resultCode != SQLITE_DONE){
2502 return CDSCHECKSUM_FAILED;
2505 return CDSCHECKSUM_OK;
2509 CDSGetChecksumResult CalendarDataStorage::GetChecksum(string checksumName){
2511 CDSGetChecksumResult getChecksumResult;
2515 // Check if the checksum already exists.
2517 sqlite3_stmt *getHandle;
2519 resultCode = sqlite3_prepare_v2(db, "SELECT checksumvalue from checksums WHERE checksumname=(?1);", -1, &getHandle, nullptr);
2521 if (resultCode != 0){
2522 getChecksumResult.getChecksumResult = CDSCHECKSUM_FAILED;
2523 return getChecksumResult;
2526 resultCode = sqlite3_bind_text(getHandle, 1, checksumName.c_str(), -1, SQLITE_STATIC);
2528 if (resultCode != 0){
2529 getChecksumResult.getChecksumResult = CDSCHECKSUM_FAILED;
2530 return getChecksumResult;
2533 resultCode = sqlite3_step(getHandle);
2535 if (resultCode == SQLITE_ROW){
2536 } else if (resultCode == SQLITE_DONE) {
2537 getChecksumResult.getChecksumResult = CDSCHECKSUM_NOHASH;
2538 return getChecksumResult;
2540 getChecksumResult.getChecksumResult = CDSCHECKSUM_FAILED;
2541 return getChecksumResult;
2544 stringstream checksumStream;
2546 checksumStream << sqlite3_column_text(getHandle, 0);
2548 getChecksumResult.checksumValue = checksumStream.str();
2550 getChecksumResult.getChecksumResult = CDSCHECKSUM_OK;
2552 return getChecksumResult;
2556 CDSChecksumResult CalendarDataStorage::UpdateChecksum(std::string checksumName, std::string checksumValue){
2560 // Check if the checksum already exists.
2562 sqlite3_stmt *getHandle;
2563 sqlite3_stmt *statementHandle;
2565 resultCode = sqlite3_prepare_v2(db, "SELECT checksumvalue from checksums WHERE checksumname=(?1);", -1, &getHandle, nullptr);
2567 if (resultCode != 0){
2568 return CDSCHECKSUM_FAILED;
2571 resultCode = sqlite3_bind_text(getHandle, 1, checksumName.c_str(), -1, SQLITE_STATIC);
2573 if (resultCode != 0){
2574 return CDSCHECKSUM_FAILED;
2577 resultCode = sqlite3_step(getHandle);
2579 if (resultCode == SQLITE_ROW){
2580 } else if (resultCode == SQLITE_DONE) {
2581 return CDSCHECKSUM_NOHASH;
2583 return CDSCHECKSUM_FAILED;
2586 // Update the checksum.
2588 resultCode = sqlite3_prepare_v2(db, "UPDATE checksums SET checksumvalue=(?1) WHERE checksumname=(?2);", -1, &statementHandle, nullptr);
2590 if (resultCode != 0){
2591 return CDSCHECKSUM_FAILED;
2594 resultCode = sqlite3_bind_text(statementHandle, 1, checksumValue.c_str(), -1, SQLITE_STATIC);
2596 if (resultCode != 0){
2597 return CDSCHECKSUM_FAILED;
2600 resultCode = sqlite3_bind_text(statementHandle, 2, checksumName.c_str(), -1, SQLITE_STATIC);
2602 if (resultCode != 0){
2603 return CDSCHECKSUM_FAILED;
2606 resultCode = sqlite3_step(statementHandle);
2608 if (resultCode != SQLITE_DONE){
2609 return CDSCHECKSUM_FAILED;
2612 return CDSCHECKSUM_OK;
2616 CDSCleanupResult CalendarDataStorage::Clear(){
2618 // Remove all data from the tables and reset the sequence numbers.
2621 sqlite3_stmt *statementHandle;
2623 resultCode = sqlite3_prepare_v2(db, "DELETE FROM calendarentries", - 1, &statementHandle, nullptr);
2625 if (resultCode != 0){
2626 return CDSCLEANUP_FAILED;
2629 resultCode = sqlite3_step(statementHandle);
2631 if (resultCode != SQLITE_DONE){
2632 return CDSCLEANUP_FAILED;
2635 resultCode = sqlite3_prepare_v2(db, "DELETE FROM sqlite_sequence WHERE name='calendarentries';", -1, &statementHandle, nullptr);
2637 if (resultCode != 0){
2638 return CDSCLEANUP_FAILED;
2641 resultCode = sqlite3_step(statementHandle);
2643 if (resultCode != SQLITE_DONE){
2644 return CDSCLEANUP_FAILED;
2647 resultCode = sqlite3_prepare_v2(db, "DELETE FROM calendars", -1, &statementHandle, nullptr);
2649 if (resultCode != 0){
2650 return CDSCLEANUP_FAILED;
2653 resultCode = sqlite3_step(statementHandle);
2655 if (resultCode != SQLITE_DONE){
2656 return CDSCLEANUP_FAILED;
2659 resultCode = sqlite3_prepare_v2(db, "DELETE FROM sqlite_sequence WHERE name='calendars';", -1, &statementHandle, nullptr);
2661 if (resultCode != 0){
2662 return CDSCLEANUP_FAILED;
2665 resultCode = sqlite3_step(statementHandle);
2667 if (resultCode != SQLITE_DONE){
2668 return CDSCLEANUP_FAILED;
2671 resultCode = sqlite3_prepare_v2(db, "DELETE FROM accounts", -1, &statementHandle, nullptr);
2673 if (resultCode != 0){
2674 return CDSCLEANUP_FAILED;
2677 resultCode = sqlite3_step(statementHandle);
2679 if (resultCode != SQLITE_DONE){
2680 return CDSCLEANUP_FAILED;
2683 resultCode = sqlite3_prepare_v2(db, "DELETE FROM sqlite_sequence WHERE name='accounts'", -1, &statementHandle, nullptr);
2685 if (resultCode != 0){
2686 return CDSCLEANUP_FAILED;
2689 resultCode = sqlite3_step(statementHandle);
2691 if (resultCode != SQLITE_DONE){
2692 return CDSCLEANUP_FAILED;
2695 // Update the checksum.
2697 UpdateChecksum("internal_updatedata", to_string(GenerateRandomNumber(CDS_RANDOMPOW)));
2699 return CDSCLEANUP_OK;