Exemplo n.º 1
0
        public async Task <SaveQuizFeedbackResponseDTO> SaveQuizFeedbackAsync(SaveQuizFb_QuizFeedbackDTO quizFbReceived)
        {
            float rightAnswerNumber = 0;

            var result = new SaveQuizFeedbackResponseDTO();

            QuizFeedback quizFb = new QuizFeedback()
            {
                Character = new Character()
                {
                    Id = quizFbReceived.CharacterId
                },
                Quiz = await _quizRepo.GetQuizAsync(quizFbReceived.QuizId),
            };

            if (quizFb.Quiz == null)
            {
                result._result = SaveQuizFeedbackResponseDTO.RequestResult.QuizNotFound;
                return(result);
            }

            if (quizFb.Quiz.Questions.Count == 0)
            {
                result._result = SaveQuizFeedbackResponseDTO.RequestResult.QuizWithoutQuestions;
                return(result);
            }

            if (quizFb.Quiz.Questions.Count != quizFbReceived.QuestionAnswers.Count ||
                quizFbReceived.QuestionAnswers.GroupBy(qa => qa.QuestionId).Any(q => q.Count() > 1))
            {
                result._result = SaveQuizFeedbackResponseDTO.RequestResult.InvalidQuizFeedback;
                return(result);
            }

            foreach (var qtAnswerReceived in quizFbReceived.QuestionAnswers)
            {
                var qtAnswer = new QuestionAnswer()
                {
                    Question = quizFb.Quiz.Questions.Where(q => q.Id == qtAnswerReceived.QuestionId).FirstOrDefault()
                };

                if (qtAnswer.Question == null)
                {
                    result._result = SaveQuizFeedbackResponseDTO.RequestResult.QuestionNotFound;
                    return(result);
                }

                if (qtAnswerReceived.ChosenAnswerIds.Count == 0 ||
                    (qtAnswerReceived.ChosenAnswerIds.Count > 1 &&
                     qtAnswer.Question.Answers.Where(a => a.IsCorrect).Count() == 1))
                {
                    result._result = SaveQuizFeedbackResponseDTO.RequestResult.InvalidQuizFeedback;
                    return(result);
                }

                foreach (var answerID in qtAnswerReceived.ChosenAnswerIds)
                {
                    var chonsenAnswer = qtAnswer.Question.Answers.Where(a => a.Id == answerID).FirstOrDefault();

                    if (chonsenAnswer == null)
                    {
                        result._result = SaveQuizFeedbackResponseDTO.RequestResult.AnswerNotFound;
                        return(result);
                    }

                    qtAnswer.ChosenAnswers.Add(chonsenAnswer);
                }

                quizFb.QuestionAnswers.Add(qtAnswer);

                var correctAnswerIds = qtAnswer.Question.Answers.Where(a => a.IsCorrect).Select(a => a.Id).ToHashSet();
                var AnswerIds        = qtAnswerReceived.ChosenAnswerIds.ToHashSet();

                int hits   = Enumerable.Intersect(AnswerIds, correctAnswerIds).Count();
                int misses = AnswerIds.Except(correctAnswerIds).Count();

                if (misses <= hits)
                {
                    rightAnswerNumber += (float)(hits - misses) / correctAnswerIds.Count;
                }
            }

            quizFb.PercentageOfCorrectChosenAnswers = (float)Math.Round(rightAnswerNumber * 100 / quizFb.Quiz.Questions.Count, 2);

            //Save awnsers
            result._result = await _characterService.SaveQuizfeedback(quizFb);

            if (result._result != SaveQuizFeedbackResponseDTO.RequestResult.Success)
            {
                return(result);
            }

            //fill with correct answers
            foreach (var qtAnswer in quizFb.QuestionAnswers)
            {
                qtAnswer.ChosenAnswers = qtAnswer.Question.Answers.Where(c => c.IsCorrect).ToList();
            }

            //Return correct answers
            result.QuizFeedback = _mapper.Map <QuizFeedbackReadDTO>(quizFb);
            return(result);
        }
Exemplo n.º 2
0
        public async Task <SaveQuizFeedbackResponseDTO.RequestResult> SaveQuizfeedback(QuizFeedback quizFeedback)
        {
            var character = await _characterRepo.GetCharacterAllAsync(quizFeedback.Character.Id);

            if (character == null)
            {
                return(SaveQuizFeedbackResponseDTO.RequestResult.CharacterNotFound);
            }

            quizFeedback.Character = character;
            character.QuizFeedbacks.Add(quizFeedback);

            if (character.QuizFeedbacks.Where(c => c.Quiz.Id == quizFeedback.Quiz.Id).Count() == 1)
            {
                quizFeedback.ExperienceGained = (int)quizFeedback.PercentageOfCorrectChosenAnswers;
                quizFeedback.GoldGained       = (int)quizFeedback.PercentageOfCorrectChosenAnswers;

                var prevLevel = character.Level;

                character.TotalXP += quizFeedback.ExperienceGained;
                character.Gold    += quizFeedback.GoldGained;

                quizFeedback.LevelGained = character.Level - prevLevel;
            }

            try
            {
                await _characterRepo.SaveChangesAsync();

                return(SaveQuizFeedbackResponseDTO.RequestResult.Success);
            }
            catch (Exception)
            {
                return(SaveQuizFeedbackResponseDTO.RequestResult.BadRequest);
            }
        }