public async Task <string> GetQuestion(string companyName, int questionId) { var payload = new QuestionDto { CompanyName = companyName, QuestionId = questionId }; var request = new RestRequest("api/interview/question", Method.POST) { RequestFormat = DataFormat.Json }.AddBody(payload); var response = await _apiClient.ExecuteTaskAsync <QuestionResponse>(request); var responseData = response.Data; return(responseData.StatusCode == HttpStatusCode.NotFound ? "Tell me more about yourself" : response.Data.Question); }
public void Post_AddQuestionToSurvey_ReturnsSurveyQuestion() { // Arrange var questionDto = new QuestionDto { Comment = "Connecting to survey comment", Text = "Connecting to survey text" }; var id = 2; // Act var result = _controller.AddQuestionToSurvey(id, questionDto) as CreatedResult; var surveyQuestion = result.Value as SurveyQuestion; // Assert Assert.Equal(id, surveyQuestion.Survey.Id); Assert.Equal(questionDto.Text, surveyQuestion.Question.Text); }
public Question Update(QuestionDto questionDto, Guid questionEntityId) { var question = _repository.GetLastByFilter <Question>(c => c.EntityId == questionEntityId); if (question.DeletedDate != null) { return(null); } question.Id = Guid.NewGuid(); question.AuthorId = Guid.NewGuid(); question.QuestionString = questionDto.QuestionString; _repository.Insert(question); _repository.Save(); return(question); }
public async Task <ActionResult <Question> > Create(QuestionDto item) { //new question object var nq = new Question { HasCorrectAnswer = item.HasCorrectAnswer, IsOpenQuestion = item.IsOpenQuestion, Points = item.Points, Text = item.Text, TimeLimitSeconds = item.TimeLimitSeconds }; var created = await _repository.Create(nq, item.QuizeId); return(CreatedAtAction( nameof(this.Get), new { id = created.Id }, created)); }
public ActionResult PostQuestion(QuestionDto questionDto) { if (questionDto == null) { return(BadRequest()); } var question = _mapper.Map <Question>(questionDto); _context.Questions.Add(question); _context.SaveChanges(); questionDto.Id = question.Id; var requestUrl = Request == null ? "http://localhost/api/question" : Request.GetDisplayUrl(); return(Created(new Uri(requestUrl + "/" + question.Id), questionDto)); }
public IActionResult Get(int questionId) { Entity_Question question = _questionRepository.GetQuestion(questionId); if (question == null) { return(BadRequest()); } QuestionDto questionDto = new QuestionDto() { Id = question.Id, Content = question.Content, Type = question.Type, Replies = _replyRepository.GetRepliesForQuestion(question.Id, question.Type).ToArray() }; return(Json(questionDto)); }
public async Task UpdateQuestionNoAccess() { //Perpare TestingContext context = new TestingContext(); IQuestionService questionService = InitQuestionService(context); ApplicationDbContext dbContext = context.GetSimple <ApplicationDbContext>(); int firstQuestionId = dbContext.Questions.First().Id; QuestionDto dto = await questionService.GetQuestionAsync(firstQuestionId); dto.Title = "Another Title"; //Act and Assert Exception ex = await Assert.ThrowsAsync <SecurityException>(async() => { await questionService.UpdateQuestionAsync(dto); }); }
public void UpdateQuestion(QuestionDto questionDto, long id) { if (!ModelState.IsValid) { throw new HttpResponseException(HttpStatusCode.BadRequest); } Question questionInDb = _context.Questions.SingleOrDefault(q => q.Id == id); if (questionInDb == null) { throw new HttpResponseException(HttpStatusCode.NotFound); } //questionInDb.QuestionTitle = question.QuestionTitle; Mapper.Map(questionDto, questionInDb); _context.SaveChanges(); }
public async Task <IActionResult> Edit([FromRoute] Guid id, [FromBody] QuestionDto questionModel) { if (!ModelState.IsValid) { return(BadRequest()); } var question = await _context.Questions.Where(q => q.Id.Equals(id) && q.Removed == false) .FirstOrDefaultAsync(); if (question == null) { return(BadRequest(new ErrorsModel <string> { Errors = new List <string> { "question not found" } })); } var userId = HttpContext.User.Claims.First(c => c.Type.Equals("uid")).Value; var role = (await _userManager.GetRolesAsync(new User { Id = userId })).First(); if (!question.UserId.Equals(new Guid(userId)) || !role.Equals("Admin")) { return(BadRequest(new ErrorsModel <string> { Errors = new List <string> { "can't edit this question" } })); } question.Title = questionModel.Title; question.Description = questionModel.Description; question.UpdatedAt = DateTime.Now; _context.Questions.Update(question); await _context.SaveChangesAsync(); return(Ok()); }
public static QuestionDto GetQuestionModel(long questionId) { QuestionDto model = null; var sql = @" SELECT q.* ,c.FullName as EX_CreatedBy ,u.FullName as EX_UpdatedBy ,c.Department as EX_CreatedByDept ,u.Department as EX_UpdatedByDept FROM [Questions] q left join Accounts c on c.UserName = q.CreatedBy left join Accounts u on u.UserName = q.UpdatedBy where q.Id = @Id select Value from Tags where ContentId = @Id "; try { using (SqlConnection connection = GetConnection()) { connection.Open(); using (var multi = connection.QueryMultiple(sql, new { Id = questionId })) { var question = multi.Read <Entities.Question>().SingleOrDefault(); if (question != null) { model = question.MapToDto(); model.Tags = multi.Read <string>().ToList(); } } } } catch (Exception ex) { throw new ApplicationException(ex.Message); } return(model); }
public void DTOQuestionAnswerDTO_QuestionDTO_QuestionDTO() { QuestionDto inputQuestion = new QuestionDto(); inputQuestion.Content = "This is a content of first qustion"; inputQuestion.Answers = new HashSet <AnswerDto>(); AnswerDto inputeAnswer = new AnswerDto(); inputeAnswer.Content = "Answer numbre one is correct"; inputeAnswer.IsCorrect = true; inputQuestion.Answers.Append(inputeAnswer); Question middle = inputQuestion.Question; QuestionDto outputQuestion = new QuestionDto(middle); CollectionAssert.AreEqual(inputQuestion.Answers, outputQuestion.Answers); Assert.AreSame(inputQuestion.Content, outputQuestion.Content); }
public IActionResult Update(int id, [FromBody] QuestionDto questionDto) { // map dto to entity and set id var c = _mapper.Map <Question>(questionDto); c.ID = id; try { // save c = _questionService.Update(c); return(Ok(_mapper.Map <QuestionDto>(c))); } catch (AppException ex) { // return error message if there was an exception return(BadRequest(ex.Message)); } }
public async Task QuestionController_Create_CreatesQuestion() { var updatedQuestion = new QuestionDto { Id = "question3", QuestionNumber = 3, TopicId = "topic1", QuestionText = "Why not?" }; var payload = JsonConvert.SerializeObject(updatedQuestion); var content = new StringContent(payload, Encoding.UTF8, "application/json"); var httpResponse = await _client.PostAsync(RequestUri, content); var actual = await _client.GetAsync(RequestUri + "question3"); httpResponse.EnsureSuccessStatusCode(); var stringActualResponse = await actual.Content.ReadAsStringAsync(); var question = JsonConvert.DeserializeObject <QuestionDto>(stringActualResponse); question.Id.Should().Be("question3"); question.QuestionText.Should().Be("Why not?"); }
/// <inheritdoc /> public async Task <QuestionDto> Update(QuestionDto questionDto) { var check = await Get(questionDto.Id); if (check == null) { return(null); } var questionEntity = new QuestionEntity(); questionEntity.CopyPropertiesFrom(questionDto); await _questionRespository.Save(questionEntity); questionDto.CopyPropertiesFrom(questionEntity); return(questionDto); }
public IHttpActionResult UpdateQuestion(int id, QuestionDto questionDto) { if (!ModelState.IsValid) { return(BadRequest()); } var questionInDb = _context.Questions.SingleOrDefault(c => c.Id == id); if (questionInDb == null) { return(NotFound()); } Mapper.Map(questionDto, questionInDb); _context.SaveChanges(); return(Ok()); }
public async Task <IActionResult> Create([FromBody] QuestionDto question) { Guard.IsNotNull(question, nameof(question)); if (!ModelState.IsValid) { return(this.BadRequest(this.ModelState)); } try { var result = await this.repository.AddQuestionAsync(question).ConfigureAwait(false); return(result.ToActionResult()); } catch (Exception e) { this.logger.LogError(e, e.Message); return(new StatusCodeResult(500)); } }
public async Task <IActionResult> Post([FromBody] QuestionForCreationDto creationDto) { if (creationDto == null) { return(BadRequest()); } if (!ModelState.IsValid) { return(new Helpers.UnprocessableEntityObjectResult(ModelState)); } var questionDto = new QuestionDto(); questionDto.CopyPropertiesFrom(creationDto); await _questionService.Create(questionDto); return(Ok(questionDto)); }
public static TopQuestionsViewModel MapToTopQuestionsViewModelMod(this QuestionDto dbEntity, MediaConverter mediaConverter, IEnumerable <TagDb> dbTags, IEnumerable <PhotoDb> dbFirstPhotos, IEnumerable <PhotoDb> dbSecondPhotos, BackgroundSizeType backgroundSizeType) { var viewModel = new TopQuestionsViewModel { QuestionId = dbEntity.QuestionId, Condition = dbEntity.Condition, Options = dbEntity.Options.Select(x => new Option { Text = x.Text, Voters = x.Voters }).ToList(), Author = new AuthorViewModel { UserId = dbEntity.Author.UserId, Login = dbEntity.Author.FirstName + " " + dbEntity.Author.LastName, SexType = dbEntity.Author.SexType, SmallAvatarUrl = mediaConverter.ToFullAvatarUrl(dbEntity.Author.OriginalAvatarUrl, AvatarSizeType.Small) }, BackgroundUrl = mediaConverter.ToFullBackgroundurlUrl(dbEntity.OriginalBackgroundUrl, backgroundSizeType), QuestionType = dbEntity.QuestionType, QuestionAddDate = dbEntity.AddedDate, LikesCount = dbEntity.LikesCount, DislikesCount = dbEntity.DislikesCount, YourAnswerType = dbEntity.YourAnswerType, YourFeedbackType = dbEntity.YourFeedbackType, IsFavorite = dbEntity.IsFavorite, IsSaved = dbEntity.IsSaved, CommentsCount = dbEntity.CommentsCount, Photos = new List <List <PhotoViewModel> > { MapPhotosDbToViewModel(dbFirstPhotos, mediaConverter), MapPhotosDbToViewModel(dbSecondPhotos, mediaConverter) }, Tags = MapTagsDbToTagViewModel(dbTags) // FirstOption = dbEntity.Options.FirstOrDefault(x=>x.) }; return(viewModel); }
public async Task Test_Create_Question() { var mockQuestion = new Question { Id = 1 }; var mockQuestionRepo = new Mock <IQuestionRepository>(); mockQuestionRepo.Setup(u => u.CreateQuestionAsync(It.IsAny <Question>())) .ReturnsAsync(mockQuestion); var questionManager = new QuestionManager(mockQuestionRepo.Object); var questionToTest = new QuestionDto(); var createdQuestion = await questionManager.CreateQuestionAsync(questionToTest); Assert.NotNull(createdQuestion); Assert.Equal(1, createdQuestion.Id); mockQuestionRepo.Verify(u => u.CreateQuestionAsync(It.IsAny <Question>()), Times.Once); }
public static QuestionDto ToQuestionDto(this Question question) { if (question == null) { return(null); } var questionDto = new QuestionDto { Id = question.Id, Text = question.Text, TextAnswersList = question.TextAnswers .Select(x => x.ToTextAnswerDto()) .ToList(), MultichoiceAnswersList = question.MultichoiceAnswers .Select(x => x.ToMultichoiceAnswerDto()) .ToList() }; return(questionDto); }
public async Task <ActionResult <QuestionDto> > Get(string uuid, CancellationToken ct) { Question question; try { question = await _context.Questions .SingleOrDefaultAsync(q => q.Uuid == uuid, ct); } catch (Exception ex) { _logger.LogError(EventIds.DatabaseError, ex, ex.Message); throw; } if (question == null) { return(NotFound()); } return(QuestionDto.FromQuestion(question)); }
/// <inheritdoc /> public async Task <List <QuestionDto> > Get(QuestionResourceParameters questionResourceParameters) { var listResult = await _questionRespository.Get(questionResourceParameters.Filter, questionResourceParameters.Limit, questionResourceParameters.Offset); if (listResult == null) { return(null); } var listQuestionDto = new List <QuestionDto>(); foreach (var question in listResult) { var questionDto = new QuestionDto(); questionDto.CopyPropertiesFrom(question); listQuestionDto.Add(questionDto); } return(listQuestionDto); }
public IActionResult Save(QuestionDto questionDto) { var question = Mapper.Map <QuestionDto, Question>(questionDto); if (question.Id == 0) { _logger.LogInformation("--------------- Creating question -----------------"); _questionService.Create(question); } else { _logger.LogInformation("--------------- UPDATING question -----------------"); _questionService.Update(question); } TempData["message"] = "toast-success"; return(RedirectToAction("Index", "Questions")); }
public async Task <IActionResult> UpdateQuestion([FromHeader] string userId, QuestionDto dto) { var question = _questionService.Get(dto.Id); if (question is null) { return(BadRequest()); } var authResult = await _authorizationService.AuthorizeAsync(User, question, nameof(QuestionPolicy)); if (!authResult.Succeeded) { return(Forbid()); } dto.AuthorId = userId; _questionService.Update(dto); return(NoContent()); }
public QuestionDto SaveOrUpdateQuestion(QuestionDto questionToSave, AppUser user) { questionToSave.LastUpdateDate = questionToSave.DateCreated = DateTime.Now; questionToSave.LastUpdateByDisplayName = questionToSave.CreatedByDisplayName = Utils.FormatFullName(user.FirstName, user.LastName); Question question = Mapper.Map <QuestionDto, Question>(questionToSave); // Initialize properties which are not in the dto question.CreatedBy = question.LastUpdateBy = user.Id; question.RankSum = 0; // Initialize MatchingVector question = InitializeMatchingVector(question); // save in db base.Add(question); _context.SaveChanges(); return(Mapper.Map <Question, QuestionDto>(question)); }
///TODO- need to add this profile fields in db and api public IActionResult GetCertificateQuestionByID(int id) { var qa = _questionService.GetById(id); QuestionDto question = new QuestionDto() { ID = qa.ID, QuestionTitle = qa.QuestionTitle, CreatedBy = qa.CreatedBy, CreatedOn = qa.CreatedOn, ModifiedBy = qa.ModifiedBy, ModifiedOn = qa.ModifiedOn }; question.Certificates = new List <CertificateDto>(); foreach (CertificateQuestion c in qa.CertificateQuestions) { Certificate certificate = c.Certificate; CertificateDto certificateDto = new CertificateDto(); if (certificate == null) { certificate = _certificateService.GetById(c.CertificateID); certificateDto = new CertificateDto() { ID = certificate.ID, Name = certificate.Name, ParentID = certificate.ParentID, CreatedBy = certificate.CreatedBy, CreatedOn = certificate.CreatedOn, ModifiedBy = certificate.ModifiedBy, ModifiedOn = certificate.ModifiedOn, Status = certificate.Status, IsCertificateQA = certificate.IsCertificateQA }; } question.Certificates.Add(certificateDto); } return(Ok(question)); }
public async Task <ActionResult> Edit(QuestionViewModel questionViewModel) { if (ModelState.IsValid) { var questDto = new QuestionDto { Id = questionViewModel.Id, Point = questionViewModel.Point, TestId = questionViewModel.TestId, QuestionContent = questionViewModel.QuestionContent, Answers = new List <AnswerDto>() }; if (questionViewModel.Answers != null) { foreach (var answer in questionViewModel.Answers) { questDto.Answers.Add(new AnswerDto { Id = answer.Id, AnswerContent = answer.AnswerContent, IsTrue = answer.IsTrue, QuestionId = answer.QuestionId }); } } try { await QuestionService.UpdateAsync(questDto); return(RedirectToAction("Edit", "Question", new { questionId = questDto.Id })); } catch (TestException e) { ViewBag.Error = e.Message; return(View("Error")); } } return(View(questionViewModel)); }
public async Task <bool> SaveAsync(QuestionDto model) { if (model.Question.Id == 0) { GetDbSet <Question>().Add(model.Question); await SaveChangesAsync(); } else { Attach(model.Question, EntityState.Modified); } var answerDb = GetDbSet <Answer>(); List <Answer> answerList = answerDb.Where(o => o.QuestionId == model.Question.Id).ToList(); answerDb.RemoveRange(answerList); model.Answers.ForEach(o => o.QuestionId = model.Question.Id); answerDb.AddRange(model.Answers); return(await SaveChangesAsync()); }
public async Task <ActionResult <QuestionDto> > Put([FromBody] QuestionDto item) { try { if (item == null || item.Id == null) { return(BadRequest()); } if (await _supervisor.UpdateQuestionAsync(item)) { return(Ok(item)); } else { return(NotFound()); } } catch (Exception ex) { return(StatusCode(500, ex)); } }
public async Task <IActionResult> Put(int id, [FromBody] QuestionDto questionDto) { if (id != questionDto.Id) { return(BadRequest()); } if (await context.Quizzes.FindAsync(questionDto.QuizId) == null) { return(NotFound()); } var question = await context.Questions.SingleOrDefaultAsync(x => x.Id == id); mapper.Map(questionDto, question); context.Entry(question).State = EntityState.Modified; await context.SaveChangesAsync(); return(Ok(mapper.Map <QuestionDto>(question))); }