public async Task GenerateTest_ShouldAddExercisesToStorage()
        {
            await controller.GenerateTest(testQuery, default(CancellationToken));

            A.CallTo(() => fakeTestStorage.AddTest(
                         A <Test> .That.Matches(t => t.OwnerLogin == "admin"), A <CancellationToken> ._))
            .MustHaveHappened();
        }
コード例 #2
0
        public IActionResult AddTest([FromBody] TestStorage test)
        {
            test.PublishDate = DateTime.Now.ToString("yyyy-MM-dd");
            string type    = HttpContext.Request.Query["type"];
            string direct  = HttpContext.Request.Query["direct"];
            string account = HttpContext.Session.GetString("admin");

            test.Publisher = admin.GetByAccount(account).name;
            if (direct != "")
            {
                test.Grade = "exam";
            }
            switch (type)
            {
            case "choice":
                test.Type = TestSort.choice.ToString();
                break;

            case "blank":
                test.Type = TestSort.blank.ToString();
                break;

            case "judege":
                test.Type = TestSort.judege.ToString();
                break;

            case "answer":
                test.Type = TestSort.answer.ToString();
                break;

            default:
                break;
            }
            var a = Test.AddTest(test);

            if (a != null)
            {
                if (direct != "")
                {
                    Exam.AddTestToExam(new List <ExamContent>()
                    {
                        new ExamContent {
                            ExamId = Convert.ToInt32(direct), TestId = a.Id
                        }
                    });
                }
                return(Content("1"));
            }
            else
            {
                return(Content("0"));
            }
        }
コード例 #3
0
        public async Task <ActionResult <TestDto> > GenerateTest(TestQueryDto testQueryDto, CancellationToken token)
        {
            var collection = await storage.FindCollection(testQueryDto.CollectionId, token);

            if (collection is null)
            {
                return(NotFound());
            }

            if (!User.OwnsResource(collection))
            {
                return(Forbid());
            }

            var cards = await storage.GetCollectionCards(testQueryDto.CollectionId, token);

            if (testQueryDto.Filter != null)
            {
                var filter = filterGenerator.GetFilter(testQueryDto.Filter);
                cards = filter(cards).ToList();
            }

            if (cards.Count == 0)
            {
                return(UnprocessableEntity("Not enough cards for test"));
            }

            var testBuilder = testBuilderFactory.GetBuilder(cards, new RandomCardsSelector());

            foreach (var block in testQueryDto.Blocks)
            {
                if (generatorsByCaption.ContainsKey(block.Type))
                {
                    testBuilder = testBuilder.WithGenerator(generatorsByCaption[block.Type], block.Amount);
                }
            }

            var exercises = testBuilder.Build().ToList();
            var test      = new Test(exercises, User.Identity.Name);
            await testStorage.AddTest(test, token);

            return(Ok(new TestDto(test)));
        }