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)));
}
