public async Task <ViewResult> AcceptedSolutions(string courseId, int slideIndex = 0, bool isLti = false)
        {
            var userId   = User.Identity.GetUserId();
            var course   = courseManager.GetCourse(courseId);
            var slide    = (ExerciseSlide)course.Slides[slideIndex];
            var isPassed = visitsRepo.IsPassed(slide.Id, userId);

            if (!isPassed)
            {
                await visitsRepo.SkipSlide(courseId, slide.Id, userId);
            }
            var solutions = solutionsRepo.GetAllAcceptedSolutions(courseId, slide.Id);

            foreach (var solution in solutions)
            {
                solution.LikedAlready      = solution.UsersWhoLike.Any(u => u == userId);
                solution.RemoveSolutionUrl = Url.Action("RemoveSolution", "Course", new { courseId = courseId, slideIndex = slide.Index, solutionId = solution.Id });
            }

            var model = new AcceptedSolutionsPageModel
            {
                CourseId          = courseId,
                CourseTitle       = course.Title,
                Slide             = slide,
                AcceptedSolutions = solutions,
                User            = User,
                LikeSolutionUrl = Url.Action("LikeSolution"),
                IsLti           = isLti,
                IsPassed        = isPassed
            };

            return(View(model));
        }
Beispiel #2
0
        private async Task <AcceptedSolutionsPageModel> CreateAcceptedSolutionsModel(Course course, ExerciseSlide slide, bool isLti)
        {
            var userId   = User.Identity.GetUserId();
            var isPassed = visitsRepo.IsPassed(course.Id, slide.Id, userId);

            if (!isPassed)
            {
                await visitsRepo.SkipSlide(course.Id, slide.Id, userId);
            }
            var submissions = solutionsRepo.GetBestTrendingAndNewAcceptedSolutions(course.Id, slide.Id);

            foreach (var submission in submissions)
            {
                submission.LikedAlready      = submission.UsersWhoLike.Any(u => u == userId);
                submission.RemoveSolutionUrl = Url.Action("RemoveSubmission", "Course", new { course.Id, slideId = slide.Id, submissionId = submission.Id });
            }

            var model = new AcceptedSolutionsPageModel
            {
                CourseId          = course.Id,
                CourseTitle       = course.Title,
                Slide             = slide,
                AcceptedSolutions = submissions,
                User            = User,
                LikeSolutionUrl = Url.Action("LikeSolution"),
                IsLti           = isLti,
                IsPassed        = isPassed
            };

            return(model);
        }
Beispiel #3
0
        public async Task <string> SubmitQuiz(string courseId, string slideIndex, string answer, bool isLti)
        {
            var intSlideIndex = int.Parse(slideIndex);
            var course        = courseManager.GetCourse(courseId);
            var userId        = User.Identity.GetUserId();
            var slide         = course.Slides[intSlideIndex];
            var slideId       = slide.Id;

            if (visitsRepo.IsPassed(userId, slideId))
            {
                return("already answered");
            }
            var time    = DateTime.Now;
            var answers = JsonConvert.DeserializeObject <List <QuizAnswer> >(answer).GroupBy(x => x.QuizId);
            var quizBlockWithTaskCount = course.Slides[intSlideIndex].Blocks.Count(x => x is AbstractQuestionBlock);
            var incorrectQuizzes       = new List <string>();
            var fillInBlockType        = typeof(FillInBlock);
            var allQuizInfos           = new List <QuizInfoForDb>();

            foreach (var ans in answers)
            {
                var quizInfos = CreateQuizInfo(course, intSlideIndex, ans);
                foreach (var quizInfo in quizInfos)
                {
                    allQuizInfos.Add(quizInfo);
                    if (!quizInfo.IsRightAnswer && quizInfo.QuizType == fillInBlockType)
                    {
                        incorrectQuizzes.Add(ans.Key);
                    }
                }
            }
            var blocksInAnswerCount = allQuizInfos.Select(x => x.QuizId).Distinct().Count();

            if (blocksInAnswerCount != quizBlockWithTaskCount)
            {
                return("has empty blocks");
            }
            var score = allQuizInfos
                        .Where(forDb => forDb.IsRightQuizBlock)
                        .Select(forDb => forDb.QuizId)
                        .Distinct()
                        .Count();

            foreach (var quizInfoForDb in allQuizInfos)
            {
                await userQuizzesRepo.AddUserQuiz(courseId, quizInfoForDb.IsRightAnswer, quizInfoForDb.ItemId, quizInfoForDb.QuizId,
                                                  slideId, quizInfoForDb.Text, userId, time, quizInfoForDb.IsRightQuizBlock);
            }

            await visitsRepo.AddAttempt(slideId, userId, score);

            if (isLti)
            {
                LtiUtils.SubmitScore(slide, userId);
            }

            return(string.Join("*", incorrectQuizzes.Distinct()));
        }