Beispiel #1
0
        public TestStatsDTO GetTestStatsById(int id)
        {
            var    test                 = uOw.TestRepo.GetByID(id);
            double?avarageGrade         = test.TestHistory?.Average(x => x.ResultGrade);
            int?   countOfAccepted      = test.TestHistory?.Where(x => (x.ResultGrade >= (test.Requirment / 100) * test.Grade)).Count();
            int    percantageOfAccepted = countOfAccepted.HasValue ? (int)((double)countOfAccepted / (double)test.TestHistory.Count() * 100) : 0;
            Dictionary <int, int>    questionCountOfRightAnswersStats = new Dictionary <int, int>();
            Dictionary <double, int> testResultsGradesStats           = new Dictionary <double, int>();

            if (test.Questions != null)
            {
                for (int i = 0; i < test.Questions.Count + 1; i++)
                {
                    questionCountOfRightAnswersStats.Add(i, 0);
                }
            }

            if (test.TestHistory != null)
            {
                foreach (var testResult in test.TestHistory)
                {
                    int i = 0;
                    foreach (var question in testResult.Questions)
                    {
                        i++;
                        var gradeForQuestion    = GetGradeForQuestion(question, testResult.Test.ConsiderPartialAnswers, testResult.Test.Grade, testResult.Questions.Count);
                        var maxGradeForQuestion = GetWeightOfQuestion(testResult.Test, question);

                        if (gradeForQuestion == maxGradeForQuestion)
                        {
                            questionCountOfRightAnswersStats[i] += 1;
                        }
                    }
                    if (!testResultsGradesStats.ContainsKey(testResult.ResultGrade))
                    {
                        testResultsGradesStats.Add(testResult.ResultGrade, 0);
                    }

                    testResultsGradesStats[testResult.ResultGrade] += 1;
                }
            }

            var maxNumber       = questionCountOfRightAnswersStats.Skip(1).Max(x => x.Value);
            var numberOfEasiest = questionCountOfRightAnswersStats.FirstOrDefault(x => x.Value == maxNumber).Key;

            var minNumber       = questionCountOfRightAnswersStats.Skip(1).Min(x => x.Value);
            var numberOfHardest = questionCountOfRightAnswersStats.FirstOrDefault(x => x.Value == minNumber).Key;

            var easiestQuestion = test.Questions.Skip(numberOfEasiest - 1).Take(1).FirstOrDefault();
            var hardestQuestion = test.Questions.Skip(numberOfHardest - 1).Take(1).FirstOrDefault();

            var model = new TestStatsDTO
            {
                BarsOfGrades         = testResultsGradesStats,
                BarsOfQuestions      = questionCountOfRightAnswersStats,
                AvarageGrade         = avarageGrade.HasValue ? avarageGrade.Value : 0,
                PercantageOfAccepted = percantageOfAccepted,
                Test            = Mapper.Map <TestDTO>(test),
                EasiestQuestion = Mapper.Map <QuestionDTO>(easiestQuestion),
                HardestQuestion = Mapper.Map <QuestionDTO>(hardestQuestion),
                Results         = new List <TestResultDTO>()
            };

            foreach (var testResult in test.TestHistory.OrderByDescending(x => x.TimeStart))
            {
                model.Results.Add(Mapper.Map <TestResultDTO>(testResult));
            }
            return(model);
        }
Beispiel #2
0
        public TestStatsDTO GetTestStatsById(int id)
        {
            var    test                 = uOw.TestRepo.GetByID(id);
            double?avarageGrade         = test.TestHistory?.Average(x => x.ResultGrade);
            int?   countOfAccepted      = test.TestHistory?.Where(x => (x.ResultGrade >= (test.Requirment / 100) * test.Grade)).Count();
            int    percantageOfAccepted = countOfAccepted.HasValue ? (int)((double)countOfAccepted / (double)test.TestHistory.Count() * 100) : 0;
            Dictionary <int, int>    questionCountOfRightAnswersStats = new Dictionary <int, int>();
            Dictionary <int, int>    questionsCountOfAllTries         = new Dictionary <int, int>();
            Dictionary <int, double> questionsPercantageCorrect       = new Dictionary <int, double>();

            Dictionary <int, int>    questionsMap           = new Dictionary <int, int>();
            Dictionary <double, int> testResultsGradesStats = new Dictionary <double, int>();

            if (test.Questions != null)
            {
                var questionsArray = test.Questions.ToArray();
                for (int i = 0; i < questionsArray.Length; i++)
                {
                    questionsMap.Add(questionsArray[i].Id, i + 1);
                    questionsCountOfAllTries.Add(questionsArray[i].Id, 0);
                }
                for (int i = 1; i < test.Questions.Count + 1; i++)
                {
                    questionCountOfRightAnswersStats.Add(i, 0);
                }
            }

            if (test.TestHistory != null)
            {
                foreach (var testResult in test.TestHistory)
                {
                    int i = 0;
                    foreach (var question in testResult.Questions)
                    {
                        i++;
                        var gradeForQuestion    = GetGradeForQuestion(question, testResult.Test.ConsiderPartialAnswers, testResult.Test.Grade, testResult.Questions.Count);
                        var maxGradeForQuestion = GetWeightOfQuestion(testResult.Test, question, testResult.Questions.ToList());

                        if (gradeForQuestion == maxGradeForQuestion)
                        {
                            questionCountOfRightAnswersStats[questionsMap[question.QuestionId]] += 1;
                        }
                    }
                    if (!testResultsGradesStats.ContainsKey(testResult.ResultGrade))
                    {
                        testResultsGradesStats.Add(testResult.ResultGrade, 0);
                    }

                    testResultsGradesStats[testResult.ResultGrade] += 1;
                }

                var groupedQuestionsIds = test.TestHistory
                                          .SelectMany(x => x.Questions.Select(y => y.QuestionId))
                                          .GroupBy(x => x)
                                          .ToDictionary(x => x.Key, y => y.Count());
                foreach (var element in questionCountOfRightAnswersStats)
                {
                    if (groupedQuestionsIds.ContainsKey(questionsMap.FirstOrDefault(x => x.Value == element.Key).Key))
                    {
                        questionsPercantageCorrect.Add(element.Key, 100 * (double)element.Value / (double)groupedQuestionsIds[questionsMap.FirstOrDefault(x => x.Value == element.Key).Key]);
                    }
                    else
                    {
                        questionsPercantageCorrect.Add(element.Key, -1);
                    }
                }
            }

            //var numbersToDelete = questionCountOfRightAnswersStats.Where(x => x.Value == -1).Select(x => x.Key).ToList();
            //foreach (var numberToDelete in numbersToDelete)
            //{
            //	questionCountOfRightAnswersStats.Remove(numberToDelete);
            //}

            var maxNumber         = questionsPercantageCorrect.Count != 0 ? questionsPercantageCorrect.Where(x => x.Value != -1).Max(x => x.Value) : 0;
            var numberOfEasiest   = questionsPercantageCorrect.FirstOrDefault(x => x.Value == maxNumber).Key;
            var easiestQuestionId = questionsMap.FirstOrDefault(x => x.Value == numberOfEasiest).Key;

            var minNumber         = questionsPercantageCorrect.Count != 0 ? questionsPercantageCorrect.Where(x => x.Value != -1).Min(x => x.Value) : 0;
            var numberOfHardest   = questionsPercantageCorrect.FirstOrDefault(x => x.Value == minNumber).Key;
            var hardersQuestionId = questionsMap.FirstOrDefault(x => x.Value == numberOfHardest).Key;

            var easiestQuestion = numberOfEasiest != 0 ? test.Questions.FirstOrDefault(x => x.Id == easiestQuestionId) : new Question();
            var hardestQuestion = numberOfHardest != 0 ? test.Questions.FirstOrDefault(x => x.Id == hardersQuestionId) : new Question();

            var model = new TestStatsDTO
            {
                BarsOfGrades    = testResultsGradesStats,
                BarsOfQuestions = questionCountOfRightAnswersStats,
                BarsOfPercantageCorrectAnswers = questionsPercantageCorrect,
                AvarageGrade         = avarageGrade ?? 0,
                PercantageOfAccepted = percantageOfAccepted,
                Test            = Mapper.Map <TestDTO>(test),
                EasiestQuestion = Mapper.Map <QuestionDTO>(easiestQuestion),
                HardestQuestion = Mapper.Map <QuestionDTO>(hardestQuestion),
                Results         = new List <TestResultDTO>()
            };

            foreach (var testResult in test.TestHistory.OrderByDescending(x => x.TimeStart))
            {
                model.Results.Add(Mapper.Map <TestResultDTO>(testResult));
            }
            return(model);
        }