public void CommentRepozitoryTest() { var Repository = new CommentRepository(new InMemoryDbContextFactory()); Assert.Throws <System.InvalidOperationException>(() => Repository.GetById(0)); var Comment1 = new CommentModel() { Author = 1, AuthorName = "Milos Hlava", Date = new DateTime(2019, 1, 4), Id = 1, Text = "Testovaci koment" }; var Comment2 = new CommentModel() { Author = 2, AuthorName = "Jozef Hlava", Date = new DateTime(2019, 1, 5), Id = 2, Text = "Testovaci koment cislo 2" }; Repository.Create(Comment1); Repository.Create(Comment2); var ReceivedComment1 = Repository.GetById(1); var ReceivedComment2 = Repository.GetById(2); Assert.Equal(Comment1, ReceivedComment1); Assert.Equal(Comment2, ReceivedComment2); Comment1.Text = "Updatovany text"; Repository.Update(Comment1); ReceivedComment1 = Repository.GetById(1); Assert.Equal(Comment1, ReceivedComment1); List <CommentModel> ReceivedAllComments = Repository.GetAll(); var AllComments = new List <CommentModel>(); AllComments.Add(Comment1); AllComments.Add(Comment2); var Comparer = new CollectionComparer <CommentModel>(); Assert.True(Comparer.Equals(AllComments, ReceivedAllComments)); Repository.Delete(1); Assert.Throws <System.InvalidOperationException>(() => Repository.GetById(1)); Repository.Delete(2); Assert.Throws <System.InvalidOperationException>(() => Repository.GetById(2)); }
/// <summary> /// 删除一个评论 /// </summary> /// <param name="validationErrors">返回的错误信息</param> /// <param name="id">一评论的主键</param> /// <returns></returns> public bool Delete(ref ValidationErrors validationErrors, string id) { try { return(repository.Delete(id) == 1); } catch (Exception ex) { validationErrors.Add(ex.Message); ExceptionsHander.WriteExceptions(ex); } return(false); }
public async Task <ActionResult> DeleteComment(int id) { // var userPost = await db.UserPosts.FindAsync( id); var comment = await _cRepository.FindById(id); if (comment == null) { return(View("Error")); } await _cRepository.Delete(comment); return(RedirectToAction("Index", "Home")); }
/// <summary> /// Handles the item command /// </summary> /// <param name="source"></param> /// <param name="e"></param> protected void rptComments_ItemCommand(object source, RepeaterCommandEventArgs e) { switch (e.CommandName) { case "DeleteComment": repository.Delete(new Guid(e.CommandArgument.ToString())); break; case "ApproveComment": Comment c = repository.Fetch(new Guid(e.CommandArgument.ToString())); if (c != null) { c.ModerationStatus = Comment.ModerationApproved; repository.Save(c); } break; } if (updateContainerControl != null) { int commentCount = repository.GetCount(ContentGuid, Comment.ModerationApproved); updateContainerControl.UpdateCommentStats( ContentGuid, commentCount); } WebUtils.SetupRedirect(this, Request.RawUrl); }
public async Task DeleteComment(int commentId) { var comment = await _commentRepository.GetByIdAsync(commentId); _commentRepository.Delete(comment); await _unitOfWork.Commit(); }
public ActionResult Delete(int id) { // Pobranie komentarza po identyfikatorze var comment = _commentRepo.GetCommentById(id); if (comment != null) { try { // Usunięcie komentarza i zapisanie zmian w bazie danych _commentRepo.Delete(comment); _commentRepo.SaveChanges(); TempData["Message"] = "Komentarz został usunięty."; } catch (Exception) { TempData["Error"] = "Nie można usunąć tego komentarza."; } return(RedirectToAction("Details", "Company", new { id = comment.ServiceId })); } else { TempData["Error"] = "Nie ma takiego komentarza."; return(RedirectToAction("Index", "Company")); } }
public async Task DeleteComment() { // Arrange var options = new DbContextOptionsBuilder <MyAlbumDbContext>() .UseInMemoryDatabase(databaseName: "CommentRepository_DeleteComment_MyAlbumDatabase") .Options; using (var context = new MyAlbumDbContext(options)) { UnitOfWork unitOfWork = new UnitOfWork(context); int seedCommentId = new Random().Next(1, 100); List <Comment> seedComments = SeedComments(seedCommentId, context).ToList(); CommentRepository commentRepository = new CommentRepository(context); Comment deletedComment = seedComments[0]; // Assert #1 Assert.Equal(seedComments.Count(), context.Comments.Count()); // Act commentRepository.Delete(deletedComment); await unitOfWork.CompleteAsync(); // Assert #2 seedComments.Remove(deletedComment); Assert.True(seedComments.SequenceEqual(context.Comments)); } }
public void Delete(Product product) { //_repo.UnitOfWork.LazyLoadingEnabled = true; //_repo_Comment.UnitOfWork.LazyLoadingEnabled = true; try { List <Comment> Comments = product.Comment.ToList(); foreach (var item in Comments) { _repo_Comment.Delete(item); } _repo_Comment.UnitOfWork.Commit(); _repo.Delete(product); this.Save(); } finally { //_repo_Comment.UnitOfWork.LazyLoadingEnabled = false; //_repo.UnitOfWork.LazyLoadingEnabled = false; } }
public async Task <ActionResult <CommentResponse> > DeleteComment(long id) { var comment = await _commentRepository.Delete(id); var commentResponse = MapModelToResponse(comment); return(commentResponse); }
public ActionResult DeleteReply(int id) { Comment comment = new Comment(); CommentRepository commentRepository = new CommentRepository(); comment = commentRepository.GetById(id); commentRepository.Delete(comment); return(RedirectToAction("Articles")); }
public void DeleteByNullValue() { // Arrange CommentRepository commentRepository = new CommentRepository(dbContext); // Act // Assert Assert.ThrowsException <ArgumentNullException>(() => commentRepository.Delete(entityToDelete: null)); }
public IActionResult Delete(int id) { List <Comment> ItemCommentsToDelete = _commentRepository.GetByItemId(id); ItemCommentsToDelete.ForEach(ic => _commentRepository.Delete(ic)); _itemRepository.Delete(id); return(NoContent()); }
public void DeleteByNullKey_Exception() { // Arrange CommentRepository commentRepository = new CommentRepository(dbContext); object wrongId = null; // Act // Assert Assert.ThrowsException <ArgumentNullException>(() => commentRepository.Delete(wrongId)); }
public void DeleteByWrongKey_Exception() { // Arrange CommentRepository commentRepository = new CommentRepository(dbContext); Guid wrongId = default(Guid); // Act // Assert Assert.ThrowsException <InvalidOperationException>(() => commentRepository.Delete(wrongId)); }
internal Comment Delete(int id, string email) { Comment toDelete = Get(id); if (toDelete.Author != email || !_repo.Delete(id, email)) { throw new UnauthorizedAccessException("Invalid Access"); } return(toDelete); }
public IHttpActionResult Delete(int cid) { //Comment comment = commentRepository.Get(cid); //if(comment == null) //{ // return StatusCode(HttpStatusCode.NoContent); //} commentRepository.Delete(cid); return(StatusCode(HttpStatusCode.NoContent)); }
public void DeleteComment(int id) { try { _repository.Delete(id); } catch (Exception e) { } }
public IHttpActionResult DeleteComment(int id, int cid) { Comment comment = comRepo.GetAll().Where <Comment>(x => x.CommentId == cid && x.PostId == id).FirstOrDefault(); if (comment == null) { return(StatusCode(HttpStatusCode.NoContent)); } comRepo.Delete(cid); return(StatusCode(HttpStatusCode.NoContent)); }
public void Delete_Void_ReturnNull() { _comment.Id = _commentRepository.Create(_comment); var result = _commentRepository.Get(_comment.Id); AreEqualComments(result, _comment); _commentRepository.Delete(_comment.Id); result = _commentRepository.Get(_comment.Id); Assert.IsNull(result); }
public ActionResult DeleteComment(int id) { List <Comment> comments = new List <Comment>(); CommentRepository commentRepository = new CommentRepository(); comments = commentRepository.GetAll(filter: c => c.Id == id || c.ParentComment.Id == id); foreach (var comment in comments) { commentRepository.Delete(comment); } return(RedirectToAction("Articles")); }
public IHttpActionResult DeleteCommentWithId(int cid, int id) { CommentRepository cr = new CommentRepository(); Comment c = cr.GetById(cid); if (c.PostId == id) { cr.Delete(cid); return(StatusCode(HttpStatusCode.NoContent)); } return(StatusCode(HttpStatusCode.NotFound)); }
public IHttpActionResult Delete(int id) { ReplyRepository r = new ReplyRepository(); var replist = con.Replies.Where(x => x.ComID == id).ToList(); foreach (var x in replist) { r.Delete(x.ReplyId); } cr.Delete(id); return(StatusCode(HttpStatusCode.NoContent)); }
public void TestEntityDelete() { var comment = CommentBuilder.New().Build(); var mockTeste = new Mock <IDeleteDB <Comment> >(); var commentRepository = new CommentRepository(mockTeste.Object); commentRepository.Delete(comment); mockTeste.Verify(x => x.DeleteRegister(It.IsAny <Comment>())); }
// // GET: /Comment/Delete/5 public ActionResult Delete(int id, int taskId) { var commentDB = commentRepository.Search(id); if (commentDB.UserId != User.Identity.GetUserId()) { ModelState.AddModelError("", "No rights to delete this comment!"); return(RedirectToAction("Details", "Task", new { id = taskId })); } commentRepository.Delete(id); return(RedirectToAction("Details", "Task", new { id = taskId })); }
/// <summary> /// Delete selected document. /// </summary> void deleteToolStripMenuItem_Click(object sender, EventArgs e) { Document selectedDocument = documentRepository.GetDocumentByVersion( listView1.SelectedItems[0].Text, int.Parse(listView1.SelectedItems[0].SubItems[1].Text)); bool operationAllowed = false; if (selectedDocument.Owner.Equals(loggedEmployee)) { operationAllowed = true; } else if (selectedDocument.Writers.Contains(loggedEmployee)) { operationAllowed = true; } if (operationAllowed) { if (MessageBox.Show("Are you sure you want to delete seleceted document", "Confirmation dialog", MessageBoxButtons.YesNo) == DialogResult.Yes) { foreach (Comment comment in commentRepository.GetCommentsForDocument(selectedDocument)) { commentRepository.Delete(comment); } foreach (Employee employee in selectedDocument.Readers) { employee.Reading.Remove(selectedDocument); employeeRepository.Update(employee); } foreach (Employee employee in selectedDocument.Writers) { employee.Reading.Remove(selectedDocument); employeeRepository.Update(employee); } documentContentRepository.Delete(selectedDocument.Content); documentRepository.Delete(selectedDocument); populateLists(); updateListView(ownDocuments, readableDocuments, writableDocuments); this.documentToolStripMenuItem.Enabled = false; } } else { MessageBox.Show("Only user with write permission can delete document."); } }
public void DeleteComment_NoExists_NotFail_Test() { var context = new MyEventsContext(); var comment = context.Comments.FirstOrDefault(); int expected = context.Comments.Count(); ICommentRepository target = new CommentRepository(); target.Delete(0); int actual = context.Comments.Count(); Assert.AreEqual(expected, actual); }
public async Task <ActionResult <Comment> > DeleteComment(int id) { var chat = await _repository.Delete(id); if (chat != null) { return(chat); } else { return(NotFound()); } }
public void DeleteComment(string key, long id) { Comment comment = _repository.Get(id); if (comment.Author.Id == CurrentUserId) //TODO: check admin or security rights { _repository.Delete(comment); } else { throw new SecurityException("Unauthorized"); } }
public ActionResult Delete(int id) { if (AuthenticationManager.LoggedUser == null) { return(RedirectToAction("Login", "Home")); } CommentRepository RepoComment = RepositoryFactory.GetCommentRepository(); Comment comment = RepoComment.GetById(id); RepoComment.Delete(comment); return(RedirectToAction("Index", "CommentManagement", new { ParentTaskId = comment.ParentTaskId })); }
public IActionResult DeleteCommentById(int id) { Comment comment = (from c in _commentRepository.Get() where c.Id == id select c) .SingleOrDefault(); if (null != comment) { _commentRepository.Delete(comment); _commentRepository.Save(); } return(Ok()); }
public ActionResult DeleteComment(int id) { if (AuthenticationManager.LoggedUser == null) { return(RedirectToAction("Login", "Home")); } CommentRepository comrepo = RepositoryFactory.GetCommentRepository(); Comment comment = comrepo.GetByID(id); comrepo.Delete(comment); return(RedirectToAction("TaskDetails", "TaskManagement", new { id = comment.CommenterID })); }
public void DeleteFails() { dbFactory.Run(db => db.Insert(new Comment { Id = 1, Message = "Test Item" })); var repository = new CommentRepository(dbFactory, personRepository, issueRepository); repository.Delete(2); dbFactory.Run(db => { var response = db.Select<Comment>(); Assert.AreEqual(response.Count, 1); Assert.AreEqual(response[0].Message, "Test Item"); }); }
public ActionResult DeleteComment(int id) { List<Comment> comments = new List<Comment>(); CommentRepository commentRepository = new CommentRepository(); comments = commentRepository.GetAll(filter: c => c.Id == id || c.ParentComment.Id == id); foreach (var comment in comments) { commentRepository.Delete(comment); } return RedirectToAction("Articles"); }
public ActionResult DeleteReply(int id) { Comment comment = new Comment(); CommentRepository commentRepository = new CommentRepository(); comment = commentRepository.GetById(id); commentRepository.Delete(comment); return RedirectToAction("Articles"); }