public void addComment(CommentDto CommentDto) { var comment = _mapper.Map <Comment>(CommentDto); _commentRep.Create(comment); _commentRep.Save(); }
public void updateComment(CommentDto CommentDto) { var comment = _mapper.Map <Comment>(CommentDto); _commentRep.Update(comment); _commentRep.Save(); }
public IActionResult Post([FromBody] CommentDto dto) { try { addComment.Execute(dto); return(StatusCode(201)); } catch (EntityAlreadyExistsException e) { return(StatusCode(409, new { Errors = new List <string> { e.Message } })); } catch (EntityAlreadyHasAnEntryException e) { return(StatusCode(409, new { Errors = new List <string> { e.Message } })); } catch (Exception e) { return(StatusCode(500, new { Errors = new List <string> { e.Message } })); } }
public async Task <ActionResult <CommentDto> > Add([FromBody] CommentDto comment) { comment.Id = null; var addedComment = await _commentsService.Add(comment); return(Created(addedComment.Id.ToString(), addedComment)); }
public ActionResult AddComment([FromBody] CommentDto commentDto) { var currUserId = _uow.Users.GetUserId(User.Identity.Name); commentDto.UserId = currUserId.ToString(); var currComment = _mapper.Map <Comment>(commentDto); _uow.Comments.Add(currComment); var currPost = _uow.Posts.Find(x => x.Id == currComment.PostId).FirstOrDefault(); if (currPost.Comments != null) { currPost.Comments.Add(currComment.Id); } else { currPost.Comments = new List <ObjectId>(); currPost.Comments.Add(currComment.Id); } _uow.Posts.Edit(currPost); return(Ok(currComment)); }
public IActionResult Put(int id, [FromBody] CommentDto dto) { try { dto.Id = id; editComment.Execute(dto); return(StatusCode(204)); } catch (EntityNotFoundException e) { return(NotFound(new { Errors = new List <string> { e.Message } })); } catch (Exception e) { return(StatusCode(500, new { Errors = new List <string> { e.Message } })); } }
public async Task <IActionResult> AddComment(CommentDto comment) { Comment createComment = new Comment { Text = comment.Text, ArticleId = comment.ArticleId, ParentId = comment.ParentId, Date = DateTime.Now, Email = comment.Email, Name = comment.UserName }; try { await _commentRep.CreateAsync(createComment); await _uow.Commit(); return(Json(new JsonResponse { Success = true, Data = new { date = _convert.ConvertMiladiToShamsi(createComment.Date, "yyyy/MM/dd"), id = createComment.Id } })); } catch (Exception err) { return(Json(new JsonResponse { Success = false, ErrorMessage = err.Message })); } }
public bool Handle(NewCommentRequest request, IOutputPort <NewCommentResponse> outputPort) { if (_userRepository.FindById(request.UserId) == null) { outputPort.Handle(new NewCommentResponse(new[] { new Error(404, "user not found") })); return(false); } if (_videoRepository.FindById(request.VideoId) == null) { outputPort.Handle(new NewCommentResponse(new[] { new Error(404, "video not found") })); return(false); } var commentInfo = new CommentDto() { PostingDate = request.PostingDate, Text = request.Text, UserId = request.UserId, VideoId = request.VideoId, }; int commentId = _commentRepository.Create(commentInfo); outputPort.Handle(new NewCommentResponse(commentId)); return(true); }
/// <inheritdoc/> public async Task <int> UpdateAsync(CommentDto commentDto) { if (commentDto == null) { throw new ArgumentNullException(nameof(commentDto)); } var comment = await _context.Comments.FindAsync(commentDto.Id); if (comment == null) { return(0); } // If have class context use: // entity = _mapper.Map<EntityDto, Entity>(entityDto); // _context.Entry(entity).State = EntityState.Modified; comment.CloudId = commentDto.CloudId; comment.PostId = commentDto.PostId; comment.Name = commentDto.Name; comment.Email = commentDto.Email; comment.Body = commentDto.Body; return(await _context.SaveChangesAsync()); }
public async Task <IActionResult> Create([FromBody] CommentDto comment) { Guard.IsNotNull(comment, nameof(comment)); if (!ModelState.IsValid) { return(this.BadRequest(this.ModelState)); } try { if (string.IsNullOrWhiteSpace(comment.Commenter)) { comment.Commenter = this.username; // generated anonymous username } var result = await this.repository.AddCommentAsync(comment).ConfigureAwait(false); return(result.ToActionResult()); } catch (Exception e) { this.logger.LogError(e, e.Message); return(new StatusCodeResult(500)); } }
public void DeleteCommentTest() { // Arrange var expected = new CommentDto { Id = "1", BookId = "1", Book = new Book() { Id = "1", Title = "Stephen", Description = "King" }, UserId = "1", User = new UserProfile() { Id = "1", FirstName = "Oleksii", LastName = "Rudenko" }, Message = "Best book ever", TimeStamp = DateTime.Now }; var repository = new Mock <IRepository <Comment> >(); repository.Setup(r => r.Get(expected.Id)).Returns(new Comment { Id = "1", BookId = "1", Book = new Book() { Id = "1", Title = "Stephen", Description = "King" }, UserId = "1", User = new UserProfile() { Id = "1", FirstName = "Oleksii", LastName = "Rudenko" }, Message = "Best book ever", TimeStamp = DateTime.Now }); var mapper = new Mock <IMapper>(); mapper.Setup(m => m.Map <Comment, CommentDto>(It.IsAny <Comment>())).Returns(expected); var svc = new CommentService(repository.Object, mapper.Object); // Act svc.DeleteComment(expected); // Assert repository.Verify(r => r.Get(It.IsAny <string>()), Times.Once()); repository.Verify(r => r.Delete(It.IsAny <string>()), Times.Once()); repository.Verify(r => r.Save(), Times.Once()); }
public async Task <bool> Update(CommentDto model) { var articleNo = _mapper.Map <Comment>(model); _repoArticalNo.Update(articleNo); return(await _repoArticalNo.SaveAll()); }
public async Task <ActionResult <CommentDto> > CreateComment([FromRoute] int forumId, [FromBody] CommentDto newComment) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var forum = await _context.Forums .Where(o => o.Id == forumId) .Include(o => o.Comments) .FirstOrDefaultAsync(); if (forum == null) { return(BadRequest("Forum not found.")); } var comment = new Comment { Author = await _userManager.GetUserAsync(HttpContext.User), Text = newComment.Text, CreationDate = DateTimeOffset.Now }; forum.Comments.Add(comment); await _context.SaveChangesAsync(); return(_mapper.Map <CommentDto>(comment)); }
public void UpdateComment(CommentDto comment) { var commentMap = _mapper.Map <Comment>(comment); _commentRepository.Update(commentMap); _unitOfWork.Complete(); }
public IResult DeleteComment(CommentDto commentDto) { var comment = _mapper.Map <Comment>(commentDto); _commentRepository.Delete(comment); return(new SuccessResult(string.Format(Messages.SuccessfulDelete, nameof(Picture)))); }
private CommentDto CreateLinksForComment(CommentDto comment) { comment.Links.Add(new LinkDto(_urlHelper.Link("GetCommentForReview", new { id = comment.Id }), "self", "GET")); comment.Links.Add( new LinkDto(_urlHelper.Link("DeleteComment", new { id = comment.Id }), "delete_comment", "DELETE")); //comment.Links.Add( // new LinkDto(_urlHelper.Link("UpdateComment", // new { id = comment.Id }), // "update_game", // "PUT")); comment.Links.Add( new LinkDto(_urlHelper.Link("PartiallyUpdateComment", new { id = comment.Id }), "partially_update_comment", "PATCH")); return(comment); }
public void CheckCommentEmail() { CommentDto commentDto = JsonConvert.DeserializeObject <CommentDto>(commentResponse.GetCommentResponse(14)); Assert.AreEqual("*****@*****.**", commentDto.email, "Email must be: [email protected]"); Assert.AreNotEqual("Nathan@solon", commentDto.email, "Email must be incorrect: Nathan@solon"); }
public IActionResult Post( [FromBody] CommentDto dto, [FromServices] ICreateCommentCommand command) { _executor.ExecuteCommand(command, dto); return(StatusCode(StatusCodes.Status201Created)); }
public IHttpActionResult EditComment(CommentDto dto) { var currentUserId = User.Identity.GetUserId(); var result = _commentService.EditComment(dto, currentUserId); return(this.ReturnHttpResponse(result)); }
public void Test() { CommentSearchDto commentSearchDto = new CommentSearchDto() { SubjectId = Guid.Parse("5dc6bb5f-9cfa-ff24-00a8-d50e576b275a") }; long userId = 7; List <CommentDto> comments = _baseRepository .Select .Include(r => r.UserInfo) .Include(r => r.RespUserInfo) .IncludeMany(r => r.Childs.Take(2), t => t.Include(u => u.UserInfo)) .IncludeMany(r => r.UserLikes) .WhereIf(commentSearchDto.SubjectId != null, r => r.SubjectId == commentSearchDto.SubjectId) .Where(r => r.RootCommentId == commentSearchDto.RootCommentId) .OrderByDescending(!commentSearchDto.RootCommentId.HasValue, r => r.CreateTime) .OrderBy(commentSearchDto.RootCommentId.HasValue, r => r.CreateTime) .ToPagerList(commentSearchDto, out long totalCount) .Select(r => { CommentDto commentDto = Mapper.Map <CommentDto>(r); commentDto.TopComment = r.Childs.ToList().Select(u => { CommentDto childrenDto = Mapper.Map <CommentDto>(u); return(childrenDto); }).ToList(); commentDto.IsLiked = r.UserLikes.Where(u => u.CreateUserId == userId).IsNotEmpty(); return(commentDto); }).ToList(); //return new PagedResultDto<CommentDto>(comments, totalCount); }
public IActionResult Create([FromBody] CommentDto comment, [FromHeader] int UserID) { if (_user.GetUserById(UserID) == null) { return(StatusCode(StatusCodes.Status400BadRequest)); } var newComment = new Comment() { CreatedByUserId = UserID, Text = comment.Text, PostId = comment.PostId }; _context.Comments.Add(newComment); var success = _context.SaveChanges(); if (success < 1) { return(StatusCode(StatusCodes.Status400BadRequest)); } this._loggerCommunication.logAction("Created a new comment"); return(StatusCode(StatusCodes.Status201Created, new JsonResult(newComment))); }
public IActionResult Update(int id, [FromBody] CommentDto comment, [FromHeader] int UserID, [FromHeader] string UserRole) { var currentComment = _context.Comments.Find(id); if (currentComment == null) { return(StatusCode(StatusCodes.Status404NotFound)); } if (currentComment.CreatedByUserId != UserID && UserRole != "Admin") { return(StatusCode(StatusCodes.Status403Forbidden)); } currentComment.Text = comment.Text; _context.Comments.Update(currentComment); var success = _context.SaveChanges(); if (success < 1) { return(StatusCode(StatusCodes.Status400BadRequest)); } this._loggerCommunication.logAction("Updated a comment with id:" + id); return(StatusCode(StatusCodes.Status202Accepted, new JsonResult(currentComment))); }
public List <CommentDto> GetAllComment(CommentDto input) { var query = (from comment in _context.Comment.ToList() join topic in _context.Topic.ToList() on comment.TopicId equals topic.Id select new CommentDto { TopicName = topic.Name, ContentType = comment.ContentType, Id = comment.Id, DateCreated = comment.DateCreated, Status = comment.Status, UserId = comment.UserId, Content = comment.Content }).ToList().Skip((input.PagedResultDto.Page - 1) * input.PagedResultDto.SkipCount).Take(input.PagedResultDto.MaxResultCount); // Map Records List <CommentDto> ratingDto = MappingProfile.MappingConfigurationSetups().Map <List <CommentDto> >(query); //Apply Sort ratingDto = Sort(input.PagedResultDto.Sort, input.PagedResultDto.SortOrder, ratingDto); // Apply search if (!string.IsNullOrEmpty(input.PagedResultDto.Search)) { ratingDto = ratingDto.Where(p => p.Status != null && p.Status.ToLower().ToString().ToLower().Contains(input.PagedResultDto.Search.ToLower()) || p.TopicName != null && p.TopicName.ToString().ToLower().Contains(input.PagedResultDto.Search.ToLower()) || p.DateCreated != null && p.DateCreated.ToString().ToLower().Contains(input.PagedResultDto.Search.ToLower()) || p.ContentType != null && p.ContentType.ToString().ToLower().ToString().Contains(input.PagedResultDto.Search.ToLower()) || p.Content != null && p.Content.ToString().ToLower().ToString().Contains(input.PagedResultDto.Search.ToLower()) ).ToList(); } return(ratingDto); }
public async Task <IActionResult> GetNews(long id) { News news = await _dbContext.News.Include(u => u.Author).Include(p => p.Photo) .FirstOrDefaultAsync(n => n.Id == id); if (news != null) { var newsToReturn = NewsForDetailsDto.Map(news); List <Comment> comments = await _dbContext.Comments.Include(a => a.Author) .Where(c => c.NewsId == id).ToListAsync(); var commentsToReturn = CommentDto.Map(comments); newsToReturn.Comments = commentsToReturn; List <News> x = await _dbContext.News.Include(p => p.Photo) .Where(s => s.Section == newsToReturn.Section && s.Id != id) .OrderByDescending(z => z.AddedAt).ToListAsync(); List <LatestNewsDto> otherInfotoReturn = LatestNewsDto.Map(x.Take(5).ToList()); return(Ok(new DataForNewsDetailsComponentDto { NewsForDetails = newsToReturn, NewsForOtherInfos = otherInfotoReturn })); } else { return(NoContent()); } }
private static IEnumerable <CommentDto> CreateCommentsDtoCollection() { var root = new CommentDto { Id = "1", Name = "Andrew", Body = "Hi, how are you" }; var subRoot = new CommentDto { Id = "2", Name = "Bob", Body = "Fine, you?", ParentId = root.Id }; var leaf = new CommentDto { Id = "3", Name = "John", Body = "What`s up, guys", ParentId = subRoot.Id }; return(new List <CommentDto> { root, subRoot, leaf }); }
protected virtual async Task Create(CommentDto input) { Comment comment = MappingProfile.MappingConfigurationSetups().Map <Comment>(input); _context.Comment.Add(comment); await _context.SaveChangesAsync(); }
private async Task SaveChildCommentsAsync(IList <CommentDto> allComments, CommentDto parent, Comment parentModel, Post post) { var children = allComments .Where(c => c.ParrentId == parent.Id) .ToList(); if (children.Count == 0) { return; } foreach (var child in children) { var dbComment = new Comment() { Author = child.Author, Publish = child.Publish, Post = post, Content = child.Content, Parent = parentModel, Updated = DateTime.Now, }; _db.Comments.Add(dbComment); await SaveChildCommentsAsync(allComments, child, dbComment, post).ConfigureAwait(false); } }
public async Task AddComment(CommentDto comment) { try { var result = UnitOfWork.Comments.Create(Mapper.Map <Comment>(comment)); } catch (Exception e) { Debug.WriteLine(e); throw; } var phone = await UnitOfWork.Phones.Get(comment.PhoneId).Include(p => p.Comments).FirstOrDefaultAsync(); var average = phone.Comments.Select(c => c.Grade).Average(); phone.Grade = Convert.ToInt32(average); UnitOfWork.Phones.Update(phone); try { await UnitOfWork.SaveAsync(); } catch (Exception e) { Debug.WriteLine(e); throw; } }
public void CommentDtoValidationTest() { var validator = new DtoModelsValidator(); var emptyFieldsComment = new CommentDto() { User = null, Text = null }; var shortUsernameComment = new CommentDto() { User = "******", Text = "Text" }; var validComment = new CommentDto() { User = "******", Text = "Text" }; var nullCommentErrors = validator.GetCommentDtoValidationErrors(null); var emptyFieldsCommentErrors = validator.GetCommentDtoValidationErrors(emptyFieldsComment); var shortUsernameCommentErrors = validator.GetCommentDtoValidationErrors(shortUsernameComment); var validCommentErrors = validator.GetCommentDtoValidationErrors(validComment); Assert.AreEqual(nullCommentErrors.Count, 3); Assert.AreEqual(emptyFieldsCommentErrors.Count, 2); Assert.AreEqual(shortUsernameCommentErrors.Count, 1); Assert.AreEqual(validCommentErrors.Count, 0); }
public async Task <CommentDto> Comment(CommentDto dto) { // Creamos un nuevo comentario y lo añadimos al contexto Comment comment = new Comment(); comment = _mapper.Map <Comment>(dto); comment.Date = DateTime.Now; _context.Comments.Add(comment); await _context.SaveChangesAsync(); // Creamos un nuevo PostComment y lo añadimos al contexto PostComment postComment = new PostComment { PostId = dto.PostId, CommentId = comment.Id }; _context.PostsComments.Add(postComment); // Guardamos los cambios y devolvemos el dto de entrada await _context.SaveChangesAsync(); return(comment.ToDto(postComment.PostId)); }
internal static List<CommentDto> GetList(List<Comment> list, List<Comment> source) { var dtoList = new List<CommentDto>(); foreach (var i in list) { var item = new CommentDto { ID = i.CommentID, Comment = i.Comment1, Date = i.Date, Parent = i.ReplyCommentID == null ? null : new CommentDto { ID = i.ReplyCommentID.Value }, Place = i.Place.ToEntity<PlaceDto>(), User = i.User.ToEntity<UserDto>(), }; item.Replys = CommentBusiness.GetList(source.Where(l => l.ReplyCommentID == i.CommentID).ToList(), source.Where(l => l.ReplyCommentID != i.CommentID).ToList()); dtoList.Add(item); } return dtoList; }
private List<CommentDto> getCommentDto( List<OpenComment> moreList ) { List<CommentDto> list = new List<CommentDto>(); foreach (OpenComment c in moreList) { Dictionary<String, String> userInfo = getUserInfo( c.Member, c.Author ); CommentDto dto = new CommentDto(); dto.Id = c.Id; dto.UserName = userInfo["userName"]; dto.UserFace = userInfo["userFace"]; dto.AuthorText = userInfo["authorText"]; dto.Content = c.Content; dto.Created = c.Created.ToString( "g" ); list.Add( dto ); } return list; }
public virtual void Create(CommentDto item) { this.unitOfWork.Entities<Comment, long>().Create(Mapper.Map<Comment>(item)); }