public ActionResult NewPost(NewPostViewModel viewModel)
{
var repository = DIContainer.Kernel.Get <IRepository>();
ApprovalEnums autoApproval = ApprovalEnums.Pending;
if (UserManager.IsInRole(UserManager.FindByName(User.Identity.Name).Id, "Admin"))
{
autoApproval = ApprovalEnums.Approved;
}
var tags = repository.TagStringToTags(viewModel.ListOfTags);
Post newPost = new Post
{
ApprovalStatus = autoApproval,
Body = viewModel.Body,
Date = DateTime.Now,
IsFeatured = false,
Subject = viewModel.Subject,
Tags = tags,
User = UserManager.FindByName(User.Identity.Name)
};
repository.SaveNewPost(newPost);
return(RedirectToAction("PostView"));
}
public async Task BlogController_New_For_Post_Does_Not_Add_Post_If_Invalid()
{
// Arrange
DateTime now = DateTime.UtcNow;
now = now.AddMilliseconds(now.Millisecond * -1);
NewPostViewModel model = new NewPostViewModel();
using (BlogController target = new BlogController())
{
target.ModelState.AddModelError("Body", "A body must be specified.");
// Act
ActionResult result = await target.New(model);
// Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(ViewResult));
ViewResult view = result as ViewResult;
Assert.IsNotNull(view.Model);
Assert.AreSame(model, view.Model);
Assert.AreEqual(string.Empty, view.ViewName);
}
}
private void SavePost(NewPostViewModel newPost, bool publishPost)
{
if (string.IsNullOrEmpty(newPost.Excerpt))
{
newPost.Excerpt = _excerptGenerator.CreateExcerpt(newPost.Body);
}
Post post = new Post {
Title = newPost.Title,
Body = newPost.Body,
Excerpt = newPost.Excerpt,
Slug = _slugGenerator.CreateSlug(newPost.Title),
LastModified = DateTimeOffset.Now,
};
if (publishPost)
{
post.PubDate = DateTimeOffset.Now;
post.IsPublic = true;
}
if (Request != null)
{
_dataStore.SaveFiles(Request.Form.Files.ToList());
}
_dataStore.SavePost(post);
}
public async Task <IActionResult> CreatePost(NewPostViewModel viewModel, int blogId)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
var blogOwnerId = blogId;
var isAuthorized = await _authorizationService.AuthorizeAsync(User, blogOwnerId, PostOperations.Create);
if (isAuthorized.Succeeded)
{
var post = new Post
{
Title = viewModel.Title,
Content = viewModel.Content,
BlogId = blogId
};
_postService.CreatePost(post);
return(RedirectToAction("Index", "Blog"));
}
return(new UnauthorizedResult());
}
public async Task <IActionResult> Create(NewPostViewModel newPostViewModel)
{
#region CREATING A NEW POST
var userId = _userManager.GetUserId(User);
var user = _userManager.FindByIdAsync(userId).Result;
var post = _postBLL.BuildPost(newPostViewModel, user);
await _postService.Add(post);
#endregion
#region INCREASING THE TOTAL POST AMOUNT IN FORUM
var forum = _forumService.GetById(newPostViewModel.ForumId);
forum.AmountTotalPost += 1;
#endregion
#region INSERTING NEW FORUM AMOUNT
bool userFirstPostByForum = _forumService.CheckUserFirstPostByForum(userId.ToString(), newPostViewModel.ForumId);
//If it is the first time that the user is creating a post related with the forum, then increase one user of the forum bcz a new user has just used the forum for the first time.
if (userFirstPostByForum == true)
{
var model = _forumBLL.GetForumUserNewAmount(user, forum);
await _forumService.AddNewUser(model);
}
#endregion
await _forumService.Update(forum);
return(RedirectToAction("Index", "Post", new { id = post.Id }));
}
public ActionResult NewPost(NewPostViewModel npvm)
{
if (Session["ID"] != null)
{
var post = new Post()
{
Caption = npvm.Caption,
Time = DateTime.Now,
Private_Public = npvm.Private_Public,
User_Id = (int)Session["ID"]
};
if (npvm.Picture != null)
{
post.Has_Picture = true;
}
else
{
post.Has_Picture = false;
}
ActionResult Return = RegisterPost(post);
if (npvm.Picture != null)
{
string name = post.Time.ToString().Replace(':', '_').Replace('/', '_').Replace('-', '_');
string path = Path.Combine(Server.MapPath("~/images"), post.User_Id.ToString(), name + ".jpg");
npvm.Picture.SaveAs(path);
}
return(Return);
}
return(null);
}
public ActionResult New(NewPostViewModel vm)
{
if (ModelState.IsValid)
{
Post post = new Post
{
CategoryId = vm.CategoryId,
Title = vm.Title,
Content = vm.Content,
AuthorId = User.Identity.GetUserId(),
Slug = UrlService.URLFriendly(vm.Slug),
CreationTime = DateTime.Now,
ModificationTime = DateTime.Now,
PhotoPath = this.SaveImage(vm.FeaturedImage)
};
db.Posts.Add(post);
db.SaveChanges();
TempData["SuccessMessage"] = "Post has been created successfully.";
return(RedirectToAction("Index"));
}
ViewBag.CategoryId = new SelectList(db.Categories.OrderBy(x => x.CategoryName).ToList(), "Id", "CategoryName");
return(View());
}
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 Save(FormViewModel formData)
{
if (formData == null)
{
return(RedirectToAction("NewPost"));
}
var model = new NewPostViewModel()
{
Categories = _unitOfWork.Categories.GetAll()
.Select(Mapper.Map <Category, CategoryDto>).ToList(),
Post = formData.Post,
Img = formData.Img
};
if (!ModelState.IsValid)
{
return(View("PostForge", model));
}
formData.Post.Img = _imageManager.SaveImage(formData.Img,
_contextService.GetMapPath(_path));
if (formData.Post.Img == null)
{
return(View("PostForge", model));
}
_unitOfWork.Posts.Add(Mapper.Map <PostDto, Post>(formData.Post));
_unitOfWork.Complete();
return(RedirectToAction("Index", "Post"));
}
public async Task <IActionResult> StartPost([FromBody] NewPostViewModel postViewModel)
{
var startPostCommand = new StartPostCommand(postViewModel.Author, postViewModel.Title);
await _mediator.Publish(startPostCommand, CancellationToken.None);
return(Ok());
}
public IActionResult AddPost(NewPostViewModel model)
{
if (ModelState.IsValid)
{
User user = context.Users.Where(u => u.ID == model.UserID).FirstOrDefault();
Blog newPost = new Blog
{
MedicineName = model.MedicineName,
Description = model.Description,
StreetNumberAndName = model.StreetNumberAndName,
City = model.City,
State = model.State,
ZipCode = model.ZipCode,
PostTime = DateTime.Now,
UserID = model.UserID,
User = user
};
context.Blogs.Add(newPost);
context.SaveChanges();
return(Redirect($"/Users/ViewBlog?id={user.ID}"));
//TempData["id"] = user.ID;
//return RedirectToAction("/Users/ViewBlog");
}
return(View(model));
}
public IActionResult AddPost(string name)
{
NewPostViewModel newPost = new NewPostViewModel();
User newUser = context.Users.Single(x => x.Name == User.Identity.Name);
newPost.UserID = newUser.ID;
return(View(newPost));
}
public async Task Put(int postId, NewPostViewModel postModel)
{
var newPostData = new NewPostDTO {
Body = postModel.Body
};
await postService.Update(newPostData, postId);
}
public NewPostView(ImageSource IS, MediaFile file)
{
viewModel = new NewPostViewModel(IS, file);
viewModel.initData();
InitializeComponent();
viewModel.Navigation = this.Navigation;
this.BindingContext = viewModel;
}
public async Task <IActionResult> AddNewPost(NewPostViewModel model)
{
model.UserId = await _currentUserService.GetUserId();
var postId = await _postService.CreatePost(model);
return(RedirectToAction(nameof(Index), new { id = postId }));
}
public async Task Post(string userId, NewPostViewModel postModel)
{
var newPostData = new NewPostDTO {
Body = postModel.Body,
UserId = userId
};
await postService.Create(newPostData);
}
public async Task <IActionResult> NewPost()
{
var model = new NewPostViewModel
{
Categories = await _categoryService.GetCategories()
};
return(View(model));
}
public ActionResult ThemMoi()
{
NewPostViewModel model = new NewPostViewModel
{
MaQH = db.QuanHuyens.ToList(),
MaTTP = db.TinhTPs.ToList(),
};
return(View(model));
}
public NewPostPage()
{
InitializeComponent();
viewModel = new NewPostViewModel();
BindingContext = viewModel;
viewModel.Navigation = Navigation;
LoadPetTypePicker();
LoadPetSizePicker();
}
public async Task <IActionResult> Patch(long id, [FromBody] NewPostViewModel model)
{
if (ModelState.IsValid)
{
var post = this.unitOfWork.PostsRepository.GetById(id);
if (post == null)
{
return(NotFound());
}
if (post.UserId != User.Claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier).Value)
{
return(Forbid());
}
else
{
post.CategoryId = model.CategoryId;
post.Title = model.Title;
post.Text = model.Content;
foreach (var tag in model.Tags)
{
var wantedTag = this.unitOfWork.TagsRepository.GetByName(tag);
if (wantedTag == null)
{
wantedTag = new Tag {
Name = tag
};
this.unitOfWork.TagsRepository.Add(wantedTag);
this.unitOfWork.PostsRepository.AddPostTag(new PostTag
{
Tag = wantedTag,
Post = post
});
}
else
{
if (!this.unitOfWork.PostsRepository.HasTag(post.PostId, wantedTag.TagId))
{
PostTag postTag = new PostTag {
PostId = post.PostId, TagId = wantedTag.TagId
};
this.unitOfWork.PostsRepository.AddPostTag(postTag);
}
}
}
}
await this.unitOfWork.Save();
return(NoContent());
}
else
{
return(BadRequest());
}
}
public ViewResult NewPost()
{
var model = new NewPostViewModel()
{
Categories = _unitOfWork.Categories.GetAll()
.Select(Mapper.Map <Category, CategoryDto>).ToList(),
Post = new PostDto()
};
return(View("PostForge", model));
}
public async Task <IActionResult> CreatetPost([FromBody] NewPostViewModel post)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newPostRespond = await _postService.CreatePost(post);
return(Ok(newPostRespond));
}
public async System.Threading.Tasks.Task <IActionResult> Add(NewPostViewModel data)
{
if (!ModelState.IsValid)
{
return(View(data));
}
var usr = HttpContext.User.Identity.Name;
await _postListService.Add(usr, data.Title, data.Description, data.allowComment, data.Content, data.Tags, data.CategoryId);
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> AddPost(NewPostViewModel model)
{
var userId = _userManager.GetUserId(User);
var user = _userManager.FindByIdAsync(userId).Result;
var post = BuildPost(model, user);
await _postService.Add(post);
await _userService.UpdateUserRating(userId, typeof(Post));
return(RedirectToAction("Index", "Post", new { id = post.Id }));
}
public IActionResult Create(int id)
{
var forum = _forumService.GetById(id);
var model = new NewPostViewModel
{
ForumName = forum.Title,
ForumId = forum.Id,
AuthorName = User.Identity.Name
};
return(View(model));
}
private Post BuildPost(NewPostViewModel model, ApplicationUser user)
{
var forum = forumService.GetById(model.ForumId);
return(new Post
{
Title = model.Title,
Content = model.Content,
Created = DateTime.Now,
User = user,
Forum = forum
});
}
public NewPostViewModel GetForumById(int id)
{
var forum = _forumService.GetById(id);
var model = new NewPostViewModel
{
ForumId = forum.Id,
ForumTitle = forum.Title,
ForumImageUrl = forum.ImageUrl
};
return(model);
}
private Post BuildPost(NewPostViewModel model, ApplicationUser user)
{
var topic = _Context.Topics.Single(x => x.Id == model.TopicId);
return(new Post
{
Title = model.Title,
Content = model.Content,
Created = DateTime.Now,
User = user,
Topic = topic
});
}
public IActionResult Create(int id) //id is Forum.Id
{
var forum = _forumService.GetById(id);
var model = new NewPostViewModel
{
ForumName = forum.Title,
ForumId = forum.Id,
ForumImageUrl = forum.ImageUrl,
AuthorName = User.Identity.Name //Get logged in user
};
return(View(model));
}
public IActionResult Create(int id)
{
var forum = forumService.GetById(id);
var viemModel = new NewPostViewModel()
{
ForumId = forum.Id,
ForumName = forum.Title,
ForumImageUrl = forum.ImageURL,
AuhtorName = User.Identity.Name
};
return(View(viemModel));
}
