public JsonResult AddCategory([FromBody] PostCategoryViewModel postCateVm)
{
bool stt = false;
string msg = string.Empty;
var comment = postCategoryService.Add(postCateVm);
if (comment == null)
{
msg = "<div class='alert alert-success'>Add thất bại</div>";
}
else
{
stt = true;
msg = "<div class='alert alert-success'>Add thành công</div>";
}
postCategoryService.Save();
return(Json(new
{
status = stt,
message = msg
}));
}
public HttpResponseMessage Create(HttpRequestMessage request, PostCategoryViewModel postCategoryVm)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
PostCategory newPostCategory = new PostCategory();
newPostCategory.UpdatePostCategory(postCategoryVm);
newPostCategory.CreatedDate = DateTime.Now;
var category = _postCategoryService.Add(newPostCategory);
_postCategoryService.Save();
var responseData = Mapper.Map <PostCategory, PostCategoryViewModel>(newPostCategory);
response = request.CreateResponse(HttpStatusCode.Created, responseData);
}
return response;
}));
}
public HttpResponseMessage Update(HttpRequestMessage request, PostCategoryViewModel postCategoryVm)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
var dbPostCategory = _postCategoryService.GetById(postCategoryVm.ID);
dbPostCategory.UpdatePostCategory(postCategoryVm);
dbPostCategory.UpdatedDate = DateTime.Now;
_postCategoryService.Update(dbPostCategory);
_postCategoryService.Save();
var responseData = Mapper.Map <PostCategory, PostCategoryViewModel>(dbPostCategory);
response = request.CreateResponse(HttpStatusCode.Created, dbPostCategory);
}
return response;
}));
}
public HttpResponseMessage Put(HttpRequestMessage request, PostCategoryViewModel postCategoryVM)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
var postCategoryDb = _postCategoryService.GetById(postCategoryVM.ID);
postCategoryDb.UpdatePostCategory(postCategoryVM);
postCategoryDb.UpdatedDate = DateTime.Now;
postCategoryDb.UpdatedBy = User.Identity.Name;
_postCategoryService.Update(postCategoryDb);
_postCategoryService.SaveChanges();
response = request.CreateResponse(HttpStatusCode.OK);
}
return response;
}));
}
public HttpResponseMessage Post(HttpRequestMessage request, PostCategoryViewModel postCategoryVm)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (ModelState.IsValid)
{
request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
PostCategory newPostCategory = new PostCategory();
newPostCategory.UpdatePostCategory(postCategoryVm);
var category = _postCategoryService.Add(newPostCategory);
_postCategoryService.Save();
response = request.CreateResponse(HttpStatusCode.Created, category);
}
return response;
}));
}
public static void UpdatePostCategory(this PostCategory postCategory, PostCategoryViewModel postCategoryViewModel)
{
postCategory.ID = postCategoryViewModel.ID;
postCategory.Name = postCategoryViewModel.Name;
postCategory.Alias = postCategoryViewModel.Alias;
postCategory.Description = postCategoryViewModel.Description;
postCategory.ParentID = postCategoryViewModel.ParentID;
postCategory.DisplayOrder = postCategoryViewModel.DisplayOrder;
postCategory.Image = postCategoryViewModel.Image;
postCategory.HomeFlag = postCategoryViewModel.HomeFlag;
postCategory.CreatedDate = postCategoryViewModel.CreatedDate;
postCategory.CreatedBy = postCategoryViewModel.CreatedBy;
postCategory.UpdatedDate = postCategoryViewModel.UpdatedDate;
postCategory.UpdatedBy = postCategoryViewModel.UpdatedBy;
postCategory.MetaKeyword = postCategoryViewModel.MetaKeyword;
postCategory.MetaDescription = postCategoryViewModel.MetaDescription;
postCategory.Status = postCategoryViewModel.Status;
}
public HttpResponseMessage Put(HttpRequestMessage request, PostCategoryViewModel postCategoryVm)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (ModelState.IsValid)
{
request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
var postCategoryDb = _postCategoryService.GetById(postCategoryVm.ID);
postCategoryDb.UpdatePostCategory(postCategoryVm);
_postCategoryService.Update(postCategoryDb);
_postCategoryService.Save();
response = request.CreateResponse(HttpStatusCode.OK);
}
return response;
}));
}
public HttpResponseMessage Post(HttpRequestMessage request, PostCategoryViewModel postCategoryViewModel)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (ModelState.IsValid)
{
//xuất ra lỗi
request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
else //nếu thành công thì thêm đối tượng
{
PostCategory newPostCategory = new PostCategory(); //tạo 1 đối tượng PostCategory
newPostCategory.UpdatePostCategory(postCategoryViewModel); //copy tất cả giá trị của postCategoryViewModel sang newPostCategory
var category = _postCategoryService.Add(newPostCategory);
_postCategoryService.Save();
response = request.CreateResponse(HttpStatusCode.Created, category);
}
return response;
}));
}
public HttpResponseMessage Update(HttpRequestMessage requestMessage, PostCategoryViewModel postCategoryViewModel)
{
return(CreateHttpResponse(requestMessage, () =>
{
HttpResponseMessage responseMessage = null;
if (!ModelState.IsValid)
{
responseMessage = requestMessage.CreateResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
PostCategory postCategory = _postCategoryService.GetById(postCategoryViewModel.ID);
postCategory.UpdatePostCategory(postCategoryViewModel);
postCategory.UpdatedDate = DateTime.Now;
postCategory.UpdatedBy = User.Identity.Name;
_postCategoryService.Update(postCategory);
_postCategoryService.Save();
var responseData = Mapper.Map <PostCategory, PostCategoryViewModel>(postCategory);
responseMessage = requestMessage.CreateResponse(HttpStatusCode.Created, responseData);
}
return responseMessage;
}));
}
public IActionResult Update([FromBody] PostCategoryViewModel model)
{
if (!ModelState.IsValid)
{
var errors = ModelState.ToDictionary(x => x.Key, x => x.Value.Errors.Select(e => e.ErrorMessage).ToList())
.Select(x => new ValidationResponse()
{
Key = x.Key,
Validations = x.Value
});
return(BadRequest(errors));
}
return(DoActionWithReturnResult(() =>
{
bool isUpdate = _postCategoryService.Update(model, CurrentUserId);
if (isUpdate)
{
_postCategoryService.Save();
}
return Json(isUpdate);
}));
}
public HttpResponseMessage Put(HttpRequestMessage request, PostCategoryViewModel postCategoryViewModel)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (ModelState.IsValid)
{
//xuất ra lỗi
request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
else //nếu thành công thì thêm đối tượng
{
var postCategoryDb = _postCategoryService.GetById(postCategoryViewModel.ID);
postCategoryDb.UpdatePostCategory(postCategoryViewModel);
_postCategoryService.Update(postCategoryDb);
_postCategoryService.Save();
response = request.CreateResponse(HttpStatusCode.OK);
}
return response;
}));
}
public PartialViewResult CategoryPartial()
{
var categories = categoryService.GetByStatus();
var postCategoryViewModels = new List <PostCategoryViewModel>();
foreach (var item in categories)
{
var postCategoryViewModel = new PostCategoryViewModel();
var postViewModels = new List <PostViewModel>();
postCategoryViewModel.CategoryId = item.CategoryId;
postCategoryViewModel.CategoryName = item.CategoryName;
var posts = postService.GetByCategoryId(item.CategoryId);
foreach (var i in posts)
{
var postViewModel = new PostViewModel();
//postViewModel.PostId = i.PostId;
//postViewModel.CategoryId = i.CategoryId;
//postViewModel.Caption = i.Caption;
//postViewModel.Image = i.Image;
//postViewModel.CreatedBy = i.CreatedBy;
//postViewModel.CreatedTime = i.CreatedTime;
//postViewModel.Comments = i.Comments;
//postViewModel.Likes = i.Likes;
postViewModel = Mapper.Map <PostViewModel>(i);
//foreach (var j in postViewModel.Comments)
//{
// j.User = userService.GetById(Convert.ToInt32(j.CreatedBy));
//}
postViewModel.User = userService.GetById(Convert.ToInt32(i.CreatedBy));
postViewModels.Add(postViewModel);
}
postCategoryViewModel.Posts = postViewModels;
postCategoryViewModels.Add(postCategoryViewModel);
}
return(PartialView("_CategoryPartial", postCategoryViewModels));
}
// GET: Post
public ActionResult Index(int id, int page = 1)
{
int pageSize = 2;
int totalRow = 0;
PostCategory postCategoryDb = _postCategoryService.GetByID(id);
PostCategoryViewModel postCategoryVm = Mapper.Map <PostCategoryViewModel>(postCategoryDb);
ViewBag.Category = postCategoryVm;
IEnumerable <Post> listPostDb = _postService.GetByCategoryPaging(id, page, pageSize, out totalRow);
IEnumerable <PostViewModel> listPostVm = Mapper.Map <IEnumerable <PostViewModel> >(listPostDb);
int totalPage = (int)Math.Ceiling((double)totalRow / pageSize);
PaginationClient <PostViewModel> pagination = new PaginationClient <PostViewModel>()
{
PageIndex = page,
PageDisplay = Common.CommonConstant.PageDisplay,
PageSize = pageSize,
TotalPage = totalPage,
TotalRows = totalRow,
Items = listPostVm,
};
return(View(pagination));
}
public IActionResult Put(int id, [FromBody] PostCategoryViewModel value)
{
if (ModelState.IsValid)
{
var existingCategory = this.dbContext.PostCategories.Find(id);
if (existingCategory == null)
{
return(NotFound());
}
else
{
existingCategory.UserId = User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier).Value;;
existingCategory.Title = value.Title;
existingCategory.Description = value.Description;
this.dbContext.PostCategories.Update(existingCategory);
this.dbContext.SaveChanges();
return(Ok());
}
}
else
{
return(BadRequest());
}
}
public async Task <ActionResult <Category> > PostCategory(PostCategoryViewModel model)
{
var category = new Category()
{
CategoryId = Guid.NewGuid(),
Name = model.Name,
ProductCounter = 0
};
_context.Category.Add(category);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
var getCategoryViewModel = new GetCategoryViewModel(category);
return(CreatedAtAction("GetCategory", new { id = category.CategoryId }, getCategoryViewModel));
}
public static void UpdatePostCategory(this PostCategory postCategory, PostCategoryViewModel postCategoryVm)
{
/** public int ID { set; get; }
* public string Name { set; get; }
* public string Alias { set; get; }
* public string Description { set; get; }
* public int? ParentID { set; get; }
* public int? DisplayOrder { set; get; }
* public string Image { set; get; }
* public bool? HomeFlag { set; get; }
*
* DateTime? CreatedDate { set; get; }
* string CreatedBy { set; get; }
* DateTime? UpdatedDate { set; get; }
* string UpdatedBy { set; get; }
* string MetaKeyword { set; get; }
* string MetaDescription { set; get; }
* bool Status { set; get; }*/
postCategory.ID = postCategoryVm.ID;
postCategory.Name = postCategoryVm.Name;
postCategory.Alias = postCategoryVm.Alias;
postCategory.Description = postCategoryVm.Description;
postCategory.ParentID = postCategoryVm.ParentID;
postCategory.DisplayOrder = postCategoryVm.DisplayOrder;
postCategory.Image = postCategoryVm.Image;
postCategory.HomeFlag = postCategoryVm.HomeFlag;
postCategory.CreatedDate = postCategoryVm.CreatedDate;
postCategory.CreatedBy = postCategoryVm.CreatedBy;
postCategory.UpdatedDate = postCategoryVm.UpdatedDate;
postCategory.UpdatedBy = postCategoryVm.CreatedBy;
postCategory.MetaKeyword = postCategoryVm.MetaKeyword;
postCategory.MetaDescription = postCategoryVm.MetaDescription;
postCategory.Status = postCategoryVm.Status;
}
public HttpResponseMessage Put(HttpRequestMessage request, PostCategoryViewModel postCategoryVM)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (ModelState.IsValid)
{
request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
//get id postCategory
var postCategoryDB = _postCategoryService.GetId(postCategoryVM.ID);
//call update method
postCategoryDB.UpdatePostCategory(postCategoryVM);
_postCategoryService.Update(postCategoryDB);
//save change
_postCategoryService.Save();
//status request
response = request.CreateResponse(HttpStatusCode.OK);
}
return response;
}));
}
public ActionResult SavePost(PostCategoryViewModel vm, HttpPostedFileBase file, string newItem = null)
{
#region Spam Detextion
if (SpamDetector.IsContentSpam(vm.Post.Title))
{
return(RedirectToAction("Index", "Post"));
}
#endregion
#region GetUserAndSaveUserImage
//Verify whether user has neccessary data
ApplicationUser user = null;
string id = User.Identity.GetUserId();
if (id != string.Empty && id != null)
{
user = context.Users.Where(a => a.Id == id).First();
}
int idd = vm.Post.PostId;
var post = vm.Post;
if (file != null && file.ContentLength > 0)
{
if (Path.GetExtension(file.FileName).ToLower() == ".jpg" || Path.GetExtension(file.FileName).ToLower() == ".png")
{
var sourceImage = Image.FromStream(file.InputStream);
sourceImage = ResizeImage(sourceImage, 500, 500);
//Generowanie plik
var fileExt = Path.GetExtension(file.FileName);
var filename = Guid.NewGuid() + fileExt; // Unikalny identyfikator + rozszerzenie
//W jakim folderze ma byc umiesczony dany plik oraz jego nazwa! Oraz zapis
var path = Path.Combine(Server.MapPath(AppConfig.ImagesPostFolder), filename);
//file.SaveAs(path);
sourceImage.Save(path);
post.MainPicture = filename;
}
}
else if (file == null && newItem != null && newItem != String.Empty)
{
var fractImg = FractalGenerator.GenereateFractal1(user.Email);
var filename = Guid.NewGuid() + ".jpg";
var path = Path.Combine(Server.MapPath(AppConfig.ImagesPostFolder), filename);
fractImg.Save(path);
post.MainPicture = filename;
}
#endregion
#region Sentimental Analisys
var sentimentalInt = new SentimentalInterpreter();
var isContentHappy = sentimentalInt.IsHappy(post.Title);
if (isContentHappy)
{
post.IsHappy = true;
}
#endregion
post.DateOfInsert = DateTime.Now;
post.UserId = user.Id;
post.User = user;
if (user.Posts.Where(a => a.PostId == post.PostId).Count() == 0)
{
user.Posts.Add(post);
}
context.Posts.AddOrUpdate(post);
context.SaveChanges();
//InsertOrUpdate(post);
return(RedirectToAction("Post", "Manage"));
}
public async Task <IActionResult> Post(PostCategoryViewModel postCategoryViewModel)
{
await _postCategoryService.CreateEntity(postCategoryViewModel);
return(CreatedAtRoute("GetPostCategory", new { id = postCategoryViewModel.Id }, postCategoryViewModel));
}
public void Update(PostCategoryViewModel postCategoryVm)
{
var postCategory = Mapper.Map <PostCategoryViewModel, PostCategory>(postCategoryVm);
_postCategoryRepository.Update(postCategory);
}
public PostCategoryViewModel UpdatePostCategory(PostCategoryViewModel model)
{
throw new NotImplementedException();
}
/// <summary>
/// The CopyFromPostCategoryViewModel
/// </summary>
/// <param name="postCategory">The postCategory<see cref="PostCategory"/></param>
/// <param name="postCategoryViewModel">The postCategoryViewModel<see cref="PostCategoryViewModel"/></param>
public static void CopyFromPostCategoryViewModel(this PostCategory postCategory, PostCategoryViewModel postCategoryViewModel)
{
postCategory.Name = postCategoryViewModel.Name;
postCategory.Alias = postCategoryViewModel.Alias;
postCategory.Description = postCategoryViewModel.Description;
postCategory.Image = postCategoryViewModel.Image;
postCategory.MetaDescription = postCategoryViewModel.MetaDescription;
postCategory.MetaKeyword = postCategoryViewModel.MetaKeyword;
postCategory.Status = postCategoryViewModel.Status;
postCategory.HomeFlag = postCategoryViewModel.HomeFlag;
postCategory.ID = postCategoryViewModel.ID;
postCategory.CreatedDate = postCategoryViewModel.CreatedDate;
postCategory.CreatedBy = postCategoryViewModel.CreatedBy;
postCategory.UpdatedDate = postCategoryViewModel.UpdatedDate;
postCategory.UpdatedBy = postCategoryViewModel.UpdatedBy;
}
public IActionResult SaveEntity(PostCategoryViewModel postCategoryVm)
{
try
{
if (postCategoryVm.Id == 0)
{
var errorByPostItemName = "Tên danh mục bài viết đã tồn tại";
if (_postCategoryService.ValidateAddPostCategoryName(postCategoryVm))
{
ModelState.AddModelError("",
errorByPostItemName);
}
if (_postCategoryService.ValidateAddPostCategoryOrder(postCategoryVm))
{
ModelState.AddModelError("",
"Thứ tự đã tồn tại");
}
if (_postCategoryService.ValidateAddPostCategoryHomeOrder(postCategoryVm))
{
ModelState.AddModelError("",
"Thứ tự trang chủ đã tồn tại");
}
if (_postCategoryService.ValidateAddPostCategoryHotOrder(postCategoryVm))
{
ModelState.AddModelError("",
"Thứ tự khu vực HOT đã tồn tại");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Select(x => x.Value.Errors).FirstOrDefault(y => y.Count > 0)?.First()
.ErrorMessage));
}
_postCategoryService.Add(postCategoryVm);
}
else
{
var errorByPostItemName = "Tên danh mục bài viết đã tồn tại";
if (_postCategoryService.ValidateUpdatePostCategoryName(postCategoryVm))
{
ModelState.AddModelError("",
errorByPostItemName);
}
if (_postCategoryService.ValidateUpdatePostCategoryOrder(postCategoryVm))
{
ModelState.AddModelError("",
"Thứ tự đã tồn tại");
}
if (_postCategoryService.ValidateUpdatePostCategoryHomeOrder(postCategoryVm))
{
ModelState.AddModelError("",
"Thứ tự trang chủ đã tồn tại");
}
if (_postCategoryService.ValidateUpdatePostCategoryHotOrder(postCategoryVm))
{
ModelState.AddModelError("",
"Thứ tự khu vực HOT đã tồn tại");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Select(x => x.Value.Errors).FirstOrDefault(y => y.Count > 0)?.First()
.ErrorMessage));
}
_postCategoryService.Update(postCategoryVm);
}
//if (!ModelState.IsValid)
//{
// IEnumerable<ModelError> allErrors = ModelState.Values.SelectMany(v => v.Errors);
// return new BadRequestObjectResult(allErrors);
//}
_postCategoryService.Save();
return(new OkObjectResult(postCategoryVm));
}
catch (Exception ex)
{
throw ex;
}
}
