public async Task <IResponse <ActionResult> > CreateQuote([FromBody] QuoteModel quote)
        {
            var validationResult = quoteValidator.Validate(quote);

            if (!validationResult.IsValid)
            {
                return(Invalid <ActionResult>(validationResult.Errors.Select(x => x.ErrorMessage).ToArray()));
            }

            try
            {
                var serviceModel = new Data.ServiceModels.Quote
                {
                    Text    = quote.Text,
                    Mode    = quote.Mode,
                    Correct = quote.Correct,
                    Answers = quote.Answers == null?Array.Empty <QuoteAnswer>() : quote.Answers.Select(x => new QuoteAnswer
                    {
                        Text      = x.Text,
                        IsCorrect = x.IsCorrect
                    }).ToArray(),
                };

                await quoteService.CreateQuote(serviceModel);

                return(Success <ActionResult>(null));
            }
            catch (FqqException fex)
            {
                return(Error <ActionResult>(fex));
            }
        }
        /// <summary>
        /// create quote (make record in database)
        /// </summary>
        /// <param name="quoteModel"></param>
        /// <returns></returns>
        public async Task CreateQuote(Data.ServiceModels.Quote quoteModel)
        {
            var dbQuote = new Quote
            {
                Text    = quoteModel.Text,
                Mode    = (byte)quoteModel.Mode,
                Correct = quoteModel.Correct == null ? (bool?)null : quoteModel.Correct == BinaryType.Yes
            };

            await quote.AddAsync(dbQuote);

            await dbContext.SaveChangesAsync();

            if (quoteModel.Mode == QuoteMode.Multy)
            {
                var dbquoteAnswer = quoteModel.Answers.Select(x => new QuoteAnswer
                {
                    QuoteId   = dbQuote.Id,
                    Text      = x.Text,
                    IsCorrect = x.IsCorrect
                }).ToArray();

                await quoteAnswer.AddRangeAsync(dbquoteAnswer);

                await dbContext.SaveChangesAsync();
            }
        }
        /// <summary>
        /// delete quote
        /// </summary>
        /// <param name="quoteModel"></param>
        /// <returns></returns>
        public async Task DeleteQuote(Data.ServiceModels.Quote quoteModel)
        {
            try
            {
                var quoteAnswers = quoteAnswer.Where(x => x.QuoteId == quoteModel.Id);

                if (quoteAnswers != null)
                {
                    foreach (var item in quoteAnswers)
                    {
                        quoteAnswer.Remove(item.Id);
                    }
                }

                quote.Remove(quoteModel.Id);
                await dbContext.SaveChangesAsync();
            }
            catch (InvalidOperationException iox)
            {
                throw new FqqException(FqqExceptionCode.QuoteNotFound, false, iox);
            }
            catch (Exception ex)
            {
                throw new FqqException(FqqExceptionCode.GeneralError, "General error when deleting quote", true, ex);
            }
        }
        public async Task <IResponse <ActionResult> > DeleteQuote([FromBody] DeleteQuoteModel quote)
        {
            try
            {
                var serviceQuote = new Data.ServiceModels.Quote
                {
                    Id = quote.Id
                };

                await quoteService.DeleteQuote(serviceQuote);

                return(Success <ActionResult>(null));
            }
            catch (FqqException fex)
            {
                return(Error <ActionResult>(fex));
            }
        }
        /// <summary>
        /// edit quote
        /// </summary>
        /// <param name="quoteModel"></param>
        /// <returns></returns>
        public async Task EditQuote(Data.ServiceModels.Quote quoteModel)
        {
            try
            {
                var quoteRepoModel = new Data.RepositoryModels.Quote
                {
                    Id      = quoteModel.Id,
                    Correct = quoteModel.Correct == null ? (bool?)null : quoteModel.Correct == BinaryType.Yes,
                    Mode    = (byte)quoteModel.Mode,
                    Text    = quoteModel.Text,
                };

                await quote.Update(quoteRepoModel);

                var dbAnswers = quoteAnswer.Where(x => x.QuoteId == quoteModel.Id);

                if (dbAnswers != null)
                {
                    foreach (var item in dbAnswers)
                    {
                        quoteAnswer.Remove(item.Id);
                    }
                }

                if (quoteModel.Answers?.Any() == true)
                {
                    var dbquoteAnswer = quoteModel.Answers.Select(x => new QuoteAnswer
                    {
                        QuoteId   = quoteModel.Id,
                        Text      = x.Text,
                        IsCorrect = x.IsCorrect
                    }).ToArray();

                    await quoteAnswer.AddRangeAsync(dbquoteAnswer);
                }

                await dbContext.SaveChangesAsync();
            }
            catch (InvalidOperationException iox)
            {
                throw new FqqException(FqqExceptionCode.QuoteNotFound, false, iox);
            }
        }