public ActionResult DeleteComment(int id)
{
var a = new NewsComment { Id = id, UpdatedById = CurrentUser.UserInfo.Id };
var feedback = _commentRepository.DeleteNewsComment(a);
return Json(feedback);
}
public ActionResult DelectComment(int id)
{
NewsComment newsComment = db.NewsComment.Find(id);
int UserID = Convert.ToInt32(Session["UserID"].ToString());
var delc = db.NewsComment.Where(c => c.NCID == id).Where(c => c.UserID == UserID).SingleOrDefault();
db.NewsComment.Remove(newsComment);
db.SaveChanges();
return(RedirectToAction("MyComment"));
}
public IHttpActionResult PostNewsComment(NewsComment newsComment)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.NewsComments.Add(newsComment);
db.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = newsComment.ID }, newsComment));
}
/// <summary>
/// Deletes a news comment
/// </summary>
/// <param name="newsComment">News comment</param>
public virtual void DeleteNewsComment(NewsComment newsComment)
{
if (newsComment == null)
{
throw new ArgumentNullException(nameof(newsComment));
}
_newsCommentRepository.Delete(newsComment);
//event notification
_eventPublisher.EntityDeleted(newsComment);
}
/// <summary>
/// Inserts a news comment
/// </summary>
/// <param name="comment">News comment</param>
public virtual void InsertNewsComment(NewsComment comment)
{
if (comment == null)
{
throw new ArgumentNullException(nameof(comment));
}
_newsCommentRepository.Insert(comment);
//event notification
_eventPublisher.EntityInserted(comment);
}
public ActionResult NewsCommentAdd(int newsItemId, NewsItemModel model)
{
if (!_newsSettings.Enabled)
{
return(RedirectToAction("Index", "Home"));
}
var newsItem = _newsService.GetNewsById(newsItemId);
if (newsItem == null || !newsItem.Published || !newsItem.AllowComments)
{
return(RedirectToAction("Index", "Home"));
}
if (ModelState.IsValid)
{
if (_workContext.CurrentCustomer.IsGuest() && !_newsSettings.AllowNotRegisteredUsersToLeaveComments)
{
ModelState.AddModelError("", _localizationService.GetResource("News.Comments.OnlyRegisteredUsersLeaveComments"));
}
else
{
var comment = new NewsComment()
{
NewsItemId = newsItem.Id,
CustomerId = _workContext.CurrentCustomer.Id,
IpAddress = _webHelper.GetCurrentIpAddress(),
CommentTitle = model.AddNewComment.CommentTitle,
CommentText = model.AddNewComment.CommentText,
IsApproved = true,
CreatedOnUtc = DateTime.UtcNow,
UpdatedOnUtc = DateTime.UtcNow,
};
_customerContentService.InsertCustomerContent(comment);
//notify store owner
if (_newsSettings.NotifyAboutNewNewsComments)
{
_workflowMessageService.SendNewsCommentNotificationMessage(comment, _localizationSettings.DefaultAdminLanguageId);
}
//The text boxes should be cleared after a comment has been posted
//That' why we reload the page
TempData["nop.news.addcomment.result"] = _localizationService.GetResource("News.Comments.SuccessfullyAdded");
return(RedirectToRoute("NewsItem", new { newsItemId = newsItem.Id, SeName = newsItem.GetSeName() }));
}
}
//If we got this far, something failed, redisplay form
PrepareNewsItemModel(model, newsItem, true);
return(View(model));
}
public ActionResult NewsText(int id)
{
var model = new NewsComment();
model.News = GetNewsText(id);
model.Comments = GetComments(id);
model.NewComment = new Comment()
{
NewsId = id
};
return(View(model));
}
public virtual IActionResult CommentDelete(int id)
{
//try to get a news comment with the specified id
NewsComment comment = _newsService.GetNewsCommentById(id)
?? throw new ArgumentException("No comment found with the specified id", nameof(id));
_newsService.DeleteNewsComment(comment);
//activity log
_customerActivityService.InsertActivity("DeleteNewsComment", string.Format("DeleteNewsComment{0}", comment.Id), comment);
return(new NullJsonResult());
}
public async Task Create(int newsId, string userId, string content)
{
var comment = new NewsComment
{
NewsId = newsId,
UserId = userId,
Content = content,
};
await this.newsRepository.AddAsync(comment);
await this.newsRepository.SaveChangesAsync();
}
public ActionResult ECCAdd(NewsComment esscommComm)
{
if (esscommComm.NCContent == null)
{
return(Content("<script>alert('请输入评论内容');history.go(-1);</script>"));
}
else
{
esscommComm.NCTime = DateTime.Now;
db.NewsComment.Add(esscommComm);
db.SaveChanges();
return(RedirectToAction("NewsWenZhang", "NewsVNKH", new { Newsid = esscommComm.NewsID }));
}
}
// [Route("News/AddComment/{NewsId}")]
public ActionResult AddComment(int id, string name, string email, string comment)
{
NewsComment CommentObj = new NewsComment()
{
NewsID = id,
Name = name,
Email = email,
Comment = comment,
SubmitDate = DateTime.Now
};
CommentRepo.AddComment(CommentObj);
return(PartialView("ShowComments", CommentRepo.GetCommentByNewsId(id)));
}
public IHttpActionResult DeleteNewsComment(int id)
{
NewsComment newsComment = db.NewsComments.Find(id);
if (newsComment == null)
{
return(NotFound());
}
db.NewsComments.Remove(newsComment);
db.SaveChanges();
return(Ok(newsComment));
}
public void NotThrow_IfAllParametersAreValid_AndSetCorrectValues()
{
// Arrange
var username = "******";
var content = "test content";
var date = DateTime.UtcNow;
// Act
var comment = new NewsComment(content, username, date);
// Assert
Assert.AreEqual(content, comment.Content);
Assert.AreEqual(username, comment.Username);
Assert.AreEqual(date, comment.PostedOn);
}
public void Update(NewsComment obj, out OperationResult operationResult)
{
lock (Lock)
{
if (obj == null)
{
operationResult = new OperationResult {
Type = OperationResult.ResultType.Warning
};
return;
}
Common.Instance.Update
(obj, objs => objs.NewsCommentId == obj.NewsCommentId && objs.LanguageId == obj.LanguageId, out operationResult);
}
}
public async Task <ActionResult> AddCommentForNews([FromBody] NewsComment newsComment)
{
var username = User.Claims.FirstOrDefault(x => x.Type == "FullName").Value;
newsComment.Author = username;
if (newsComment.Comment == "" || newsComment.Comment == null)
{
return(BadRequest(new { message = "Vajāg uzrakstīt komentaru" }));
}
else
{
await NewsService.AddCommentsForNews(newsComment);
}
return(Ok());
}
public virtual void CommentDelete(NewsComment model)
{
var newsItem = _newsService.GetNewsById(model.NewsItemId);
var comment = newsItem.NewsComments.FirstOrDefault(x => x.Id == model.Id);
if (comment == null)
{
throw new ArgumentException("No comment found with the specified id");
}
newsItem.NewsComments.Remove(comment);
//update totals
newsItem.CommentCount = newsItem.NewsComments.Count;
_newsService.UpdateNews(newsItem);
}
protected void btn_edit_Click(object sender, EventArgs e)
{
try
{
NewsComment newsComment = ReceiveHtml();
NewsCommentBSO newsCommentBSO = new NewsCommentBSO();
newsCommentBSO.UpdateNewsComment(newsComment);
//clientview.Text = String.Format(Resources.StringAdmin.UpdateSuccessful, "Nhận xét", newsComment.Title);
clientview.Text = "<div class='alert alert-sm alert-danger bg-gradient'>Cập nhật thành công !</div>";
initControl(newsComment.CommentNewsID);
}
catch (Exception ex)
{
clientview.Text = ex.Message.ToString();
}
}
protected void btn_add_Click(object sender, EventArgs e)
{
try
{
NewsComment newsComment = ReceiveHtml();
NewsCommentBSO newsCommentBSO = new NewsCommentBSO();
int id = newsCommentBSO.CreateNewsCommentGet(newsComment);
// clientview.Text = String.Format(Resources.StringAdmin.AddNewsSuccessful);
clientview.Text = "<div class='alert alert-sm alert-danger bg-gradient'>Thêm mới thành công !</div>";
initControl(id);
}
catch (Exception ex)
{
clientview.Text = ex.Message.ToString();
}
}
public ActionResult Delete(int?id)
{
if (id == null)
{
return(HttpNotFound("ID is missing"));
}
NewsComment newsComment = db.NewsComments.Find(id);
if (newsComment == null)
{
return(HttpNotFound("ID was not found"));
}
return(View());
}
public async Task <IActionResult> Create([Bind("CommentID,CommentText,NewsID")] NewsComment newsComment)
{
ModelState.Remove("ReviewerName");
ModelState.Remove("CommentDate");
if (ModelState.IsValid)
{
newsComment.ReviewerName = _userManager.GetUserName(this.User);
newsComment.CommentDate = DateTime.Now;
_context.Add(newsComment);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["NewsID"] = new SelectList(_context.NewsInfos, "NewsID", "NewsTitle", newsComment.NewsID);
return(View(newsComment));
}
public void Insert(NewsComment obj, out OperationResult operationResult)
{
lock (Lock)
{
if (obj == null)
{
operationResult = new OperationResult {
Type = OperationResult.ResultType.Warning
};
}
else
{
Common.Instance.Insert(obj, out operationResult);
}
}
}
/// <summary>
/// 页面加载
/// </summary>
/// <param name="e"></param>
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
object[] parameters = e.Parameter as object[];
if (parameters != null && parameters.Length == 1)
{
_news = parameters[0] as CNNews;
NewsTitle.Text = _news.Title;
NewsInfo.Text = _news.SourceName + " " + _news.PublishTime;
_totalHtml = ChatBoxTool.BaseChatHtml;
if (App.Theme == ApplicationTheme.Dark)
{
_totalHtml += "<style>body{background-color:black;color:white;}</style>";
}
NewsComment.NavigateToString(_totalHtml);
List <CNNewsComment> refresh_comments = await NewsService.GetNewsCommentsAysnc(_news.ID, 1, 200);
if (refresh_comments != null)
{
string comments = "";
foreach (CNNewsComment comment in refresh_comments)
{
if ((App.LoginedUser != null) && (App.LoginedUser.Name == comment.AuthorName))
{
comments += ChatBoxTool.Send(comment.AuthorAvatar,
comment.AuthorName, comment.Content, comment.PublishTime);
}
else
{
comments += ChatBoxTool.Receive(comment.AuthorAvatar,
comment.AuthorName,
comment.Content, comment.PublishTime, comment.ID);
}
}
comments += "<a id='ok'></a>";
_totalHtml = _totalHtml.Replace("<a id='ok'></a>", "") + comments + "<a id='ok'></a>";
NewsComment.NavigateToString(_totalHtml);
Loading.IsActive = false;
}
}
}
public ActionResult Comment(NewsComment pc)
{
var vm = new ListNewsCommentViewModel { Comments = new List<NewsComment>(), CurrentUserId = CurrentUser.UserInfo.Id };
if (ModelState.IsValid)
{
pc.PostedById = CurrentUser.UserInfo.Id;
// Call Repository to perform insert
var feedback = _commentRepository.InsertNewsComment(pc);
if (feedback.Success)
{
vm.Comments.Add(feedback.Data);
return View(vm);
}
}
return View(vm);
}
protected virtual object CreateModelPart(NewsComment part, MessageContext messageContext)
{
Guard.NotNull(messageContext, nameof(messageContext));
Guard.NotNull(part, nameof(part));
var m = new Dictionary <string, object>
{
{ "NewsTitle", part.NewsItem.Title.NullEmpty() },
{ "Title", part.CommentTitle.NullEmpty() },
{ "Text", HtmlUtils.FormatText(part.CommentText, true, false, false, false, false, false).NullEmpty() },
{ "NewsUrl", BuildRouteUrl("NewsItem", new { SeName = part.NewsItem.GetSeName(messageContext.Language.Id) }, messageContext) }
};
PublishModelPartCreatedEvent <NewsComment>(part, m);
return(m);
}
private void BindData()
{
NewsComment newsComment = NewsManager.GetNewsCommentByID(this.NewsCommentID);
if (newsComment != null)
{
this.txtTitle.Text = newsComment.Title;
this.lblNews.Text = GetNewsInfo(newsComment.NewsID);
this.lblCustomer.Text = GetCustomerInfo(newsComment.CustomerID);
this.txtComment.Text = newsComment.Comment;
this.lblCreatedOn.Text = DateTimeHelper.ConvertToUserTime(newsComment.CreatedOn).ToString();
}
else
{
Response.Redirect("NewsComments.aspx");
}
}
/// <summary>
/// Method add or modifies a news
/// </summary>
/// <param name="news">news object that we want to add or modifie</param>
/// <returns>New news with id included or modified object</returns>
public async Task <News> SaveNews(News news, string username)
{
// If warehouse does not have id, that means that it's a new entity, and we need an add functionality
if (news.Id == null || news.Id.Equals(Guid.Empty))
{
var warehouse = await DB.WarehouseDB.FirstOrDefaultAsync(x => x.Id == news.WarehouseId);
warehouse.HasProblems = true;
news.Author = username;
news.CreatedDate = DateTime.Now;
// Adding new warehouse to DB
await DB.NewsDB.AddAsync(news);
var firstComment = new NewsComment()
{
Comment = news.ShortDescription,
NewsId = news.Id,
Date = DateTime.Now,
Author = username
};
await DB.NewsCommentDB.AddAsync(firstComment);
DB.WarehouseDB.Update(warehouse);
// Saving changes in DB
await DB.SaveChangesAsync();
}
// If warehouse has an id, that means that it's not a new entity, and we need an edit functionality
else
{
// Getting object from DB that has similar id like in our param variable
var newsFromDb = await DB.NewsDB.Include(x => x.Warehouse).FirstOrDefaultAsync(x => x.Id == news.Id);
// Using mapper to edit all fields
Mapper.Map(news, newsFromDb);
// Updating DB
DB.NewsDB.Update(newsFromDb);
// Saving changes in DB
await DB.SaveChangesAsync();
}
// Returning object
return(news);
}
public void AddCommentToNews_AndRedirectToNews_IfAddingCommentNotFailed()
{
// Arrange
var mockedNews = new News();
var mockedNewsComment = new NewsComment();
var mockedNewsService = new Mock <INewsService>();
mockedNewsService.Setup(s => s.FindById(It.IsAny <string>())).Returns(mockedNews).Verifiable();
mockedNewsService.Setup(s => s.Save()).Verifiable();
var mockedNewsCommentFactory = new Mock <INewsCommentFactory>();
mockedNewsCommentFactory.Setup(f => f.CreateNewsComment(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <DateTime>())).Returns(mockedNewsComment).Verifiable();
var mockedDateProvider = new Mock <IDateProvider>();
mockedDateProvider.Setup(d => d.GetDate()).Verifiable();
var mockedContext = new Mock <ControllerContext>();
mockedContext.Setup(c => c.HttpContext.User.Identity.Name).Returns("test");
var controller = new HomeController(mockedNewsService.Object, mockedNewsCommentFactory.Object, mockedDateProvider.Object);
controller.ControllerContext = mockedContext.Object;
var model = new NewsDetailsViewModel()
{
NewsId = mockedNews.Id
};
// Act
var result = controller.AddNewsComment(model) as RedirectToRouteResult;
// Assert
Assert.IsTrue(result.RouteValues.ContainsKey("newsId"));
Assert.AreEqual(mockedNews.Id, result.RouteValues["newsId"]);
Assert.AreEqual("News", result.RouteValues["action"]);
Assert.IsTrue(mockedNews.Comments.Count == 1);
Assert.IsTrue(mockedNews.Comments.Contains(mockedNewsComment));
mockedNewsService.Verify(s => s.FindById(model.NewsId), Times.Once);
mockedNewsService.Verify(s => s.Save(), Times.Once);
mockedNewsCommentFactory.Verify(f => f.CreateNewsComment(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <DateTime>()), Times.Once);
}
protected void btn_comment_Click(object sender, EventArgs e)
{
string Name = txtName.Text;
string Comment = txtComment.Text;
string NewsID = Page.RouteData.Values["ID"] as string;
string Date = DateTime.Now.ToShortDateString();
NewsComment nc = new NewsComment()
{
Name = Name,
Description = Comment,
NewsID = int.Parse(NewsID)
};
dcx.NewsComments.InsertOnSubmit(nc);
dcx.SubmitChanges();
Response.Redirect(Page.Request.Url.ToString(), true);
}
public ActionResult Edit(NewsComment newsComment)
{
if (ModelState.IsValid)
{
var newsCommentDao = new NewsCommentDao();
var result = newsCommentDao.UpdateNewsComment(newsComment);
if (result)
{
SetNotification("Cập nhật News Comment thành công .", "success");
return(RedirectToAction("Index", "NewsComment"));
}
else
{
ModelState.AddModelError("", "Cập nhật News Comment không thành công .");
}
}
return(View());
}
public ActionResult Create(NewsComment newsComment)
{
if (ModelState.IsValid)
{
var newsCommentDao = new NewsCommentDao();
var Id = newsCommentDao.InsertNewsComment(newsComment);
if (Id > 0)
{
SetNotification("Thêm mới News Comment thành công .", "success");
return(RedirectToAction("Index", "NewsComment"));
}
else
{
ModelState.AddModelError("", "Thêm mới News Comment không thành công .");
}
}
return(View());
}
public bool UpdateNewsComment(NewsComment entity)
{
var newsComment = dbContext.NewsComments.Find(entity.Id);
if (newsComment == null)
{
throw new ArgumentNullException(nameof(newsComment));
}
newsComment.CommentTitle = entity.CommentTitle;
newsComment.CommentText = entity.CommentText;
newsComment.NewsItemId = entity.NewsItemId;
newsComment.CustomerId = entity.CustomerId;
newsComment.IsApproved = entity.IsApproved;
dbContext.SaveChanges();
return(true);
}
public ActionResult CreateNewsComment(string content, int newsID)
{
User user = Session["user"] as User;
NewsComment comment = new NewsComment
{
Content = content,
UserID = user.ID,
NewsID = newsID,
Commentdate = DateTime.Now
};
db.NewsComments.Add(comment);
db.SaveChanges();
comment.User = user;
return(PartialView("_PartialNewsComment", comment));
}
