public ActionResult Edit(EditPostViewModel post)
{
if (ModelState.IsValid)
{
_postRepository.EditPost(post);
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError("", "All fields, except image, should be filled!");
return(View(post));
}
public ViewResult Create()
{
EditPostViewModel model = new EditPostViewModel
{
Post = new Post(),
Categories = repository.Categories.ToList(),
Tags = repository.Tags.ToList()
};
return(View("Edit", model));
}
public async Task <IActionResult> EditPostContent(EditPostViewModel model)
{
var userId = _userManager.GetUserId(User);
var user = await _userManager.FindByIdAsync(userId);
var post = BuildPostEdit(model, user);
await _postService.EditPostContent(post);
return(RedirectToAction("Index", "Post", new { id = post.Id }));
}
//编辑博文
public async Task <int> UpdatePost(EditPostViewModel editPostViewModel)
{
var postEntity = _mapper.Map <PostEntity>(editPostViewModel);
postEntity.UpdateTime = DateTime.Now;
var entity = UpdateEntity(postEntity);
entity.Property(m => m.CreateTime).IsModified = false;
entity.Property(m => m.Content).IsModified = false;
return(await _UnitOfWork.SaveChangesAsync());
}
public async Task <IActionResult> EditPost(EditPostViewModel vm)
{
User user = await _userManager.GetUserAsync(HttpContext.User);
Post post = await _postRepository.GetById(vm.Post.Id);
post.Contents = vm.Contents;
await _postRepository.Update(post);
return(RedirectToAction("Topic", new { id = vm.Post.Topic.Id }));
}
public ActionResult EditPost(EditPostViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
m_Posts.UpdatePost(model.EncodedId, model.Title, model.Content);
TempData["Notification"] = "You successfully update your post.";
return(Redirect($"/Posts/Details/{model.EncodedId}"));
}
public ViewResult EditPost(int id)
{
var post = postRepository.Posts.Include(p => p.Channel).First(p => p.Id == id);
var model = new EditPostViewModel {
Post = post,
Channels = channelRepository.Channels.Where(c => c.Name != "Blank").OrderBy(c => c.Id).Include(c => c.Parent).ToHashSet(),
UserId = post.User == null ? 6 : post.User.Id,
ChannelId = post.Channel == null ? 1 : post.Channel.Id
};
return(View(model));
}
public ActionResult Edit(EditPostViewModel _post)
{
if (ModelState.IsValid)
{
var entity = _mapper.Map <PostModel>(_post);
_postManager.Update(entity);
return(Redirect(_post.ReturnUrl));
}
return(View(_post));
}
public async Task <IActionResult> Edit(EditPostViewModel model)
{
if (ModelState.IsValid)
{
/* Update topic of the post.
* We use `create` command instead of `update`,
* because one topic can relate to multiple posts (one-to-many relations)*/
var topicDTO = new TopicDTO {
Text = model.Topic
};
var topicCommand = new CreateTopicCommand {
Model = topicDTO
};
int topicId;
try
{
topicId = await _mediator.Send(topicCommand);
}
catch (RequestValidationException failures)
{
foreach (var error in failures.Failures)
{
ModelState.AddModelError(string.Empty, error.Value[0]);
}
return(View(model));
}
// Update post.
var postDTO = _mapper.Map <EditPostViewModel, PostDTO>(model);
postDTO.TopicId = topicId;
var postCommand = new UpdatePostCommand {
Model = postDTO
};
try
{
await _mediator.Send(postCommand);
}
catch (RequestValidationException failures)
{
foreach (var error in failures.Failures)
{
ModelState.AddModelError(string.Empty, error.Value[0]);
}
return(View(model));
}
return(RedirectToAction("Read", "Posts", new { id = postDTO.Id }));
}
return(View(model));
}
public async Task <IActionResult> EditPost(EditPostViewModel postvm)
{
var post = new Post
{
Id = postvm.Id,
Title = postvm.Title,
Introduction = postvm.Introduction,
Body = postvm.Body,
Description = postvm.Description,
Tags = postvm.Tags,
Featured = postvm.Featured,
CommentsAllowed = postvm.CommentsAllowed,
Slug = SlugGenerator.ToSlug(postvm.Title)
};
if (postvm.Image == null)
{
post.Image = postvm.CurrentImage;
}
else
{
if (!string.IsNullOrEmpty(postvm.CurrentImage))
{
_fileManager.RemovePostImage(postvm.CurrentImage);
}
post.Image = _fileManager.SavePostImage(postvm.Image);
}
if (post.Id > 0)
{
if (postvm.CategoryId != postvm.CurrentCategoryId)
{
var category = _repo.GetCategoryNoTracking(postvm.CategoryId);
post.Category = category;
}
post.CreatedDate = postvm.CreatedDate;
_repo.UpdatePost(post);
}
else
{
var category = _repo.GetCategory(postvm.CategoryId);
post.Category = category;
_repo.AddPost(post);
}
if (await _repo.SaveChangesAsync())
{
return(RedirectToAction("ManageBlog"));
}
else
{
return(View(post));
}
}
public async Task <IActionResult> Edit(EditPostViewModel model)
{
if (!this.ModelState.IsValid)
{
return(this.View(model));
}
var userId = this.userManager.GetUserId(this.User);
var parentUserProfile = this.postsService.GetUserByPostId(model.PostId);
await this.postsService.EditPost(model.PostId, model.Content, model.Title, userId);
return(this.Redirect($"/Profiles/Profile?id={parentUserProfile}"));
}
public async Task <IActionResult> EditPost(int id)
{
var post = await _context.Posts.Where(p => p.Id == id).FirstOrDefaultAsync();
var viewModel = new EditPostViewModel
{
Title = post.Title,
Content = post.Content,
IsVisible = post.IsVisible
};
return(View(viewModel));
}
public IActionResult EditPost(Guid id)
{
try
{
Post post = _forumsRepository.GetPostById(id);
EditPostViewModel model = _mapper.Map <Post, EditPostViewModel>(post);
return(View(model));
}
catch
{
return(View());
}
}
public EditPostViewModel BuildEditPostViewModel(int postId)
{
var post = _postRepository.GetPost(postId);
var model = new EditPostViewModel()
{
Id = post.Id,
Content = post.Content,
SubTitle = post.SubTitle,
Title = post.Title
};
return(model);
}
public async Task <IActionResult> PublishPost(EditPostViewModel model)
{
if (model?.Post == null)
{
throw new ArgumentNullException(nameof(model));
}
model.Post.LoadCategoriesFromString(Request.Form["Categories"]);
await Service.Publish(model.Post);
return(RedirectToAction("ViewPost", "Blog", new { model.Post.Permalink }));
}
public async Task <IActionResult> Edit(EditPostViewModel model)
{
if (!this.ModelState.IsValid)
{
this.TempData["InfoMessage"] = "Something went wrong!";
return(this.View(model));
}
await this.postService.EditPostAsync(model.Id, model.Title, model.Content);
this.TempData["InfoMessage"] = "Post successfully edited!";
return(this.RedirectToAction("DetailedPost", "Posts", new { id = model.Id }));
}
public ActionResult Add()
{
var viewModel = new EditPostViewModel()
{
Content = new ContentRegistrationPM()
{
Published = false,
},
Tags = new List <string>()
};
return(View("Edit", viewModel));
}
/// <summary>
/// Generate single edit post view model.
/// </summary>
/// <returns>Singel view model.</returns>
public EditPostViewModel GetEditPostViewModel()
{
var post = new EditPostViewModel()
{
Id = 1,
Text = "Text_One",
Title = "Title_One",
Topic = "Topic_One",
TopicId = 1,
};
return(post);
}
public void Given_valid_EditPostViewModel_When_Edit_Returns_Home_Index()
{
//Given
var model = new EditPostViewModel();
//When
var result = _postController.Edit(model) as RedirectToRouteResult;
//Then
Assert.NotNull(result);
Assert.AreEqual("Home", result.RouteValues["controller"].ToString());
Assert.AreEqual("Index", result.RouteValues["action"].ToString());
}
public virtual ActionResult EditPost(EditPostViewModel viewModel)
{
if (!this.ModelState.IsValid)
{
return(this.View(viewModel));
}
this.forumStorageWriter.UpdatePost(viewModel);
TopicPageRoutedata topicPage = this.forumStorageReader.GetRouteDataForPost(viewModel.TopicId, viewModel.PostIndex);
return(this.RedirectToPost(topicPage));
}
public async Task UpdateAsync(string id, EditPostViewModel input)
{
var post = this.postsRepository
.All()
.FirstOrDefault(x => x.Id == id);
post.Id = input.Id;
post.Title = input.Title;
post.Content = input.Content;
post.CategoryId = input.CategoryId;
post.ModifiedOn = DateTime.UtcNow;
await this.postsRepository.SaveChangesAsync();
}
private Post BuildPostEdit(EditPostViewModel model, ApplicationUser user)
{
var forum = _forumService.GetById(model.ForumId);
return(new Post
{
Id = model.PostId,
Title = model.Title,
Content = model.Content,
Created = DateTime.Now,
User = user,
Forum = forum
});
}
private EditPostViewModel GetEditPostViewModel(IEnumerable <string> categories, Post post = null)
{
var model = new EditPostViewModel
{
AllCategories = categories
};
if (post != null)
{
model.Post = post;
}
return(model);
}
public IActionResult EditPost(EditPostViewModel model)
{
try
{
Post post = _mapper.Map <EditPostViewModel, Post>(model);
_forumsRepository.UpdatePost(post);
_unitOfWork.Commit();
return(RedirectToAction(nameof(this.BrowseThreads)));
}
catch
{
return(View());
}
}
public ViewResult Edit(int postId)
{
var model = new EditPostViewModel
{
Post = repository.Posts
.FirstOrDefault(p => p.PostId == postId),
Categories = repository.Categories,
Tags = repository.Tags.OrderBy(tag => tag.Name)
};
return(View(model));
}
public void Given_inValid_EditPostViewModel_When_Edit_Returns_Edit_View()
{
//Given
var model = new EditPostViewModel();
_postController.ModelState.AddModelError(string.Empty, "There is an error with your model, boy!");
//When
var result = _postController.Edit(model) as ViewResult;
//Then
Assert.NotNull(result);
Assert.IsInstanceOf <EditPostViewModel>(result.Model);
Assert.AreEqual(String.Empty, result.ViewName);
}
public ActionResult Edit(EditPostViewModel viewModel)
{
if (viewModel.Content.Id.HasValue)
{
BlogService.EditPost(viewModel.Content, viewModel.Tags);
}
else
{
viewModel.Content.AuthorId = User.UserId;
BlogService.AddPost(User.Blogs.First().Id, viewModel.Content, viewModel.Tags);
}
return(Json(new ProcessResult(new { ContentId = viewModel.Content.Id })));
}
public async Task <ActionResult> Edit(string boton, EditPostViewModel viewModel)
{
if (boton.ToLower().Contains("modificar publicación"))
{
return(RedirectToAction("Publicar", new { id = viewModel.EditorPost.Id }));
}
if (ModelState.IsValid)
{
await ActualizarPost(viewModel.EditorPost);
return(RedirectToAction("Details", new { id = viewModel.EditorPost.Id }));
}
return(View(viewModel));
}
public ActionResult EditPost(EditPostViewModel post, int id)
{
if (post != null && this.ModelState.IsValid)
{
var databasePost = this.posts.GetById(id);
databasePost.PostType = post.PostType;
databasePost.Title = post.Title;
databasePost.Content = post.Content;
var pet = this.pets.GetById(post.PetId);
pet.PetType = post.Pet.PetType;
pet.Name = post.Pet.Name;
pet.Age = post.Pet.Age;
pet.Description = post.Pet.Description;
pet.Color = post.Pet.Color;
var location = this.locations.GetById(post.LocationId);
location.City = post.Location.City;
location.Street = post.Location.Street;
location.AdditionalInfo = post.Location.AdditionalInfo;
if (post.UploadedImage != null)
{
using (var memory = new MemoryStream())
{
post.UploadedImage.InputStream.CopyTo(memory);
var content = memory.GetBuffer();
var image = new Photo
{
Content = content,
FileExtension = post.UploadedImage.FileName.Split(new[] { '.' }).Last()
};
this.images.Update();
databasePost.Gallery.Add(image);
}
}
this.pets.Update();
this.locations.Update();
this.posts.Update();
this.TempData["Notification"] = "Post Edited Succesfully!";
return(this.RedirectToAction("AllByUser"));
}
return(this.View(post));
}
public async Task <IActionResult> EditPostAsync(EditPostViewModel model)
{
try
{
var post = await _postService.GetAsync(new Guid(model.PostId));
post.Message = model.Message;
await _postService.EditAsync(post);
}
catch (Exception ex)
{
throw ex;
}
return(RedirectToAction("ViewPost", new { postId = model.PostId }));
}
public ActionResult EditPost(EditPostViewModel model)
{
if (!this.ModelState.IsValid)
{
return this.View(model);
}
this.posts.UpdatePost(model.EncodedId, model.Title, model.Content);
this.TempData["Notification"] = "You successfully update your post.";
return this.Redirect($"/Posts/Details/{model.EncodedId}");
}
public ActionResult Edit(EditPostViewModel postViewModel)
{
String nameFieldWithImageName = "Task.ImageName";
String fullPath = String.Empty;
String fileName = String.Empty;
if (ModelState.IsValid)
{
HttpPostedFileBase postedFileBase = null;
if (Request.Files.Count != 0 && Request.Files[0].FileName != String.Empty)
{
postedFileBase = Request.Files[0];
if (!AvailableExtensions.Any(x => x.Contains(Path.GetExtension(postedFileBase.FileName))))
{
ModelState.AddModelError(nameFieldWithImageName, "File has invalid extension");
}
else
{
fileName = String.Format("{0}{1}", Guid.NewGuid(), Path.GetExtension(postedFileBase.FileName));
fullPath = Path.Combine(Server.MapPath(PathImages), fileName);
}
}
if (ModelState.IsValid)
{
try
{
if (postedFileBase != null)
{
if (postViewModel.Task.TaskId != 0)
{
String nameOldImage = _todoService.GetTaskById(postViewModel.Task.TaskId).ImageName;
String oldFilePath = String.Format("{0}{1}", Server.MapPath(PathImages), nameOldImage);
if (System.IO.File.Exists(oldFilePath))
{
System.IO.File.Delete(oldFilePath);
}
}
postedFileBase.SaveAs(fullPath);
postViewModel.Task.ImageName = fileName;
}
else
{
//if Add new task without image - ImageName=null
//else old imagename
postViewModel.Task.ImageName = postViewModel.Task.TaskId == 0 ? null : _todoService.GetTaskById(postViewModel.Task.TaskId).ImageName;
}
if (postViewModel.Task.TaskId == 0)
{
_todoService.AddTask(postViewModel.Task, postViewModel.TaskTagsId);
}
else
{
_todoService.UpdateTask(postViewModel.Task, postViewModel.TaskTagsId);
}
return RedirectToAction("Index", new { state = "success" });
}
catch (FileLoadException)
{
ModelState.AddModelError(nameFieldWithImageName, "File is not loaded");
}
catch (DirectoryNotFoundException)
{
ModelState.AddModelError(nameFieldWithImageName, "DirectoryNotFound");
}
}
}
EditViewModel viewModel = new EditViewModel();
viewModel.Performers = _todoService.GetPerformerList().ToList();
viewModel.Statuses = _todoService.GetStatusList().ToList();
viewModel.Priorities = _todoService.GetPriorityList().ToList();
viewModel.Tags = _todoService.GetTagList().ToList();
viewModel.Task = postViewModel.Task;
viewModel.PathToImage = Url.Content(PathImages);
viewModel.TagsSelected = postViewModel.TaskTagsId;
return View(viewModel);
}
