public async Task <AnswerDto> CreateAnswerAsync(AnswerDto answer)
{
var dbAnswer = AnswerMapper.ToDb(answer);
var createdAnswer = await _answerRepo.CreateAnswerAsync(dbAnswer);
return(AnswerMapper.ToDto(createdAnswer));
}
public async Task CreateAnswerAsync(AnswerDto answerDto)
{
var answer = AnswerMapper.ToEntity(answerDto);
answer.AnswerId = Guid.Empty;
await _answerRepo.CreateAnswerAsync(answer);
}
/// <summary>
/// Edit answer
/// </summary>
/// <param name="answerDTO"></param>
/// <returns></returns>
public AnswerDTO Edit(AnswerDTO answerDTO, Guid currentUser)
{
try
{
AnswerDTO answerupdated = new AnswerDTO();
var answerFound = db.Answers.Where(x => x.Id == answerDTO.Id).FirstOrDefault();
if (answerFound == null)
{
throw new NoSuchQuestionFound();
}
answerFound.Body = answerDTO.Body;
answerFound.EditDate = DateTime.Now;
answerupdated = AnswerMapper.ToDTO(answerFound);
answerupdated.Upvoted = CheckUpvote(currentUser, answerFound.Id);
answerupdated.Downvoted = CheckDownvote(currentUser, answerFound.Id);
db.SaveChanges();
return(answerupdated);
}
catch (NoSuchAnswerFound)
{
throw new NoSuchQuestionFound();
}
catch
{
return(null);
}
}
public HttpResponseMessage Edit(Guid Id, Answer answerToEdit)
{
try
{ if (answerLogic.FindAuthorId(Id) != CurrentUserId())
{
throw new Unauthorised();
}
answerToEdit.Id = Id;
AnswerDTO answer = answerLogic.Edit(AnswerMapper.ToDTO(answerToEdit));
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, answer);
return(response); }
catch (Unauthorised e)
{
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Forbidden, new { error = e.Message });
return(response);
}
catch (NoSuchAnswerFound e)
{
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.BadRequest, new { error = e.Message });
return(response);
}
catch (Exception e)
{
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.BadRequest, e.Message);
return(response);
}
}
public void MapAnswerToEntity()
{
//Arrange
var userDto = new UserDto {
UserId = Guid.NewGuid(),
UserName = "******"
};
var questionDto = new QuestionDto {
QuestionId = Guid.NewGuid(),
};
var answerDto = new AnswerDto
{
AnswerId = Guid.NewGuid(),
AnswerText = "Answer text",
CreatedDate = DateTime.Today,
ModifiedDate = DateTime.Today,
QuestionId = Guid.NewGuid(),
UserId = Guid.NewGuid(),
};
//Act
var answer = AnswerMapper.ToEntity(answerDto);
//Assert
Assert.Equal(answerDto.AnswerId, answer.AnswerId);
Assert.Equal(answerDto.AnswerText, answer.AnswerText);
Assert.Equal(answerDto.CreatedDate, answer.CreatedDate);
Assert.Equal(answerDto.ModifiedDate, answer.ModifiedDate);
Assert.Equal(answerDto.QuestionId, answer.QuestionId);
Assert.Equal(answerDto.UserId, answer.UserId);
}
public MappersTests()
{
var userService = new Mock <IUserService>();
_questionMapper = new QuestionMapper(userService.Object);
_answerMapper = new AnswerMapper(userService.Object);
}
public async Task <IEnumerable <AnswerDto> > GetAnswersAsync()
{
var dbAnswers = await _answerRepo.GetAnswersAsync();
var answers = dbAnswers.Select(a => AnswerMapper.ToDto(a));
return(answers);
}
public ActionResult Answer(AnswerViewModel viewModel)
{
if (ModelState.IsValid)
{
Service.Answer(AnswerMapper.Map(viewModel));
}
return(GetQuestionAnswers(viewModel.QuestionId));
}
public List <AnswerDto> Handle(long id)
{
var questionId = new QuestionId(id);
var answers = _session.CreateCriteria <Answer>().Add(Restrictions.Eq("Question", questionId))
.List <Answer>();
var answerMapper = new AnswerMapper(_userService);
return(answerMapper.MapAnswers(answers));
}
///convert to list of AnswerDTO.
public IEnumerable <AnswerDTO> GetAnswersAsDTOs()
{
try
{
var aList = GetAnswers();
return(AnswerMapper.MapAnswerToAnswerDTOs(aList));;
}
catch (Exception ex)
{
//UnitOfWork.WriteErrorLog(ex);
}
return(null);
}
///////////////INTERFACE METHOD//////////////////////
public AnswerDTO CreateAnswerDTO(int post_id, int parent_id)
{
try
{
var a = CreateAnswer(post_id, parent_id);
return(AnswerMapper.MapAnswerToAnswerDTO(a));
}
catch (Exception ex)
{
// UnitOfWork.WriteErrorLog(ex);
}
return(null);
}
public async Task <IEnumerable <AnswerDto> > GetAllAnswersAsync()
{
var answers = await _answerRepo.GetAllAnswersAsync();
var answerDtos = new List <AnswerDto>();
foreach (var answer in answers)
{
answerDtos.Add(AnswerMapper.ToDto(answer));
}
return(answerDtos);
}
/// <summary>
/// Downvote an answer
/// </summary>
/// <param name="voterId"></param>
/// <param name="answerId"></param>
/// <returns></returns>
public AnswerDTO Downvote(Guid voterId, Guid answerId)
{
try
{
AnswerDTO answerDTO = new AnswerDTO();
Answer answerFound = db.Answers.Where(x => x.Id == answerId).FirstOrDefault();
var voteColumn = db.Voters.Where(x => x.AnswerId == answerId && x.UserId == voterId).FirstOrDefault();
if (voteColumn == null)
{
Vote newVote = new Vote()
{
Id = Guid.NewGuid(),
UserId = voterId,
AnswerId = answerId,
Status = (int)EntityConstants.VOTE.Downvote
};
answerFound.DownvoteCount++;
db.Voters.Add(newVote);
}
else
{
if (voteColumn.Status == (int)EntityConstants.VOTE.Downvote)
{
answerDTO = AnswerMapper.ToDTO(answerFound);
answerDTO.Upvoted = false;
answerDTO.Downvoted = true;
db.SaveChanges();
return(answerDTO);
}
else if (voteColumn.Status == (int)EntityConstants.VOTE.Upvote)
{
answerFound.UpvoteCount--;
answerFound.DownvoteCount++;
voteColumn.Status = (int)EntityConstants.VOTE.Downvote;
}
}
db.SaveChanges();
answerDTO = AnswerMapper.ToDTO(answerFound);
answerDTO.Upvoted = false;
answerDTO.Downvoted = true;
return(answerDTO);
}
catch
{
return(null);
}
}
/// <summary>
/// Add answer to db
/// </summary>
/// <param name="answerDTO"></param>
/// <returns></returns>
public AnswerDTO Add(AnswerDTO answerDTO)
{
try
{
var answerToSave = db.Answers.Add(AnswerMapper.ToDB(answerDTO));
db.SaveChanges();
var answersaved = db.Answers.Include("Author").Where(x => x.Id == answerToSave.Id).FirstOrDefault();
AnswerDTO answerToReturn = AnswerMapper.ToDTO(answersaved);
answerToReturn.Upvoted = false;
answerToReturn.Downvoted = false;
return(answerToReturn);
}
catch
{
return(null);
}
}
public HttpResponseMessage Add(Answer answerToAdd, Guid id)
{
try
{
if (answerToAdd != null && ModelState.IsValid && id != null)
{
AnswerDTO answerDTO = AnswerMapper.ToDTO(answerToAdd);
answerDTO.QuestionId = id;
var email = CurrentEmail();
UserDTO author = userLogic.Find(email);
answerDTO.Author = author;
answerDTO.AuthorId = author.Id;
var answer = answerLogic.Add(answerDTO);
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, answer);
return(response);
}
else
{
var validationErrors = new List <string>();
foreach (var state in ModelState)
{
foreach (var error in state.Value.Errors)
{
validationErrors.Add((error.ErrorMessage));
}
}
var jsonerrors = JsonConvert.SerializeObject(new
{
errors = validationErrors
});
return(Request.CreateResponse(HttpStatusCode.Forbidden, JsonConvert.DeserializeObject(jsonerrors)));
}
}
catch (Exception e)
{
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.BadRequest, e.Message);
return(response);
}
}
/// <summary>
/// Get all answers of a question
/// </summary>
/// <param name="questionId"></param>
/// <returns></returns>
public List <AnswerDTO> All(Guid questionId, Guid currentUser)
{
try{
List <AnswerDTO> answerDTOs = new List <AnswerDTO>();
var answers = db.Answers.Include("Author").Where(x => x.QuestionId == questionId).ToList();
foreach (var answer in answers)
{
AnswerDTO temp = AnswerMapper.ToDTO(answer);
if (currentUser != Guid.Empty && currentUser != null)
{
temp.Upvoted = CheckUpvote(currentUser, answer.Id);
temp.Downvoted = CheckDownvote(currentUser, answer.Id);
}
answerDTOs.Add(temp);
}
return(answerDTOs);
}
catch
{
return(null);
}
}
/// <summary>
/// Delete User from database
/// </summary>
/// <param name="answerId"></param>
/// <returns></returns>
public AnswerDTO Delete(Guid answerId)
{
try
{
Answer answer = db.Answers.Where(x => x.Id == answerId).FirstOrDefault();
if (answer == null)
{
throw new NoSuchAnswerFound();
}
AnswerDTO answerDTO = AnswerMapper.ToDTO(answer);
db.Answers.Remove(answer);
db.SaveChanges();
return(answerDTO);
}
catch (NoSuchAnswerFound)
{
throw new NoSuchAnswerFound();
}
catch
{
return(null);
}
}
/// <summary>
/// Un Down Vote
/// </summary>
/// <param name="voterId"></param>
/// <param name="answerId"></param>
/// <returns></returns>
public AnswerDTO UnDownVote(Guid voterId, Guid answerId)
{
try
{
AnswerDTO answerDTO = new AnswerDTO();
Answer answerFound = db.Answers.Where(x => x.Id == answerId).FirstOrDefault();
Vote voteColumn = db.Voters.Where(x => x.AnswerId == answerId && x.UserId == voterId).FirstOrDefault();
if (voteColumn == null)
{
}
else
{
if (voteColumn.Status == (int)EntityConstants.VOTE.Downvote)
{
db.Voters.Remove(voteColumn);
answerFound.DownvoteCount--;
answerDTO = AnswerMapper.ToDTO(answerFound);
answerDTO.Upvoted = false;
answerDTO.Downvoted = false;
db.SaveChanges();
return(answerDTO);
}
else if (voteColumn.Status == (int)EntityConstants.VOTE.Upvote)
{
}
}
db.SaveChanges();
answerDTO = AnswerMapper.ToDTO(answerFound);
answerDTO.Upvoted = false;
answerDTO.Downvoted = false;
return(answerDTO);
}
catch
{
return(null);
}
}
public void MapAnswerToDtoWithNull()
{
var answerDto = AnswerMapper.ToDto(null);
Assert.Null(answerDto);
}
public void MapAnswerToEntityWithNull()
{
var answer = AnswerMapper.ToEntity(null);
Assert.Null(answer);
}
public ServiceAnswer(IMapper mapper)
{
this.mapper = (AnswerMapper)mapper;
}
public async Task UpdateAnswerAsync(AnswerDto answerDto)
{
var answer = AnswerMapper.ToEntity(answerDto);
await _answerRepo.UpdateAnswerAsync(answer);
}
public async Task <AnswerDto> GetAnswerAsync(Guid answerId)
{
var answer = await _answerRepo.GetAnswerAsync(answerId);
return(AnswerMapper.ToDto(answer));
}
public async Task <AnswerDto> GetAnswerAsync(int id)
{
var dbAnswer = await _answerRepo.GetAnswerAsync(id);
return(AnswerMapper.ToDto(dbAnswer));
}
public AnswerDTO GetAnswerAsDTO(int AnswerPostID)
{
var a = GetAnswer(AnswerPostID);
return(AnswerMapper.MapAnswerToAnswerDTO(a));
}
