Exemplo n.º 1
0
        public QuestionTemplate Create(
            Barrier barrier,
            Organization organization,
            string text,
            string supportNotes
            )
        {
            DateTimeOffset createDate = DateTimeOffset.UtcNow;
            int            last       = _context.QuestionTemplates.Max(qt => qt.Order) + 1;

            QuestionTemplate newQuestionTemplate = new QuestionTemplate
            {
                CreateDate   = createDate,
                Barrier      = barrier,
                Organization = organization,
                Status       = Status.Active,
                Text         = text,
                Order        = last,
                SupportNotes = supportNotes
            };

            _context.QuestionTemplates.Add(newQuestionTemplate);

            _context.SaveChanges();
            return(newQuestionTemplate);
        }
Exemplo n.º 2
0
        public void AnswerQuestion_WhenAnswerTemplateFound_SetQuestionAnswered()
        {
            // Arrange
            var questionStub = new Question();
            var answerStub   = new AnswerTemplate()
            {
                Id        = 1,
                IsCorrect = true
            };
            var questionTemplateStub = new QuestionTemplate();

            questionTemplateStub.Answers.Add(answerStub);

            var mockQuizRepo             = new Mock <IQuizRepository>();
            var mockQuestionTemplateRepo = new Mock <IQuestionTemplateRepository>();

            mockQuestionTemplateRepo.Setup(repo => repo.GetByID(It.IsAny <int>()))
            .Returns(value: questionTemplateStub);

            var mockUow = new Mock <IUnitOfWork>();

            mockUow.Setup(repo => repo.QuestionTemplateRepository)
            .Returns(mockQuestionTemplateRepo.Object);

            var manager = new QuizFlowManager(mockUow.Object, null);

            // Act
            manager.AnswerQuestion(questionStub, 1);

            // Assert
            Assert.True(questionStub.IsAnswered);
            Assert.Single(questionStub.Answers);
            Assert.True(questionStub.Answers.First().IsCorrect);
        }
Exemplo n.º 3
0
        public QuestionTemplate Edit(
            QuestionTemplate questionTemplate,
            Barrier barrier,
            Organization organization,
            string text,
            string supportNotes,
            Status status
            )
        {
            if (questionTemplate == null)
            {
                throw new ArgumentNullException(nameof(questionTemplate));
            }
            QuestionTemplate newQuestionTemplate = new QuestionTemplate
            {
                Barrier      = barrier,
                Organization = organization,
                Text         = text,
                SupportNotes = supportNotes,
                Status       = status,
                Order        = questionTemplate.Order,
                previous     = questionTemplate,
            };

            _context.QuestionTemplates.Add(newQuestionTemplate);

            questionTemplate.Status = Status.Inactive;
            _context.QuestionTemplates.Update(questionTemplate);
            _context.SaveChanges();
            return(newQuestionTemplate);
        }
Exemplo n.º 4
0
        private QuestionTemplate Create(
            Barrier barrier,
            Organization organization,
            Status status,
            string text,
            string supportNotes
            )
        {
            DateTime createDate = DateTime.UtcNow;

            QuestionTemplate newQuestionTemplate = new QuestionTemplate
            {
                CreateDate   = createDate,
                Barrier      = barrier,
                Organization = organization,
                Status       = status,
                Text         = text,
                SupportNotes = supportNotes
            };

            _context.QuestionTemplates.Add(newQuestionTemplate);

            _context.SaveChanges();
            return(newQuestionTemplate);
        }
        public bool ValidateResponse(QuestionTemplate questionTemplate)
        {
            bool validate = false;

            try
            {
                _obsService.ValidateResponse(Encounter.Id, Encounter.ClientId, questionTemplate.Id,
                                             questionTemplate.GetResponse());
                validate = true;
                questionTemplate.ErrorSummary = string.Empty;
            }
            catch (NullReferenceException ex)
            {
            }
            catch (Exception e)
            {
                questionTemplate.ErrorSummary = "Response required !";
                try
                {
                    _dialogService.ShowErrorToast(e.Message, 6000);
                }
                catch (Exception exception)
                {
                }
            }

            return(validate);
        }
        private QuestionTemplate ReorderQuestionTemplateInternal(QuestionTemplate questionTemplate, int newOrder)
        {
            // Reordering is not necessary for question templates that are not Active
            if (questionTemplate.Status != Status.Active)
            {
                return(questionTemplate);
            }

            questionTemplate.Order = newOrder;
            _context.QuestionTemplates.Update(questionTemplate);

            var questionTemplates = _context.QuestionTemplates
                                    .Where(qt => qt.Status == Status.Active)
                                    .Where(qt => qt.Id != questionTemplate.Id)
                                    .OrderBy(qt => qt.Order)
            ;

            int order = 1;

            foreach (QuestionTemplate qt in questionTemplates)
            {
                if (order == newOrder)
                {
                    // Skip new order to make room for updated QT
                    order += 1;
                }
                qt.Order = order++;
                _context.QuestionTemplates.Update(qt);
            }

            _context.SaveChanges();
            return(questionTemplate);
        }
Exemplo n.º 7
0
        /// <summary>
        /// Answers specified quiz question.
        /// </summary>
        /// <param name="question">The question to answer.</param>
        /// <param name="answerTemplateId">The answer template identifier.</param>
        public void AnswerQuestion(Question question, int answerTemplateId)
        {
            ThrowIf.Null(question, nameof(question));
            ThrowIf.Completed(question.Quiz);

            if (question.IsAnswered)
            {
                throw new QuizFlowException(
                          QuizFlowErrorCodes.QuestionAlreadyAnswered,
                          "Question already answered.");
            }

            QuestionTemplate questionTemplate = this.Uow.QuestionTemplateRepository
                                                .GetByID(question.TemplateId);

            ThrowIf.NotFound(questionTemplate, question.TemplateId);

            AnswerTemplate answerTemplate = questionTemplate.GetAnswer(answerTemplateId);

            ThrowIf.NotFound(answerTemplate, answerTemplateId);

            var answer = new Answer()
            {
                TemplateId = answerTemplateId,
                IsCorrect  = answerTemplate.IsCorrect
            };

            question.Answers.Add(answer);
            question.DateEnd = DateTime.Now;
            this.Uow.Save();
        }
Exemplo n.º 8
0
 public static QuestionTemplateDto AsDto(this QuestionTemplate entity)
 {
     return(new QuestionTemplateDto()
     {
         QuestionText = entity.QuestionText,
         InputType = entity.InputType,
         Order = entity.Order
     });
 }
Exemplo n.º 9
0
        public QuestionTemplate GetQuestionTemplate(string questionTemplateId)
        {
            QuestionTemplate questionTemplate = _context.QuestionTemplates.FirstOrDefault(qt => qt.Id.Equals(questionTemplateId));

            if (questionTemplate == null)
            {
                throw new NotFoundInDBException($"QuestionTemplate not found: {questionTemplateId}");
            }
            return(questionTemplate);
        }
        public void GetExists()
        {
            QuestionTemplateService questionTemplateService = new QuestionTemplateService(_context);

            QuestionTemplate questionTemplateCreate = questionTemplateService.Create(Barrier.GM, Organization.All, "text", "supportNotes");

            QuestionTemplate questionTemplateGet = questionTemplateService.GetQuestionTemplate(questionTemplateCreate.Id);

            Assert.Equal(questionTemplateCreate, questionTemplateGet);
        }
        public void AllowNextQuestion(QuestionTemplate questionTemplate)
        {
            if (!questionTemplate.Allow)
            {
                return;
            }

            AllowAllInLine(questionTemplate);
            SaveChangesCommand.RaiseCanExecuteChanged();
        }
Exemplo n.º 12
0
        private void RemoveQuestionAction(object sender, RoutedEventArgs e)
        {
            QuestionTemplate temp = (QuestionTemplate)questionList.SelectedItem;

            if (temp == null)
            {
                return;
            }
            questionList.Items.Remove(temp);
            questionList.Items.Refresh();
        }
        public void ReorderQuestionTemplateToLast()
        {
            QuestionTemplateService       questionTemplateService = new QuestionTemplateService(_context);
            IQueryable <QuestionTemplate> getAll = questionTemplateService.GetAll();

            QuestionTemplate questionTemplate = getAll.ToList()[3];
            int newOrder = _context.QuestionTemplates.Max(qt => qt.Order);
            QuestionTemplate resultingQuestionTemplate = questionTemplateService.ReorderQuestionTemplate(questionTemplate);

            Assert.Equal(newOrder, resultingQuestionTemplate.Order);
        }
Exemplo n.º 14
0
        public void GetNextQuestion_WhenCurrentQuestionNotAnswered_ReturnsQuizProceedCommandWithCurrentQuestion()
        {
            // Arrange
            var quiz = new Quiz()
            {
                Id = 1
            };
            var currentQuestion = new Question()
            {
                Id   = 2,
                Quiz = quiz
            };

            quiz.Questions.Add(currentQuestion);

            var questionTemplate = new QuestionTemplate();

            questionTemplate.Answers.Add(new AnswerTemplate()
            {
                IsCorrect = false
            });
            questionTemplate.Answers.Add(new AnswerTemplate()
            {
                IsCorrect = true
            });

            var mockQuizRepo             = new Mock <IQuizRepository>();
            var mockQuestionTemplateRepo = new Mock <IQuestionTemplateRepository>();

            mockQuestionTemplateRepo
            .Setup(repo => repo.GetByID(It.IsAny <int>()))
            .Returns(questionTemplate);

            var mockUow = new Mock <IUnitOfWork>();

            mockUow.Setup(repo => repo.QuizRepository)
            .Returns(mockQuizRepo.Object);
            mockUow.Setup(repo => repo.QuestionTemplateRepository)
            .Returns(mockQuestionTemplateRepo.Object);

            var manager = new QuizFlowManager(mockUow.Object, null);

            // Act
            var command = manager.GetNextQuestion(quiz);

            // Assert
            var commandProceed = Assert.IsType <QuizFlowCommandProceedContract>(command);

            Assert.Equal(1, commandProceed.QuizId);
            Assert.Equal(2, commandProceed.QuestionId);
            Assert.Equal(2, commandProceed.Template.Answers.Count);
            Assert.DoesNotContain(commandProceed.Template.Answers, answer => answer.IsCorrect);
        }
Exemplo n.º 15
0
        public Question Create(
            QuestionTemplate template,
            Evaluation evaluation
            )
        {
            Question newQuestion = CreateInternal(template, evaluation);

            _context.Questions.Add(newQuestion);

            _context.SaveChanges();
            return(newQuestion);
        }
        public void ReorderQuestionTemplate()
        {
            QuestionTemplateService       questionTemplateService = new QuestionTemplateService(_context);
            IQueryable <QuestionTemplate> getAll = questionTemplateService.GetAll();

            QuestionTemplate questionTemplate        = getAll.ToList()[3];
            QuestionTemplate newNextQuestionTemplate = getAll.ToList()[10];
            int newOrder = newNextQuestionTemplate.Order;

            QuestionTemplate resultingQuestionTemplate = questionTemplateService.ReorderQuestionTemplate(questionTemplate, newNextQuestionTemplate);

            Assert.Equal(newOrder - 1, resultingQuestionTemplate.Order);
        }
Exemplo n.º 17
0
        private void AddQuestionAction(object sender, RoutedEventArgs e)
        {
            AddQuestionWindow win = new AddQuestionWindow(quest_ord_num++);

            win.ShowDialog();
            QuestionTemplate temp = win.created;

            if (temp != null)
            {
                questionList.Items.Add(temp);
            }
            questionList.Items.Refresh();
        }
Exemplo n.º 18
0
        public QuestionTemplate EditQuestionTemplate(
            string questionTemplateId,
            Barrier barrier,
            Organization organization,
            string text,
            string supportNotes,
            Status status
            )
        {
            QuestionTemplate questionTemplate = _questionTemplateService.GetQuestionTemplate(questionTemplateId);

            return(_questionTemplateService.Edit(questionTemplate, barrier, organization, text, supportNotes, status));
        }
        public void EditQuestionTemplate()
        {
            QuestionTemplateService questionTemplateService = new QuestionTemplateService(_context);
            string           initialText      = "initial text";
            QuestionTemplate questionTemplate = questionTemplateService.Create(Barrier.GM, Organization.All, initialText, "supportNotes");

            string           newtext    = "new text";
            Barrier          newBarrier = Barrier.PS1;
            QuestionTemplate resultingQuestionTemplate = questionTemplateService.Edit(questionTemplate, newBarrier, Organization.Commissioning, newtext, "supportNotes", Status.Active);

            Assert.Equal(newtext, resultingQuestionTemplate.Text);
            Assert.Equal(newBarrier, resultingQuestionTemplate.Barrier);
            Assert.Equal(questionTemplate, resultingQuestionTemplate.previous);
        }
Exemplo n.º 20
0
 public QuestionTemplate Delete(QuestionTemplate questionTemplate)
 {
     /* ReorderQuestionTemplate gives the question template
      *  that should be deleted the highest order, and gives the
      *  remaining question templates the correct order. The
      *  consquence is that all active question templates are
      *  ordered correctly.
      */
     ReorderQuestionTemplate(questionTemplate);
     questionTemplate.Status = Status.Voided;
     _context.QuestionTemplates.Update(questionTemplate);
     _context.SaveChanges();
     return(questionTemplate);
 }
Exemplo n.º 21
0
        private QuestionTemplateView ToQuestionTemplateView(QuestionTemplate template)
        {
            QuestionTemplateView view = new QuestionTemplateView()
            {
                QuestionTemplateId = template.QuestionTemplateId,
                Used       = template.Used,
                Label      = template.Label,
                Type       = template.Type,
                CreateDate = template.CreateDate,
                Answers    = template.Answers
            };

            return(view);
        }
Exemplo n.º 22
0
        public void EditQuestionTemplate(QuestionTemplateView view, int id)
        {
            QuestionTemplate oldTemplate = _templates.FindOne(template => template.QuestionTemplateId == id);

            if (oldTemplate == null)
            {
                return;
            }
            oldTemplate.Label   = view.Label;
            oldTemplate.Type    = view.Type;
            oldTemplate.Answers = view.Answers;

            _templates.Delete(template => template.QuestionTemplateId == id);
            _templates.Insert(oldTemplate);
        }
Exemplo n.º 23
0
        public void GetExists()
        {
            QuestionTemplateService questionTemplateService = new QuestionTemplateService(_context);
            QuestionTemplate        questionTemplate        = questionTemplateService.GetAll().First();

            EvaluationService evaluationService = new EvaluationService(_context);
            Evaluation        evaluation        = evaluationService.GetAll().First();

            QuestionService questionService = new QuestionService(_context);
            Question        questionCreate  = questionService.Create(questionTemplate, evaluation);

            Question questionGet = questionService.GetQuestion(questionCreate.Id).First();

            Assert.Equal(questionCreate, questionGet);
        }
        public async Task <int> AddQuestionToSurveyAsync(int surveyTemplateId, int questionPosition, string content,
                                                         string select, bool isRequired)
        {
            var surveyTemplate = await _surveyTemplateRepository.GetByIdAsync(surveyTemplateId);

            if (content == "")
            {
                content = "Brak pytania";
            }
            var questionTemplate = new QuestionTemplate(questionPosition, content, select, isRequired);

            surveyTemplate.AddQuestionTemplate(questionTemplate);
            await _questionTemplateRepository.AddAsync(questionTemplate);

            return(questionTemplate.Id);
        }
Exemplo n.º 25
0
        public void GetExists()
        {
            QuestionTemplateService questionTemplateService = new QuestionTemplateService(fixture.context);
            QuestionTemplate        questionTemplate        = questionTemplateService.GetAll().First();

            ProjectService    projectService    = new ProjectService(fixture.context);
            Project           project           = projectService.Create("QuestionService_GetExists");
            EvaluationService evaluationService = new EvaluationService(fixture.context);
            Evaluation        evaluation        = evaluationService.Create("QuestionService_GetExists", project, "");

            QuestionService questionService = new QuestionService(fixture.context);
            Question        questionCreate  = questionService.Create(questionTemplate, evaluation);

            Question questionGet = questionService.GetQuestion(questionCreate.Id).First();

            Assert.Equal(questionCreate, questionGet);
        }
Exemplo n.º 26
0
        public void ReorderQuestionTemplateToLast()
        {
            QuestionTemplateService       questionTemplateService = new QuestionTemplateService(fixture.context);
            IQueryable <QuestionTemplate> getAll = questionTemplateService.GetAll();

            QuestionTemplate questionTemplate = getAll
                                                .Where(qt => qt.Status == Status.Active)
                                                .First(qt => qt.Order == 2)
            ;
            int newOrder = getAll
                           .Where(qt => qt.Status == Status.Active)
                           .Max(qt => qt.Order)
            ;
            QuestionTemplate resultingQuestionTemplate = questionTemplateService.ReorderQuestionTemplate(questionTemplate);

            Assert.Equal(newOrder, resultingQuestionTemplate.Order);
        }
Exemplo n.º 27
0
        public void Create()
        {
            QuestionTemplateService questionTemplateService = new QuestionTemplateService(_context);
            QuestionTemplate        questionTemplate        = questionTemplateService.GetAll().First();

            EvaluationService evaluationService = new EvaluationService(_context);
            Evaluation        evaluation        = evaluationService.GetAll().First();

            QuestionService questionService = new QuestionService(_context);

            int nQuestionBefore = questionService.GetAll().Count();

            questionService.Create(questionTemplate, evaluation);
            int nQuestionsAfter = questionService.GetAll().Count();

            Assert.Equal(nQuestionBefore + 1, nQuestionsAfter);
        }
Exemplo n.º 28
0
        public QuestionTemplate Create(
            Barrier barrier,
            Organization organization,
            string text,
            string supportNotes,
            int newOrder = 0
            )
        {
            DateTimeOffset createDate = DateTimeOffset.UtcNow;
            int            last       = _context.QuestionTemplates
                                        .Where(qt => qt.Status == Status.Active)
                                        .Max(qt => qt.Order) + 1
            ;
            int maxAdminOrder = _context.QuestionTemplates
                                .Where(qt => qt.Status == Status.Active)
                                .Max(qt => qt.AdminOrder) + 1
            ;

            // If newOrder == 0, we want to place the new
            // question template as the last one in the barrier
            if (newOrder == 0)
            {
                newOrder = _context.QuestionTemplates
                           .Where(qt => qt.Status == Status.Active)
                           .Where(qt => qt.Barrier == barrier)
                           .Max(qt => qt.Order) + 1
                ;
            }

            QuestionTemplate newQuestionTemplate = new QuestionTemplate
            {
                CreateDate   = createDate,
                Barrier      = barrier,
                Organization = organization,
                Status       = Status.Active,
                Text         = text,
                Order        = last,
                SupportNotes = supportNotes,
                AdminOrder   = maxAdminOrder
            };

            _context.QuestionTemplates.Add(newQuestionTemplate);
            _context.SaveChanges();

            return(ReorderQuestionTemplateInternal(newQuestionTemplate, newOrder));
        }
Exemplo n.º 29
0
        public QuestionTemplate ReorderQuestionTemplate(
            string questionTemplateId,
            string newNextQuestionTemplateId
            )
        {
            QuestionTemplate questionTemplate = _questionTemplateService.GetQuestionTemplate(questionTemplateId);

            if (string.IsNullOrEmpty(newNextQuestionTemplateId))
            {
                return(_questionTemplateService.ReorderQuestionTemplate(questionTemplate));
            }
            else
            {
                QuestionTemplate newNextQuestionTemplate = _questionTemplateService.GetQuestionTemplate(newNextQuestionTemplateId);
                return(_questionTemplateService.ReorderQuestionTemplate(questionTemplate, newNextQuestionTemplate));
            }
        }
Exemplo n.º 30
0
        private static Question CreateInternal(
            QuestionTemplate template,
            Evaluation evaluation
            )
        {
            DateTime createDate = DateTime.UtcNow;

            return(new Question
            {
                CreateDate = createDate,
                Barrier = template.Barrier,
                Evaluation = evaluation,
                Organization = template.Organization,
                Text = template.Text,
                SupportNotes = template.SupportNotes,
                QuestionTemplate = template,
            });
        }
Exemplo n.º 31
0
 protected Question(QuestionTemplate template)
 {
     this.QuestionTemplate = template;
 }
Exemplo n.º 32
0
 internal NumericQuestion(QuestionTemplate questionTemplate)
     : base(questionTemplate)
 {
 }