public async Task <IActionResult> Update([FromForm] UpdatePostDto updatePostDto)
{
UpdatePostViewModel updatePostViewModel = CustomMapper.GetUpdatePostViewModel(updatePostDto);
if (updatePostDto.PhotoFile != null)
{
var post = await _postService.GetById(updatePostDto.Id);
string existingFilePath = post.HeaderPhotoPath;
try
{
_fileService.UpdateLocalFile(updatePostDto.PhotoFile, existingFilePath);
}
catch (IOException) { }
}
var result = await _postService.Update(updatePostViewModel);
if (result.IsValid)
{
return(Ok());
}
return(BadRequest(result.Errors));
}
public ActionResult UpdatePost(UpdatePostViewModel model)
{
if (!ModelState.IsValid)
{
return(PartialView(model));
}
var image = model.Image;
byte[] fileBytes = {};
if (model.Image != null)
{
using (var ms = new MemoryStream())
{
image.CopyTo(ms);
fileBytes = ms.ToArray();
}
}
var isPostUpdated = _historyRepository.UpdatePost(new PostViewModel
{
PostId = model.PostId,
Title = model.Title,
Content = model.Content,
PostDate = model.PostDate,
TimePeriodId = model.SelectedPeriodId,
EventTypes = model.SelectedEventTypes ?? new List <int>(),
FigureTypes = model.SelectedFigureTypes ?? new List <int>(),
Image = Convert.ToBase64String(fileBytes)
});
return(Json(new { success = isPostUpdated }));
}
public IActionResult Update(Guid id, [Bind("Post,SelectedTags")] UpdatePostViewModel viewModel)
{
if (ModelState.IsValid)
{
var post = this.postRepository.GetById(id);
if (null != post && id == post.Id)
{
post.UpdateFrom(viewModel.Post);
this.postRepository.Update(post);
var postTags = this.postRepository.GetPostTags(id);
this.postRepository.Remove(postTags);
this.postRepository.SaveChanges();
foreach (var selectedTag in viewModel.SelectedTags)
{
var tag = this.tagRepository.GetById(Guid.Parse(selectedTag));
var postTag = new PostTag(post, tag);
this.postRepository.AddPostTag(postTag);
}
this.postRepository.SaveChanges();
return(RedirectToAction("List"));
}
else
{
return(NotFound());
}
}
else
{
return(View(viewModel));
}
}
public async Task <IActionResult> ConfirmEditPost(UpdatePostViewModel post)
{
var postDto = Mapper.Map <PostDto>(post);
postDto.User = User.CreateUserDto();
await _postManager.UpdatePost(postDto);
return(RedirectToAction("Index", "Home"));
}
public ActionResult EditPost(int id)
{
UpdatePostViewModel model = ModelMapper.ConvertToUpdatePostViewModel(_postService.Get(id));
ViewBag.CategoryList = ToSelectList(ModelMapper.ConvertToViewModel(_categoryService.GetAll(), true), model.Categories);
ViewBag.LabelList = ToSelectList(ModelMapper.ConvertToViewModel(_labelService.GetAll()), model.Labels);
return(View(model));
}
public ActionResult Update(UpdatePostViewModel modelForUpdate)
{
var validationText = modelForUpdate.MessageStringContent.Replace("script>", "text>");
var postDto = Mapper.Map <UpdatePostDto>(modelForUpdate);
postDto.MessageStringContent = validationText;
_postService.UpdatePost(postDto);
var topicId = _postService.GetTopicIdByPostId(modelForUpdate.PostId);
return(RedirectToAction("Item", "Topic", new { Id = topicId }));
}
public async Task <IActionResult> Edit(UpdatePostViewModel post)
{
var command = _mapper.Map <UpdatePostCommand>(post);
var result = await _mediator.Send(command);
if (result.Succeeded)
{
return(Ok(result));
}
return(BadRequest(result.ToString()));
}
public async Task Put(Guid id, [FromBody] UpdatePostDto updatePostDto)
{
var updatePostViewModel = new UpdatePostViewModel()
{
InitialPostId = id,
Text = updatePostDto.Text,
Title = updatePostDto.Title
};
await _postService.UpdatePostAsync(updatePostViewModel);
}
public async Task ConfirmEditPost_UpdateModel_Ok()
{
var model = new UpdatePostViewModel {
Id = 1, Title = "Test"
};
var user = _controller.SetupUser(1);
await _controller.ConfirmEditPost(model);
_postManager.Verify(repo => repo.UpdatePost(It.Is <PostDto>(blog =>
blog.Title == "Test" && blog.Id == 1 && blog.User.Id == user.Id)), Times.Once);
}
public async Task <IActionResult> EditPost(UpdatePostViewModel post)
{
var postDto = await _postManager.GetPost(post.Id);
if (postDto == null)
{
return(NotFound());
}
var model = Mapper.Map <UpdatePostViewModel>(postDto);
return(View(model));
}
public ActionResult EditPost(UpdatePostViewModel model)
{
try
{
model.CoverPhoto = model.PhotoFile == null? model.CoverPhoto : this.WriteToFile(model.PhotoFile);
_postService.Update(ModelMapper.ConvertToModel(model));
}
catch (Exception ex)
{
throw ex;
}
return(RedirectToAction(nameof(Index)));
}
public ActionResult Edit(UpdatePostViewModel model)
{
var post = GameGram.Domain.BLL.PostBLL.Find(model.Id);
if (post != null)
{
post.Caption = model.Caption;
post.Content = model.Content;
GameGram.Domain.BLL.PostBLL.Update(post);
}
return(RedirectToAction("Index"));
}
public IActionResult UpdatePost(int id)
{
ArtGalleryContext GetPost = new ArtGalleryContext();
UpdatePostViewModel EVM = new UpdatePostViewModel();
var TargetPost = GetPost.Post.Include(A => A.PostTags).ThenInclude(A => A.Tag).Include(A => A.Images).Where(A => A.PostId == id).FirstOrDefault();
var SlideImages = GetPost.Image.Where(A => A.PostId == id).Where(A => A.IsPrimary == false).ToList();
var file = GetPost.Files.Where(A => A.PostId == id).ToList();
EVM.Post = TargetPost;
EVM.ForEditSlideImages = SlideImages;
EVM.ForEditFile = file;
return(View(EVM));
}
public async Task <bool> ModifyPost(string CID, string PID, UpdatePostViewModel model)
{
var com = await GetCommunity(CID);
var post = com.Posts.SingleOrDefault(x => x.Id == PID);
com.Posts.Remove(post);
post.Title = model.Title;
post.Description = model.Description;
com.Posts.Add(post);
var result = await _Community.ReplaceOneAsync(x => x.Id == CID, com);
return(result.IsAcknowledged);
}
public IActionResult Update(Guid id)
{
var post = this.postRepository.GetById(id);
if (null != post)
{
var tags = this.tagRepository.GetAll();
var viewModel = new UpdatePostViewModel(post, tags);
return(View(viewModel));
}
else
{
return(NotFound());
}
}
public async void Update_Post_By_Id_Throws_Given_Dto_Values_Are_Empty()
{
IPostService postService = new PostService(_mockPostRepository.Object);
var initialPost = new Post(new Content(PostText), new Title(PostTitle), Guid.NewGuid());
UpdatePostViewModel viewModel = new UpdatePostViewModel
{
Text = "",
Title = null,
InitialPostId = initialPost.Id
};
await Assert.ThrowsAsync <ArgumentNullException>(async() => await postService.UpdatePostAsync(viewModel));
}
public ActionResult Edit(Guid?id)
{
var post = GameGram.Domain.BLL.PostBLL.Find(id);
if (post != null)
{
UpdatePostViewModel model = new UpdatePostViewModel()
{
Id = post.Id,
Caption = post.Caption,
Content = post.Content
};
return(View(model));
}
return(RedirectToAction("Add"));
}
// GET: Admin/Post/Edit/5
public async Task <ActionResult> Edit(Guid id)
{
var post = await db.Posts.FindAsync(id);
var model = new UpdatePostViewModel
{
Id = post.Id,
CategoryId = post.CategoryId,
PostContent = post.PostContent,
UserId = post.UserId,
PostTitle = post.PostTitle,
Decsription = post.Decsription
};
ViewBag.CategoryId = new SelectList(db.Categories, "Id", "CategoryName", model.CategoryId);
return(View(model));
}
public async Task <IActionResult> Edit(int?id)
{
var viewModel = new UpdatePostViewModel();
viewModel.SelCategories = (await _blogRepository.GetCategories()).ToList()
.Select(a => new SelectListItem()
{
Value = a.Name, //a.Id.ToString(),
Text = a.Name
}).DistinctBy(x => x.Text).ToList();
//viewModel.SelectedCategoriesIds = (await _blogRepository.GetCategories()).ToList().Select(x => x.Id).ToList();
ViewData["sidebar-collapse"] = true;
if (id == null)
{
viewModel.Post = new Post();
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier); // will give the user's userId
var userName = User.FindFirstValue(ClaimTypes.Name); // will give the user's userName
CustomUser applicationUser = await _userManager.GetUserAsync(User);
string userEmail = applicationUser?.Email; // will give the user's Email
viewModel.Post.CustomUser = applicationUser;
viewModel.Post.CustomUserId = userId;
return(View(viewModel));
}
var post = await _blogRepository.GetPostById(id.Value);
viewModel.SelectedCategories = post.Categories.Select(x => x.Name).ToList(); //(await _blogRepository.GetCategories()).ToList().Select(x => x.Name).ToList();
viewModel.Post = post;
if (post != null)
{
return(View(viewModel));
}
return(NotFound());
}
/// <summary>
/// Update post
/// </summary>
/// <param name="viewModel">post data</param>
/// <returns></returns>
public async Task UpdatePostAsync(UpdatePostViewModel viewModel)
{
Guard.Against.GuidEmpty(viewModel.InitialPostId, nameof(viewModel.InitialPostId));
Guard.Against.Null(viewModel, nameof(viewModel));
if (string.IsNullOrEmpty(viewModel.Text) && string.IsNullOrEmpty(viewModel.Title))
{
throw new ArgumentNullException("At least 1 value shouldn't be empty");
}
var post = await _postRepository.GetByIdAsync(viewModel.InitialPostId);
Guard.Against.PostNotExists(post, viewModel.InitialPostId);
post.Content.Text = viewModel.Text;
post.Title.Text = viewModel.Title;
await _postRepository.UpdateAsync(post);
}
public async Task <IActionResult> UpdatePost(UpdatePostViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View("Edit", viewModel));
}
var existing = await _blogRepository.GetPostById(viewModel.Post.Id) ?? viewModel.Post;
//string categories = Request.Form["categories"];
//var myCategories = categories.Split(",", StringSplitOptions.RemoveEmptyEntries).Select(c => c.Trim().ToLowerInvariant()).ToList();
existing.Categories.ToList().ForEach(x =>
{
existing.Categories.Remove(x);
});
if (viewModel.SelectedCategories != null)
{
foreach (string category in viewModel.SelectedCategories)
{
Category cat = new Category
{
Name = category
};
existing.Categories.Add(cat);
}
}
existing.Title = viewModel.Post.Title.Trim();
existing.Slug = !string.IsNullOrWhiteSpace(viewModel.Post.Slug) ? viewModel.Post.Slug.Trim() : Models.Post.CreateSlug(viewModel.Post.Title);
existing.IsPublished = viewModel.Post.IsPublished;
existing.Content = viewModel.Post.Content.Trim();
existing.Excerpt = viewModel.Post.Excerpt.Trim();
await SaveFilesToDisk(existing);
await _blogRepository.SavePost(existing);
return(Redirect(existing.GetEncodedLink()));
}
public async Task <ActionResult> Edit(UpdatePostViewModel model)
{
if (ModelState.IsValid)
{
var post = await db.Posts.FindAsync(model.Id);
post.PostContent = model.PostContent;
post.CategoryId = model.CategoryId;
post.UserId = User.Identity.GetUserId();
post.UpdatedDate = DateTime.Now;
post.PostTitle = model.PostTitle;
post.Decsription = model.Decsription;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewBag.CategoryId = new SelectList(db.Categories, "Id", "CategoryName", model.CategoryId);
return(View());
}
public async void Update_Post_By_Id_Throws_Post_Doesnot_Exist()
{
IPostService postService = new PostService(_mockPostRepository.Object);
var initialPost = new Post(new Content(PostText), new Title(PostTitle), Guid.NewGuid());
UpdatePostViewModel viewModel = new UpdatePostViewModel
{
Text = "New Text",
Title = "New Title"
};
Post post = new Post(new Content(PostText), new Title(PostTitle), Guid.NewGuid());
viewModel.InitialPostId = initialPost.Id;
_mockPostRepository.Setup(repo => repo.GetByIdAsync(It.Is <Guid>(id => id == post.Id))).ReturnsAsync(post);
_mockPostRepository.Setup(repo => repo.UpdateAsync(post)).Returns(Task.CompletedTask);
await Assert.ThrowsAsync <PostNotExistsException>(async() => await postService.UpdatePostAsync(viewModel));
}
public async Task <IActionResult> UpdatePost([FromForm] UpdatePostViewModel viewModel)
{
var callerId = await _authHelper.GetCallerId(_caller);
if (await _authHelper.CheckIfUserIsBanned(callerId))
{
return(new BadRequestObjectResult(
new
{
Message = "User currently bannend",
StatusCodes.Status403Forbidden
}));
}
var result = await _postRepository.UpdatePostAsync(new UpdatePost(viewModel, callerId));
var post = await _postRepository.GetPostById(viewModel.Id, callerId);
post.Files = await _postFilesUploadHelper.ReplacePostFiles(post.Files, viewModel.Files, post.Id);
await _filesRepository.UpdatePostImagesAsync(post.Files, post.Id);
if (result > 0)
{
return(new OkObjectResult(new
{
Message = " ai fost ba in stare sa faci un post klumea bine ba usere ba",
post,
result
}));
}
return(new BadRequestObjectResult(
new
{
result,
StatusCodes.Status403Forbidden
}));
}
public ActionResult AddPost()
{
var addPostViewModel = new UpdatePostViewModel
{
PeriodsList = _historyRepository.GetTimePeriods().Select(p => new SelectListItem
{
Text = p.Name,
Value = p.TimePeriodId.ToString()
}).ToList(),
FigureTypes = _historyRepository.GetFigureTypes().Select(p => new SelectListItem
{
Text = p.FigureTypeName,
Value = p.FigureTypeId.ToString()
}).ToList(),
EventTypes = _historyRepository.GetEventTypes().Select(p => new SelectListItem
{
Text = p.EventTypeName,
Value = p.EventTypeId.ToString()
}).ToList()
};
return(PartialView(addPostViewModel));
}
public ActionResult UpdatePost(int postId)
{
var post = _historyRepository.GetPostById(postId);
if (post == null)
{
return(Json(new { success = false }));
}
var addPostViewModel = new UpdatePostViewModel
{
PeriodsList = _historyRepository.GetTimePeriods().Select(p => new SelectListItem
{
Text = p.Name,
Value = p.TimePeriodId.ToString()
}).ToList(),
FigureTypes = _historyRepository.GetFigureTypes().Select(p => new SelectListItem
{
Text = p.FigureTypeName,
Value = p.FigureTypeId.ToString()
}).ToList(),
EventTypes = _historyRepository.GetEventTypes().Select(p => new SelectListItem
{
Text = p.EventTypeName,
Value = p.EventTypeId.ToString()
}).ToList(),
PostId = post.PostId,
Title = post.Title,
Content = post.Content,
SelectedPeriodId = post.TimePeriodId,
PostDate = post.PostDate,
SelectedEventTypes = post.EventTypes,
SelectedFigureTypes = post.FigureTypes
};
return(PartialView(addPostViewModel));
}
public IActionResult UpdatePost([FromRoute] int id, [FromBody] UpdatePostViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest("Bad request"));
}
var dbPost = _database.Posts.FirstOrDefault(x => x.Id == id);
if (dbPost == null)
{
return(BadRequest("Invalid....."));
}
if (dbPost.Deleted == true)
{
return(BadRequest("fdjkhfkjshdkf"));
}
dbPost.Status = model.Status;
_database.Posts.Update(dbPost);
_database.SaveChanges();
return(Ok(dbPost));
}
public async Task <IActionResult> ModifyPost([FromRoute] string CID, [FromRoute] string PID, [FromBody] UpdatePostViewModel post)
{
var result = await _MongocourseService.ModifyPost(CID, PID, post);
if (result)
{
return(Ok(new { status = 1, Message = "Successfully Modified" }));
}
return(BadRequest());
}
public IActionResult UpdatePost([FromBody] UpdatePostViewModel model)
{
var user = userRepository.GetApplicationUserByUsername(User.Identity.Name, true);
if (user == null)
{
return(Unauthorized());
}
var post = postRepository.GetPostByPostId(model.PostId, true, new string[] { "CurrentVersion", "PostTags", "ExternalFiles" });
if (post == null)
{
return(NotFound());
}
try {
bool errors = false;
if (model.CurrentVersion != null)
{
var postVersion = postRepository.GetPostVersionByPostVersionId((int)model.CurrentVersion);
if (postVersion == null)
{
errors = true;
ModelState.AddModelError("PostVersion", "PostVersion not found");
}
post.CurrentVersion = postVersion;
}
if (model.AliasSet)
{
post.Alias = model.Alias;
}
if (model.Published != null)
{
post.Published = (bool)model.Published;
if (post.FirstPublished == null)
{
post.FirstPublished = DateTime.Now;
}
}
if (model.List != null)
{
post.List = (bool)model.List;
}
if (model.PostTags != null)
{
var newTags = new List <PostTag>();
var allTags = tagRepository.GetTags().ToDictionary(x => x.TagId, x => x);
foreach (var tag in model.PostTags)
{
if (!allTags.ContainsKey(tag))
{
return(BadRequest());
}
newTags.Add(new PostTag()
{
PostId = post.PostId, TagId = tag
});
}
post.PostTags = newTags;
}
if (errors)
{
return(BadRequest(ModelStateHelper.GetModelStateErrors(ModelState)));
}
postRepository.UpdatePost(post);
return(Ok(Conversions.PostViewModelFromPost(post)));
}
catch (Exception) {
return(BadRequest());
}
}
public async Task <ValidationResult> Update(UpdatePostViewModel updatePostViewModel)
{
return(await _mediator.Send(
_mapper.Map <UpdatePostCommand>(updatePostViewModel)));
}
