public async Task CreateAsync_WithValidData_ShouldAddCommentToDatabase() { // Arrange var context = InMemoryDbContext.Initiliaze(); var commentsRepository = new EfDeletableEntityRepository <Comment>(context); var postsRepository = new EfDeletableEntityRepository <Post>(context); var service = new CommentsService(commentsRepository, postsRepository); await this.SeedUsersAndPost(context); var model = new CommentCreateModel { CreatorId = "userId", PostId = 52, Text = "Comment Text", }; // Act int expectedCount = context.Comments.Count() + 1; await service.CreateAsync(model); int actualCount = context.Comments.Count(); // Assert Assert.Equal(expectedCount, actualCount); }
public virtual PartialViewResult Add(CommentCreateModel model) { var commentsTarget = FullContext.GetCommentsTarget(); var targetEntityId = commentsTarget.EntityId.Value; if (!ModelState.IsValid) { return(OverView(targetEntityId)); } var createDto = MapToCreateDto(model, targetEntityId); var command = new AddCommentCommand(FullContext, createDto); _commandPublisher.Publish(command); OnCommentCreated(createDto.Id); switch (commentsTarget.Type.ToInt()) { case int type when ContextExtensions.HasFlagScalar(type, ContextType.Activity | ContextType.PagePromotion): var activityCommentsInfo = GetActivityComments(targetEntityId); return(OverView(activityCommentsInfo)); default: return(OverView(targetEntityId)); } }
public IActionResult CreateComment([FromBody] CommentCreateModel commentModel) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } string userId = User.FindFirstValue(ClaimTypes.NameIdentifier); User user = _repoWrapper.User.FindByCondition(u => u.Id.ToString() == userId).FirstOrDefault(); if (user == null) { return(BadRequest("Token is incorrect")); } Podcast podcast = _repoWrapper.Podcast.FindByCondition(p => p.Id == commentModel.PodcastId).FirstOrDefault(); if (podcast == null) { return(NotFound("PodcastId is incorrect")); } Comment comment = new Comment() { Text = commentModel.Text, PodcastId = commentModel.PodcastId, UserId = user.Id, PublicationDate = DateTime.Now }; _repoWrapper.Comment.Create(comment); _repoWrapper.Save(); return(Ok(comment)); }
public ActionResult AddComment(CommentCreateModel commentModel, int ticketId) { var user = this.Data.Users.All().FirstOrDefault(u => u.UserName == this.User.Identity.Name); var ticket = this.Data.Tickets.GetById(ticketId); if (ModelState.IsValid) { var newComment = new Comment() { Content = commentModel.Content, Ticket = ticket, User = user }; this.Data.Comments.Add(newComment); this.Data.SaveChanges(); return(PartialView("_CommentPartial", new CommentDisplayModel() { Content = commentModel.Content, Username = this.User.Identity.Name })); } else { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Invalid comment")); } }
public async Task <IActionResult> CreateCommentAsync([FromRoute] int postId, [FromBody] CommentCreateModel model) { if (string.IsNullOrWhiteSpace(model.Content)) { throw new IsRequiredException("content"); } if (model.Content.Length < 20) { throw new ContentIsInvalidException(); } if (!await _postRepository.AnyByIdAsync(postId)) { throw new NotFound404Exception("post"); } DateTime now = DateTime.Now; var comment = new Comment { AccountId = CurrentAccountId, PostId = postId, Content = model.Content, CreatedDate = now, UpdatedDate = now }; await _postRepository.CreateCommentAsync(comment); return(Ok(CommentDTO.GetFrom(comment))); }
public IHttpActionResult Post(CommentCreateModel comment) { var userId = this.context.Users.FirstOrDefault(u => u.UserName == comment.AuthorUsername).Id; if (comment != null && this.ModelState.IsValid) { var databaseComment = new Comment { Content = comment.Content, NewsItemId = comment.NewsItemId, AuthorId = userId, CreatedOn = DateTime.Now }; context.Comments.Add(databaseComment); context.SaveChanges(); return(Ok(new { id = databaseComment.Id, content = databaseComment.Content, author = databaseComment.Author.UserName, createdOn = databaseComment.CreatedOn, })); } else { return(this.BadRequest(this.ModelState)); } }
public virtual PartialViewResult CreateView(Guid activityId) { var model = new CommentCreateModel { UpdateElementId = GetOverviewElementId(activityId) }; return(PartialView(CreateViewPath, model)); }
public async Task AddCommentAsync(CommentCreateModel model) { var commentDto = _mapper.Map <CommentDTO>(model); commentDto.AppUserId = (await _currentUser.GetCurrentUser(_httpContextAccessor.HttpContext)).Id; await _commentService.AddCommentAsync(commentDto); }
public async Task <IActionResult> Create(CommentCreateModel model) { var user = await _userManager.GetUserAsync(User); await _service.Create(model, user.Id); return(NoContent()); }
public async Task Create(CommentCreateModel model, string userId) { var entity = _mapper.Map <Comment>(model); entity.UserId = userId; await _context.AddAsync(entity); }
public async Task <IActionResult> Post([FromBody] CommentCreateModel model) { _logger.LogInformation($"Create new videoGame : {HttpContext.Request.Query} "); if (await _service.CreateAsync(_mapper.Map <CommentDTO>(model))) { return(Ok()); } return(BadRequest()); }
public ActionResult CreateComment(CommentCreateModel model) { if (ModelState.IsValid) { var comment = model.ConvertToComment(); comment.Id = CommentHelper.CreateComment(comment); return(PartialView("_Comment", new CommentViewModel(comment))); } return(Json(new { error = CommentHelper.BuildErrorMessage(ModelState) })); }
public void CreateComment(CommentCreateModel model, int userId) { using (var unitOfWork = _unitOfWorkFactory.Create()) { Comment comment = Mapper.Map <Comment>(model); comment.AuthorId = userId; unitOfWork.Comments.Create(comment); } }
public async Task <IActionResult> PostComment([FromBody] CommentCreateModel rateModel, [FromRoute][Required] int id) { var command = Mapper.Map <CommandCreateComment>(rateModel); command.PlaceId = id; await Mediator.Send(command); return(Ok()); }
public async Task <IActionResult> Create(CommentCreateModel model) { User user = await _userManager.GetUserAsync(User); _commentService.CreateComment(model, user.Id); List <CommentModel> models = _commentService.GetAllComments(model.AdId); return(PartialView("_AllComments", models)); }
public IHttpActionResult CreateComment([FromBody] CommentCreateModel commentToCreate) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var service = CreateCommentService(); service.CreateComment(commentToCreate); return(Ok()); }
public void AddComment(CommentCreateModel commentToCreate) { var entity = new Comment() { UserId = _userId, Text = commentToCreate.Text, PostId = commentToCreate.PostId }; _ctx.Comments.Add(entity); _ctx.SaveChanges(); }
public void CreateComment(CommentCreateModel commentToCreate) { var entity = new Comment() { //UserId = commentToCreate.UserId, Text = commentToCreate.Text, CreatedAtUtc = commentToCreate.CreatedAtUtc }; _ctx.Comments.Add(entity); _ctx.SaveChanges(); }
protected virtual CommentCreateDto MapToCreateDto(CommentCreateModel createModel, Guid activityId) { var currentMemberId = _intranetMemberService.GetCurrentMember().Id; var dto = new CommentCreateDto( Guid.NewGuid(), currentMemberId, activityId, createModel.Text, createModel.ParentId, createModel.LinkPreviewId); return(dto); }
public IActionResult Create([FromBody] CommentCreateModel model) { if (!_accountDomainService.CheckIfUserExistsFromHeader(HttpContext.Request)) { return(Unauthorized()); } else { long creatorId = long.Parse(HttpContext.Request.Headers["X-Account-Id"]); var comment = new Comment(model.Content, creatorId, model.PostId); _commentRepository.Create(comment); return(Ok()); } }
public IActionResult Create(CommentCreateModel commentCreateModel, int id) { var userName = User.Identity.Name; var e = _db.Comments.Add(new CommentModel { Author = _db.Users.FirstOrDefault(u => u.UserName == userName), CreateDate = DateTime.Now, Text = commentCreateModel.CommentText, Post = _db.Posts.FirstOrDefault(p => p.Id == id) }); _db.SaveChanges(); return(RedirectToAction("Index", "Comment", new { id = id })); }
public async Task <bool> CreateComment(CommentCreateModel model, string userName, string link, int?commentId) { var userProfile = await context .Profiles .Include(u => u.User) .FirstOrDefaultAsync(p => p.User.UserName == userName); var news = await context .News .FirstOrDefaultAsync(n => n.Id == model.NewsId); if (news != null) { await statisticNewsService.SetState(model.NewsId, userName, "view", string.Empty); var now = DateTime.Now; await context.Comments.AddAsync(new Data.dbModels.Comment { News = news, DateComment = now, Text = model.TextComment, Owner = userProfile, UserNameTo = model.UsernameAddresTo, CommentIdTo = model.CommentIdTo }); if (!string.IsNullOrEmpty(model.UsernameAddresTo)) { var profileFrom = userProfile.Id; var userFromName = userProfile.User.UserName; var userToId = (await context .Users .FirstOrDefaultAsync(u => u.UserName == model.UsernameAddresTo)) ?.Id; var profileTo = await context.Profiles.FirstOrDefaultAsync(p => p.UserId == userToId); if (profileTo != null) { await SetNotificationAsync(profileTo, profileFrom, link, userFromName, commentId); } } await context.SaveChangesAsync(); return(true); } return(false); }
public async Task <IActionResult> Create([FromBody] CommentCreateModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState.ToDictionary( kvp => kvp.Key, kvp => kvp.Value.Errors.Select(e => e.ErrorMessage).ToArray() ))); } var postCreatorId = await this.service.CreateAsync(model); return(Ok(postCreatorId)); }
public IActionResult Add(CommentCreateModel commentCreateModel) { var userId = int.Parse(User.FindFirst("Id").Value); var response = _commentsService.Add(commentCreateModel.Comment, commentCreateModel.TicketId, userId); if (response.IsSuccessful) { return(RedirectToAction("Details", "Ticket", new { id = commentCreateModel.TicketId })); } else { return(RedirectToAction("ActionNonSuccessful", "Info", new { Message = response.Message })); } }
public static CommentDTO ConvertToCommentDTO(CommentCreateModel createModel) { if (createModel == null) { throw new ArgumentNullException(); } CommentDTO commentDTO = new CommentDTO { PostId = createModel.PostId, Content = createModel.Content }; return(commentDTO); }
public async Task <ActionResult> CreateComment(CommentCreateModel model) { var username = User.GetUserName(); string link = model.NewsId.ToString(); var commentIdTo = model.CommentIdTo; var result = await commentService.CreateComment(model, username, link, commentIdTo); if (result) { return(Ok()); } return(BadRequest()); }
public ActionResult Create(CommentCreateModel model) { if (ModelState.IsValid) { return(View(model)); } var service = CreateCommentService(); if (service.CreateComment(model)) { TempData["SaveResult"] = "Your note was created."; return(RedirectToAction("Index")); } ModelState.AddModelError("", "Note could not be created."); return(View(model)); }
private async Task <CommentCreateDto> MapToCreateDtoAsync( CommentCreateModel createModel, Guid activityId) { var currentMemberId = await _intranetMemberService.GetCurrentMemberIdAsync(); var dto = new CommentCreateDto( Guid.NewGuid(), currentMemberId, activityId, createModel.Text, createModel.ParentId, createModel.LinkPreviewId); return(dto); }
public async Task <ActionResult> Create([FromBody] CommentCreateModel commentModel) { if (!ModelState.IsValid) { return(BadRequest(new ResponseModel(400, "Invalid value was entered! Please, redisplay form."))); } var commentDto = _mapper.Map <CommentDto>(commentModel); commentDto.AuthorId = this.GetCurrentUserId(); var result = await _commentService.CreateAsync(commentDto); return(result.Succeeded ? Ok(new ResponseModel(200, "Completed.", "Comment created.")) : (ActionResult)BadRequest(new ResponseModel(400, "Failed.", result.Error))); }
public async Task <IHttpActionResult> Add([FromBody] CommentCreateModel model) { if (model.EntityType.Is(IntranetEntityTypeEnum.Social, IntranetEntityTypeEnum.News, IntranetEntityTypeEnum.Events)) { var member = await _intranetMemberService.GetCurrentMemberAsync(); var activityGroupId = _groupActivityService.GetGroupId(model.EntityId); if (activityGroupId.HasValue) { var group = _groupService.Get(activityGroupId.Value); if (group == null || group.IsHidden) { return(StatusCode(HttpStatusCode.Forbidden)); } } if (activityGroupId.HasValue && !member.GroupIds.Contains(activityGroupId.Value)) { return(StatusCode(HttpStatusCode.Forbidden)); } } var createDto = await MapToCreateDtoAsync(model, model.EntityId); var command = new AddCommentCommand(model.EntityId, model.EntityType, createDto); _commandPublisher.Publish(command); await OnCommentCreatedAsync(createDto.Id, model.EntityType); switch (model.EntityType) { case IntranetEntityTypeEnum type when type.Is(IntranetEntityTypeEnum.News, IntranetEntityTypeEnum.Social, IntranetEntityTypeEnum.Events): var activityCommentsInfo = GetActivityComments(model.EntityId); return(Ok(await _commentsHelper.OverViewAsync(activityCommentsInfo.Id, activityCommentsInfo.Comments, activityCommentsInfo.IsReadOnly))); default: return(Ok(await _commentsHelper.OverViewAsync(model.EntityId))); } }
private void ValidateCommentCreateModel(CommentCreateModel model) { if (model == null) { throw new ServerErrorException( "Comment cannot be null", HttpStatusCode.BadRequest); } if (string.IsNullOrEmpty(model.Text)) { throw new ServerErrorException( "Comment text must be set", HttpStatusCode.BadRequest); } }