public IActionResult Comment(int id, AddCommentModel newComment) { int userId = int.Parse(HttpContext.User.FindFirstValue("Id")); _commentsService.Add(userId, ICommentsService.CommentType.Question, id, newComment.Message); return(RedirectToAction("Details", new { id })); }
public ResultModel AddComment(AddCommentModel model) { ResultModel result = new ResultModel(); sqlCommand = new SqlCommand() { Connection = connectionHelper.connection, CommandType = CommandType.StoredProcedure, CommandText = "AddCommentSP", }; sqlCommand.Parameters.Add("@EventId", SqlDbType.Int).Value = model.EventId; sqlCommand.Parameters.Add("@PersonId", SqlDbType.Int).Value = model.PersonId; sqlCommand.Parameters.Add("@Title", SqlDbType.NVarChar).Value = model.Title; sqlCommand.Parameters.Add("@Content", SqlDbType.NVarChar).Value = model.Content; connectionHelper.connection.Open(); SqlDataReader sqlReader = sqlCommand.ExecuteReader(); if (sqlReader.HasRows) { if (sqlReader.Read()) { result = new ResultModel() { IsSuccess = (bool)sqlReader["IsSuccess"], Message = sqlReader["Message"] as string }; } } connectionHelper.connection.Close(); return(result); }
public ActionResult AddComment(AddCommentModel model) { var controller = DependencyResolver.Current.GetService <HomeController>(); controller.ControllerContext = new ControllerContext(this.Request.RequestContext, controller); User user = controller.GetActualUser(); Comment comment = null; Post post = null; using (BlogContext context = new BlogContext()) { post = context.Posts.SingleOrDefault(p => p.PostId == model.Postid); comment = new Comment() { Title = model.Title, Content = model.Content, UserID = user.UserId, Post = post }; PairCommentWithPost(ref post, ref comment); context.Comments.Add(comment); context.SaveChanges(); return(RedirectToAction("ViewPost", "Post", comment.Post)); // return RedirectToAction("ViewSingleComment", new { @CommentID = comment.CommentId }); } }
public IActionResult Comment([Bind(nameof(AddCommentModel.BlogComposesId), nameof(AddCommentModel.Name), nameof(AddCommentModel.Email), nameof(AddCommentModel.Message), nameof(AddCommentModel.IsAprove))] AddCommentModel model) { if (ModelState.IsValid) { try { model.Add(); model.Response = new ResponseModel("Comment Successful Wating for Review", ResponseType.Success); //logger code _logger.LogInformation("Comment Create Sucessfully"); return(RedirectToAction("Post", new { id = model.BlogComposesId })); } catch (Exception ex) { model.Response = new ResponseModel("Comment failued.", ResponseType.Failure); _logger.LogError($"Comment Add 'Failed'. Excption is : {ex.Message}"); } } return(View()); }
public async Task <IBaseResponse <List <CommentModel> > > AddComment(AddCommentModel addCommentModel, int userId) { if (addCommentModel != null) { await _applicationContext.Comments.AddAsync ( new Comment { DateTime = DateTime.Now, Text = addCommentModel.Text, UserId = userId, LectureId = addCommentModel.LectureId } ); await _applicationContext.SaveChangesAsync(); } var commentList = await _applicationContext.Comments.Where(com => com.LectureId == addCommentModel.LectureId).ToListAsync(); var comments = new List <CommentModel>(); comments = await CommonMethods.GetCommentList(commentList, comments, _applicationContext, _mapper, userId); return(new BaseResponse <List <CommentModel> > { Code = addCommentModel != null ? HttpStatusCode.Created : HttpStatusCode.BadRequest, Data = comments }); }
public async Task <ActionResult> AddComment(AddCommentModel model) { if (ModelState.IsValid) { var user = await UserManager.FindByNameAsync(User.Identity.Name); var message = new ForumMessage { ForumId = model.ForumId, ReplyMessageId = null, Message = model.Comment, UserId = user.Id }; db.ForumMessages.Add(message); await db.SaveChangesAsync(); return(RedirectToAction("Messages", "Forum", new { id = model.ForumId })); } //ViewBag.ForumId = new SelectList(db.Forums, "ForumId", "ForumId", forumMessage.ForumId); //ViewBag.UserId = new SelectList(db.Users, "Id", "FirstName", forumMessage.UserId); ModelState.AddModelError("Error ", "Please enter a valid comment"); return(RedirectToAction("Messages", "Forum", new { id = model.ForumId })); }
/// <summary> /// Add comment by specified values /// </summary> /// <param name="addCommentModel">Comment values</param> /// <exception cref="ArgumentNullException">Parameter addCommentModel is null</exception> /// <exception cref="ArgumentNullException">Message isn't specified</exception> /// <returns>Identifier value of new created comment</returns> public Guid Add(AddCommentModel addCommentModel) { if (addCommentModel == null) { throw new ArgumentNullException(nameof(addCommentModel)); } if (string.IsNullOrEmpty(addCommentModel.Message)) { throw new ArgumentNullException(nameof(addCommentModel.Message)); } var newId = Guid.NewGuid(); CommentsDataProvider.Add(new Comment { Id = newId, AppearanceCount = 0, CreatedOn = DateTime.UtcNow, Message = addCommentModel.Message, Description = addCommentModel.Description }); return(newId); }
public async Task CommentForGasStation_Delete_CommentIsDeleted() { // given var gasStationId = await CreateGasStation(); var addCommentModel = new AddCommentModel { Content = "Comment", SubjectId = gasStationId.ToString(), Tag = CommentTag.GasStation }; var createdAt = await fixture.HttpClient.PostJsonAsync <CreatedResponse>(Routes.Comments.ToString(), addCommentModel); // when await fixture.HttpClient.DeleteAsync($"{ Routes.Comments }/{ createdAt.Id }"); // then var response = await fixture.HttpClient.GetAsync($"{ Routes.PriceSubmissions }/{ createdAt.Id }"); response.StatusCode.Should().Be(HttpStatusCode.NotFound); }
public async Task CommentForGasStation_UpdateContent_UpdatedContentCanBeRetrieved() { // given var gasStationId = await CreateGasStation(); var addCommentModel = new AddCommentModel { Content = "Comment", SubjectId = gasStationId.ToString(), Tag = CommentTag.GasStation }; var createdAt = await fixture.HttpClient.PostJsonAsync <CreatedResponse>(Routes.Comments.ToString(), addCommentModel); // when var updateCommentModel = new UpdateCommentModel { Content = "Updated Comment" }; await fixture.HttpClient.PutJsonAsync($"{ Routes.Comments }/{ createdAt.Id }", updateCommentModel); // then var comment = await fixture.HttpClient.GetJsonAsync <Comment>($"{ Routes.Comments }/{ createdAt.Id }"); comment.Should().BeEquivalentTo(updateCommentModel); }
public IHttpActionResult AddComment(int gameId, AddCommentModel model) { var comment = Mapper.Map <AddCommentModel, CommentDTO>(model); _commentService.AddComment(gameId, comment); return(Ok("Comment added")); }
public IHttpActionResult Reply(int commentId, AddCommentModel model) { var comment = Mapper.Map <AddCommentModel, CommentDTO>(model); _commentService.Reply(commentId, comment); return(Ok("Reply added")); }
public async Task EditCommentAsync(AddCommentModel addCommentModel, int id) { Comment comment = await _mySerialListDBContext.Comments.Where(c => c.Id == id).FirstOrDefaultAsync(); comment.Description = addCommentModel.Description; comment.CreateAt = DateTime.Now; await _mySerialListDBContext.SaveChangesAsync(); }
public void ShouldReturnBaseServiceResultSuccess() { AddCommentModel model = null; BaseServiceResult <Guid> result = TestedController.Add(model); Assert.NotNull(result); Assert.True(result.IsSuccess); Assert.Empty(result.ErrorMessage); }
public async Task CommentPost(AddCommentModel model) { var commentPostRequest = new CommentPostRequest { Content = model.Content, PostId = model.PostId }; await _postsManagementService.CommentPost(commentPostRequest); }
public async Task CreatComment(AddCommentModel addCommentModel) { var commentEntity = new Comment(); commentEntity.ArticleId = addCommentModel.ArticleId; commentEntity.AuthorId = addCommentModel.AuthorId; commentEntity.Body = addCommentModel.Body; commentEntity.CreatedDate = DateTime.UtcNow; context.Comments.Add(commentEntity); await context.SaveChangesAsync(); }
public async Task <ActionResult> AddComment(AddCommentModel model) { if (ModelState.IsValid) { await model.AddComment(User.Identity.Name); return(RedirectToAction("Details", "Post", new { id = model.PostId })); } return(View(model)); }
public async Task AddCommentAsync(AddCommentModel addCommentModel, string userId) { await CheckFilmProductionExist(addCommentModel.FilmProductionId); if (!await _userFilmProductionsRepository.IsFilmProductionAddedAsync(addCommentModel.FilmProductionId, userId)) { throw new HttpStatusCodeException(HttpStatusCode.BadRequest, "Dodaj Produkcje filmową do swojej list aby móc ją komentować."); } await _reviewFilmProductionRepository.AddCommentAsync(addCommentModel, userId); }
public async Task <IActionResult> PostComment([FromBody] AddCommentModel addCommentModel) { var UserId = int.Parse(HttpContext.User.Identity.Name); var PhotoId = addCommentModel.ProfilePhotoId; var Message = addCommentModel.Message; var comment = await Task.Run(() => _commentService.CreateComment(UserId, PhotoId, Message)); var model = _mapper.Map <CommentModel>(comment); return(Ok(model)); }
public void ShouldThrowArgumentNullExceptionWhenAddWithEmptyModel() { AddCommentModel model = null; var exception = Record.Exception( () => TestedService.Add(model) ); Assert.NotNull(exception); Assert.IsType <ArgumentNullException>(exception); }
public async Task AddCommentAsync(AddCommentModel addCommentModel, string userId) { await _mySerialListDBContext.Comments.AddAsync(new Comment { FilmProductionId = addCommentModel.FilmProductionId, Description = addCommentModel.Description, CreateAt = DateTime.Now, UserId = userId }); await _mySerialListDBContext.SaveChangesAsync(); }
public async Task <IActionResult> AddComment([FromBody] AddCommentModel addCommentModel) { var response = await _commentService.AddComment(addCommentModel, Convert.ToInt32(Request.Cookies["userId"])); if (response.Code <= HttpStatusCode.PermanentRedirect) { return(Json(response.Data)); } else { return(BadRequest()); } }
public IHttpActionResult Create(int id, AddCommentModel model) { var userId = this.User.Identity.GetUserId(); var comment = new Comment { Content = model.Content, BookId = model.Id, UserId = userId }; return(this.Ok(comment)); }
public ActionResult Index(AddCommentModel model) { if (model.User != null && model.User.Avatar != null && model.User.Avatar.ContentLength > 0) { model.User.Avatar.SaveAs("C:/Users/Alexander/Documents/Temp/" + model.User.Avatar.FileName); } if (!string.IsNullOrWhiteSpace(model.Comment)) { CommentsRepository.Comments.Add(model.Comment); } return(View(new ArticleModel())); }
//AddComment Method allows to post a comment on a plant by taking information like plantID , Title and comment. public bool AddComment(AddCommentModel model) { Comments comments = new Comments { PlantID = model.PlantID, Title = model.Title, Comment = model.Comment, UserID = _userID, CreatedDate = DateTimeOffset.UtcNow }; ctx.Comments.Add(comments); return(ctx.SaveChanges() == 1); }
public async Task EditCommentAsync(AddCommentModel addCommentModel, int id, string userId) { if (!await _reviewFilmProductionRepository.CommentExsistsAsync(id)) { throw new HttpStatusCodeException(HttpStatusCode.NotFound, "Komentarz nie istnieje."); } if (!await _reviewFilmProductionRepository.IsUserCommentAsync(id, userId)) { throw new HttpStatusCodeException(HttpStatusCode.BadRequest, "Nie możesz edytować tego komentarza."); } await _reviewFilmProductionRepository.EditCommentAsync(addCommentModel, id); }
public IHttpActionResult AddComment(AddCommentModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var service = CreateSocialInteractionsService(); if (!service.AddComment(model)) { return(InternalServerError()); } return(Ok("Comment Added")); }
public async Task <long> Create(AddCommentModel model) { var comment = new Entities.Comment( content: model.Content, createdAt: DateTime.UtcNow, tag: model.Tag, subjectId: model.SubjectId); auditMetadataProvider.AddAuditMetadataToNewEntity(comment); dbContext.Add(comment); await dbContext.SaveChangesAsync(); return(comment.Id); }
public IActionResult Edit(int id, AddCommentModel newComment) { int userId = int.Parse(HttpContext.User.FindFirstValue("Id")); try { _commentsService.Update(userId, id, newComment.Message); } catch (AskMateNotAuthorizedException) { return(Forbid()); } return(RedirectToAction("Details", "Questions", new { id = newComment.QuestionId })); }
public BaseServiceResult <Guid> Add([FromBody] AddCommentModel addCommentModel) { try { var newId = CommentService.Add(addCommentModel); return(BaseServiceResult <Guid> .Success(newId)); } catch (Exception e) { Logger?.LogError(e, "Trying to: add comment."); return(BaseServiceResult <Guid> .Error(e)); } }
public async Task <IActionResult> AddComment(long postId, AddCommentModel model) { var session = HttpContext.Session; var userId = session.GetString(CommonConstants.USER_SESSION); if (userId == null) { return(Unauthorized()); } var accessId = Convert.ToInt64(userId); var result = await commentService.AddComment(accessId, postId, model); return(Ok(result)); }
public override bool Execute() { int numEvents = eventServices.GetAllEvents().Count(); int numUserProfiles = accountServices.GetAllUserProfiles().Count(); int eventId = random.Next(1, numEvents); int userProfileId = random.Next(1, numUserProfiles); AddCommentModel addCommentModel = new AddCommentModel(); addCommentModel.EventId = eventId; addCommentModel.UserProfileId = userProfileId; addCommentModel.Comment = "OHOHOHO " + Name + " " + DateTime.Now.ToString(); return eventServices.AddComment(addCommentModel); }