/// <summary>
        /// Führt den Befehl zum Hinzufügen einer Abstimmungsoption zur Abstimmung aus.
        /// </summary>
        private void executeAddOptionTextCommand()
        {
            string optionText = EnteredOptionText;
            if (optionText != null)
                optionText = optionText.Trim();

            // Erstelle Option Objekt aus eingegebenem Text.
            Option tmp = new Option()
            {
                Text = optionText
            };

            // Führe Validierung direkt hier im ViewModel aus (Nicht wie sonst im Controller).
            RemoveFailureMessagesForProperty("Text");
            tmp.ClearValidationErrors();
            tmp.ValidateTextProperty();
            if (!tmp.HasValidationErrors())
            {
                // Füge die Option der Liste hinzu und setze Eingabefeld zurück.
                BallotOptionsCollection.Add(tmp);
                EnteredOptionText = "";

                checkCommandExecution();
            }
            else
            {
                // Setze Validierungsfehler.
                ReportValidationError("Text", tmp.GetValidationErrors()["Text"]);
            }
        }
        /// <summary>
        /// Sendet einen Request zum Anlegen einer neuen Abstimmungsoption an den Server.
        /// </summary>
        /// <param name="groupId">Die Id der Gruppe zu der die Abstimmung gehört.</param>
        /// <param name="ballotId">Die Id der Abstimmung für die eine neue Option angelegt werden soll.</param>
        /// <param name="newOption">Das Objekt vom Typ Option mit den Daten der neuen Abstimmungsoption.</param>
        /// <returns>Liefert true, wenn die Abstimmungsoption erfolgreich angelegt werden konnte. Liefert false, 
        ///     wenn die Abstimmungsoption nicht angelegt werden konnte, da z.B. die Validierung der Daten fehlgeschlagen ist.</returns>
        /// <exception cref="ClientException">Wirft ClientException, wenn Erzeugung der Abstimmungsoption fehlschlägt, 
        ///     oder vom Server abgelehnt wird.</exception>
        public async Task<bool> CreateBallotOptionAsync(int groupId, int ballotId, Option newOption)
        {
            bool successful = false;

            if (newOption == null)
                return successful;

            // Führe Validierung der Abstimmungsoptionsdaten durch. Abbruch bei Validierungsfehler.
            clearValidationErrors();
            newOption.ClearValidationErrors();
            newOption.ValidateAll();
            if (newOption.HasValidationErrors())
            {
                reportValidationErrors(newOption.GetValidationErrors());
                return successful;
            }

            // Generiere JSON-Dokument.
            string jsonContent = jsonParser.ParseOptionToJson(newOption);
            if (jsonContent == null)
            {
                Debug.WriteLine("CreateBallotOptionAsync: Failed to serialize option to json. Cannot continue.");
                throw new ClientException(ErrorCodes.JsonParserError, "Failed to create json document.");
            }

            // Setze Request zum Anlegen der Option ab.
            string serverResponse = null;
            try
            {
                serverResponse = await groupAPI.SendCreateOptionRequest(
                    getLocalUser().ServerAccessToken,
                    groupId,
                    ballotId,
                    jsonContent);

                successful = true;
            }
            catch (APIException ex)
            {
                Debug.WriteLine("CreateBallotOptionAsync: Request failed. Error code is: {0}, ResponseCode: {1}.",
                    ex.ErrorCode, ex.ResponseStatusCode);
                handleGroupRelatedErrors(ex.ErrorCode, groupId, null, ballotId);

                throw new ClientException(ex.ErrorCode, ex.Message);
            }

            if (serverResponse != null)
            {
                // Parse Server Antwort.
                Option serverOption = jsonParser.ParseOptionFromJson(serverResponse);
                if (serverOption != null)
                {
                    // Speichere Option lokal.
                    if (!StoreOption(ballotId, serverOption, false))
                    {
                        throw new ClientException(ErrorCodes.LocalDatabaseException, 
                            "CreateBallotOptionAsync: Failed to store option with id {0}." + serverOption.Id);
                    }
                }
                else
                {
                    throw new ClientException(ErrorCodes.JsonParserError, "Failed to parse server response.");
                }
            }

            return successful;
        }
        /// <summary>
        /// Speichert die übergebene Abstimmungsoption in den lokalen Datensätzen.
        /// Die übergebene Abstimmungsoption kann inklusive Informationen über die abgegebenen
        /// Stimmen gespeichert werden.
        /// </summary>
        /// <param name="ballotId">Die Id der Abstimmung zu der die Abstimmungsoption gehört.</param>
        /// <param name="option">Das Objekt vom Typ Option mit den Daten der Abstimmungsoption.</param>
        /// <param name="includingVoters">Gibt an, ob die Informationen über die abgegebenen Stimmen ebenfalls
        ///     gespeichert werden sollen.</param>
        /// <returns>Liefert true, wenn Speicherung erfolgreich. Liefert false, wenn Option nicht gespeichert
        ///     werden konnte aufgrund fehlender Abhängigkeiten.</returns>
        /// <exception cref="ClientException">Wirft ClientException, wenn Speicherung fehlschlägt.</exception>
        public bool StoreOption(int ballotId, Option option, bool includingVoters)
        {
            bool successful = false;
            try
            {
                if (includingVoters)
                {
                    if (option != null && option.VoterIds != null)
                    {
                        foreach (int voter in option.VoterIds)
                        {
                            if (!userController.IsUserLocallyStored(voter))
                            {
                                // Abbruch, da Einfügeoperation sonst fehlschlägt.
                                return false;
                            }
                        }
                    }
                }

                if (groupDBManager.IsBallotStored(ballotId))
                {
                    groupDBManager.InsertOption(ballotId, option, includingVoters);
                    successful = true;
                }
            }
            catch (DatabaseException ex)
            {
                Debug.WriteLine("StoreOption: Failed to store the given option.");
                throw new ClientException(ErrorCodes.LocalDatabaseException, ex.Message);
            }

            return successful;
        }
        /// <summary>
        /// Wandelt ein Objekt der Klasse Option in ein zugehöriges JSON Dokument um.
        /// </summary>
        /// <param name="option">Das umzuwandelnde Option Objekt.</param>
        /// <returns>Das generierte JSON-Dokument, oder null, falls die Umwandlung fehlgeschlagen ist.</returns>
        public string ParseOptionToJson(Option option)
        {
            string jsonContent = null;
            try
            {
                jsonContent = JsonConvert.SerializeObject(option);
            }
            catch (JsonException ex)
            {
                Debug.WriteLine("ParseOptionToJson: Json parser error occurred. " +
                    "Message is {0}.", ex.Message);
            }

            return jsonContent;
        }