public ActionResult Save(Post post)
{
if (!ModelState.IsValid)
{
PostFormViewModel viewModel = new PostFormViewModel
{
Authors = _context.Users.ToList()
};
}
if (post.Id == 0)
{
post.DateCreated = DateTime.Now;
_context.Posts.Add(post);
}
else
{
Post postInDb = _context.Posts.Find(post.Id);
if (postInDb == null)
{
return(HttpNotFound("Post not found"));
}
postInDb.Title = post.Title;
postInDb.Body = post.Body;
postInDb.AuthorId = post.AuthorId;
postInDb.DateUpdated = DateTime.Now;
}
_context.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit(PostFormViewModel model)
{
ViewBag.AutorList = Mapper.Map <IEnumerable <AdmUserDto>, IList <AdmUserListViewModel> >(ServiceAdmUser.GetList());
try
{
if (ModelState.IsValid)
{
var post = ServicePost.GetItem(model.PostId);
post.Title = model.Title;
post.Resumen = System.Net.WebUtility.HtmlDecode(model.Resumen);
post.Description = System.Net.WebUtility.HtmlDecode(model.Description);
post.PublishDate = model.PublishDate;
post.AuthorId = model.AuthorId;
post.Active = model.Active;
ServicePost.Edit(post);
}
else
{
ModelState.AddModelError("Error", "Algunos datos ingresados no son válidos");
return(View(model));
}
}
catch (Exception ex)
{
ModelState.AddModelError("Error", "Se ha producido un error: " + ex.Message);
return(View(model));
}
return(RedirectToAction("Index"));
}
public async Task <IActionResult> CreatePostAsync(string board, int thread, PostFormViewModel postFormVM)
{
var anonId = await HttpContext.GetAnonGuidAsync();
if (ModelState.IsValid)
{
var postCreationDto = mapper.Map <PostCreationDto>(postFormVM, opt => opt.Items[StringConstants.UserId] = anonId);
try
{
var newPost = await threads.AddPostToThreadAsync(board, thread, postCreationDto);
return(RedirectToRoute("thread", new { Board = board, Thread = thread }, $"p{newPost.PostId}"));
}
catch (KeyNotFoundException ex)
{
logger.LogWarning($"Bad request. From {anonId} to {nameof(CreatePostAsync)}. {ex.Message}");
return(BadRequest());
}
}
else
{
logger.LogWarning($"Invalid model state from {anonId} to {nameof(CreatePostAsync)}. " +
string.Join(Environment.NewLine, ModelState.Root.Errors.Select(e => e.ErrorMessage)));
return(BadRequest());
}
}
public async Task <IActionResult> Publish(PostFormViewModel model)
{
if (model == null)
{
return(new HttpStatusCodeResult((int)HttpStatusCode.BadRequest));
}
var vm = new PostPublishViewModel
{
Theme = this._settings.Theme,
HeadPartialViewPath = this._themeService.GetHeadPartialViewPath(this._settings.Theme),
HeaderPartialViewPath = this._themeService.GetHeaderPartialViewPath(this._settings.Theme),
PostPartialViewPath = this._themeService.GetPostPartialViewPath(this._settings.Theme),
FooterPartialViewPath = this._themeService.GetFooterPartialViewPath(this._settings.Theme),
};
var env = this.Resolver.GetService(typeof(IApplicationEnvironment)) as IApplicationEnvironment;
var publishedpath = await this._publishService.PublishPostAsync(model.Body, env, this.Request).ConfigureAwait(false);
vm.MarkdownPath = publishedpath.Markdown;
vm.HtmlPath = publishedpath.Html;
return(this.View(vm));
}
public async Task <IActionResult> Create(PostFormViewModel postFormViewModel)
{
if (ModelState.IsValid)
{
var post = _mapper.Map <PostFormViewModel, Post>(postFormViewModel);
var user = await _unitOfWork.UserRepository.GetByClaimsPrincipal(HttpContext.User);
post.UserId = user.Id;
_unitOfWork.PostRepository.Insert(post);
await _unitOfWork.Complete();
var files = HttpContext.Request.Form.Files;
if (files.Count > 0)
{
await _fileHandler.UploadMedia(
files,
_env.WebRootPath,
post.FilesPathGuid.ToString(),
FileHandlerFolder.Posts);
}
return(RedirectToAction(nameof(Index)));
}
ViewData["PostCategoryId"] = GetPostCategories();
return(View(postFormViewModel));
}
public IActionResult Edit(int id)
{
var post = _posts.GetById(id);
if (post == null)
{
return(BadRequest());
}
var vM = new PostFormViewModel
{
Id = post.Id,
FormType = FormType.Edit,
Title = post.Title,
Description = post.Description,
DateCreated = post.DateCreated,
Url = post.Url,
PostType = post.PostType,
Status = post.Status,
Campus = post.Campus,
Campuses = _campus.GetAll(),
Statuses = _posts.GetListOfStatus()
};
return(View("PostForm", vM));
}
public IActionResult Create()
{
var vm = new PostFormViewModel();
vm.CategoryOptions = _categoryRepository.GetAll();
return(View(vm));
}
public ActionResult CreatePost(PostFormViewModel viewModel)
{
try
{
var currentUserId = User.Identity.GetUserId();
ApplicationUser currentUser = _context.Users.FirstOrDefault(x => x.Id == currentUserId);
var theme = _context.Themes.Single(t => t.Id == viewModel.Theme);
List <Theme> themes = _context.Themes.ToList();
if (!ModelState.IsValid)
{
viewModel.Themes = themes;
return(RedirectToAction("CreatePost", viewModel)); //return View("ThemeForm", viewModel);
}
var post = new Post
{
Title = viewModel.Title,
CreatedByUser = currentUser,
Body = viewModel.Body,
CreatedOn = DateTime.Now,
Theme = theme,
ModifiedOn = DateTime.Now
};
_context.Posts.Add(post);
_context.SaveChanges();
return(RedirectToAction("CreatePost", "Blog"));
}
catch (Exception e)
{
return(RedirectToAction("CreatePost", "Blog"));
}
}
public ActionResult Create(PostFormViewModel model)
{
try
{
if (ModelState.IsValid)
{
ServicePost.Add(new PostDto()
{
Title = model.Title,
Resumen = System.Net.WebUtility.HtmlDecode(model.Resumen),
Description = System.Net.WebUtility.HtmlDecode(model.Description),
PublishDate = model.PublishDate,
AuthorId = model.AuthorId,
RegisterDate = DateTime.Now,
Active = model.Active
});
}
else
{
ModelState.AddModelError("Error", "Algunos datos ingresados no son válidos");
return(View(model));
}
}
catch (Exception ex)
{
ModelState.AddModelError("Error", "Se ha producido un error: " + ex.Message);
return(View(model));
}
return(RedirectToAction("Index"));
}
public async void Given_Model_Publish_ShouldReturn_ViewResult(string markdown, string html, string markdownpath, string htmlpath)
{
this._requestServices.Setup(p => p.GetService(typeof(IApplicationEnvironment))).Returns(this._applicationEnvironment.Object);
this._httpContext.SetupGet(p => p.RequestServices).Returns(this._requestServices.Object);
this._controller.ActionContext = this._actionContext;
this._controller.TempData = this._tempData.Object;
var publishedpath = new PublishedPostPath()
{
Markdown = markdownpath, Html = htmlpath
};
this._publishService.Setup(p => p.PublishPostAsync(It.IsAny <string>(), It.IsAny <IApplicationEnvironment>(), It.IsAny <HttpRequest>())).Returns(Task.FromResult(publishedpath));
var model = new PostFormViewModel()
{
Title = "Title", Slug = "slug", Body = markdown
};
var result = await this._controller.Publish(model).ConfigureAwait(false) as ViewResult;
result.Should().NotBeNull();
var vm = result.ViewData.Model as PostPublishViewModel;
vm.Should().NotBeNull();
vm.Theme.Should().Be(this._defaultThemeName);
vm.MarkdownPath.Should().Be(markdownpath);
vm.HtmlPath.Should().Be(htmlpath);
}
public ActionResult Edit(PostFormViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View("PostForm", viewModel));
}
var currentUserId = User.Identity.GetUserId();
var postDto = new PostDto()
{
Contents = viewModel.Contents,
Title = viewModel.Title,
Id = viewModel.Id,
Publisher = new ApplicationUserDto()
{
Id = currentUserId
},
PubliclyVisible = viewModel.PubliclyVisible
};
var result = _postService.EditPost(postDto);
if (result.RequestStatus != RequestStatus.Success)
{
viewModel.ErrorMessage = result.Message;
return(View("PostForm"));
}
else
{
return(RedirectToAction("MyPosts"));
}
}
public ActionResult Edit(int id)
{
Post post = this.postsService
.GetAll()
.Where(x => x.Id == id)
.Include(x => x.Author)
.Include(x => x.Category)
.FirstOrDefault();
if (post == null)
{
return(this.HttpNotFound("Page not found!"));
}
var categories = this.categoriesService.GetAll().ToList();
var postViewModel = this.Mapper.Map <PostViewModel>(post);
var viewModel = new PostFormViewModel
{
Post = postViewModel,
Categories = categories
};
if (viewModel == null)
{
return(this.HttpNotFound("Page not found!"));
}
return(this.View(viewModel));
}
public ActionResult Create()
{
var viewModel = new PostFormViewModel()
{
Heading = "Add new post"
};
return(View(viewModel));
}
public async Task <IActionResult> SaveForm(PostFormViewModel postVM, IFormFile pic)
{
//if not valid, return the user the New Post page
if (!ModelState.IsValid)
{
var vM = new PostFormViewModel()
{
Campuses = _campus.GetAll(),
Statuses = _posts.GetListOfStatus()
};
return(View("PostForm", vM));
}
var userId = userManager.GetUserId(User);
var user = await userManager.FindByIdAsync(userId);
var post = new Post
{
Id = postVM.Id,
Title = postVM.Title,
Description = postVM.Description,
DateCreated = postVM.DateCreated,
Url = postVM.Url,
Status = postVM.Status,
PostType = postVM.PostType,
Campus = _campus.GetById(postVM.Campus.Id),
User = user
};
//if true, then it's a new post
if (postVM.Id == 0)
{
string filename = string.Empty;
//upload image if not null
if (pic != null)
{
filename = UploadImage(pic);
post.Url = "/images/" + Path.GetFileName(pic.FileName);
}
if (_posts.AddNewPost(post))
{
return((postVM.PostType == PostType.Issue) ? RedirectToAction("Issues") : RedirectToAction("Events"));
}
}
else
{
if (_posts.EditPost(post))
{
return(RedirectToAction("Detail", new { postVM.Id }));
}
}
return(BadRequest());
}
public ActionResult New()
{
string userId = User.Identity.GetUserId();
PostFormViewModel viewModel = new PostFormViewModel
{
Authors = _context.Users.ToList()
};
return(View("PostFormView", viewModel));
}
public ActionResult NewPost()
{
var viewModel = new PostFormViewModel()
{
ActionName = "Create",
PageHeading = "Add new post"
};
return(View("PostForm", viewModel));
}
public ActionResult Create()
{
var model = new PostFormViewModel()
{
PublishDate = DateTime.Now
};
ViewBag.AutorList = Mapper.Map <IEnumerable <AdmUserDto>, IList <AdmUserListViewModel> >(ServiceAdmUser.GetList());
return(View(model));
}
public IActionResult NewPost()
{
var campuses = _campus.GetAll();
var formVM = new PostFormViewModel()
{
Campuses = campuses,
Statuses = _posts.GetListOfStatus()
};
return(View("PostForm", formVM));
}
public ActionResult NewPost(string param1)
{
var forumTitle = param1;
var forumId = _context.Forums.Single(m => m.Title == forumTitle).Id;
var viewModel = new PostFormViewModel {
ForumName = forumTitle
};
viewModel.Forum_Id = forumId;
return(View("NewPost", viewModel));
}
public void PostFormViewModel_ShouldSet_Post()
{
// Arrange
var mockPost = new Mock <PostViewModel>();
var postFormViewModel = new PostFormViewModel();
// Act
postFormViewModel.Post = mockPost.Object;
// Assert
Assert.AreEqual(mockPost.Object, postFormViewModel.Post);
}
public async Task <IActionResult> CreatePostInBlog(PostFormViewModel model)
{
var userId = userService.GetUserId(User);
var post = new PostModel {
Name = model.Name, Content = model.Content, AuthorId = userId
};
await postService.AddToBlog(post, model.BlogId);
return(RedirectToAction(nameof(BlogsController.Details), "Blogs", new { id = model.BlogId }));
}
public void PostFormViewModel_ShouldSet_Items()
{
// Arrange
var mockList = new Mock <IEnumerable <PostCategory> >();
var postFormViewModel = new PostFormViewModel();
// Act
postFormViewModel.Categories = mockList.Object;
// Assert
Assert.AreEqual(mockList.Object, postFormViewModel.Categories);
}
public ActionResult CreatePost()
{
var viewModel = new PostFormViewModel
{
Title = "Add a Post",
Body = "Describe your Post",
Themes = _context.Themes.ToList(),
CreatedOn = DateTime.Now,
ModifiedOn = DateTime.Now
};
return(View("CreatePost", viewModel));
}
public IActionResult Create(PostFormViewModel viewModel)
{
Post newPost = new Post
{
Body = viewModel.Body,
Author = viewModel.Author,
Timestamp = viewModel.GetTimeStamp()
};
_context.Posts.Add(newPost);
_context.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
public ActionResult Create()
{
var categories = this.categoriesService.GetAll().ToList();
var viewModel = new PostFormViewModel
{
Post = new PostViewModel(),
Categories = categories
};
if (viewModel == null)
{
return(this.HttpNotFound("Page not found!"));
}
return(this.View(viewModel));
}
public ActionResult Edit(int id)
{
Post post = _context.Posts.Find(id);
if (post == null)
{
return(HttpNotFound("Post not found"));
}
PostFormViewModel viewModel = new PostFormViewModel(post)
{
Authors = _context.Users.ToList()
};
return(View("PostFormView", viewModel));
}
//[ValidateAntiForgeryToken]
public ActionResult Edit(int id, PostFormViewModel vm)
{
try
{
string userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
_postRepository.UpdatePost(vm.Post);
return(RedirectToAction("Details", new { id = vm.Post.Id }));
}
catch (Exception ex)
{
vm.CategoryOptions = _categoryRepository.GetAll();
return(View(vm));
}
}
public async Task <IActionResult> Edit(int id, PostFormViewModel postFormViewModel)
{
if (id != postFormViewModel.Id)
{
return(BadRequest());
}
if (ModelState.IsValid)
{
var user = await _unitOfWork.UserRepository.GetByClaimsPrincipal(HttpContext.User);
if (!await _unitOfWork.UserRepository
.IsUserAllowedForOperation(user, postFormViewModel.UserId, ConstantUserRoles.SuperAdmin))
{
return(Unauthorized());
}
var post = _mapper.Map <PostFormViewModel, Post>(postFormViewModel);
_unitOfWork.PostRepository.Update(post);
await _unitOfWork.Complete();
var files = HttpContext.Request.Form.Files;
if (files.Count > 0)
{
//Delete old file
_fileHandler.DeleteMedia(
_env.WebRootPath,
post.FilesPathGuid.ToString(),
FileHandlerFolder.Posts
);
//Upload new file
await _fileHandler.UploadMedia(
files,
_env.WebRootPath,
post.FilesPathGuid.ToString(),
FileHandlerFolder.Posts);
}
return(RedirectToAction(nameof(Index)));
}
ViewData["PostCategoryId"] = GetPostCategories();
return(View(postFormViewModel));
}
public IActionResult Create(PostFormViewModel vm)
{
try
{
vm.Post.CreateDateTime = DateAndTime.Now;
vm.Post.IsApproved = true;
vm.Post.UserProfileId = GetCurrentUserProfileId();
_postRepository.Add(vm.Post);
return(RedirectToAction("Details", new { id = vm.Post.Id }));
}
catch
{
vm.CategoryOptions = _categoryRepository.GetAll();
return(View(vm));
}
}
public async Task <IActionResult> Preview(PostFormViewModel model)
{
if (model == null)
{
return(new HttpStatusCodeResult((int)HttpStatusCode.BadRequest));
}
var vm = new PostPreviewViewModel()
{
Theme = this._settings.Theme,
HeadPartialViewPath = this._themeService.GetHeadPartialViewPath(this._settings.Theme),
HeaderPartialViewPath = this._themeService.GetHeaderPartialViewPath(this._settings.Theme),
PostPartialViewPath = this._themeService.GetPostPartialViewPath(this._settings.Theme),
FooterPartialViewPath = this._themeService.GetFooterPartialViewPath(this._settings.Theme),
};
var page = new PageSettings();
page.Title = "Hello World";
page.Description = "This is description";
page.Author = new Author()
{
Name = "joebloggs"
};
page.Date = DateTime.Today;
page.BaseUrl = this._settings.BaseUrl;
page.Url = "/posts/post.html";
page.Pages = new List <PageSettings>();
vm.Page = page;
var env = this.Resolver.GetService(typeof(IApplicationEnvironment)) as IApplicationEnvironment;
var loader = new ThemeLoader(this._settings, new FileHelper(this._settings));
var site = await loader.LoadAsync(env).ConfigureAwait(false);
vm.Site = site;
var parsedHtml = this._markdownHelper.Parse(model.Body);
vm.Html = parsedHtml;
return(this.View(vm));
}
