Home | News | Projects | Releases
Bugs | RFE | Repositories | Help
CalendarDataStorage: Update code
authorSteve Brokenshire <sbrokenshire@xestia.co.uk>
Wed, 11 Jan 2017 19:58:14 +0000 (19:58 +0000)
committerSteve Brokenshire <sbrokenshire@xestia.co.uk>
Wed, 11 Jan 2017 19:58:14 +0000 (19:58 +0000)
source/libraries/CalendarDataStorage/CalendarDataStorage.cpp
source/libraries/CalendarDataStorage/CalendarDataStorage.h

index a47a354..b1d2c5b 100644 (file)
@@ -37,7 +37,8 @@ void CalendarDataStorage::SetupTables(){
        // Setup the accounts table.
        
        const char *accountsTableString;
        // Setup the accounts table.
        
        const char *accountsTableString;
-       accountsTableString = "CREATE TABLE accounts(id INTEGER PRIMARY KEY "
+       accountsTableString = "CREATE TABLE accounts(id INTEGER PRIMARY KEY AUTOINCREMENT"
+               ", preferencesid INTEGER"
                ", name TEXT"
                ");";
        
                ", name TEXT"
                ");";
        
@@ -51,11 +52,12 @@ void CalendarDataStorage::SetupTables(){
        // Setup the calendars table.
        
        const char *calendarTableString;
        // Setup the calendars table.
        
        const char *calendarTableString;
-       calendarTableString = "CREATE TABLE calendars(id INTEGER PRIMARY KEY "
+       calendarTableString = "CREATE TABLE calendars(id INTEGER PRIMARY KEY AUTOINCREMENT"
                ", accountid INTEGER"
                ", name TEXT"
                ", calendarid TEXT"
                ", colour TEXT"
                ", accountid INTEGER"
                ", name TEXT"
                ", calendarid TEXT"
                ", colour TEXT"
+               ", description TEXT"
                ");";
        
        resultCode = sqlite3_exec(db, calendarTableString, callback, nullptr, &setupTablesErrMsg);
                ");";
        
        resultCode = sqlite3_exec(db, calendarTableString, callback, nullptr, &setupTablesErrMsg);
@@ -68,7 +70,7 @@ void CalendarDataStorage::SetupTables(){
        // Setup the calendar entries table.
        
        const char *calendarentriesTableString;
        // Setup the calendar entries table.
        
        const char *calendarentriesTableString;
-       calendarentriesTableString = "CREATE TABLE calendarentries(id INTEGER PRIMARY KEY "
+       calendarentriesTableString = "CREATE TABLE calendarentries(id INTEGER PRIMARY KEY AUTOINCREMENT"
                ", calendarid INTEGER"
                ", entryname TEXT"
                ", entrydescription TEXT"
                ", calendarid INTEGER"
                ", entryname TEXT"
                ", entrydescription TEXT"
@@ -89,6 +91,7 @@ void CalendarDataStorage::SetupTables(){
                ", entrydurationhour INTEGER"
                ", entrydurationminute INTEGER"
                ", entrydurationsecond INTEGER"
                ", entrydurationhour INTEGER"
                ", entrydurationminute INTEGER"
                ", entrydurationsecond INTEGER"
+               ", filename TEXT"
                ");";
        
        resultCode = sqlite3_exec(db, calendarentriesTableString, callback, nullptr, &setupTablesErrMsg);
                ");";
        
        resultCode = sqlite3_exec(db, calendarentriesTableString, callback, nullptr, &setupTablesErrMsg);
@@ -131,7 +134,7 @@ bool CalendarDataStorage::DidInitOK()
        
 }
 
        
 }
 
-CDSAccountResult CalendarDataStorage::AddAccount(string accountName)
+CDSAccountResult CalendarDataStorage::AddAccount(string accountName, int accountPreferencesID)
 {
        
        CDSAccountResult addResult = CDSACCOUNT_UNITTESTFAIL;
 {
        
        CDSAccountResult addResult = CDSACCOUNT_UNITTESTFAIL;
@@ -139,7 +142,7 @@ CDSAccountResult CalendarDataStorage::AddAccount(string accountName)
        
        sqlite3_stmt *statementHandle;
        
        
        sqlite3_stmt *statementHandle;
        
-       resultCode = sqlite3_prepare_v2(db, "INSERT INTO accounts (name) VALUES(?1);", -1, &statementHandle, nullptr);
+       resultCode = sqlite3_prepare_v2(db, "INSERT INTO accounts (name, preferencesid) VALUES(?1, ?2);", -1, &statementHandle, nullptr);
        
        if (resultCode != 0){
                return CDSACCOUNT_FAILED;
        
        if (resultCode != 0){
                return CDSACCOUNT_FAILED;
@@ -147,6 +150,12 @@ CDSAccountResult CalendarDataStorage::AddAccount(string accountName)
        
        resultCode = sqlite3_bind_text(statementHandle, 1, accountName.c_str(), -1, SQLITE_STATIC);
        
        
        resultCode = sqlite3_bind_text(statementHandle, 1, accountName.c_str(), -1, SQLITE_STATIC);
        
+       if (resultCode != 0){
+               return CDSACCOUNT_FAILED;
+       }
+
+       resultCode = sqlite3_bind_int(statementHandle, 2, accountPreferencesID);
+       
        if (resultCode != 0){
                return CDSACCOUNT_FAILED;
        }
        if (resultCode != 0){
                return CDSACCOUNT_FAILED;
        }
@@ -178,7 +187,7 @@ CDSAccountList CalendarDataStorage::GetAccountList()
        
        sqlite3_stmt *statementHandle;
        
        
        sqlite3_stmt *statementHandle;
        
-       resultCode = sqlite3_prepare_v2(db, "SELECT id, name from accounts;", -1, &statementHandle, nullptr);
+       resultCode = sqlite3_prepare_v2(db, "SELECT id, name, preferencesid from accounts;", -1, &statementHandle, nullptr);
        
        if (resultCode != 0){
                accountList.getAccountListResult = CDSACCOUNT_FAILED;
        
        if (resultCode != 0){
                accountList.getAccountListResult = CDSACCOUNT_FAILED;
@@ -207,6 +216,7 @@ CDSAccountList CalendarDataStorage::GetAccountList()
                CDSGetAccountInfo accountInfo;
                
                accountInfo.accountID = sqlite3_column_int(statementHandle, 0);
                CDSGetAccountInfo accountInfo;
                
                accountInfo.accountID = sqlite3_column_int(statementHandle, 0);
+               accountInfo.accountPreferencesID = sqlite3_column_int(statementHandle, 2);
                
                stringstream calendarStream;
                
                
                stringstream calendarStream;
                
@@ -236,7 +246,7 @@ CDSGetAccountInfo CalendarDataStorage::GetAccount(string accountName)
        
        sqlite3_stmt *statementHandle;
        
        
        sqlite3_stmt *statementHandle;
        
-       resultCode = sqlite3_prepare_v2(db, "SELECT name, id FROM accounts WHERE name=(?1);", -1, &statementHandle, nullptr);
+       resultCode = sqlite3_prepare_v2(db, "SELECT name, id, preferencesid FROM accounts WHERE name=(?1);", -1, &statementHandle, nullptr);
 
        if (resultCode != 0){
                accountInfo.accountInfoResult = CDSACCOUNT_FAILED;
 
        if (resultCode != 0){
                accountInfo.accountInfoResult = CDSACCOUNT_FAILED;
@@ -267,6 +277,7 @@ CDSGetAccountInfo CalendarDataStorage::GetAccount(string accountName)
                
                accountInfo.accountName = accountNameStream.str();
                accountInfo.accountID = sqlite3_column_int(statementHandle, 1);
                
                accountInfo.accountName = accountNameStream.str();
                accountInfo.accountID = sqlite3_column_int(statementHandle, 1);
+               accountInfo.accountPreferencesID = sqlite3_column_int(statementHandle, 2);
                
                accountInfo.accountInfoResult = CDSACCOUNT_OK;
                return accountInfo;
                
                accountInfo.accountInfoResult = CDSACCOUNT_OK;
                return accountInfo;
@@ -450,7 +461,7 @@ CDSAccountResult CalendarDataStorage::DeleteAccount(int accountID)
        
 }
 
        
 }
 
-CDSCalendarResult CalendarDataStorage::AddCalendar(int accountID, string calendarName, string calendarID, Colour calendarColour)
+CDSCalendarResult CalendarDataStorage::AddCalendar(int accountID, string calendarName, string calendarID, Colour calendarColour, string calendarDescription)
 {
 
        CDSCalendarResult addResult = CDSCALENDAR_UNITTESTFAIL;
 {
 
        CDSCalendarResult addResult = CDSCALENDAR_UNITTESTFAIL;
@@ -458,7 +469,7 @@ CDSCalendarResult CalendarDataStorage::AddCalendar(int accountID, string calenda
        
        sqlite3_stmt *statementHandle;
        
        
        sqlite3_stmt *statementHandle;
        
-       resultCode = sqlite3_prepare_v2(db, "INSERT INTO calendars (name, calendarid, accountid, colour) VALUES(?1, ?2, ?3, ?4);", -1, &statementHandle, nullptr);
+       resultCode = sqlite3_prepare_v2(db, "INSERT INTO calendars (name, calendarid, accountid, colour, description) VALUES(?1, ?2, ?3, ?4, ?5);", -1, &statementHandle, nullptr);
        
        if (resultCode != 0){
                return CDSCALENDAR_FAILED;
        
        if (resultCode != 0){
                return CDSCALENDAR_FAILED;
@@ -484,6 +495,12 @@ CDSCalendarResult CalendarDataStorage::AddCalendar(int accountID, string calenda
        
        resultCode = sqlite3_bind_text(statementHandle, 4, ((string)calendarColour).c_str(), -1, SQLITE_STATIC);
 
        
        resultCode = sqlite3_bind_text(statementHandle, 4, ((string)calendarColour).c_str(), -1, SQLITE_STATIC);
 
+       if (resultCode != 0){
+               return CDSCALENDAR_FAILED;
+       }
+
+       resultCode = sqlite3_bind_text(statementHandle, 5, calendarDescription.c_str(), -1, SQLITE_STATIC);
+
        if (resultCode != 0){
                return CDSCALENDAR_FAILED;
        }
        if (resultCode != 0){
                return CDSCALENDAR_FAILED;
        }
@@ -535,7 +552,7 @@ CDSGetCalendarInfo CalendarDataStorage::GetCalendar(std::string accountName, std
        
        // Check if the calendar exists.
        
        
        // Check if the calendar exists.
        
-       resultCode = sqlite3_prepare_v2(db, "SELECT id, accountid, name, calendarid, colour FROM calendars WHERE accountid=(?1) AND calendarid=(?2);", -1, &statementHandle, nullptr);
+       resultCode = sqlite3_prepare_v2(db, "SELECT id, accountid, name, calendarid, colour, description FROM calendars WHERE accountid=(?1) AND calendarid=(?2);", -1, &statementHandle, nullptr);
        
        if (resultCode != 0){
                calendarResult.calendarInfoResult = CDSCALENDAR_FAILED;
        
        if (resultCode != 0){
                calendarResult.calendarInfoResult = CDSCALENDAR_FAILED;
@@ -580,6 +597,10 @@ CDSGetCalendarInfo CalendarDataStorage::GetCalendar(std::string accountName, std
                calendarStream << sqlite3_column_text(statementHandle, 4);
                calendarResult.calendarColour = calendarStream.str();
                
                calendarStream << sqlite3_column_text(statementHandle, 4);
                calendarResult.calendarColour = calendarStream.str();
                
+               calendarStream.str("");
+               calendarStream << sqlite3_column_text(statementHandle, 5);
+               calendarResult.calendarDescription = calendarStream.str();
+               
                calendarResult.calendarID = sqlite3_column_int(statementHandle, 0);
                calendarResult.accountID = sqlite3_column_int(statementHandle, 1);
                calendarResult.calendarInfoResult = CDSCALENDAR_OK;
                calendarResult.calendarID = sqlite3_column_int(statementHandle, 0);
                calendarResult.accountID = sqlite3_column_int(statementHandle, 1);
                calendarResult.calendarInfoResult = CDSCALENDAR_OK;
@@ -601,11 +622,12 @@ CDSGetCalendarInfo CalendarDataStorage::GetCalendar(int calendarID)
        
        CDSGetCalendarInfo calendarResult;
        sqlite3_stmt *statementHandle;
        
        CDSGetCalendarInfo calendarResult;
        sqlite3_stmt *statementHandle;
+       sqlite3_stmt *accountHandle;
        int resultCode;
        
        // Check if the calendar exists.
        
        int resultCode;
        
        // Check if the calendar exists.
        
-       resultCode = sqlite3_prepare_v2(db, "SELECT id, accountid, name, calendarid, colour FROM calendars WHERE id=(?1);", -1, &statementHandle, nullptr);
+       resultCode = sqlite3_prepare_v2(db, "SELECT id, accountid, name, calendarid, colour, description FROM calendars WHERE id=(?1);", -1, &statementHandle, nullptr);
        
        if (resultCode != 0){
                calendarResult.calendarInfoResult = CDSCALENDAR_FAILED;
        
        if (resultCode != 0){
                calendarResult.calendarInfoResult = CDSCALENDAR_FAILED;
@@ -642,9 +664,45 @@ CDSGetCalendarInfo CalendarDataStorage::GetCalendar(int calendarID)
                calendarStream.str("");
                calendarStream << sqlite3_column_text(statementHandle, 4);
                calendarResult.calendarColour = calendarStream.str();
                calendarStream.str("");
                calendarStream << sqlite3_column_text(statementHandle, 4);
                calendarResult.calendarColour = calendarStream.str();
+
+               calendarStream.str("");
+               calendarStream << sqlite3_column_text(statementHandle, 5);
+               calendarResult.calendarDescription = calendarStream.str();
                
                calendarResult.calendarID = sqlite3_column_int(statementHandle, 0);
                calendarResult.accountID = sqlite3_column_int(statementHandle, 1);
                
                calendarResult.calendarID = sqlite3_column_int(statementHandle, 0);
                calendarResult.accountID = sqlite3_column_int(statementHandle, 1);
+               
+               // Get the account name.
+               
+               resultCode = sqlite3_prepare_v2(db, "SELECT name FROM accounts WHERE id=(?1);", -1, &accountHandle, nullptr);
+       
+               if (resultCode != 0){
+                       calendarResult.calendarInfoResult = CDSCALENDAR_FAILED;
+                       return calendarResult;
+               }
+
+               resultCode = sqlite3_bind_int(accountHandle, 1, calendarResult.accountID);
+       
+               if (resultCode != 0){
+                       calendarResult.calendarInfoResult = CDSCALENDAR_FAILED;
+                       return calendarResult;
+               }
+       
+               resultCode = sqlite3_step(accountHandle);
+               
+               if (resultCode == SQLITE_ROW){
+                       
+                       stringstream accountStream;
+                       accountStream << sqlite3_column_text(accountHandle, 0);
+                       calendarResult.accountName = accountStream.str();
+                       calendarResult.accountInfoResult = CDSACCOUNT_OK;
+                       
+               } else {
+
+                       calendarResult.accountInfoResult = CDSACCOUNT_FAILED;
+                       
+               }
+               
                calendarResult.calendarInfoResult = CDSCALENDAR_OK;
                return calendarResult;
                
                calendarResult.calendarInfoResult = CDSCALENDAR_OK;
                return calendarResult;
                
@@ -660,7 +718,7 @@ CDSGetCalendarInfo CalendarDataStorage::GetCalendar(int calendarID)
 }
 
 
 }
 
 
-CDSCalendarResult CalendarDataStorage::UpdateCalendar(int calendarID, string calendarName)
+CDSCalendarResult CalendarDataStorage::UpdateCalendar(int calendarID, string calendarName, Colour calendarColour, std::string calendarDescription)
 {
        
        CDSCalendarResult updateResult = CDSCALENDAR_UNITTESTFAIL;
 {
        
        CDSCalendarResult updateResult = CDSCALENDAR_UNITTESTFAIL;
@@ -695,7 +753,7 @@ CDSCalendarResult CalendarDataStorage::UpdateCalendar(int calendarID, string cal
        
        // Update the account.
        
        
        // Update the account.
        
-       resultCode = sqlite3_prepare_v2(db, "UPDATE calendars SET name=(?1) WHERE id=(?2);", -1, &statementHandle, nullptr);
+       resultCode = sqlite3_prepare_v2(db, "UPDATE calendars SET name=(?1), colour=(?2), description=(?3) WHERE id=(?4);", -1, &statementHandle, nullptr);
        
        if (resultCode != 0){
                return CDSCALENDAR_FAILED;
        
        if (resultCode != 0){
                return CDSCALENDAR_FAILED;
@@ -703,11 +761,23 @@ CDSCalendarResult CalendarDataStorage::UpdateCalendar(int calendarID, string cal
        
        resultCode = sqlite3_bind_text(statementHandle, 1, calendarName.c_str(), -1, SQLITE_STATIC);
        
        
        resultCode = sqlite3_bind_text(statementHandle, 1, calendarName.c_str(), -1, SQLITE_STATIC);
        
+       if (resultCode != 0){
+               return CDSCALENDAR_FAILED;
+       }
+
+       resultCode = sqlite3_bind_text(statementHandle, 2, string(calendarColour).c_str(), -1, SQLITE_STATIC);
+       
+       if (resultCode != 0){
+               return CDSCALENDAR_FAILED;
+       }
+
+       resultCode = sqlite3_bind_text(statementHandle, 3, calendarDescription.c_str(), -1, SQLITE_STATIC);
+       
        if (resultCode != 0){
                return CDSCALENDAR_FAILED;
        }
        
        if (resultCode != 0){
                return CDSCALENDAR_FAILED;
        }
        
-       resultCode = sqlite3_bind_int(statementHandle, 2, calendarID);
+       resultCode = sqlite3_bind_int(statementHandle, 4, calendarID);
        
        if (resultCode != 0){
                return CDSCALENDAR_FAILED;
        
        if (resultCode != 0){
                return CDSCALENDAR_FAILED;
@@ -1154,9 +1224,10 @@ CDSAddEntryResult CalendarDataStorage::AddEvent(int calendarID, std::string file
        std::string sqlParameter = "INSERT INTO calendarentries (calendarid, entryname, entrydescription,"
        " entrystartyear, entrystartmonth, entrystartday, entrystarthour, entrystartminute, entrystartsecond,"
        " entryendyear, entryendmonth, entryendday, entryendhour, entryendminute, entryendsecond, "
        std::string sqlParameter = "INSERT INTO calendarentries (calendarid, entryname, entrydescription,"
        " entrystartyear, entrystartmonth, entrystartday, entrystarthour, entrystartminute, entrystartsecond,"
        " entryendyear, entryendmonth, entryendday, entryendhour, entryendminute, entryendsecond, "
-       " entrydurationweek, entrydurationday, entrydurationhour, entrydurationminute, entrydurationsecond)"
+       " entrydurationweek, entrydurationday, entrydurationhour, entrydurationminute, entrydurationsecond, "
+       " filename)"
        " VALUES ((?1), (?2), (?3), (?4), (?5), (?6), (?7), (?8), (?9), (?10), "
        " VALUES ((?1), (?2), (?3), (?4), (?5), (?6), (?7), (?8), (?9), (?10), "
-       " (?11), (?12), (?13), (?14), (?15), (?16), (?17), (?18), (?19), (?20))";
+       " (?11), (?12), (?13), (?14), (?15), (?16), (?17), (?18), (?19), (?20), (?21))";
        
        resultCode = sqlite3_prepare_v2(db, sqlParameter.c_str(), -1, &statementHandle, nullptr);
 
        
        resultCode = sqlite3_prepare_v2(db, sqlParameter.c_str(), -1, &statementHandle, nullptr);
 
@@ -1318,6 +1389,13 @@ CDSAddEntryResult CalendarDataStorage::AddEvent(int calendarID, std::string file
                return addResult;
        }
        
                return addResult;
        }
        
+       resultCode = sqlite3_bind_text(statementHandle, 21, filename.c_str(), -1, SQLITE_STATIC);
+       
+       if (resultCode != 0){
+               addResult.addEventResult = CDSENTRY_FAILED;
+               return addResult;
+       }
+       
        resultCode = sqlite3_step(statementHandle);
        
        if (resultCode != SQLITE_DONE){
        resultCode = sqlite3_step(statementHandle);
        
        if (resultCode != SQLITE_DONE){
@@ -1336,30 +1414,54 @@ CDSAddEntryResult CalendarDataStorage::AddEvent(int calendarID, std::string file
        
 }
 
        
 }
 
-CDSGetCalendarEntryInfo CalendarDataStorage::GetEvent(int calendarEntryID)
+CDSEditEntryResult CalendarDataStorage::UpdateEvent(int eventID, std::string filename)
 {
        
 {
        
-       CDSGetCalendarEntryInfo entryResult;
+       CDSEditEntryResult editResult;
+       editResult.editEventResult = CDSENTRY_UNITTESTFAIL;
        
        
-       // Check if the calendar entry exists.
+       // Load the event file.
+       
+       CalendarEventObject eventData;
+       CalendarObjectLoadResult eventLoadResult = eventData.LoadFile(filename);
+       
+       // Check the result of the event file load.
+       
+       switch (eventLoadResult){
+               
+               case CALENDAROBJECTLOAD_OK:
+                       break;
+               case CALENDAROBJECTLOAD_MISSING:
+                       editResult.editEventResult = CDSENTRY_MISSINGFILE;
+                       return editResult;
+               case CALENDAROBJECTLOAD_INVALIDFORMAT:
+                       editResult.editEventResult = CDSENTRY_INVALIDFILE;
+                       return editResult;
+               case CALENDAROBJECTLOAD_CANNOTOPEN:
+                       editResult.editEventResult = CDSENTRY_CANNOTOPENFILE;
+                       return editResult;
+               
+       }
+       
+       // Check if event exists first.
        
        int resultCode;
        
        sqlite3_stmt *findHandle;
        sqlite3_stmt *statementHandle;
        
        
        int resultCode;
        
        sqlite3_stmt *findHandle;
        sqlite3_stmt *statementHandle;
        
-       resultCode = sqlite3_prepare_v2(db, "SELECT id FROM calendarentries WHERE id=(?1);", -1, &findHandle, nullptr);
+       resultCode = sqlite3_prepare_v2(db, "SELECT id from calendarentries WHERE id=(?1);", -1, &findHandle, nullptr);
        
        if (resultCode != 0){
        
        if (resultCode != 0){
-               entryResult.getEventResult = CDSENTRY_FAILED;
-               return entryResult;
+               editResult.editEventResult = CDSENTRY_FAILED;
+               return editResult;
        }
        
        }
        
-       resultCode = sqlite3_bind_int(findHandle, 1, calendarEntryID);
+       resultCode = sqlite3_bind_int(findHandle, 1, eventID);
        
        if (resultCode != 0){
        
        if (resultCode != 0){
-               entryResult.getEventResult = CDSENTRY_FAILED;
-               return entryResult;
+               editResult.editEventResult = CDSENTRY_FAILED;
+               return editResult;
        }
        
        resultCode = sqlite3_step(findHandle);
        }
        
        resultCode = sqlite3_step(findHandle);
@@ -1367,158 +1469,663 @@ CDSGetCalendarEntryInfo CalendarDataStorage::GetEvent(int calendarEntryID)
        if (resultCode == SQLITE_ROW){
                
        } else if (resultCode == SQLITE_DONE) {
        if (resultCode == SQLITE_ROW){
                
        } else if (resultCode == SQLITE_DONE) {
-               entryResult.getEventResult = CDSENTRY_NOENTRY;
-               return entryResult;
+               editResult.editEventResult = CDSENTRY_NOENTRY;
+               return editResult;
        } else {
        } else {
-               entryResult.getEventResult = CDSENTRY_FAILED;
-               return entryResult;
+               editResult.editEventResult = CDSENTRY_FAILED;
+               return editResult;
        }
        
        }
        
-       // Get the calendar entry data.
-       
-       std::string sqlParameter = "SELECT entryname, entrydescription,"
-       " entrystartyear, entrystartmonth, entrystartday, entrystarthour, entrystartminute, entrystartsecond,"
-       " entryendyear, entryendmonth, entryendday, entryendhour, entryendminute, entryendsecond, "
-       " entrydurationweek, entrydurationday, entrydurationhour, entrydurationminute, entrydurationsecond, "
-       " calendarid, id"
-       " FROM calendarentries WHERE id=(?1)";
+       // Get the required values from the event object.
        
        
-       resultCode = sqlite3_prepare_v2(db, sqlParameter.c_str(), -1, &statementHandle, nullptr);
-
-       if (resultCode != 0){
-               entryResult.getEventResult = CDSENTRY_FAILED;
-               return entryResult;
-       }
+       int eventStartYear = 0;
+       int eventStartMonth = 0;
+       int eventStartDay = 0;
+       int eventStartHour = 0;
+       int eventStartMinute = 0;
+       int eventStartSecond = 0;
+       int eventStartDuration = 0;
+       std::string eventString = "";
        
        
-       resultCode = sqlite3_bind_int(statementHandle, 1, calendarEntryID);
+       // Start Date.
        
        
-       if (resultCode != 0){
-               entryResult.getEventResult = CDSENTRY_FAILED;
-               return entryResult;
+       if (eventData.DateTimeStartData.size() < 16){
+               
+               editResult.editEventResult = CDSENTRY_INVALIDFILE;
+               return editResult;
+               
        }
        
        }
        
-       resultCode = sqlite3_step(statementHandle);
+       eventString = eventData.DateTimeStartData.substr(0,4);
        
        
-       if (resultCode == SQLITE_ROW){
-               
-               // Get the calendar entry name,
-               
-               stringstream entryStream;
+       if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
                
                
-               entryStream << sqlite3_column_text(statementHandle, 0);
-               entryResult.entryName = entryStream.str();
+               eventStartYear = atoi(eventString.c_str());
                
                
-               entryStream.str("");
+       } else {
                
                
-               // Get the calendar entry description.
+               editResult.editEventResult = CDSENTRY_INVALIDFILE;
+               return editResult;
                
                
-               entryStream << sqlite3_column_text(statementHandle, 1);
-               entryResult.entryDescription = entryStream.str();               
+       }
 
 
-               entryStream.str("");
+       eventString = eventData.DateTimeStartData.substr(4,2);
+       
+       if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
                
                
-               entryResult.entryStartYear = sqlite3_column_int(statementHandle, 2);
-               entryResult.entryStartMonth = sqlite3_column_int(statementHandle, 3);
-               entryResult.entryStartDay = sqlite3_column_int(statementHandle, 4);
-               entryResult.entryStartHour = sqlite3_column_int(statementHandle, 5);
-               entryResult.entryStartMinute = sqlite3_column_int(statementHandle, 6);
-               entryResult.entryStartSecond = sqlite3_column_int(statementHandle, 7);
-               entryResult.entryEndYear = sqlite3_column_int(statementHandle, 8);
-               entryResult.entryEndMonth = sqlite3_column_int(statementHandle, 9);
-               entryResult.entryEndDay = sqlite3_column_int(statementHandle, 10);
-               entryResult.entryEndHour = sqlite3_column_int(statementHandle, 11);             
-               entryResult.entryEndMinute = sqlite3_column_int(statementHandle, 12);
-               entryResult.entryEndSecond = sqlite3_column_int(statementHandle, 13);
-               entryResult.entryDurationWeeks = sqlite3_column_int(statementHandle, 14);
-               entryResult.entryDurationDays = sqlite3_column_int(statementHandle, 15);
-               entryResult.entryDurationHours = sqlite3_column_int(statementHandle, 16);
-               entryResult.entryDurationMinutes = sqlite3_column_int(statementHandle, 17);
-               entryResult.entryDurationSeconds = sqlite3_column_int(statementHandle, 18);
-               entryResult.calendarID = sqlite3_column_int(statementHandle, 19);
-               entryResult.calendarEntryID = sqlite3_column_int(statementHandle, 20);
+               eventStartMonth = atoi(eventString.c_str());
                
                
-       } else if (resultCode == SQLITE_DONE) {
-               entryResult.getEventResult = CDSENTRY_NOCALENDAR;
-               return entryResult;
        } else {
        } else {
-               entryResult.getEventResult = CDSENTRY_FAILED;
-               return entryResult;
-       }
-       
-       entryResult.getEventResult = CDSENTRY_OK;
-       
-       return entryResult;
-       
-}
-
-CDSEntryResult CalendarDataStorage::DeleteEvent(int calendarEntryID)
-{
-       
-       CDSEntryResult deleteResult = CDSENTRY_UNITTESTFAIL;
-       
-       // Check if the calendar entry exists.
-       
-       int resultCode;
-       
-       sqlite3_stmt *findHandle;
-       sqlite3_stmt *statementHandle;
-       
-       resultCode = sqlite3_prepare_v2(db, "SELECT id FROM calendarentries WHERE id=(?1);", -1, &findHandle, nullptr);
-       
-       if (resultCode != 0){
-               return CDSENTRY_FAILED;
-       }
-       
-       resultCode = sqlite3_bind_int(findHandle, 1, calendarEntryID);
-       
-       if (resultCode != 0){
-               return CDSENTRY_FAILED;
+               
+               editResult.editEventResult = CDSENTRY_INVALIDFILE;
+               return editResult;
+               
        }
        
        }
        
-       resultCode = sqlite3_step(findHandle);
+       eventString = eventData.DateTimeStartData.substr(6,2);
        
        
-       if (resultCode == SQLITE_ROW){
+       if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
+               
+               eventStartDay = atoi(eventString.c_str());
                
                
-       } else if (resultCode == SQLITE_DONE) {
-               return CDSENTRY_NOENTRY;
        } else {
        } else {
-               return CDSENTRY_FAILED;
+               
+               editResult.editEventResult = CDSENTRY_INVALIDFILE;
+               return editResult;
+               
        }
 
        }
 
-       // Delete the account.
-       
-       resultCode = sqlite3_prepare_v2(db, "DELETE FROM calendarentries WHERE id=(?1);", -1, &statementHandle, nullptr);
+       eventString = eventData.DateTimeStartData.substr(9,2);
        
        
-       if (resultCode != 0){
-               return CDSENTRY_FAILED;
+       if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
+               
+               eventStartHour = atoi(eventString.c_str());
+               
+       } else {
+               
+               editResult.editEventResult = CDSENTRY_INVALIDFILE;
+               return editResult;
+               
        }
        
        }
        
-       resultCode = sqlite3_bind_int(statementHandle, 1, calendarEntryID);
+       eventString = eventData.DateTimeStartData.substr(11,2);
        
        
-       if (resultCode != 0){
-               return CDSENTRY_FAILED;
+       if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
+               
+               eventStartMinute = atoi(eventString.c_str());
+               
+       } else {
+               
+               editResult.editEventResult = CDSENTRY_INVALIDFILE;
+               return editResult;
+               
        }
        
        }
        
-       resultCode = sqlite3_step(statementHandle);
+       eventString = eventData.DateTimeStartData.substr(13,2);
        
        
-       if (resultCode == SQLITE_DONE){
-               deleteResult = CDSENTRY_OK;
+       if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
+               
+               eventStartSecond = atoi(eventString.c_str());
+               
        } else {
        } else {
-               return CDSENTRY_FAILED;
+               
+               editResult.editEventResult = CDSENTRY_INVALIDFILE;
+               return editResult;
+               
        }
        
        }
        
-       // Update the checksum.
-       
-       UpdateChecksum("internal_updatedata", to_string(GenerateRandomNumber(CDS_RANDOMPOW)));
+       //eventYear = eventStartDate.substr(0, 4);
        
        
-       return deleteResult;    
+       // End Date.
        
        
-}
-
-CDSEntryList CalendarDataStorage::GetEventList(int calendarID){
+       int eventEndYear = 0;
+       int eventEndMonth = 0;
+       int eventEndDay = 0;
+       int eventEndHour = 0;
+       int eventEndMinute = 0;
+       int eventEndSecond = 0;
+       int eventEndDuration = 0;
        
        
-       CDSEntryList entryList;
-       entryList.getEventListResult = CDSENTRY_UNITTESTFAIL;
+       if (eventData.DateTimeEndData != ""){
+       
+               if (eventData.DateTimeEndData.size() < 16){
+               
+                       editResult.editEventResult = CDSENTRY_INVALIDFILE;
+                       return editResult;
+               
+               }
+       
+               eventString = eventData.DateTimeEndData.substr(0,4);
+       
+               if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
+               
+                       eventEndYear = atoi(eventString.c_str());
+               
+               } else {
+               
+                       editResult.editEventResult = CDSENTRY_INVALIDFILE;
+                       return editResult;
+               
+               }
+
+               eventString = eventData.DateTimeEndData.substr(4,2);
+       
+               if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
+               
+                       eventEndMonth = atoi(eventString.c_str());
+               
+               } else {
+               
+                       editResult.editEventResult = CDSENTRY_INVALIDFILE;
+                       return editResult;
+               
+               }
+       
+               eventString = eventData.DateTimeEndData.substr(6,2);
+       
+               if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
+               
+                       eventEndDay = atoi(eventString.c_str());
+               
+               } else {
+               
+                       editResult.editEventResult = CDSENTRY_INVALIDFILE;
+                       return editResult;
+               
+               }
+
+               eventString = eventData.DateTimeEndData.substr(9,2);
+       
+               if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
+               
+                       eventEndHour = atoi(eventString.c_str());
+               
+               } else {
+               
+                       editResult.editEventResult = CDSENTRY_INVALIDFILE;
+                       return editResult;
+               
+               }
+       
+               eventString = eventData.DateTimeEndData.substr(11,2);
+       
+               if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
+               
+                       eventEndMinute = atoi(eventString.c_str());
+               
+               } else {
+               
+                       editResult.editEventResult = CDSENTRY_INVALIDFILE;
+                       return editResult;
+               
+               }
+       
+               eventString = eventData.DateTimeEndData.substr(13,2);
+       
+               if (all_of(eventString.begin(), eventString.end(), ::isdigit)){
+               
+                       eventEndSecond = atoi(eventString.c_str());
+               
+               } else {
+               
+                       editResult.editEventResult = CDSENTRY_INVALIDFILE;
+                       return editResult;
+               
+               }
+               
+       }
+
+       eventString = eventData.DurationData;
+       
+       // Process the duration data.
+       
+       int eventDurationWeeks = 0;
+       int eventDurationDays = 0;
+       int eventDurationHours = 0;
+       int eventDurationMinutes = 0;
+       int eventDurationSeconds = 0;
+       
+       // Get the duration (if DTEND hasn't been specified).
+       
+       if (eventData.DurationData.size() > 0){
+               
+               bool FoundP = false;
+               bool FoundW = false;
+               bool DateTimeMode = false;
+               
+               std::string::iterator eventDataChar = eventData.DurationData.begin();
+               std::string currentValue = "";
+               
+               if (*eventDataChar != 'P'){
+                       
+                       eventDataChar = eventData.DurationData.end();
+                       
+               }
+               
+               for(eventDataChar; eventDataChar != eventData.DurationData.end(); eventDataChar++){
+                       
+                       // Check if value is a digit.
+                       
+                       if (isdigit(*eventDataChar)){
+                               
+                               currentValue += *eventDataChar;
+                               
+                       } else {
+                               
+                               // Check that the value matches one of the letters.
+                               
+                               if (*eventDataChar == 'W' && DateTimeMode == false){
+                               
+                                       eventDurationWeeks = atoi(currentValue.c_str());
+                                       
+                               } else if (*eventDataChar == 'D' && DateTimeMode == false){
+
+                                       eventDurationDays = atoi(currentValue.c_str());
+                                       
+                               } else if (*eventDataChar == 'T' && DateTimeMode == false){
+                                       
+                                       DateTimeMode = true;
+                                       
+                               } else if (*eventDataChar == 'H'){
+
+                                       eventDurationHours = atoi(currentValue.c_str());
+                                       
+                               } else if (*eventDataChar == 'M'){
+                                       
+                                       eventDurationMinutes = atoi(currentValue.c_str());
+                                       
+                               } else if (*eventDataChar == 'S'){
+                               
+                                       eventDurationSeconds = atoi(currentValue.c_str());
+                                       
+                               }
+                                       
+                               // Reset the current value.
+                               
+                               currentValue = "";
+                               
+                       }
+                       
+               }
+               
+       }
+       
+       // Add the calendar entry.
+       
+       std::string sqlParameter = "UPDATE calendarentries SET entryname=(?2), entrydescription=(?3),"
+       " entrystartyear=(?4), entrystartmonth=(?5), entrystartday=(?6), entrystarthour=(?7), entrystartminute=(?8), entrystartsecond=(?9),"
+       " entryendyear=(?10), entryendmonth=(?11), entryendday=(?12), entryendhour=(?13), entryendminute=(?14), entryendsecond=(?15), "
+       " entrydurationweek=(?16), entrydurationday=(?17), entrydurationhour=(?18), entrydurationminute=(?19), entrydurationsecond=(?20), "
+       " WHERE id=(?1)";
+       
+       resultCode = sqlite3_prepare_v2(db, sqlParameter.c_str(), -1, &statementHandle, nullptr);
+
+       resultCode = sqlite3_bind_int(statementHandle, 1, eventID);
+       
+       if (resultCode != 0){
+               editResult.editEventResult = CDSENTRY_FAILED;
+               return editResult;
+       }
+       
+       // Process Entry Name.
+       
+       resultCode = sqlite3_bind_text(statementHandle, 2, eventData.SummaryData.c_str(), -1, SQLITE_STATIC);
+       
+       if (resultCode != 0){
+               editResult.editEventResult = CDSENTRY_FAILED;
+               return editResult;
+       }
+       
+       // Process Entry Description.
+       
+       string eventDescription;
+       
+       try {
+               eventDescription = eventData.DescriptionList.at(0);
+       }
+       
+       catch (out_of_range &err){
+               eventDescription = "";
+       }
+       
+       resultCode = sqlite3_bind_text(statementHandle, 3, eventDescription.c_str(), -1, SQLITE_STATIC);
+       
+       if (resultCode != 0){
+               editResult.editEventResult = CDSENTRY_FAILED;
+               return editResult;
+       }
+       
+       // Process Entry Start Date information.
+       
+       resultCode = sqlite3_bind_int(statementHandle, 4, eventStartYear);
+       
+       if (resultCode != 0){
+               editResult.editEventResult = CDSENTRY_FAILED;
+               return editResult;
+       }
+
+       resultCode = sqlite3_bind_int(statementHandle, 5, eventStartMonth);
+       
+       if (resultCode != 0){
+               editResult.editEventResult = CDSENTRY_FAILED;
+               return editResult;
+       }
+
+       resultCode = sqlite3_bind_int(statementHandle, 6, eventStartDay);
+       
+       if (resultCode != 0){
+               editResult.editEventResult = CDSENTRY_FAILED;
+               return editResult;
+       }
+
+       resultCode = sqlite3_bind_int(statementHandle, 7, eventStartHour);
+       
+       if (resultCode != 0){
+               editResult.editEventResult = CDSENTRY_FAILED;
+               return editResult;
+       }
+
+       resultCode = sqlite3_bind_int(statementHandle, 8, eventStartMinute);
+       
+       if (resultCode != 0){
+               editResult.editEventResult = CDSENTRY_FAILED;
+               return editResult;
+       }
+       
+       resultCode = sqlite3_bind_int(statementHandle, 9, eventStartSecond);
+       
+       if (resultCode != 0){
+               editResult.editEventResult = CDSENTRY_FAILED;
+               return editResult;
+       }
+       
+       // Process Entry Start End information.
+       
+       resultCode = sqlite3_bind_int(statementHandle, 10, eventEndYear);
+       
+       if (resultCode != 0){
+               editResult.editEventResult = CDSENTRY_FAILED;
+               return editResult;
+       }
+
+       resultCode = sqlite3_bind_int(statementHandle, 11, eventEndMonth);
+       
+       if (resultCode != 0){
+               editResult.editEventResult = CDSENTRY_FAILED;
+               return editResult;
+       }
+
+       resultCode = sqlite3_bind_int(statementHandle, 12, eventEndDay);
+       
+       if (resultCode != 0){
+               editResult.editEventResult = CDSENTRY_FAILED;
+               return editResult;
+       }
+
+       resultCode = sqlite3_bind_int(statementHandle, 13, eventEndHour);
+       
+       if (resultCode != 0){
+               editResult.editEventResult = CDSENTRY_FAILED;
+               return editResult;
+       }
+
+       resultCode = sqlite3_bind_int(statementHandle, 14, eventEndMinute);
+       
+       if (resultCode != 0){
+               editResult.editEventResult = CDSENTRY_FAILED;
+               return editResult;
+       }
+       
+       resultCode = sqlite3_bind_int(statementHandle, 15, eventEndSecond);
+       
+       if (resultCode != 0){
+               editResult.editEventResult = CDSENTRY_FAILED;
+               return editResult;
+       }
+       
+       resultCode = sqlite3_bind_int(statementHandle, 16, eventDurationWeeks);
+       
+       if (resultCode != 0){
+               editResult.editEventResult = CDSENTRY_FAILED;
+               return editResult;
+       }
+       
+       resultCode = sqlite3_bind_int(statementHandle, 17, eventDurationDays);
+       
+       if (resultCode != 0){
+               editResult.editEventResult = CDSENTRY_FAILED;
+               return editResult;
+       }
+       
+       resultCode = sqlite3_bind_int(statementHandle, 18, eventDurationHours);
+       
+       if (resultCode != 0){
+               editResult.editEventResult = CDSENTRY_FAILED;
+               return editResult;
+       }
+       
+       resultCode = sqlite3_bind_int(statementHandle, 19, eventDurationMinutes);
+       
+       if (resultCode != 0){
+               editResult.editEventResult = CDSENTRY_FAILED;
+               return editResult;
+       }
+       
+       resultCode = sqlite3_bind_int(statementHandle, 20, eventDurationSeconds);
+       
+       if (resultCode != 0){
+               editResult.editEventResult = CDSENTRY_FAILED;
+               return editResult;
+       }
+       
+       resultCode = sqlite3_step(statementHandle);
+       
+       if (resultCode != SQLITE_DONE){
+               editResult.editEventResult = CDSENTRY_FAILED;
+               return editResult;
+       }
+       
+       editResult.calendarEntryID = sqlite3_last_insert_rowid(db);
+       editResult.editEventResult = CDSENTRY_OK;
+       
+       // Update the checksum.
+       
+       UpdateChecksum("internal_updatedata", to_string(GenerateRandomNumber(CDS_RANDOMPOW)));
+       
+       return editResult;
+       
+}
+
+CDSGetCalendarEntryInfo CalendarDataStorage::GetEvent(int calendarEntryID)
+{
+       
+       CDSGetCalendarEntryInfo entryResult;
+       
+       // Check if the calendar entry exists.
+       
+       int resultCode;
+       
+       sqlite3_stmt *findHandle;
+       sqlite3_stmt *statementHandle;
+       
+       resultCode = sqlite3_prepare_v2(db, "SELECT id FROM calendarentries WHERE id=(?1);", -1, &findHandle, nullptr);
+       
+       if (resultCode != 0){
+               entryResult.getEventResult = CDSENTRY_FAILED;
+               return entryResult;
+       }
+       
+       resultCode = sqlite3_bind_int(findHandle, 1, calendarEntryID);
+       
+       if (resultCode != 0){
+               entryResult.getEventResult = CDSENTRY_FAILED;
+               return entryResult;
+       }
+       
+       resultCode = sqlite3_step(findHandle);
+       
+       if (resultCode == SQLITE_ROW){
+               
+       } else if (resultCode == SQLITE_DONE) {
+               entryResult.getEventResult = CDSENTRY_NOENTRY;
+               return entryResult;
+       } else {
+               entryResult.getEventResult = CDSENTRY_FAILED;
+               return entryResult;
+       }
+       
+       // Get the calendar entry data.
+       
+       std::string sqlParameter = "SELECT entryname, entrydescription,"
+       " entrystartyear, entrystartmonth, entrystartday, entrystarthour, entrystartminute, entrystartsecond,"
+       " entryendyear, entryendmonth, entryendday, entryendhour, entryendminute, entryendsecond, "
+       " entrydurationweek, entrydurationday, entrydurationhour, entrydurationminute, entrydurationsecond, "
+       " calendarid, id, filename"
+       " FROM calendarentries WHERE id=(?1)";
+       
+       resultCode = sqlite3_prepare_v2(db, sqlParameter.c_str(), -1, &statementHandle, nullptr);
+
+       if (resultCode != 0){
+               entryResult.getEventResult = CDSENTRY_FAILED;
+               return entryResult;
+       }
+       
+       resultCode = sqlite3_bind_int(statementHandle, 1, calendarEntryID);
+       
+       if (resultCode != 0){
+               entryResult.getEventResult = CDSENTRY_FAILED;
+               return entryResult;
+       }
+       
+       resultCode = sqlite3_step(statementHandle);
+       
+       if (resultCode == SQLITE_ROW){
+               
+               // Get the calendar entry name,
+               
+               stringstream entryStream;
+               
+               entryStream << sqlite3_column_text(statementHandle, 0);
+               entryResult.entryName = entryStream.str();
+               
+               entryStream.str("");
+               
+               // Get the calendar entry description.
+               
+               entryStream << sqlite3_column_text(statementHandle, 1);
+               entryResult.entryDescription = entryStream.str();               
+
+               entryStream.str("");
+               
+               // Get the calendar entry filename.
+               
+               entryStream << sqlite3_column_text(statementHandle, 21);
+               entryResult.entryFilename = entryStream.str();
+
+               entryStream.str("");
+               
+               entryResult.entryStartYear = sqlite3_column_int(statementHandle, 2);
+               entryResult.entryStartMonth = sqlite3_column_int(statementHandle, 3);
+               entryResult.entryStartDay = sqlite3_column_int(statementHandle, 4);
+               entryResult.entryStartHour = sqlite3_column_int(statementHandle, 5);
+               entryResult.entryStartMinute = sqlite3_column_int(statementHandle, 6);
+               entryResult.entryStartSecond = sqlite3_column_int(statementHandle, 7);
+               entryResult.entryEndYear = sqlite3_column_int(statementHandle, 8);
+               entryResult.entryEndMonth = sqlite3_column_int(statementHandle, 9);
+               entryResult.entryEndDay = sqlite3_column_int(statementHandle, 10);
+               entryResult.entryEndHour = sqlite3_column_int(statementHandle, 11);             
+               entryResult.entryEndMinute = sqlite3_column_int(statementHandle, 12);
+               entryResult.entryEndSecond = sqlite3_column_int(statementHandle, 13);
+               entryResult.entryDurationWeeks = sqlite3_column_int(statementHandle, 14);
+               entryResult.entryDurationDays = sqlite3_column_int(statementHandle, 15);
+               entryResult.entryDurationHours = sqlite3_column_int(statementHandle, 16);
+               entryResult.entryDurationMinutes = sqlite3_column_int(statementHandle, 17);
+               entryResult.entryDurationSeconds = sqlite3_column_int(statementHandle, 18);
+               entryResult.calendarID = sqlite3_column_int(statementHandle, 19);
+               entryResult.calendarEntryID = sqlite3_column_int(statementHandle, 20);
+               
+       } else if (resultCode == SQLITE_DONE) {
+               entryResult.getEventResult = CDSENTRY_NOCALENDAR;
+               return entryResult;
+       } else {
+               entryResult.getEventResult = CDSENTRY_FAILED;
+               return entryResult;
+       }
+       
+       entryResult.getEventResult = CDSENTRY_OK;
+       
+       return entryResult;
+       
+}
+
+CDSEntryResult CalendarDataStorage::DeleteEvent(int calendarEntryID)
+{
+       
+       CDSEntryResult deleteResult = CDSENTRY_UNITTESTFAIL;
+       
+       // Check if the calendar entry exists.
+       
+       int resultCode;
+       
+       sqlite3_stmt *findHandle;
+       sqlite3_stmt *statementHandle;
+       
+       resultCode = sqlite3_prepare_v2(db, "SELECT id FROM calendarentries WHERE id=(?1);", -1, &findHandle, nullptr);
+       
+       if (resultCode != 0){
+               return CDSENTRY_FAILED;
+       }
+       
+       resultCode = sqlite3_bind_int(findHandle, 1, calendarEntryID);
+       
+       if (resultCode != 0){
+               return CDSENTRY_FAILED;
+       }
+       
+       resultCode = sqlite3_step(findHandle);
+       
+       if (resultCode == SQLITE_ROW){
+               
+       } else if (resultCode == SQLITE_DONE) {
+               return CDSENTRY_NOENTRY;
+       } else {
+               return CDSENTRY_FAILED;
+       }
+
+       // Delete the account.
+       
+       resultCode = sqlite3_prepare_v2(db, "DELETE FROM calendarentries WHERE id=(?1);", -1, &statementHandle, nullptr);
+       
+       if (resultCode != 0){
+               return CDSENTRY_FAILED;
+       }
+       
+       resultCode = sqlite3_bind_int(statementHandle, 1, calendarEntryID);
+       
+       if (resultCode != 0){
+               return CDSENTRY_FAILED;
+       }
+       
+       resultCode = sqlite3_step(statementHandle);
+       
+       if (resultCode == SQLITE_DONE){
+               deleteResult = CDSENTRY_OK;
+       } else {
+               return CDSENTRY_FAILED;
+       }
+       
+       // Update the checksum.
+       
+       UpdateChecksum("internal_updatedata", to_string(GenerateRandomNumber(CDS_RANDOMPOW)));
+       
+       return deleteResult;    
+       
+}
+
+CDSEntryList CalendarDataStorage::GetEventList(int calendarID){
+       
+       CDSEntryList entryList;
+       entryList.getEventListResult = CDSENTRY_UNITTESTFAIL;
        
        // Check if calendar exists first.
        
        
        // Check if calendar exists first.
        
@@ -1909,4 +2516,104 @@ CDSChecksumResult CalendarDataStorage::UpdateChecksum(std::string checksumName,
        
        return CDSCHECKSUM_OK;
        
        
        return CDSCHECKSUM_OK;
        
+}
+
+CDSCleanupResult CalendarDataStorage::Clear(){
+       
+       // Remove all data from the tables and reset the sequence numbers.
+
+       int resultCode; 
+       sqlite3_stmt *statementHandle;
+       
+       resultCode = sqlite3_prepare_v2(db, "DELETE FROM calendarentries", -    1, &statementHandle, nullptr);
+       
+       if (resultCode != 0){
+               cout << "Fail 1" << endl;
+               return CDSCLEANUP_FAILED;
+       }
+       
+       resultCode = sqlite3_step(statementHandle);
+       
+       if (resultCode != SQLITE_DONE){
+               cout << "Fail 2" << endl;
+               return CDSCLEANUP_FAILED;
+       }
+       
+       resultCode = sqlite3_prepare_v2(db, "DELETE FROM sqlite_sequence WHERE name='calendarentries';", -1, &statementHandle, nullptr);
+       
+       if (resultCode != 0){
+               cout << "Fail 3" << endl;
+               cout << sqlite3_errmsg(db) << endl;
+               return CDSCLEANUP_FAILED;
+       }
+
+       resultCode = sqlite3_step(statementHandle);
+       
+       if (resultCode != SQLITE_DONE){
+               cout << "Fail 4" << endl;
+               return CDSCLEANUP_FAILED;
+       }
+
+       resultCode = sqlite3_prepare_v2(db, "DELETE FROM calendars", -1, &statementHandle, nullptr);
+       
+       if (resultCode != 0){
+               cout << "Fail 5" << endl;
+               return CDSCLEANUP_FAILED;
+       }
+       
+       resultCode = sqlite3_step(statementHandle);
+       
+       if (resultCode != SQLITE_DONE){
+               cout << "Fail 6" << endl;
+               return CDSCLEANUP_FAILED;
+       }
+       
+       resultCode = sqlite3_prepare_v2(db, "DELETE FROM sqlite_sequence WHERE name='calendars';", -1, &statementHandle, nullptr);
+       
+       if (resultCode != 0){
+               cout << "Fail 7" << endl;
+               return CDSCLEANUP_FAILED;
+       }
+
+       resultCode = sqlite3_step(statementHandle);
+       
+       if (resultCode != SQLITE_DONE){
+               cout << "Fail 8" << endl;
+               return CDSCLEANUP_FAILED;
+       }
+       
+       resultCode = sqlite3_prepare_v2(db, "DELETE FROM accounts", -1, &statementHandle, nullptr);
+       
+       if (resultCode != 0){
+               cout << "Fail 9" << endl;
+               return CDSCLEANUP_FAILED;
+       }
+       
+       resultCode = sqlite3_step(statementHandle);
+       
+       if (resultCode != SQLITE_DONE){
+               cout << "Fail 10" << endl;
+               return CDSCLEANUP_FAILED;
+       }
+       
+       resultCode = sqlite3_prepare_v2(db, "DELETE FROM sqlite_sequence WHERE name='accounts'", -1, &statementHandle, nullptr);
+       
+       if (resultCode != 0){
+               cout << "Fail 11" << endl;
+               return CDSCLEANUP_FAILED;
+       }
+
+       resultCode = sqlite3_step(statementHandle);
+       
+       if (resultCode != SQLITE_DONE){
+               cout << "Fail 12" << endl;
+               return CDSCLEANUP_FAILED;
+       }
+       
+       // Update the checksum.
+
+       UpdateChecksum("internal_updatedata", to_string(GenerateRandomNumber(CDS_RANDOMPOW)));
+       
+       return CDSCLEANUP_OK;
+       
 }
\ No newline at end of file
 }
\ No newline at end of file
index 4b41b90..47c70b5 100644 (file)
@@ -49,6 +49,7 @@ enum CDSEntryResult{
 
 struct CDSGetAccountInfo{
        int accountID = 0;
 
 struct CDSGetAccountInfo{
        int accountID = 0;
+       int accountPreferencesID = 0;
        std::string accountName = "";
        CDSAccountResult accountInfoResult = CDSACCOUNT_NOACTION;
 };
        std::string accountName = "";
        CDSAccountResult accountInfoResult = CDSACCOUNT_NOACTION;
 };
@@ -59,6 +60,7 @@ struct CDSGetCalendarInfo{
        std::string accountName = "";
        std::string calendarName = "";
        std::string calendarTextID = "";
        std::string accountName = "";
        std::string calendarName = "";
        std::string calendarTextID = "";
+       std::string calendarDescription = "";
        Colour calendarColour;
        CDSAccountResult accountInfoResult = CDSACCOUNT_NOACTION;
        CDSCalendarResult calendarInfoResult = CDSCALENDAR_NOACTION;
        Colour calendarColour;
        CDSAccountResult accountInfoResult = CDSACCOUNT_NOACTION;
        CDSCalendarResult calendarInfoResult = CDSCALENDAR_NOACTION;
@@ -69,12 +71,18 @@ struct CDSAddEntryResult{
        CDSEntryResult addEventResult = CDSENTRY_NOACTION;
 };
 
        CDSEntryResult addEventResult = CDSENTRY_NOACTION;
 };
 
+struct CDSEditEntryResult{
+       int calendarEntryID = 0;
+       CDSEntryResult editEventResult = CDSENTRY_NOACTION;
+};
+
 struct CDSGetCalendarEntryInfo{
        int accountID = 0;
        int calendarID = 0;
        int calendarEntryID = 0;
        std::string entryName = "";
        std::string entryDescription = "";
 struct CDSGetCalendarEntryInfo{
        int accountID = 0;
        int calendarID = 0;
        int calendarEntryID = 0;
        std::string entryName = "";
        std::string entryDescription = "";
+       std::string entryFilename = "";
        int entryStartYear = 0;
        int entryStartMonth = 0;
        int entryStartDay = 0;
        int entryStartYear = 0;
        int entryStartMonth = 0;
        int entryStartDay = 0;
@@ -125,6 +133,12 @@ struct CDSGetChecksumResult{
        std::string checksumValue = "";
 };
 
        std::string checksumValue = "";
 };
 
+enum CDSCleanupResult{
+       CDSCLEANUP_UNITTESTFAIL = -1,
+       CDSCLEANUP_OK,
+       CDSCLEANUP_FAILED
+};
+
 class CalendarDataStorage{
 
        private:
 class CalendarDataStorage{
 
        private:
@@ -138,7 +152,7 @@ class CalendarDataStorage{
        
                // Account functions.
        
        
                // Account functions.
        
-               CDSAccountResult AddAccount(std::string accountName);
+               CDSAccountResult AddAccount(std::string accountName, int accountPreferencesID);
                CDSGetAccountInfo GetAccount(std::string accountName);
                CDSAccountResult UpdateAccount(int accountID, std::string accountName);
                CDSAccountResult DeleteAccount(int accountID);
                CDSGetAccountInfo GetAccount(std::string accountName);
                CDSAccountResult UpdateAccount(int accountID, std::string accountName);
                CDSAccountResult DeleteAccount(int accountID);
@@ -146,11 +160,11 @@ class CalendarDataStorage{
        
                // Calendar functions.
        
        
                // Calendar functions.
        
-               CDSCalendarResult AddCalendar(int accountID, std::string calendarName, std::string calendarID, Colour calendarColour);
+               CDSCalendarResult AddCalendar(int accountID, std::string calendarName, std::string calendarID, Colour calendarColour, std::string calendarDescription);
                CDSGetCalendarInfo GetCalendar(std::string accountName, std::string calendarTextID);
                CDSGetCalendarInfo GetCalendar(int calendarID);
                CDSCalendarList GetCalendarList(int accountID);
                CDSGetCalendarInfo GetCalendar(std::string accountName, std::string calendarTextID);
                CDSGetCalendarInfo GetCalendar(int calendarID);
                CDSCalendarList GetCalendarList(int accountID);
-               CDSCalendarResult UpdateCalendar(int calendarID, std::string calendarName);
+               CDSCalendarResult UpdateCalendar(int calendarID, std::string calendarName, Colour calendarColour, std::string calendarDescription);
                CDSCalendarResult DeleteCalendar(int calendarID);
        
                // Entry functions
                CDSCalendarResult DeleteCalendar(int calendarID);
        
                // Entry functions
@@ -159,6 +173,7 @@ class CalendarDataStorage{
                CDSGetCalendarEntryInfo GetEvent(int calendarEntryID);
                CDSEntryList GetEventList(int calendarID);
                CDSEntryList GetEventListByDate(int calendarYear, int calendarMonth, int calendarDay);
                CDSGetCalendarEntryInfo GetEvent(int calendarEntryID);
                CDSEntryList GetEventList(int calendarID);
                CDSEntryList GetEventListByDate(int calendarYear, int calendarMonth, int calendarDay);
+               CDSEditEntryResult UpdateEvent(int eventID, std::string filename);
                CDSEntryResult DeleteEvent(int calendarEntryID);
                
                // Checksum functions.
                CDSEntryResult DeleteEvent(int calendarEntryID);
                
                // Checksum functions.
@@ -166,6 +181,10 @@ class CalendarDataStorage{
                CDSChecksumResult AddChecksum(std::string checksumName, std::string checksumValue);             
                CDSGetChecksumResult GetChecksum(std::string checksumName);
                CDSChecksumResult UpdateChecksum(std::string checksumName, std::string checksumValue);
                CDSChecksumResult AddChecksum(std::string checksumName, std::string checksumValue);             
                CDSGetChecksumResult GetChecksum(std::string checksumName);
                CDSChecksumResult UpdateChecksum(std::string checksumName, std::string checksumValue);
+               
+               // Cleanup functions.
+               
+               CDSCleanupResult Clear();
         
 };
 
         
 };
 
Xestia Software Development
Yn Maystri
© 2006 - 2019 Xestia Software Development
Software

Xestia Address Book
Xestia Calendar
Development

Xestia Gelforn
Everything else

About
News
Privacy Policy