public static CommentDTO ToDTO(this Comment entity) { if (entity == null) { throw new ArgumentNullException("entity"); } var result = new CommentDTO() { ID = entity.ID, CreatedDate = entity.CreatedDate }; result.ContentText = !string.IsNullOrEmpty(entity.Content) ? entity.Content : string.Empty; if(entity.Person != null) { result.Person = entity.Person.ToDTO(); } if(entity.CommentXContents != null && entity.CommentXContents.Count > 0) { result.Contents = new List<ContentDTO>(); foreach (var cxc in entity.CommentXContents) { if(cxc.Content != null) { var content = cxc.Content.ToDTO(); result.Contents.Add(content); } } } return result; }
protected void btnCommentSubmit_Click(object sender, EventArgs e) { CommentDTO comment = new CommentDTO(); comment.CommentText = commentBox.Text; comment.UserName = "******"; comment.ArticleID = sessionArticleID; comment.CommentDateTime = DateTime.Now; DataTransaction.submitComment(comment); }
public async Task OnGetAsync(Guid? id) { if (!id.HasValue) return; var item = await pcc.GetPostByIdAsync(id.Value); ViewData["Post"] = item.PostId.ToString() + " : " + item.Description.Trim(); foreach (var cc in item.Comments) { var cdto = new CommentDTO(); cdto.PostPostId = cc.PostPostId.ToString(); cdto.Text = cc.Text; cdto.CommentId = cc.CommentId.ToString(); Comments.Add(cdto); } }
public void AddComment_ItemSentToDAL_ValidItemWithParrent(CommentDTO commentDto, Comment parentComment, Game game) { // Arrange _mock.Setup(a => a.Repository <Comment>().GetSingle(It.IsAny <string>())).Returns(parentComment); _mock.Setup(a => a.Repository <Game>().FindBy(It.IsAny <Expression <Func <Game, bool> > >())) .Returns(new List <Game> { game }); // Act _commentService.AddEntity(commentDto, game.Key); // Assert Mock.Verify(_mock); }
public void AddCommentToPost(int id, CommentDTO comment) { try { var client = new MongoClient(_conn); var db = client.GetDatabase(_DbName); var posts = db.GetCollection <PostDTO>("Posts"); var UpdateFilter = Builders <PostDTO> .Update.AddToSet("Comments", comment); posts.UpdateOne(g => g.PostId == id, UpdateFilter); } catch (Exception exp) { throw exp; } }
public void ShowComments() { commentBLL = new CommentBLL(); commentDTO = commentBLL.GetApprovedComments(); dataGridView1.DataSource = commentDTO.Comments; dataGridView1.Columns["ID"].Visible = false; dataGridView1.Columns["Title"].HeaderText = "標題"; dataGridView1.Columns["CommentContent"].HeaderText = "內容"; dataGridView1.Columns["MemberID"].Visible = false; dataGridView1.Columns["Member"].HeaderText = "會員"; dataGridView1.Columns["AddDate"].HeaderText = "留言時間"; dataGridView1.Columns["IsApproved"].Visible = false; dataGridView1.Columns["MealID"].Visible = false; dataGridView1.Columns["MealName"].HeaderText = "評論餐點"; dataGridView1.Columns["Rating"].HeaderText = "評分"; }
public async Task <ActionResult <CommentDTO> > PostComment(CommentDTO CommentDTO) { var comment = new Comment { QuestionId = CommentDTO.QuestionId, Text = CommentDTO.Text }; _context.Comments.Add(comment); await _context.SaveChangesAsync(); return(CreatedAtAction( nameof(GetComment), new { id = comment.Id }, CommentToDTO(comment))); }
private CommentDTO ToDTO(Comment r) { CommentDTO dto = new CommentDTO(); dto.CreateDateTime = r.CreateDateTime; dto.Uid = r.User.Id; dto.Context = r.Context; dto.PhoneNum = r.User.PhoneNum; dto.htmlcode = r.Raiders.content; dto.title = r.Raiders.title; dto.Email = r.User.Email; dto.UserName = r.User.NickName; dto.Id = r.Id; return(dto); }
public async Task <IActionResult> OnGetAsync(int?id) { if (id == null) { return(NotFound()); } CommentDTO = await _context.CommentDTO .Include(c => c.Post).FirstOrDefaultAsync(m => m.CommentId == id); if (CommentDTO == null) { return(NotFound()); } return(Page()); }
public ActionResult Update(int id) { Comment Comment = _CommentService.GetByID(id); CommentDTO CommentDTO = new CommentDTO() { ID = Comment.ID, Authority = Comment.Authority, CommentContent = Comment.CommentContent, CompanyName = Comment.CompanyName, CustomerName = Comment.CustomerName, Email = Comment.Email, ProfilePhotoURL = Comment.ProfilePhotoURL, }; return(View(CommentDTO)); }
public ActionResult <IEnumerable <CommentDTO> > Delete(CommentDTO dto) { try { _deleteCommentCommand.Execute(dto); return(NoContent()); } catch (EntityNotFoundException) { return(NotFound()); } catch (Exception) { return(StatusCode(500)); } }
public void RemoveComment_RightActivityIdButNonExistingUserId_ReturnsNotFound() { DateTime date = DateTime.Today; TimeOfDay timeOfDay = TimeOfDay.AVOND; int activityId = 1; int userId = -2; CommentDTO commentDTO = new CommentDTO() { Comment = "Dit was een zeer leuke activiteit" }; _dayActivityRepository.Setup(d => d.GetCustomDayActivity(date, timeOfDay, activityId)).Returns(_dummyDBContext.DayActivity1); ActionResult <Attendance> actionResult = _controller.RemoveComment(date, timeOfDay, activityId, userId); Assert.IsType <NotFoundResult>(actionResult?.Result); }
/// <summary> /// Creates a new comment. /// </summary> /// <param name="commentDTO"> </param> /// <exception cref="ArgumentNullException"> /// if <paramref name="commentDTO"/> is <c>null</c>. /// </exception> public void Create(CommentDTO commentDTO) { if (commentDTO == null) { throw new ArgumentNullException(nameof(commentDTO)); } Comment newComment = new Comment() { Date = DateTime.Now, Profile = _unitOfWork.UserProfileRepository.Find(profile => profile.Id == commentDTO.UserId).SingleOrDefault(), Article = _unitOfWork.ArticleRepository.Get(commentDTO.ArticleId), Body = commentDTO.Body }; _unitOfWork.CommentRepository.Create(newComment); _unitOfWork.Save(); }
public IHttpActionResult PostComment(int postId, [FromBody] CommentViewModel comment) { if (comment == null) { return(BadRequest()); } comment.PostId = postId; CommentDTO commentDTO = Mapper.Map <CommentDTO>(comment); bool success = commentService.AddComment(commentDTO, User.Identity.Name); if (success) { return(Ok()); } return(BadRequest()); }
public static Comment MapDTOToComment(this CommentDTO c) { try { var comment = new Comment() { ID = c.ID, ReviewID = c.ReviewID, Description = c.Description }; return(comment); } catch (Exception) { return(new Comment()); } }
public bool FlagComment(CommentDTO comment) { bool result; try { var tmp = db.Comment.Where(x => x.Id == comment.Id).SingleOrDefault(); tmp.isFlagged = true; db.SaveChanges(); result = true; } catch (Exception) { result = false; } return(result); }
public bool InsertComment(CommentDTO comment) { this.ConnectToDatabase(); string Query = "insert into COMMENT values('" + comment.CardId + "','" + comment.UserId + "','" + comment.Content + "',@time,'" + comment.CmtIndex + "');"; //This is command class which will handle the query and connection object. MySqlCommand command = new MySqlCommand(Query, mySQLConnection); command.Parameters.Add("@time", MySqlDbType.DateTime).Value = comment.Time; command.ExecuteNonQuery(); this.Close(); return(true); }
public IActionResult Put(Guid id, Guid CommId, [FromBody] CommentDTO value) { if (Guid.Parse(HttpContext.Session.GetString("userId")) != commentsCollection.Find(n => n.Id == CommId).FirstOrDefault().AuthorId) { return(Forbid()); } var update = Builders <Comment> .Update.Set(c => c.Content, value.Content).Set(c => c.Date, DateTime.Now); var updateRes = commentsCollection.UpdateOne(c => c.Id == CommId, update); if (updateRes.MatchedCount == 0) { return(NotFound("Comment with this id not found")); } return(new ObjectResult(commentsCollection.Find(c => c.Id == CommId).FirstOrDefault())); }
public IActionResult DeleteComment(int id) { try { CommentDTO comment = _commentService.Get(id); if (comment != null) { _commentService.Delete(comment.Id); } return(RedirectToAction("AllComments", "Home")); } catch (ValidationException ex) { ModelState.AddModelError(ex.Property, ex.Message); } return(RedirectToAction("Index", "Home")); }
public async Task <CommentDTO> GetCommentAsync(int commentId) { Comment comment = await db.Comments.GetAsync(commentId); if (comment == null) { return(null); } var commentDTO = new CommentDTO(comment.Id, comment.Text, comment.Create_Id, await db.Users.ExtractFullNameAsync(comment.Create_Id), comment.Create_Date, comment.Mod_Date); return(commentDTO); }
public async Task <OperationDetails> UpdateCommentAsync(CommentDTO commentDTO) { if (commentDTO == null) { return(new OperationDetails(false, "Comment is null", "UpdateComment")); } var comment = await _database.commentRepository.GetByIdAsync(commentDTO.CommentId); if (comment == null) { return(new OperationDetails(false, "Comment with this id is null", "UpdateComment")); } _database.commentRepository.Update(_mapper.Map(commentDTO, comment)); await _database.SaveAsync(); return(new OperationDetails(true, "User is Updated", "Update")); }
public CommentDTO Create(CommentDTO commentDto) { try { Mapper.Initialize(cfg => cfg.CreateMap <CommentDTO, Comment>()); var comment = Mapper.Map <CommentDTO, Comment>(commentDto); comment.ApplicationUser = _unitOfWork.UserManager.FindById(comment.ApplicationUserId); comment.Post = _unitOfWork.Posts.GetById(comment.PostId); _unitOfWork.Comments.Create(comment); _unitOfWork.Save(); } catch (Exception ex) { throw ex; } return(null); }
public void GetComment_GetCommentWithId2_ReturnComment() { // Arrange CommentDTO comment = Mapper.Map <CommentDTO>(unitOfWork.CommentManager.Get(2)); // Act CommentDTO result = service.GetComment(2); // Assert Assert.AreEqual(comment.Id, result.Id); Assert.AreEqual(comment.Text, result.Text); Assert.AreEqual(comment.AuthorId, result.AuthorId); Assert.AreEqual(comment.PostId, result.PostId); Assert.AreEqual(comment.ParentId, result.ParentId); Assert.AreEqual(comment.IsApproved, result.IsApproved); Assert.AreEqual(comment.Date, result.Date); }
public CommentDTO GetComment(int commentId) { var comment = db.Comments.Get(commentId); if (comment == null) { return(null); } var commentDTO = new CommentDTO(comment.Id, comment.Text, comment.Create_Id, db.Users.ExtractFullName(comment.Create_Id), comment.Create_Date, comment.Mod_Date); return(commentDTO); }
public void IsCreateSuccessful_should_be_return_0_if_commentdto_not_exists() { // Arrange CommentDTO commentDTO = new CommentDTO(); Post post = new Post(); List <User> listUser = new List <User>(); mockPostRepository.Setup(c => c.GetById(It.IsAny <int?>())) .Returns(post); mockUserRepository.Setup(c => c.GetAll()) .Returns(listUser.AsQueryable()); //Act int?result = commentService.IsCreateSuccessful(commentDTO); //Assert Assert.Equal(0, result); }
public async Task <ActionResult> Put(long id, [FromBody] CommentDTO updatedComment) { logger.LogInformation("Calling put for object: {@0}", updatedComment); try { Comment modifiedComment = await repository.UpdateAsync(mappingProvider.Map <Comment>(updatedComment)); return(Ok(mappingProvider.Map <CommentDTO>(modifiedComment))); //[Note] - zwracać zawsze aktualny status z bazy - Zwracać ten updatedComment, czy raczej powinienem zwracać z repo obiekt na nowo zaczytany z bazy //(żeby np. wyeliminować przekłamanie, gdyby coś zostało ustawione na bazie inaczej)? } catch (BlogPostsDomainException) { logger.LogWarning("There was nothing to update"); return(NotFound(id)); } }
public async Task <IActionResult> OnPostAsync(int?id) { if (id == null) { return(NotFound()); } CommentDTO = await _context.CommentDTO.FindAsync(id); if (CommentDTO != null) { _context.CommentDTO.Remove(CommentDTO); await _context.SaveChangesAsync(); } return(RedirectToPage("./Index")); }
public void InsertCommentOnActorId(CommentDTO cmt) { var film = context.Films.Find(cmt.FilmId); Comment cm = new Comment { CommentContent = cmt.Content, CommentActorId = cmt.ActorId, CommentAverage = cmt.Average, CommentAvatar = cmt.Avatar, CommentDate = cmt.Date }; film.Comments.Add(cm); cm.Film = film; context.Comments.Add(cm); context.SaveChanges(); }
public List <CommentDTO> GetAll() { List <CommentDTO> comments = new List <CommentDTO>(); foreach (var comment in unitOfWork.CommentRepository.GetAll()) { var newComment = new CommentDTO(); newComment.Id = comment.Id; newComment.CommentContent = comment.CommentContent; newComment.ArticleId = comment.ArticleId; newComment.Date = comment.Date; newComment.UserName = comment.UserName; newComment.ParentCommentId = comment.ParentCommentId; comments.Add(newComment); } return(comments); }
public async Task <IActionResult> OnGetAsync(int?id) { if (id == null) { return(NotFound()); } CommentDTO = await _context.CommentDTO .Include(c => c.Post).FirstOrDefaultAsync(m => m.CommentId == id); if (CommentDTO == null) { return(NotFound()); } ViewData["PostPostId"] = new SelectList(_context.Set <PostDTO>(), "PostId", "PostId"); return(Page()); }
public async Task <OperationDetails> CreateCommentAsync(CommentDTO commentDTO) { if (commentDTO == null) { return(new OperationDetails("Comment is null", false)); } var customer = await _dataBase.customerRepository.GetWhereAsync(c => c.Phone == commentDTO.Phone && c.Name == commentDTO.Name); if (customer.Count == 0) { return(new OperationDetails("You can not leave a comment", false)); } _dataBase.commentRepository.Create(_mapper.Map <Comment>(commentDTO)); await _dataBase.SaveAsync(); return(new OperationDetails("Comment is created!", true)); }
public ICollection <CommentDTO> GetComments() { using (var db = new SovaContext()) { var comments = db.Comments.ToList(); List <CommentDTO> commentsDTO = new List <CommentDTO>(); foreach (var c in comments) { var commentsPost = db.Posts.Where(i => i.Id == c.PostId).FirstOrDefault(); var newComment = new CommentDTO(c.CommentId, c.PostId, c.CommentText, c.CommentScore, c.CommentCreateDate, c.OwnerUserId , commentsPost, GetUserByCommentId(c.CommentId)); commentsDTO.Add(newComment); } return(commentsDTO); } }