public IActionResult GoToPost(int id)
{
PostAndUpdateViewModel realmodel = new PostAndUpdateViewModel();
PostViewModel realpostmodel = new PostViewModel();
PostUpdateViewModel realupdatemodel = new PostUpdateViewModel();
List <Post> DBPosts = postDB.GetPosts();
List <Post> IDPosts = DBPosts.Where(x => x.id == id).ToList();
Post currentmodel = IDPosts[0];
realpostmodel.id = currentmodel.id;
realpostmodel.title = currentmodel.title;
realpostmodel.description = currentmodel.description;
realpostmodel.tag = currentmodel.tag;
realpostmodel.image = currentmodel.image;
List <PostUpdate> DBUpdatePosts = postDB.GetUpdatePosts();
List <PostUpdate> IDUpdatePosts = DBUpdatePosts.Where(x => x.postID == id).ToList();
PostUpdate currentupdatemodel = DBUpdatePosts[0];
realupdatemodel.id = currentupdatemodel.id;
realupdatemodel.postID = currentupdatemodel.postID;
realupdatemodel.title = currentupdatemodel.title;
realupdatemodel.description = currentupdatemodel.description;
realupdatemodel.image = currentupdatemodel.image;
List <PostUpdateViewModel> RealUpdateList = new List <PostUpdateViewModel>();
RealUpdateList.Add(realupdatemodel);
realmodel.postupdate = IDUpdatePosts;
realmodel.post = realpostmodel;
return(View("~/Views/Post/ViewPost.cshtml", realmodel));
}
public IActionResult Update(PostUpdateViewModel model)
{
if (ModelState.IsValid)
{
var post = _postService.GetPostById(model.Id);
if (post != null)
{
// Update post parameters
post.Title = model.Title;
post.PostContent = model.PostContent;
post.CategoryId = model.CategoryId;
// Control Model's image to update post
if (model.Image != null)
{
post.ImageUrl = UploadPostImage(model.Image);
}
_postService.Update(post);
TempData["Message"] = "Paylaşım başarıyla güncellendi";
TempData["MessageState"] = "warning";
return(RedirectToAction("Posts", "Admin"));
}
TempData["Message"] = "Paylaşım bulunamadı";
TempData["MessageState"] = "danger";
return(RedirectToAction("Posts", "Admin"));
}
TempData["Message"] = "Güncelleme işlemi yapılırken bir hata oluştu !";
TempData["MessageState"] = "danger";
return(RedirectToAction("Posts", "Admin"));
}
public async Task <IActionResult> CreateUpdatePost(PostUpdateViewModel update)
{
PostUpdate realupdate = new PostUpdate();
try
{
if (ModelState.IsValid)
{
var uploads = Path.Combine(_environment.WebRootPath, "PostImages");
foreach (var file in update.files)
{
realupdate.image = file.FileName;
if (file.Length > 0)
{
using (var fileStream = new FileStream(Path.Combine(uploads, file.FileName), FileMode.Create))
{
await file.CopyToAsync(fileStream);
}
}
}
realupdate.postID = update.postID;
realupdate.title = update.title;
realupdate.description = update.description;
string resp = postDB.UpdatePost(realupdate);
}
}
catch (Exception ex)
{
TempData["msg"] = ex.Message;
}
return(RedirectToAction("Index", "Home"));
}
public async Task Update(ApplicationUserEntity applicationUserCurrent, PostUpdateViewModel postCreateEditViewModel, PostEntity lastPostEntity = null)
{
lastPostEntity = (lastPostEntity == null) ? repositoryOfPost.Read(a => a.Id == postCreateEditViewModel.PostId, a => a.Tags, a => a.UserProfile, a => a.Images) : lastPostEntity;
var postEntity = mapper.Map <PostUpdateViewModel, PostEntity>(postCreateEditViewModel);
if (!await serviceOfUser.IsThereAccess(new[] { 2, 3 }, applicationUserCurrent, lastPostEntity.UserProfile.ApplicationUserId, true))
{
return;
}
if (postCreateEditViewModel.Section != null)
{
var section = repositoryOfSection.Read(a => a.Name == postCreateEditViewModel.Section);
postEntity.Section = section;
postEntity.SectionId = section.Id;
}
if (postEntity.IsFinished == false && lastPostEntity.IsFinished == true)
{
postEntity.IsFinished = true;
}
postEntity.CountOfScore = lastPostEntity.CountOfScore;
postEntity.SumOfScore = lastPostEntity.SumOfScore;
postEntity.Created = lastPostEntity.Created;
postEntity.Tags = serviceOfTag.TagsPostUpdate(postCreateEditViewModel.Tags, lastPostEntity.Tags, postCreateEditViewModel.PostId);
repositoryOfPost.Update(postEntity);
}
public IActionResult Update(int postId)
{
var post = _postService.GetPostById(postId);
if (post != null)
{
var categories = _categoryService.GetAll();
var model = new PostUpdateViewModel
{
Id = postId,
Title = post.Title,
PostContent = post.PostContent,
CategoryId = post.CategoryId,
Categories = categories,
ImageUrl = post.ImageUrl
};
return(View(model));
}
TempData["Message"] = "Paylaşım bulunamadı !";
TempData["MessageState"] = "danger";
return(RedirectToAction("Posts", "Admin"));
}
public async Task <IActionResult> Update([FromBody] PostUpdateViewModel postCreateEditViewModel)
{
var userId = User.Claims.SingleOrDefault(a => a.Type == "UserId").Value;
await serviceOfPost.Update(userId, postCreateEditViewModel);
return(Ok());
}
public void Update(PostUpdateViewModel model)
{
var post = _dbContext.Posts.First(p => p.PostId == model.PostId);
post.PostTitle = model.PostTitle;
post.PostBody = model.PostBody;
_dbContext.SaveChanges();
}
public async Task <JsonResult> Create(PostUpdateViewModel post)
{
var userId = User.Claims.SingleOrDefault(a => a.Type == "UserId").Value;
post = await serviceOfPost.Create(userId, post);
return(Json(post));
}
public ActionResult Update(int postId)
{
var model = new PostUpdateViewModel()
{
Post = _postService.GetById(postId),
Categories = _categoryService.GetList(),
Authors = _authorService.GetList()
};
return(View(model));
}
public async Task <IActionResult> PutPost(int id, PostUpdateViewModel model)
{
if (id != model.Id)
{
return(BadRequest());
}
var post = await _context.Posts.Include(p => p.Tags).FirstOrDefaultAsync(p => p.Id == id);
if (post == null)
{
return(NotFound());
}
post.Title = model.Title;
post.Slug = model.Slug;
post.Summary = model.Summary;
post.Body = model.Body;
post.IsPublished = model.IsPublished;
foreach (var tag in post.Tags)
{
_context.PostTags.Remove(tag);
}
foreach (var t in model.Tags)
{
var postTag = new PostTag()
{
PostId = post.Id, TagId = t
};
_context.PostTags.Add(postTag);
}
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PostExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Update(PostUpdateViewModel postUpdateViewModel)
{
if (ModelState.IsValid)
{
bool isNewThumbnailUploaded = false;
var oldThumbnail = postUpdateViewModel.Thumbnail;
if (postUpdateViewModel.ThumbnailFile != null)
{
var uploadedImageResult = await ImageHelper.Upload(postUpdateViewModel.Title,
postUpdateViewModel.ThumbnailFile, PictureType.Post);
postUpdateViewModel.Thumbnail = uploadedImageResult.ResultStatus == ResultStatus.Success
? uploadedImageResult.Data.FullName
: "postImages/defaultThumbnail.jpg";
if (oldThumbnail != "postImages/defaultThumbnail.jpg")
{
isNewThumbnailUploaded = true;
}
}
var postUpdateDto = Mapper.Map <PostUpdateDto>(postUpdateViewModel);
var result = await _postService.UpdateAsync(postUpdateDto, LoggedInUser.UserName);
if (result.ResultStatus == ResultStatus.Success)
{
if (isNewThumbnailUploaded)
{
ImageHelper.Delete(oldThumbnail);
}
_toastNotification.AddSuccessToastMessage(result.Message, new ToastrOptions
{
Title = "Başarılı İşlem!"
});
return(RedirectToAction("Index", "Post"));
}
else
{
ModelState.AddModelError("", result.Message);
}
}
var categories = await _categoryService.GetAllByNoneDeletedAndActiveAsync();
postUpdateViewModel.Categories = categories.Data.Categories;
return(View(postUpdateViewModel));
}
public async Task<IActionResult> UpdatePost(int id, [FromBody] PostUpdateViewModel postUpdate) {
if (postUpdate == null)
return BadRequest();
if (!ModelState.IsValid)
return new MyUnprocessableEntityObjectResult(ModelState);
var post = await _postRepository.GetPostByIdAsync(id);
if (post == null)
return NotFound();
post.LastModified = DateTime.Now;
_mapper.Map(postUpdate, post);
if(!await _unitOfWork.SaveAsync())
{
throw new Exception($"Updating post {id} failed when saving");
}
return NoContent();
}
public IActionResult UpdatePost(int id, PostUpdateViewModel update)
{
update.postID = id;
return(View("UpdatePost", update));
}
public async Task Update(string applicationUserIdCurrent, PostUpdateViewModel postCreateEditViewModel, PostEntity lastPostEntity = null)
{
var applicationUserCurrent = repositoryOfApplicationUser.Read(a => a.Id == applicationUserIdCurrent, a => a.UserProfile);
await Update(applicationUserCurrent, postCreateEditViewModel, lastPostEntity);
}
public async Task <PostUpdateViewModel> Create(string applicationUserIdCurrent, PostUpdateViewModel postCreateEditViewModel)
{
var newPost = await Create(applicationUserIdCurrent, false);
postCreateEditViewModel.PostId = newPost.Id;
await Update(applicationUserIdCurrent, postCreateEditViewModel, newPost);
var post = repositoryOfPost.Read(a => a.Id == postCreateEditViewModel.PostId,
a => a.Tags,
a => a.Comments,
a => a.Section,
a => a.UserProfile);
return(GetViewModelWithProperty("PostUpdateViewModel", post, applicationUserIdCurrent) as PostUpdateViewModel);
}
public void Put(long id, [FromBody] PostUpdateViewModel model)
{
_postService.Update(model);
}
