/// <summary>
        /// Aktualisiert einen Reminder. Ermittelt die zu aktualisierenden Properties und führt einen
        /// Aktualisierungsrequest an den Server aus, um die Ressource zu aktualisieren. Bei einer erfolgreichen
        /// Aktualisierung wird auch der lokal gehaltene Datensatz aktualisiert.
        /// </summary>
        /// <param name="oldReminder">Das Reminder Objekt mit den Daten vor der Aktualisierung.</param>
        /// <param name="newReminder">Das Reminder Objekt mit den aktualisiertern Daten.</param>
        /// <returns>Liefert true, wenn die Aktualisierung erfolgreich durchgeführt werden konnte.
        ///     Liefert false, wenn Aktualisierung fehlgeschlagen ist, z.B. aufgrund eines Validierungsfehlers.</returns>
        /// <exception cref="ClientException">Wirft eine ClientException, wenn ein Fehler während der Aktualisierung auftritt, der
        ///     dem Nutzer gemeldet werden muss, z.B. wenn der Server den Request abgelehnt hat.</exception>
        public async Task<bool> UpdateReminderAsync(Reminder oldReminder, Reminder newReminder)
        {
            if (oldReminder == null || newReminder == null)
                return false;

            Moderator activeModerator = GetLocalModerator();
            if (activeModerator == null)
                return false;

            // Validiere zunächst die neu eingegebenen Daten, bei Validierungsfehlern kann hier gleich abgebrochen werden.
            clearValidationErrors();
            newReminder.ClearValidationErrors();
            newReminder.ValidateAll();
            if (newReminder.HasValidationErrors())
            {
                // Melde Validierungsfehler und breche ab.
                reportValidationErrors(newReminder.GetValidationErrors());
                return false;
            }

            // Erstelle Objekt für Aktualisierungsrequest an den Server.
            Reminder updatableReminder = createUpdatableReminderInstance(oldReminder, newReminder);
            if (updatableReminder == null)
            {
                Debug.WriteLine("No changes in reminder object detected. No update request required.");
                return true;
            }

            // Generiere Json-Dokument.
            string jsonContent = jsonParser.ParseReminderToJson(updatableReminder);
            if (jsonContent == null)
                return false;

            string serverResponse = null;
            try
            {
                // Sende Request an den Server.
                serverResponse = await channelApi.SendUpdateReminderRequestAsync(
                    activeModerator.ServerAccessToken,
                    oldReminder.ChannelId,
                    oldReminder.Id,
                    jsonContent);
            }
            catch (APIException ex)
            {
                if (ex.ErrorCode == ErrorCodes.ChannelNotFound)
                {
                    Debug.WriteLine("Channel not found on server. Channel probably deleted.");
                    // Behandlung Not Found. Kanal wahrscheinlich gelöscht.
                    MarkChannelAsDeleted(oldReminder.ChannelId);
                }

                if (ex.ErrorCode == ErrorCodes.ReminderNotFound)
                {
                    Debug.WriteLine("Reminder not found on server. Reminder probably deleted.");
                    // Behandlung von Not Found. Reminder wahrscheinlich gelöscht.
                    DeleteLocalReminder(oldReminder.Id);
                }

                Debug.WriteLine("Update request for reminder with id {0} has failed.", oldReminder.Id);
                throw new ClientException(ex.ErrorCode, ex.Message);
            }

            // Parse Server Antwort.
            if (serverResponse != null)
            {
                Reminder updatedReminder = jsonParser.ParseReminderFromJson(serverResponse);
                if (updatableReminder != null)
                {
                    ReplaceLocalReminder(updatedReminder);
                }
            }

            return true;
        }
        /// <summary>
        /// Erzeugt einen neuen Reminder. Führt die
        /// Validierung der Daten durch. Überträgt die Reminder-Daten an den Server und
        /// speichert die Daten lokal ab, wenn die Bestätigung vom Server kommt.
        /// </summary>
        /// <param name="newReminder">Das Objekt, welches die Daten des neu anzulegenden
        ///     Reminders beinhaltet.</param>
        /// <returns>Liefert true, wenn Reminder erfolgreich angelegt werden konnte, sonst false.</returns>
        /// <exception cref="ClientException">Wirft ClientException, wenn ein Fehler während des Erstellungsvorgangs auftritt.
        ///     Beispielsweise dann, wenn der Server den Request ablehnt.</exception>
        public async Task<bool> CreateReminderAsync(Reminder newReminder)
        {
            if (newReminder == null)
                return false;

            Moderator activeModerator = GetLocalModerator();
            if (activeModerator == null)
            {
                Debug.WriteLine("No active moderator. Need to abort CreateReminderAsync.");
                return false;
            }

            // Führe Validierung durch.
            clearValidationErrors();
            newReminder.ClearValidationErrors();
            newReminder.ValidateAll();
            if (newReminder.HasValidationErrors())
            {
                // Melde Validierungsfehler und breche ab.
                reportValidationErrors(newReminder.GetValidationErrors());
                return false;
            }

            // Erstelle JSON-Dokument.
            string jsonContent = jsonParser.ParseReminderToJson(newReminder);
            if (jsonContent == null)
            {
                Debug.WriteLine("Couldn't parse reminder to json. Need to abort execution.");
                return false;
            }

            string serverResponse = null;
            try
            {
                // Setzte Request an Server ab.
                serverResponse = await channelApi.SendCreateReminderRequestAsync(
                    activeModerator.ServerAccessToken,
                    newReminder.ChannelId,
                    jsonContent);
            }
            catch (APIException ex)
            {
                if (ex.ErrorCode == ErrorCodes.ChannelNotFound)
                {
                    Debug.WriteLine("Channel not found on server. Channel probably deleted.");
                    // Behandlung Not Found. Kanal wahrscheinlich gelöscht.
                    MarkChannelAsDeleted(newReminder.ChannelId);
                }

                Debug.WriteLine("Request to create reminder has failed.");
                throw new ClientException(ex.ErrorCode, ex.Message);
            }

            // Parse Reminder aus Server-Antwort.
            Reminder createdReminder = jsonParser.ParseReminderFromJson(serverResponse);
            if (createdReminder != null)
            {
                createdReminder.IsActive = true;    // Ist aktiv, wenn er gerade erstellt wurde.
                // Speichere Reminder lokal ab.
                StoreReminder(createdReminder);
            }

            return true;
        }