[TransactionScopeAspect]//+++
public IResult Update(PostUpdateDto post)
{
/*
* var post2 = new Post
* {
* Content = post.Content,
* Title = post.Title,
* Updated = DateTime.Now,
* Id = post.Id,
* UserId = post.UserId
* };*/
_postDal.Update2(post);
if (post.CategoryId != null)
{
string[] category = post.CategoryId.Split("*");
foreach (var item in category)
{
if (item != "")
{
var postCategory = new PostCategoryCreateDto {
PostId = post.Id, CategoryId = item
};
_postCategoryService.Add(postCategory);
}
}
}
//var postCategory2 = new PostCategory {PostId=post.Id,CategoryId=post.CategoryId, Id=post.PostCategoryId };
// _postCategoryService.Update(postCategory2);
return(new SuccessResult(Messages.PostUpdated));
}
public HttpResponseMessage Post(HttpRequestMessage request, PostCategoryViewModel postCategoryVM)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (ModelState.IsValid)
{
//check request http
request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
PostCategory postCategory = new PostCategory();
//call update method
postCategory.UpdatePostCategory(postCategoryVM);
//call add method
var category = _postCategoryService.Add(postCategory);
//save change
_postCategoryService.Save();
//status request
response = request.CreateResponse(HttpStatusCode.Created, category);
}
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();
var identity = (ClaimsIdentity)User.Identity;
IEnumerable <Claim> claims = identity.Claims;
newPostCategory.UpdatePostCategory(postCategoryVm);
var category = _postCategoryService.Add(newPostCategory);
_postCategoryService.Save();
Log log = new Log()
{
AppUserId = claims.FirstOrDefault().Value,
Content = Notification.CREATE_POSTCATEGORY,
Created = DateTime.Now
};
_logService.Create(log);
_logService.Save();
response = request.CreateResponse(HttpStatusCode.Created, category);
}
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);
newPostCategory.CreatedDate = DateTime.Now;
newPostCategory.CreatedBy = User.Identity.Name;
newPostCategory.UpdatedDate = DateTime.Now;
newPostCategory.UpdatedBy = User.Identity.Name;
var category = _postCategoryService.Add(newPostCategory);
_postCategoryService.Save();
response = request.CreateResponse(HttpStatusCode.Created, category);
}
return response;
}));
}
[HttpPost("add")]//+++
public IActionResult Add(PostCategoryCreateDto postCategoryCreateDto)
{
var result = _postCategoryService.Add(postCategoryCreateDto);
if (result.Success)
{
return(Ok(result.Message));
}
return(BadRequest(result.Message));
}
public async Task <IActionResult> Post([FromBody] InsertPostCategory model)
{
var result = await postCategoryServices.Add(model);
if (result.Status)
{
return(Ok(result));
}
return(BadRequest(result));
}
public ActionResult Add(AddViewModel model)
{
if (!ModelState.IsValid)
{
return(View("_Add", model));
}
_postCategoryService.Add(model.PostCategoryName);
return(Content("Refresh"));
}
public IActionResult Add(PostCategory PostCategory)
{
try
{
var item = _PostCategoryService.Add(PostCategory);
_PostCategoryService.SaveChange();
return(Ok(item));
}
catch (Exception ex)
{
return(Content(ex.Message));
}
}
public IHttpActionResult Add([FromBody] PostCategoryViewModel postVm)
{
try
{
var responseData = _postCategoryService.Add(postVm);
_postCategoryService.Save();
return(Ok(responseData));
}
catch (Exception ex)
{
_logger.LogError("Error at method: Add - PostCategoryApi," + ex.InnerException.InnerException.Message + "");
return(BadRequest("Error System"));
}
}
public void PostCategoryService_Create()
{
PostCategory postCategory = new PostCategory();
postCategory.Name = "Test";
postCategory.Alias = "Test";
postCategory.Status = true;
_mockRepository.Setup(m => m.Add(postCategory)).Returns((PostCategory p) => { p.ID = 1; return(p); });
var result = _categoryService.Add(postCategory);
Assert.IsNotNull(result);
Assert.AreEqual(1, result.ID);
}
// POST api/<controller>
public HttpResponseMessage Post(HttpRequestMessage message, PostCategory postCategory)
{
return(CreateHttpResponse(message, () => {
HttpResponseMessage reponse = null;
if (ModelState.IsValid)
{
Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
var category = _postCategoryService.Add(postCategory);
_postCategoryService.SaveChanges();
reponse = message.CreateResponse(HttpStatusCode.Created, category);
}
return reponse;
}));
}
public HttpResponseMessage Post(HttpRequestMessage request, PostCategoryViewModel postCategoryVm)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (ModelState.IsValid)
{
var postCategory = new PostCategory();
postCategory.UpdatePostCategory(postCategoryVm);
var category = _postCategoryService.Add(postCategory);
_postCategoryService.SaveChanges();
response = request.CreateResponse(HttpStatusCode.Created, category);
}
return response;
}));
}
public PostCategoryViewModel Add(PostCategoryViewModel model)
{
try
{
PostCategory postCategory = new PostCategory();
postCategory.UpdatePostCategory(model);
var res = _postCategoryService.Add(postCategory);
_postCategoryService.SaveChanges();
return(Mapper.Map <PostCategoryViewModel>(res));
}
catch (Exception ex)
{
LogError(ex);
return(null);
}
}
public void PostCategory_Service_Add()
{
PostCategory pc = new PostCategory()
{
ID = 2, Name = "postcategory1", Alias = "post-category-1", Description = "", Status = true
};
_mockPostCategoryRepository.Setup(m => m.Add(pc)).Returns((PostCategory p) => {
p.ID = 2;
return(p);
});
var result = _postCategoryService.Add(pc);
Assert.IsNotNull(result);
Assert.AreEqual(2, result.ID);
}
public HttpResponseMessage Post(HttpRequestMessage request, PostCategoryViewModel postCategoryViewModel)
{
return(CreateHttpResponse(request,
() => {
HttpResponseMessage response = null;
// kiểm tra ngoại lệ của dữ liệu truyền vào
if (ModelState.IsValid)
{
// nếu có lỗi thì truyền lỗi đó vào bảng lỗi trong database
request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
// không có lỗi sẽ dùng Service để lưu đối tượng vào database
PostCategory newPostCategory = new PostCategory();
// bất cứ đối tượng tạo ở Model(Shop.Web) sử dụng phương thức thì giá trị của nó sẽ tự động đẩy sang Model(Shop.Model)
newPostCategory.UpdatePostCategory(postCategoryViewModel);
var category = _postCategoryService.Add(newPostCategory);
try
{
_postCategoryService.Save();
}
catch (DbEntityValidationException e)
{
foreach (var eve in e.EntityValidationErrors)
{
Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
ve.PropertyName, ve.ErrorMessage);
}
}
throw;
}
// trả về đối tượng đã dược lưu để xử lý
response = request.CreateResponse(HttpStatusCode.Created, category);
}
return response;
}));
}
public HttpResponseMessage Post(HttpRequestMessage request, PostCategory postCategory)
{
HttpResponseMessage response = null;
if (ModelState.IsValid)
{
request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
_postCategoryService.Add(postCategory);
_postCategoryService.Save();
response = request.CreateResponse(HttpStatusCode.Created, postCategory);
}
return(response);
}
public void PostCategory_Service_Create()
{
PostCategory category = new PostCategory();
int id = 1;
category.Name = "test";
category.Alias = "test";
category.Status = true;
//set up add and return this category
_mockRepository.Setup(m => m.Add(category)).Returns((PostCategory p) => { p.ID = 1; return(p); });
// call method
var result = _categoryService.Add(category);
//check vlue
Assert.IsNotNull(result);
Assert.AreEqual(id, result.ID);
}
public HttpResponseMessage create(HttpRequestMessage request, PostCategory postCategory)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
var category = _postCategoryService.Add(postCategory);
_postCategoryService.Save();
response = request.CreateResponse(HttpStatusCode.Created, category);
}
return response;
}));
}
public void PostService_Create()
{
PostCategory ps = new PostCategory();
int id = 1;
ps.Name = "Name";
ps.Alias = "test 1";
ps.Status = true;
///setup
_mockRepository.Setup(p => p.Add(ps)).Returns((PostCategory p) => {
p.ID = 1;
return(p);
});
var resuilt = _categoryService.Add(ps);
Assert.IsNotNull(resuilt);
Assert.AreEqual(1, resuilt.ID);
}
public void PostCategory_Service_Create()
{
PostCategory category = new PostCategory
{
Name = "test",
Alias = "test",
Status = true
};
_mockRepository.Setup(x => x.Add(category)).Returns(
(PostCategory p) => {
p.ID = 1;
return(p);
});
var result = _categoryService.Add(category);
Assert.IsNotNull(result);
Assert.AreEqual(1, result.ID);
}
public void PostCategory_Post_CreatePostCate()
{
PostCategory cate = new PostCategory();
cate.ID = 1;
cate.Name = "Test 1";
cate.Alias = "Test";
cate.Status = true;
_mockRepo.Setup(m => m.Add(cate)).Returns((PostCategory p) =>
{
p.ID = 1;
return(p);
});
var res = _postCateService.Add(cate);
Assert.AreEqual(1, res.ID);
}
public void PostCategory_Service_Create()
{
PostCategory test1 = new PostCategory();
test1.Name = "Test1";
test1.Status = true;
test1.Alias = "test1";
_mockRepository.Setup(m => m.Add(test1)).Returns((PostCategory p) =>
{
p.ID = 1;
return(p);
});
var result = _postCategoryService.Add(test1);
Assert.IsNotNull(result);
Assert.AreEqual(1, result.ID);
}
public JsonResult Post(string postCategory)
{
string message = string.Empty;
var jsonObj = new JavaScriptSerializer();
var model = jsonObj.Deserialize <PostCategory>(postCategory);
model.CreatedDate = DateTime.Now;
_postCategoryService.Add(model);
_postCategoryService.Save();
message = ResultState.Add_SUCCESS;
return(Json(new
{
message = message,
status = true,
}, JsonRequestBehavior.AllowGet));
}
public void PosrCategory_Service_Create()
{
PostCategory category = new PostCategory();
int id = 1;
category.Name = "test category";
category.Alias = "test-category";
category.Status = true;
category.Image = "img";
_mockRepository.Setup(m => m.Add(category)).Returns((PostCategory p) =>
{
p.ID = 1;
return(p);
});
var result = _categoryService.Add(category);
Assert.IsNotNull(result);
Assert.AreEqual(0, result.ID);
}
public void PostCategory_Service_Create()
{
PostCategory postCategory = new PostCategory()
{
Name = "Test",
Alias = "Test",
Status = true
};
_mockRepository.Setup(m => m.Create(postCategory)).Returns((PostCategory p) =>
{
p.ID = 1;
return(p);
});
var results = _postCategoryService.Add(postCategory);
Assert.IsNotNull(results);
Assert.AreEqual(1, results.ID);
}
public HttpResponseMessage Post(HttpRequestMessage request, PostCategoryViewModel postCategoryVM)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (ModelState.IsValid)
{
var postCategory = Mapper.Map <PostCategory>(postCategoryVM);
var _postCategory = _postCategoryService.Add(postCategory);
_postCategoryService.Save();
response = request.CreateResponse(HttpStatusCode.Created, _postCategory);
}
else
{
response = request.CreateResponse(HttpStatusCode.BadRequest, ModelState);
}
return response;
}));
}
public void PostCategory_Service_Create()
{
PostCategory pc = new PostCategory();
int id = 1;
pc.Name = "test";
pc.Alias = "test";
pc.Status = true;
_mockPostCategoryRepository.Setup(x => x.Add(pc)).Returns((PostCategory postCategory) =>
{
postCategory.ID = id;
return(postCategory);
});
var result = _postCategoryService.Add(pc);
Assert.IsNotNull(result);
Assert.AreEqual(1, result.ID);
}
public IActionResult Post([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(() =>
{
var postId = _postCategoryService.Add(model, CurrentUserId);
_postCategoryService.Save();
return Json(postId);
}));
}
public HttpResponseMessage Post(HttpRequestMessage request, PostCategoryViewModel postCategoryVM)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (ModelState.IsValid)
{
request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
PostCategory newPostCate = new PostCategory();
newPostCate.UpdatePostCategory(postCategoryVM);
var category = _postCategoryService.Add(newPostCate);
_postCategoryService.Save();
response = request.CreateResponse(HttpStatusCode.Created, category);
}
return response;
}));
}
public HttpResponseMessage Post(HttpRequestMessage request, PostCategoryViewModel postCategoryVm)
{
if (ModelState.IsValid)
{
HttpResponseMessage response = null;
var model = new PostCategory();
model.UpdatePostCategory(postCategoryVm);
model.CreatedDate = DateTime.Now;
model.CreatedBy = User.Identity.Name;
_postCategoryService.Add(model);
_postCategoryService.Save();
var result = Mapper.Map <PostCategory, PostCategoryViewModel>(model);
response = request.CreateResponse(HttpStatusCode.OK, result);
return(response);
}
else
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}