public ActionResult Create(PostEditModelView postEditModel, int[] selectedTags) { if (selectedTags != null) { postEditModel.Post.Tags = Mapper.Map <IEnumerable <TagDTO>, List <TagModel> >(tagService.GetAll().Where(t => selectedTags.Contains(t.Id)).ToList()); ModelState["Post.Tags"].Errors.Clear(); } if (ModelState.IsValid) { try { var postDto = Mapper.Map <PostModel, PostDTO>(postEditModel.Post); UserDTO userDto = userService.FindUserByLogin(User.Identity.Name); postDto.User = userDto; if (User.IsInRole(Role.Admin) || User.IsInRole(Role.Moderator)) { postDto.IsPublished = true; } else { TempData["message"] = string.Format("Спасибо за публикацию! Ваш пост \"{0}\" был отправлен модератору.", postEditModel.Post.Title); } postService.AddPost(postDto); return(RedirectToAction("List")); } catch (ValidationException ex) { ModelState.AddModelError(ex.Property, ex.Message); } } postEditModel.Categories = GetCategories(); postEditModel.Tags = GetTags(); return(View(postEditModel)); }
public ContentResult AddPost(Post post) { string json; ModelState.Clear(); if (TryValidateModel(post)) { _postService.AddPost(post); json = JsonConvert.SerializeObject(new { id = post.PostId, success = true, message = "Post added successfully" }); } else { json = JsonConvert.SerializeObject(new { id = 0, success = false, message = "Failed to add the post" }); } return(Content(json, "application/json")); }
public async Task <IActionResult> Create(PostViewModel post) { post.PostedTime = DateTime.Now.Date; post.AccountId = (await _userManager.GetUserAsync(HttpContext.User)).Id; postService.AddPost(mapper.Map <PostDTO>(post)); return(View("Details", post)); }
public async Task <IActionResult> NewPost(NewPostViewModel model) { SetIsAuth(); await postService.AddPost(Int32.Parse(Request.Cookies["user"]), model.Title, model.Preview, model.Text, model.Image); return(RedirectToAction("MyPage", "User")); }
public ActionResult Add(string postContent, string Id) { if (postContent is null) { throw new ArgumentNullException(); } if (Id is null) { throw new ArgumentNullException(); } if (ModelState.IsValid) { PostDTO postDTO = new PostDTO { Content = postContent, PostDate = DateTime.Now, UserId = GetUserId(), UserPageId = Id }; _postService.AddPost(postDTO); } return(RedirectToAction($"Index/{Id}", "Home")); }
public ActionResult NewPost(string blogId, string username, string password, IDictionary <string, object> post, bool publish) { if (string.IsNullOrEmpty(blogId)) { throw new ArgumentException(); } Blog blog = blogService.GetBlog(new BlogAddress(blogId)); //TODO: (erikpo) Move into a model binder? PostInput postInput = new PostInput(blog.Name, post["title"] as string, post["description"] as string, post["mt_excerpt"] as string, (post["categories"] as object[]).OfType <string>() ?? Enumerable.Empty <string>(), string.IsNullOrEmpty(post["mt_basename"] as string) ? expressions.Slugify(post["title"] as string) : post["mt_basename"] as string, publish ? DateTime.UtcNow : (DateTime?)null, blog.CommentingDisabled); ModelResult <Post> results = postService.AddPost(postInput, EntityState.Normal); if (results.IsValid) { return(new XmlRpcResult(results.Item.ID.ToString())); } return(new XmlRpcFaultResult(0, results.GetFirstException().Message)); }
public virtual IActionResult Post([FromBody] PostModel model) { try { if (ModelState.IsValid) { var entity = new Post { Title = model.Title, Body = model.Body, BodyOverview = model.BodyOverview, MetaTitle = model.MetaTitle, MetaDescription = model.MetaDescription, MetaKeywords = model.MetaKeywords, Tags = model.Tags, AllowComments = model.AllowComments, StartDateUtc = model.StartDateUtc, EndDateUtc = model.EndDateUtc }; _postService.AddPost(entity); return(Ok()); } return(new BadRequestResult()); } catch (Exception ex) { base.LogError <PostsController>(ex); return(StatusCode(StatusCodes.Status500InternalServerError)); } }
public string NewPost(string blogId, string username, string password, Post post, bool publish) { Oxite.Model.User user = getUser(username, password); Oxite.Model.Area area = areaService.GetArea(new Guid(blogId)); Oxite.Model.Post newPost = new Oxite.Model.Post { Title = post.title, Body = post.description, Created = post.dateCreated == default(DateTime) ? DateTime.Now : post.dateCreated, Slug = string.IsNullOrEmpty(post.mt_basename) ? expressions.Slugify(post.title) : post.mt_basename, BodyShort = post.mt_excerpt, Creator = user, State = Oxite.Model.EntityState.Normal }; if (publish) { newPost.Published = DateTime.Now; } if (post.categories != null) { newPost.Tags = new List <Oxite.Model.Tag>(post.categories.Select(s => new Oxite.Model.Tag() { Name = s })); } postService.AddPost(area, newPost); Oxite.Model.Post createdPost = postService.GetPost(area, newPost.Slug); return(createdPost.ID.ToString()); }
public IActionResult AddPost([FromBody] UserViewModel model) { if (model.PostName == null || model.PostText == null) { return(View(model)); } int length = model.PostText.Length; int previewLength = length; if (length > 50) { previewLength = length / 2; } string preview = model.PostText.Substring(0, previewLength) + "..."; var post = new Post() { PostDate = DateTime.Now, PostName = model.PostName, PostPreview = preview, PostText = model.PostText, User = userService.GetUsers().Find(u => u.Id == Int32.Parse(Request.Cookies["id"])) }; postService.AddPost(post); return(PartialView("_PostsPartial", post)); }
public async Task <IActionResult> AddPost([FromBody] PostEditRequest request) { var appUser = (AppUser)HttpContext.Items["User"]; var result = await _service.AddPost(appUser, request); return(Ok(result)); }
public ActionResult Add(PostViewModel post, int studentId) { Post postMap = Mapper.Map <PostViewModel, Post>(post); postService.AddPost(postMap, studentId); return(RedirectToAction("Posts", "Post", new { studentId = studentId })); }
public IActionResult Create(HomeViewModel vm) { var userProfileId = int.Parse(HttpContext.Session.GetString("sessionUser")); var post = new Post(vm.PostFormViewModel.Content, userProfileId); _postService.AddPost(post); return(RedirectToAction("Index")); }
public ActionResult AddPost(Post post) { if (ModelState.IsValid && Request.IsAuthenticated) { postService.AddPost(post); } return(RedirectToAction("Index", "Home")); }
public void GetPosts(PostViewModel postViewModel) { var id = User.FindFirst(ClaimTypes.NameIdentifier).Value; var post = mapper.Map <Post>(postViewModel); postService.AddPost(post, id); Response.Redirect(Request.Path); }
public IActionResult Add(PostViewModel viewModel) { if (_postService.AddPost(viewModel.Post)) { return(RedirectToAction("Index")); } return(View(viewModel)); }
public async Task <ActionResult <PostDTO> > Post(PostDTO post) { if (ModelState.IsValid) { postService.AddPost(post); } return(Ok()); }
public ActionResult AddPost([FromBody] PostDto post) { var userId = (int)HttpContext.Items["UserId"]; post.UserId = userId; var addedPost = _postService.AddPost(post); return(new OkObjectResult(addedPost)); }
public IActionResult AddPost(Post post) { if (post == null) { return(BadRequest()); } var re = _IPostService.AddPost(post); return(Ok(re)); }
public int Add(PostDTO post) { ApplicationUser applicationUser = RequestContext.GetLoggedInUser(); post.UserID = applicationUser.UserID; post.Contact = applicationUser.Mobile; int postId = _postService.AddPost(post); return(postId); }
public IActionResult AddPost(PostViewModel model) { Post post = _mapper.Map <Post>(model); post.Theme = _themeService.GetThemeById(model.ThemeId); post.user = GetAuthorizeUser().Result; _postService.AddPost(post); return(RedirectToAction(nameof(Index))); }
public async Task <IActionResult> AddPost(PostDto postDto) { var post = _mapper.Map <Post>(postDto); await _postService.AddPost(post); postDto = _mapper.Map <PostDto>(post); var response = new ApiResponse <PostDto>(postDto); return(Ok(response)); }
public async Task <IActionResult> Post(Posts post) { var result = await _service.AddPost(post); if (result != null) { return(Ok(result)); } return(StatusCode(StatusCodes.Status204NoContent)); }
public ActionResult Create(AddPostViewModel post) { if (ModelState.IsValid) { postService.AddPost(Mapper.Map <Post>(post), post.UploadedImage); return(this.RedirectToAction(c => c.Index())); } return(View(Views.Create, post)); }
public async Task <CustomApiResponse> Post([FromBody] PostsDto entity) { //var inputEntity = _mapper.Map<Posts>(entity); //if (await _postService.IsExisted(entity.Name)) //{ // return new CustomApiResponse("PostName đã tồn tại", true); //} var result = await _postService.AddPost(entity); return(new CustomApiResponse(result)); }
public async Task <IActionResult> Add(NewPostModel newPostModel) { var result = await postService.AddPost(newPostModel, User); await profileService.AddBookmark( User.GetUserId(), result.PostId, newPostModel.EnableNotifications); return(Ok(result.PostId)); // todo?: return Created() }
public IActionResult AddPost([FromBody] Post post) { try { _postService.AddPost(post); return(Ok("Post added!")); } catch (Exception e) { return(BadRequest("Oops, something went wrong!" + e.Message)); } }
public IActionResult CreatePost(CreatePostViewModel model) { if (!ModelState.IsValid) { return(BadRequest()); } var postDTO = _mapper.Map <CreatePostViewModel, CreatePostDTO>(model); postDTO.AuthorId = HttpContext.User.GetUserId(); _postService.AddPost(postDTO); return(Ok()); }
public IActionResult Create([Bind("PostTitle,PostText")] Post post) { if (!string.IsNullOrEmpty(post.PostText) && !string.IsNullOrEmpty(post.PostTitle)) { post.Status = PostStatus.Created; post.AuthorEmail = User.Identity.Name; post.AuthorName = User.Identity.Name; post.CreationDate = DateTime.Now; _postService.AddPost(post); return(RedirectToAction(nameof(Index))); } return(View(post)); }
public async Task <ActionResult> AddPost([FromBody] PostInsertDto post) { try { var postAdded = await _postsService.AddPost(post, ClaimResolver.getUserIdFromToken(User)); return(Ok(postAdded)); } catch (Exception Ex) { return(BadRequest("The post cannot be added due to bad connection with the database" + Ex.Message)); } }
public void When_a_user_attempts_to_post_a_valid_post_it_should_be_added() { //Arrange Post p = pb.getValidPost(); Mock.Arrange(() => _pr.Save(Arg.IsAny <Post>())).OccursOnce(); //Act ps.AddPost(p); //Assert Mock.Assert(_pr); }