public IHttpActionResult PutComment(int id, CommentRequestModel commentRequest)
{
Comment comment;
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
comment = repository.GetById(id);
}
catch (Exception)
{
throw;
}
if (id != comment.Id)
{
return(BadRequest());
}
//
commentRequest.Id = comment.Id;
commentRequest.LostStuffId = comment.LostStuffId;
//
comment.UpdatedAt = DateTime.Now;
comment.Content = commentRequest.Content;
repository.Update(comment);
return(Ok());
}
public CommentResponseModel AddCommentToEstate(string userId, CommentRequestModel comment)
{
var user = this.users
.GetById(userId);
var newComment = new Comment()
{
Content = comment.Content,
CreatedOn = DateTime.Now,
EstateId = comment.RealEstateId,
UserId = userId,
User = user
};
user.Comments.Add(newComment);
this.users.SaveChanges();
var responseModel = new CommentResponseModel()
{
Content = newComment.Content,
CreatedOn = newComment.CreatedOn,
UserName = newComment.User.UserName
};
return responseModel;
}
public IHttpActionResult CreateArtileComment(int id, CommentRequestModel model)
{
var user = this.User.Identity.Name;
var newComment = this.articleService.AddComment(id, model.Content, user);
return(this.Created("api/articles/" + id, newComment));
}
[HttpPut] //PUT api/posts/{postId}/comment
public HttpResponseMessage AddCommentToPost(int id, CommentRequestModel commentModel,
[ValueProvider(typeof(HeaderValueProviderFactory <string>))] string
sessionKey)
{
var addCommentResponse = this.TryToExecuteOperation(() =>
{
if (!usersRepository.All().Any(x => x.SessionKey == sessionKey))
{
throw new InvalidOperationException("Not authorized user!");
}
if (commentModel == null || string.IsNullOrEmpty(commentModel.Text))
{
throw new InvalidOperationException("The comment or comment text can not be null!");
}
var user = this.usersRepository.All().FirstOrDefault(x => x.SessionKey == sessionKey);
var post = this.postsRepository.Get(id);
var comment = new Comment()
{
Text = commentModel.Text,
PostDate = DateTime.Now,
CommentedBy = user,
Post = post
};
this.commentsRepository.Add(comment);
var response = this.Request.CreateResponse(HttpStatusCode.Created);
return(response);
});
return(addCommentResponse);
}
public IHttpActionResult Post(int photoId, CommentRequestModel comment)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var photo = this.photos
.All()
.FirstOrDefault(p => p.Id == photoId);
if (photo == null)
{
return(this.NotFound());
}
var commentToAdd = new Comment()
{
Content = comment.Content,
UserId = comment.UserId
};
photo.Comments.Add(commentToAdd);
this.photos.SaveChanges();
return(this.Ok("Comment successfully added."));
}
public IHttpActionResult Put(int id, CommentRequestModel comment)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var currentComment = this.comments
.All()
.FirstOrDefault(c => c.Id == id);
if (currentComment == null)
{
return(this.NotFound());
}
if (currentComment.User.UserName != this.User.Identity.Name)
{
return(this.Unauthorized());
}
currentComment.Content = comment.Content;
this.comments.Update(currentComment);
this.comments.SaveChanges();
return(this.Ok("Comment updated"));
}
public IHttpActionResult Comment(int id, CommentRequestModel model)
{
var suggestion = this.suggestions
.GetSuggestionById(id)
.SingleOrDefault();
if (suggestion == null)
{
return(this.BadRequest("Suggestion does not exist"));
}
if (!this.suggestions.UserIsEligibleToGetSuggestion(suggestion, this.User.IsInRole(UserConstants.AdminRole)))
{
return(this.BadRequest("You do not have permission to comment that suggestion!"));
}
var newComment = this.comments
.AddComment(id, this.User.Identity.GetUserId(), Mapper.Map <Comment>(model));
var updatedSuggestion = this.suggestions
.UpdateSuggestionCommentsCount(suggestion, suggestion.CommentsCount + 1);
var result = Mapper.Map <CommentResponseModel>(newComment);
return(this.Ok(result));
}
public async Task <ApiBaseResponse> FavoritePostAsync(CommentRequestModel comment)
{
var userId = Guid.Parse(_httpContextAccessor?.HttpContext?.User?.Identity?.Name);
BlogStatsItem statsItem = new BlogStatsItem();
if (await _blogStatsItemRepository.ExistsAsync(c => c.PostId == comment.PostId))
{
statsItem = await _blogStatsItemRepository.GetAsync(c => c.PostId == comment.PostId);
statsItem.FavouriteCount = statsItem.FavouriteCount + 1;
statsItem.Favorites.Add(new Favorite {
Id = Guid.NewGuid(), UserId = userId
});
await _blogStatsItemRepository.UpdateAsync(statsItem);
}
else
{
statsItem = new BlogStatsItem
{
Id = Guid.NewGuid(),
PostId = comment.PostId,
FavouriteCount = 1,
CommentCount = 0
};
statsItem.Favorites.Add(new Favorite {
Id = Guid.NewGuid(), UserId = userId
});
await _blogStatsItemRepository.AddAsync(statsItem);
}
return(new ApiBaseResponse(HttpStatusCode.OK, ApplicationStatusCode.Success, null, "Succesfully favorited."));
}
public IHttpActionResult AddComment(CommentRequestModel model)
{
if (model == null || !this.ModelState.IsValid)
{
return this.BadRequest(InvalidModelMessage);
}
var entity = new Comment
{
Content = model.Content,
UserName = this.identityProvider.GetIdentity().GetUserId(),
CreatedOn = DateTime.Now,
RealEstateId = model.RealEstateId
};
this.comments.Add(entity);
CommentResponseModel response = this.comments
.All()
.Where(x => x.RealEstateId == entity.RealEstateId & x.Content == entity.Content)
.ProjectTo<CommentResponseModel>()
.FirstOrDefault();
return this.Created("api/Comments", response);
}
public IActionResult GetByPostId([FromBody] CommentRequestModel model)
{
if (!_accountDomainService.CheckIfUserExistsFromHeader(HttpContext.Request))
{
return(Unauthorized());
}
else
{
var comments = _commentRepository.GetAll()
.Where(p => p.PostId == model.PostId)
.Include(q => q.Creator)
.OrderBy(p => p.CreatedAt)
.Skip((model.Page - 1) * model.Size)
.Take(model.Size)
.ToList();
var outputModel = comments.Select(p => new CommentOutputModel
{
Id = p.Id,
Content = p.Content,
PostId = p.PostId,
CreatorName = p.Creator.Name,
CreatorId = p.CreatorId,
CreatedAt = p.CreatedAt
}).ToList();
return(Ok(outputModel));
}
}
public async Task <IActionResult> Post([FromBody] CommentRequestModel model)
{
Comment newComment = null;
if (ModelState.IsValid)
{
InitUserCredentials();
newComment = _mapper.Map(model, new Comment
{
Guid = Guid.NewGuid(),
UserGuid = UserGuid,
CompanyGuid = CompanyGuid,
CreationTime = DateTime.UtcNow,
CreationUserGuid = UserGuid
}
);
try
{
await _commentService.Save(newComment);
}
catch (Exception e)
{
Log.Error(e.StackTrace);
throw;
}
}
return(CreatedAtAction(nameof(Post), _mapper.Map(newComment, new CommentResponseModel())));
}
public IHttpActionResult CreateArtileComment(int id, CommentRequestModel model)
{
var user = this.User.Identity.Name;
var newComment = this.articleService.AddComment(id, model.Content, user);
return this.Created("api/articles/" + id, newComment);
}
public IActionResult AddComment([FromBody] CommentRequestModel model)
{
var user = this.User.FindFirst(ClaimTypes.NameIdentifier).Value;
PostDAL.AddComment(model, user);
return(new OkResult());
}
public Comment UpdateComment(Comment commentToUpdate, CommentRequestModel model)
{
commentToUpdate.Content = model.Content;
this.comments.SaveChanges();
return(commentToUpdate);
}
public async Task <IHttpActionResult> Edit(CommentRequestModel comment)
{
var edittedComment = await this.commentsService.EditComment(comment.Id, comment.CommentText, this.CurrentUser.UserName, this.CurrentUser.IsAdmin);
var model = this.mappingService.Map <CommentResponseModel>(edittedComment);
return(this.Data(model));
}
public IHttpActionResult AddCommentToEstate(CommentRequestModel model)
{
var loggedUserId = this.User.Identity.GetUserId();
var addedComment = this.comments
.AddCommentToEstate(loggedUserId, model);
return this.Ok(addedComment);
}
public IHttpActionResult Post(CommentRequestModel model)
{
var newComment = Mapper.Map <Comment>(model);
var id = this.comments.AddNew(newComment, this.User.Identity.GetUserId());
var result = this.comments
.GetById(id)
.ProjectTo <CommentResponseModel>()
.FirstOrDefault();
return(this.Created($"/api/Comments/{id}", result));
}
public IHttpActionResult Post(CommentRequestModel model)
{
var newComment = Mapper.Map<Comment>(model);
var id = this.comments.AddNew(newComment, this.User.Identity.GetUserId());
var result = this.comments
.GetById(id)
.ProjectTo<CommentResponseModel>()
.FirstOrDefault();
return this.Created($"/api/Comments/{id}", result);
}
public async Task <IHttpActionResult> Post(int id, CommentRequestModel comment)
{
var postedComment = await this.commentsService.AddNew(id, comment.CommentText, this.CurrentUser.UserName);
var model = await this.commentsService
.CommentById(postedComment.Id)
.Project()
.To <CommentResponseModel>()
.FirstOrDefaultAsync();
return(this.Data(model));
}
public async Task <IActionResult> Comments([FromBody] CommentRequestModel model, Guid id)
{
var response = new APIResponse <CommentResponseModel>()
{
Success = true
};
try
{
if (ModelState.IsValid)
{
var check = await _accountCtx.Citations.ForAccount(CommonAccount.Id).AsNoTracking().AnyAsync(x => x.Id == id);
if (check)
{
var user = await _accountCtx.AccountUsers.AsNoTracking().AnyAsync(x => x.Id == model.CreatedUserId);
if (user)
{
var result = await _citationSvc.SaveComment(CommonAccount.Id, id, model.CommentId, model.Comment, model.IsPublic, model.CreatedUserId);
response.Message = "Comment Saved Successfully.";
}
else
{
response.Success = false;
response.Errors.Add(new Error {
Code = 0, Message = "Invalid Created User Id"
});
}
}
else
{
response.Success = false;
response.Errors.Add(new Error {
Code = 0, Message = "Invalid Citation Id "
});
}
}
else
{
response.Success = false;
response.Errors.AddRange(ModelState.ToErrors());
}
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return(Ok(response));
}
public IHttpActionResult PostSubComment(int id, [FromBody] CommentRequestModel model)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var dataModel = Mapper.Map <Comment>(model);
var commentId = this.comments.AddSubComment(id, dataModel, this.User.Identity.Name);
return(this.Ok(commentId));
}
public IHttpActionResult PostComment(CommentRequestModel model)
{
if (!this.ModelState.IsValid)
{
return this.BadRequest(this.ModelState);
}
var dataModel = Mapper.Map<Comment>(model);
var commentId = this.comments.Add(dataModel, this.User.Identity.Name);
return this.Ok(commentId);
}
public IHttpActionResult Post(CommentRequestModel model)
{
var comment = this.comments
.CreateComment(content: model.Content, realEstateId: model.RealEstateId, userId: this.User.Identity.GetUserId());
var commentResult = this.comments
.GetCommentDetails(comment.Id)
.ProjectTo <CommentResponseModel>()
.FirstOrDefault();
var location = string.Format("api/comments/{0}", comment.Id);
return(this.Created(location, commentResult));
}
public static void AddComment(CommentRequestModel model, string userId)
{
var comment = new CommentModel
{
Content = model.Content,
UserId = userId,
PostId = model.PostId
};
using (var ctx = new AppDbContext())
{
ctx.Add(comment);
ctx.SaveChanges();
}
}
public void PutWithInvalidModelShouldReturnInvalidModelStateResult()
{
var controller = ControllerMockFactory.GetCommentsController(this.comments, this.photos);
controller.ModelState.AddModelError("content", "Invalid content!");
var updatedComment = new CommentRequestModel();
var result = controller.Put(0, updatedComment);
var expectedUpdatedCount = 0;
var expectedSaveChanges = 0;
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(InvalidModelStateResult));
Assert.AreEqual(expectedUpdatedCount, this.comments.UpdatedEntities.Count);
Assert.AreEqual(expectedSaveChanges, this.comments.NumberOfSaves);
}
public void PostWithInvalidModelShouldReturnInvalidModelStateResult()
{
var controller = ControllerMockFactory.GetCommentsController(this.comments, this.photos);
controller.ModelState.AddModelError("content", "Invalid content!");
var commentToBeAdded = new CommentRequestModel();
var result = controller.Post(0, commentToBeAdded);
var expectedNumberOfCommentsAdded = 0;
var expectedSaveChanges = 0;
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(InvalidModelStateResult));
Assert.AreEqual(expectedNumberOfCommentsAdded, this.photos.GetById(0).Comments.Count);
Assert.AreEqual(expectedSaveChanges, this.photos.NumberOfSaves);
}
public IHttpActionResult PutComment(int id, CommentRequestModel commentRequest)
{
Comment comment;
var userData = GetCurrentUser(db);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
comment = repository.GetById(id);
}
catch (Exception)
{
throw;
}
if (userData.Id.Equals(comment.UserId))
{
if (id != comment.Id)
{
return(BadRequest());
}
//
commentRequest.Id = comment.Id;
commentRequest.LostStuffId = comment.LostStuffId;
//
comment.UpdatedAt = DateTime.Now;
comment.Content = commentRequest.Content;
repository.Update(comment);
return(Ok("The comment was edited " +
new { comment.Id,
comment.Content,
comment.LostStuffId,
comment.UserId,
comment.UserName }));
}
else
{
return(BadRequest("You do not have permissions to edit!"));
}
}
public void PutWithInvalidUserShouldReturnUnauthorisedResult()
{
var controller = ControllerMockFactory.GetCommentsController(this.comments, this.photos, false);
var updatedComment = new CommentRequestModel()
{
Content = "Edited Content"
};
var result = controller.Put(TestConstants.DefaultNonExistingModelId, updatedComment);
var expectedUpdatedCount = 0;
var expectedSaveChanges = 0;
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
Assert.AreEqual(expectedUpdatedCount, this.comments.UpdatedEntities.Count);
Assert.AreEqual(expectedSaveChanges, this.comments.NumberOfSaves);
}
public void PostWithInvalidPhotoIdShouldReturnNotFoundResult()
{
var controller = ControllerMockFactory.GetCommentsController(this.comments, this.photos);
var commentToBeAdded = new CommentRequestModel()
{
Content = TestConstants.ValidContent,
UserId = TestConstants.ValidUserId
};
var result = controller.Post(TestConstants.DefaultNonExistingModelId, commentToBeAdded);
var expectedNumberOfCommentsAdded = 0;
var expectedSaveChanges = 0;
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
Assert.AreEqual(expectedNumberOfCommentsAdded, this.photos.GetById(0).Comments.Count);
Assert.AreEqual(expectedSaveChanges, this.photos.NumberOfSaves);
}
public void PutWithValidDataShouldReturnOkResult()
{
var controller = ControllerMockFactory.GetCommentsController(this.comments, this.photos);
var updatedComment = new CommentRequestModel()
{
Content = "Edited Content"
};
var result = controller.Put(0, updatedComment);
var actual = result as OkNegotiatedContentResult <string>;
var expectedContent = "Comment updated";
var expectedUpdatedCount = 1;
var expectedSaveChanges = 1;
Assert.IsNotNull(result);
Assert.AreEqual(expectedContent, actual.Content);
Assert.AreEqual(expectedUpdatedCount, this.comments.UpdatedEntities.Count);
Assert.AreEqual(expectedSaveChanges, this.comments.NumberOfSaves);
}
public IHttpActionResult PostNewComment(CommentRequestModel model)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var userId = this.User.Identity.GetUserId();
var newComment = Mapper.Map <Comment>(model);
newComment.UserId = userId;
this.commentsService.AddNewComment(newComment);
var createdCommentResponse = Mapper.Map <CommentEstateDetailsResponseModel>(newComment);
return(this.Created("api/comments", createdCommentResponse));
}
public void PostWithValidDataShouldReturnOkResult()
{
var controller = ControllerMockFactory.GetCommentsController(this.comments, this.photos);
var commentToBeAdded = new CommentRequestModel()
{
Content = TestConstants.ValidContent,
UserId = TestConstants.ValidUserId
};
var result = controller.Post(0, commentToBeAdded);
var actual = result as OkNegotiatedContentResult <string>;
var expectedContent = "Comment successfully added.";
var expectedSaveChanges = 1;
var expectedNumberOfCommentsAdded = 1;
Assert.IsNotNull(result);
Assert.AreEqual(expectedContent, actual.Content);
Assert.AreEqual(expectedNumberOfCommentsAdded, this.photos.GetById(0).Comments.Count);
Assert.AreEqual(expectedSaveChanges, this.photos.NumberOfSaves);
}
public IHttpActionResult Post(int id, CommentRequestModel comment)
{
if (!ModelState.IsValid)
{
return(this.BadRequest());
}
var currentUserId = this.User.Identity.GetUserId();
var commentToAdd = new Comment
{
ArticleId = id,
Content = comment.Content,
UserId = currentUserId
};
this.comments.Add(commentToAdd);
return(this.Ok("Comment added!"));
}
public IHttpActionResult Put(int id, CommentRequestModel model)
{
var comment = this.comments
.GetCommentById(id)
.SingleOrDefault();
if (comment == null)
{
return(this.NotFound());
}
if (!this.comments.UserIsEligibleToModifyComment(comment, this.User.Identity.GetUserId(), this.User.IsInRole(UserConstants.AdminRole)))
{
return(this.BadRequest("You are not allowed to modify this comment!"));
}
var updatedComment = this.comments
.UpdateComment(comment, model);
return(this.Ok(Mapper.Map <CommentResponseModel>(updatedComment)));
}
public async Task <IActionResult> Put([FromBody] CommentRequestModel model, Guid guid)
{
if (ModelState.IsValid)
{
if (guid == Guid.Empty)
{
return(new BadRequestResult());
}
Comment comment = await _commentService.Get(guid);
if (comment == null)
{
return(new NoContentResult());
}
InitUserCredentials();
if (comment.UserGuid != UserGuid)
{
return(new UnauthorizedResult());
}
var mapped = _mapper.Map(model, comment);
mapped.LastUpdateUserGuid = UserGuid;
mapped.LastUpdateTime = DateTime.Now;
try
{
await _commentService.Save(mapped);
}
catch (Exception e)
{
Log.Error(e.StackTrace);
throw;
}
}
return(new OkResult());
}
public async Task <IActionResult> Post(Guid deviceId, [FromBody] CommentRequestModel commentString)
{
try
{
var commentId = await _commentService.CreateAsync(Token, deviceId, commentString.Comment);
return(Created(HttpContext.Request.GetEncodedUrl(), commentId));
}
catch (ArgumentNullException ex)
{
_logger.LogError(ex.Message);
return(BadRequest(ex.Message));
}
catch (ArgumentException ex)
{
_logger.LogError(ex.Message);
return(BadRequest(ex.Message));
}
catch (ApplicationException ex)
{
_logger.LogError(ex.Message);
return(BadRequest(ex.Message));
}
}
public void PutWithInvalidModelShouldReturnInvalidModelStateResult()
{
var controller = ControllerMockFactory.GetCommentsController(this.comments, this.photos);
controller.ModelState.AddModelError("content", "Invalid content!");
var updatedComment = new CommentRequestModel();
var result = controller.Put(0, updatedComment);
var expectedUpdatedCount =0;
var expectedSaveChanges = 0;
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(InvalidModelStateResult));
Assert.AreEqual(expectedUpdatedCount, this.comments.UpdatedEntities.Count);
Assert.AreEqual(expectedSaveChanges, this.comments.NumberOfSaves);
}
public IHttpActionResult Put(int id, CommentRequestModel comment)
{
if (!this.ModelState.IsValid)
{
return this.BadRequest(this.ModelState);
}
var currentComment = this.comments
.All()
.FirstOrDefault(c => c.Id == id);
if (currentComment == null)
{
return this.NotFound();
}
if (currentComment.User.UserName != this.User.Identity.Name)
{
return this.Unauthorized();
}
currentComment.Content = comment.Content;
this.comments.Update(currentComment);
this.comments.SaveChanges();
return this.Ok("Comment updated");
}
public void PostWithInvalidModelShouldReturnInvalidModelStateResult()
{
var controller = ControllerMockFactory.GetCommentsController(this.comments, this.photos);
controller.ModelState.AddModelError("content", "Invalid content!");
var commentToBeAdded = new CommentRequestModel();
var result = controller.Post(0, commentToBeAdded);
var expectedNumberOfCommentsAdded = 0;
var expectedSaveChanges = 0;
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(InvalidModelStateResult));
Assert.AreEqual(expectedNumberOfCommentsAdded, this.photos.GetById(0).Comments.Count);
Assert.AreEqual(expectedSaveChanges, this.photos.NumberOfSaves);
}
public void PostWithInvalidPhotoIdShouldReturnNotFoundResult()
{
var controller = ControllerMockFactory.GetCommentsController(this.comments, this.photos);
var commentToBeAdded = new CommentRequestModel()
{
Content = TestConstants.ValidContent,
UserId = TestConstants.ValidUserId
};
var result = controller.Post(TestConstants.DefaultNonExistingModelId, commentToBeAdded);
var expectedNumberOfCommentsAdded = 0;
var expectedSaveChanges = 0;
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
Assert.AreEqual(expectedNumberOfCommentsAdded, this.photos.GetById(0).Comments.Count);
Assert.AreEqual(expectedSaveChanges, this.photos.NumberOfSaves);
}
public IHttpActionResult Post(int photoId, CommentRequestModel comment)
{
if (!this.ModelState.IsValid)
{
return this.BadRequest(this.ModelState);
}
var photo = this.photos
.All()
.FirstOrDefault(p => p.Id == photoId);
if (photo == null)
{
return this.NotFound();
}
var commentToAdd = new Comment()
{
Content = comment.Content,
UserId = comment.UserId
};
photo.Comments.Add(commentToAdd);
this.photos.SaveChanges();
return this.Ok("Comment succesfully added.");
}
public void PutWithInvalidUserShouldReturnUnauthorisedResult()
{
var controller = ControllerMockFactory.GetCommentsController(this.comments, this.photos, false);
var updatedComment = new CommentRequestModel()
{
Content = "Edited Content"
};
var result = controller.Put(TestConstants.DefaultNonExistingModelId, updatedComment);
var expectedUpdatedCount = 0;
var expectedSaveChanges = 0;
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
Assert.AreEqual(expectedUpdatedCount, this.comments.UpdatedEntities.Count);
Assert.AreEqual(expectedSaveChanges, this.comments.NumberOfSaves);
}
public void PutWithValidDataShouldReturnOkResult()
{
var controller = ControllerMockFactory.GetCommentsController(this.comments, this.photos);
var updatedComment = new CommentRequestModel()
{
Content = "Edited Content"
};
var result = controller.Put(0, updatedComment);
var actual = result as OkNegotiatedContentResult<string>;
var expectedContent = "Comment updated";
var expectedUpdatedCount = 1;
var expectedSaveChanges = 1;
Assert.IsNotNull(result);
Assert.AreEqual(expectedContent, actual.Content);
Assert.AreEqual(expectedUpdatedCount, this.comments.UpdatedEntities.Count);
Assert.AreEqual(expectedSaveChanges, this.comments.NumberOfSaves);
}
public void PostWithValidDataShouldReturnOkResult()
{
var controller = ControllerMockFactory.GetCommentsController(this.comments, this.photos);
var commentToBeAdded = new CommentRequestModel()
{
Content = TestConstants.ValidContent,
UserId = TestConstants.ValidUserId
};
var result = controller.Post(0, commentToBeAdded);
var actual = result as OkNegotiatedContentResult<string>;
var expectedContent = "Comment succesfully added.";
var expectedSaveChanges = 1;
var expectedNumberOfCommentsAdded = 1;
Assert.IsNotNull(result);
Assert.AreEqual(expectedContent, actual.Content);
Assert.AreEqual(expectedNumberOfCommentsAdded, this.photos.GetById(0).Comments.Count);
Assert.AreEqual(expectedSaveChanges, this.photos.NumberOfSaves);
}
public IHttpActionResult Post(CommentRequestModel model)
{
var userId = this.User.Identity.GetUserId();
var realEstate = this.data.RealEstates.GetById(model.RealEstateId);
if (realEstate == null)
{
return this.BadRequest("No such realEstate with the provided id");
}
var comment = new Comment()
{
RealEstateId = model.RealEstateId,
Content = model.Content,
CreatedOn = DateTime.UtcNow,
UserId = userId
};
this.data.Comments.Add(comment);
this.data.SaveChanges();
var response = this.data.Comments.All()
.Where(c => c.Id == comment.Id)
.ProjectTo<CommentResponseModel>()
.FirstOrDefault();
return this.Created("api/Comments", response);
}
