public async Task <IDataResult <Product> > Add(ProductCreateDto productCreateDto)
{
var product = new Product
{
ProductName = productCreateDto.ProductName,
ProductTypeId = productCreateDto.ProductTypeId,
// Title = productCreateDto.Title,
Content = productCreateDto.Content,
UserId = productCreateDto.UserId,
Created = DateTime.Now
};
await _productDal.Add(product);
// var postSave = new SuccessDataResult<Product>(product, Messages.UserRegistered);
if (productCreateDto.Categories != null)
{
var entity = new SuccessDataResult <Product>(product);
foreach (var item in productCreateDto.Categories)
{
await _productCategoryService.Add(
new ProductCategoryCreateDto { ProductId = entity.Data.Id, CategoryId = item }
);
}
}
return(new SuccessDataResult <Product>(product, Messages.ProductAdded));
}
public IActionResult SaveEntity(ProductCategoryViewModel productVm)
{
if (!ModelState.IsValid)
{
IEnumerable <ModelError> allErrors = ModelState.Values.SelectMany(v => v.Errors);
ErrorMesage e = new ErrorMesage();
if (productVm.SortOrder == 0)
{
e.Message = "Vui lòng nhập SortOrder";
e.Error = true;
return(new BadRequestObjectResult(e));
}
return(new BadRequestObjectResult(allErrors));
}
else
{
productVm.SeoAlias = TextHelper.ToUnsignString(productVm.Name);
if (productVm.Id == 0)
{
_productCategoryService.Add(productVm);
}
else
{
_productCategoryService.Update(productVm);
}
_productCategoryService.Save();
return(new OkObjectResult(productVm));
}
}
public async Task <IActionResult> SaveEntity(ProductCategoryViewModel productViewModel)
{
if (!ModelState.IsValid)
{
var allErrors = ModelState.Values.SelectMany(v => v.Errors);
return(new BadRequestObjectResult(allErrors));
}
else
{
productViewModel.SeoAlias = AliasHelper.ConvertToAlias(productViewModel.Name);
if (productViewModel.Id == 0)
{
var notificationId = Guid.NewGuid().ToString();
var announcement = new AnnouncementViewModel
{
Title = User.GetSpecificClaim("FullName"),
DateCreated = DateTime.Now,
Content = $"Product Category {productViewModel.Name} has been created",
Id = notificationId,
UserId = User.GetUserId(),
Image = User.GetSpecificClaim("Avatar"),
Status = Status.Active
};
var announcementUsers = new List <AnnouncementUserViewModel>()
{
new AnnouncementUserViewModel()
{
AnnouncementId = notificationId, HasRead = false, UserId = User.GetUserId()
}
};
_productCategoryService.Add(announcement, announcementUsers, productViewModel);
await _hubContext.Clients.All.SendAsync("ReceiveMessage", announcement);
}
else
{
var notificationId = Guid.NewGuid().ToString();
var announcement = new AnnouncementViewModel
{
Title = User.GetSpecificClaim("FullName"),
DateCreated = DateTime.Now,
Content = $"Product Category {productViewModel.Name} has been updated",
Id = notificationId,
UserId = User.GetUserId(),
Image = User.GetSpecificClaim("Avatar"),
Status = Status.Active
};
var announcementUsers = new List <AnnouncementUserViewModel>()
{
new AnnouncementUserViewModel()
{
AnnouncementId = notificationId, HasRead = false, UserId = User.GetUserId()
}
};
_productCategoryService.Update(announcement, announcementUsers, productViewModel);
await _hubContext.Clients.All.SendAsync("ReceiveMessage", announcement);
}
_productCategoryService.Save();
return(new OkObjectResult(productViewModel));
}
}
public IActionResult SaveEntity(ProductCategoryViewModel viewModel)
{
if (!ModelState.IsValid)
{
IEnumerable <ModelError> allErrors = ModelState.Values.SelectMany(n => n.Errors);
return(new BadRequestObjectResult(allErrors));
}
else
{
viewModel.SeoAlias = TextHelper.ToUnsignString(viewModel.Name);
if (viewModel.Id == 0)
{
_productCategoryService.Add(viewModel);
}
else
{
_productCategoryService.Update(viewModel);
}
}
_productCategoryService.Save();
return(new OkObjectResult(viewModel));
}
private void btnThem_Click(object sender, EventArgs e)
{
btnThem.Text = btnThem.Text.Equals("Tạo mới danh mục") ? "Lưu" : "Tạo mới danh mục";
if (btnThem.Text.Equals("Tạo mới danh mục")) // An nut them lan 2
{
if (!isValid())
{
MessageBox.Show("Bạn phải nhập vào tên danh mục !!!");
btnThem.Text = "Lưu";
return;
}
//Code
GenericResult rs = _productCategoryService.Add(new ProductCategoryViewModel()
{
Name = txtTenDanhMuc.Text.Trim(),
ParentId = int.Parse(cbDanhMucCha.SelectedValue.ToString()),
Status = chkTrangThai.Checked ? Status.Active : Status.InActive,
Image = "" /// Load Image
});
FormHelper.showDialog(rs);
//End Code
loadGvDanhMucHangHoa();
update_Edit();
datagv_DanhMuc.Enabled = true;
setBtnBack_False();
}
else //Vua nhan nut them
{
saveStament();
setBtnBack_True();
reStart();
datagv_DanhMuc.Enabled = false;
}
}
public HttpResponseMessage Create(HttpRequestMessage request, ProductCategoryViewModel productCategoryVm)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
var newProductCategory = new ProductCategory();
var identity = (ClaimsIdentity)User.Identity;
IEnumerable <Claim> claims = identity.Claims;
newProductCategory.UpdateProductCategory(productCategoryVm);
newProductCategory.CreatedDate = DateTime.Now;
_productCategoryService.Add(newProductCategory);
_productCategoryService.Save();
Log log = new Log()
{
AppUserId = claims.FirstOrDefault().Value,
Content = Notification.CREATE_PRODUCTCATEGORY,
Created = DateTime.Now
};
_logService.Create(log);
_logService.Save();
var responseData = Mapper.Map <ProductCategory, ProductCategoryViewModel>(newProductCategory);
response = request.CreateResponse(HttpStatusCode.Created, responseData);
}
return response;
}));
}
public IActionResult Create([FromBody] ProductCategoryViewModel productCategoryVm)
{
var response = new SingleModelResponse <ProductCategoryViewModel>() as ISingleModelResponse <ProductCategoryViewModel>;
try
{
var newProductCategory = Mapper.Map <ProductCategory>(productCategoryVm);
//newProductCategory.UpdateProductCategory(productCategoryVm);
_productCategoryService.Add(newProductCategory);
_productCategoryService.Save();
//_appsDbContext.Add(newProductCategory);
//_appsDbContext.SaveChanges();
var responseData = Mapper.Map <ProductCategoryViewModel>(newProductCategory);
response.Model = responseData;
response.Message = productCategoryVm.Name + " đã được thêm thành công";
}
catch (Exception ex)
{
response.DidError = true;
response.ErrorMessage = ex.ToString();
}
return(response.ToHttpResponse());
}
public HttpResponseMessage Create(HttpRequestMessage request, ProductCategoryViewModel productCategoryVM)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
//check issue
if (!ModelState.IsValid)
{
//get status
response = request.CreateResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
ProductCategory newProductCategory = new ProductCategory();
//Call method add product category in folder extensions
newProductCategory.UpdateProductCategory(productCategoryVM);
//Set date
newProductCategory.CreatedDate = DateTime.Now;
//Add data
_productCategoryService.Add(newProductCategory);
//Save change
_productCategoryService.Save();
//Mapping data to dataView
var responseData = Mapper.Map <ProductCategory, ProductCategoryViewModel>(newProductCategory);
//Check request
response = request.CreateResponse(HttpStatusCode.Created, responseData);
}
return response;
}));
}
public HttpResponseMessage Create(HttpRequestMessage request, ProductCategoryViewModel productCategoryVM)
{
return(CreateHttpReponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
request.CreateErrorResponse(HttpStatusCode.BadGateway, ModelState);
}
else
{
ProductCategory objPG = new ProductCategory();
objPG.UpdateProductCategory(productCategoryVM);
objPG.CreateDate = DateTime.Now;
productCategoryService.Add(objPG);
productCategoryService.SaveChanges();
response = request.CreateResponse(HttpStatusCode.Created, objPG);
}
return response;
}));
}
//[AllowAnonymous]
public HttpResponseMessage Create(HttpRequestMessage httpRequest, ProductCategoryViewModel productCategoryViewModel)
{
return(CreateHttpResponse(httpRequest, () =>
{
HttpResponseMessage httpResponse = null;
if (!ModelState.IsValid)
{
httpResponse = httpRequest.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
var productCategory = new ProductCategory();
productCategory.UpdateProductCategory(productCategoryViewModel);
productCategory.CreateDate = DateTime.Now;
productCategory.CreateBy = User.Identity.Name;
_productCategoryService.Add(productCategory);
_productCategoryService.Save();
var responData = Mapper.Map <ProductCategory, ProductCategoryViewModel>(productCategory);
httpResponse = httpRequest.CreateResponse(HttpStatusCode.Created, responData);
}
return httpResponse;
}));
}
public HttpResponseMessage Create(HttpRequestMessage request, ProductCategoryViewModel productCategoryVm)
{
if (ModelState.IsValid)
{
var newProductCategory = new ProductCategory();
newProductCategory.UpdateProductCategory(productCategoryVm);
newProductCategory.CreatedDate = DateTime.Now;
newProductCategory.CreatedBy = User.Identity.Name;
newProductCategory.UpdatedDate = DateTime.Now;
newProductCategory.UpdatedBy = User.Identity.Name;
try
{
_productCategoryService.Add(newProductCategory);
_productCategoryService.Save();
var responseData = Mapper.Map <ProductCategory, ProductCategoryViewModel>(newProductCategory);
return(request.CreateResponse(HttpStatusCode.OK, responseData));
}
catch (NameDuplicatedException dex)
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, dex.Message));
}
}
else
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
public ActionResult CreateCategory(CreateCategoryModel model)
{
var entity = model.ToEntity();
_productCategoryService.Add(entity);
return(RedirectToAction("Index"));
}
public HttpResponseMessage Create(HttpRequestMessage request, ProductCategoryViewModel productCategoryViewModel)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
var newProductCategory = new ProductCategory();
newProductCategory.UpdateProductCategory(productCategoryViewModel);
newProductCategory.CreatedDate = DateTime.Now;
_productCategoryService.Add(newProductCategory);
_productCategoryService.Save();
var responseData = Mapper.Map <ProductCategory, ProductCategoryViewModel>(newProductCategory);
response = request.CreateResponse(HttpStatusCode.Created, responseData);
}
return response;
}));
}
public HttpResponseMessage Create(HttpRequestMessage request, ProductCategoryViewModel productCategoryVm)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (ModelState.IsValid)
{
var productCategory = new ProductCategory();
productCategory.UpdateProductCategory(productCategoryVm);
_productCategoryService.Add(productCategory);
_productCategoryService.SaveChanges();
var responeData = Mapper.Map <ProductCategory, ProductCategoryViewModel>(productCategory);
response = request.CreateResponse(HttpStatusCode.Created, responeData);
}
else
{
response = request.CreateResponse(HttpStatusCode.BadRequest, ModelState);
}
return response;
}));
}
public HttpResponseMessage Add(HttpRequestMessage request, ProductCategoryViewModel productCategoryVM)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
ProductCategory newProductCategory = new ProductCategory();
newProductCategory.UpdateProductCategory(productCategoryVM);
productCategoryService.Add(newProductCategory);
productCategoryService.Save();
//Update ViewModel
productCategoryVM = Mapper.Map <ProductCategory, ProductCategoryViewModel>(newProductCategory);
response = request.CreateResponse(HttpStatusCode.Created, productCategoryVM);
}
return response;
}));
}
public IActionResult SaveProductCategory(ProductCategoryViewModel model)
{
if (!ModelState.IsValid)
{
var errors = ModelState.Values
.SelectMany(x => x.Errors)
.Select(x => x.ErrorMessage);
return(BadRequest(errors));
}
if (!string.IsNullOrEmpty(model.SeoAlias))
{
model.SeoAlias = TextHelper.ToUnsignString(model.SeoAlias);
}
if (model.Id == 0)
{
var productCategory = _productCategoryService.Add(model);
}
else
{
_productCategoryService.Update(model);
}
_productCategoryService.Save();
return(new OkObjectResult(model));
}
public async Task <ActionResult> Create(ProductCategoryViewModel viewModel, CancellationToken cancellationToken)
{
var productCategory = Mapper.Map <ProductCategory>(viewModel);
productCategoryService.Add(productCategory);
productCategoryService.SaveChanges();
return(RedirectToAction("List"));
}
public async Task <ActionResult> Create([Bind(Include = "Id,Name")] ProductCategoryViewModel item)
{
if (ModelState.IsValid)
{
await _service.Add(_mapper.Map <ProductCategoryCore>(item));
return(Json(new { success = true }));
}
return(Json(item, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> Add([FromBody] ProductCategoryAddDto model)
{
var result = await _productCategoryService.Add(model);
if (result.Message != ApiResultMessages.Ok)
{
return(BadRequest(result));
}
return(Ok(result));
}
public ServiceResult <ProductCategory> Create(ProductCategory productCategory)
{
var validResult = ValidParentId(productCategory);
if (validResult.HasViolation)
{
return(validResult);
}
return(_productCategoryService.Add(productCategory));
}
public HttpResponseMessage Add(HttpRequestMessage request, ProductCategoryViewModel productCategoryVm)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
var Error = "";
if (string.IsNullOrEmpty(productCategoryVm.Name))
{
Error = "Tên Không được trống" + productCategoryVm.Name;
}
else if (string.IsNullOrEmpty(productCategoryVm.Alias))
{
Error = "Alias Không được trống" + productCategoryVm.Alias;
}
var Res = new Res
{
Status = false,
Message = Error
};
response = request.CreateResponse(HttpStatusCode.BadRequest, Res);
}
else
{
var newProductCategory = new ProductCategory();
newProductCategory.UpdateProductCategory(productCategoryVm);
newProductCategory.CreatedDate = DateTime.Now;
newProductCategory.UpdatedDate = DateTime.Now;
if (productCategoryVm.Status)
{
newProductCategory.Status = true;
}
else
{
newProductCategory.Status = false;
}
_productCategoryService.Add(newProductCategory);
_productCategoryService.Save();
var responseData = Mapper.Map <ProductCategory, ProductCategoryViewModel>(newProductCategory);
var Res = new Res
{
Status = true,
Message = "Thêm mới thành công !!!",
Data = responseData
};
response = request.CreateResponse(HttpStatusCode.Created, Res);
}
return response;
}));
}
public JavaScriptResult Create(ProductCategoryViewModel productCategoryVm)
{
try
{
_productCategoryService.Add(Mapper.Map <ProductCategory>(productCategoryVm));
return(JavaScript($"ShowResult('{"Data saved successfully."}','{"success"}','{"redirect"}','{"/APanel/ProductCategory"}')"));
}
catch (Exception ex)
{
return(JavaScript($"ShowResult('{ex.Message}','failure')"));
}
}
public async Task <IActionResult> Add([FromBody] ProductCategoryViewModel productCategoryVm)
{
var hasPermission = await _authorizationService.AuthorizeAsync(User, "PRODUCT_CATEGORY", Operations.Create);
if (hasPermission.Succeeded == false)
{
return(new BadRequestObjectResult(CommonConstants.Forbidden));
}
if (ModelState.IsValid)
{
_productCategoryService.Add(productCategoryVm);
_productCategoryService.SaveChanges();
return(new OkObjectResult(productCategoryVm));
}
return(new BadRequestObjectResult(ModelState));
}
public ActionResult Create(ProductCategoryViewModel productCategoryViewModel)
{
if (ModelState.IsValid)
{
var newProductCategory = new ProductCategory();
newProductCategory.UpdateProductCategory(productCategoryViewModel);
newProductCategory.CreatedDate = DateTime.Now;
_productCategoryService.Add(newProductCategory);
_productCategoryService.Save();
//var responseData = Mapper.Map<ProductCategory, ProductCategoryViewModel>(newProductCategory);
return(RedirectToAction("Index"));
}
return(View());
}
public JsonResult Post(string productCategory)
{
string message = string.Empty;
var jsonObj = new JavaScriptSerializer();
var model = jsonObj.Deserialize <ProductCategory>(productCategory);
model.CreatedDate = DateTime.Now;
_productCategoryService.Add(model);
_productCategoryService.Save();
message = ResultState.Add_SUCCESS;
return(Json(new
{
message = message,
status = true,
}, JsonRequestBehavior.AllowGet));
}
public IActionResult SaveAddOrUpdate(ProductCategory productCategory)
{
var id = productCategory.Id;
if (!string.IsNullOrEmpty(id.ToString()))
{
if (id == 0)
{
_productCategoryService.Add(productCategory);
}
var item = _productCategoryService.GetById(productCategory.Id);
item.Description = productCategory.Description;
item.Name = productCategory.Name;
_productCategoryService.Update(item);
}
return(new OkObjectResult(_productCategoryService.GetAll().Result));
}
public ProductCategoryViewModel Add(ProductCategoryViewModel model)
{
try
{
ProductCategory productCategory = new ProductCategory();
productCategory.UpdateProductCategory(model);
var res = _productCategoryService.Add(productCategory);
_productCategoryService.SaveChanges();
return(Mapper.Map <ProductCategoryViewModel>(res));
}
catch (Exception ex)
{
LogError(ex);
return(null);
}
}
public void Create()
{
ProductCategory _productCategory = new ProductCategory();
_productCategory.Name = "Đồ uống";
_productCategory.Alias = "Đồ uống";
_productCategory.CreatedDate = DateTime.Now;
_mockProductCategoryRepository.Setup(m => m.Add(_productCategory)).Returns((ProductCategory p) =>
{
p.ID = 1;
return(p);
});
var result = _productCategoryService.Add(_productCategory);
Assert.IsNotNull(result);
Assert.AreEqual(1, result.ID);
}
[Authorize] // bắt buộc đăng nhập mói vô được
public HttpResponseMessage Creat(HttpRequestMessage request, ProductCategoryViewModel productCategoryViewModel)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
var newProductCategory = new ProductCategory();
newProductCategory.UpdateProductCategory(productCategoryViewModel);
newProductCategory.CreatedDate = DateTime.Now;
newProductCategory.CreatedBy = User.Identity.Name;
_productCategoryService.Add(newProductCategory);
try
{
_productCategoryService.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;
}
var responseData = Mapper.Map <ProductCategory, ProductCategoryViewModel>(newProductCategory);
response = request.CreateResponse(HttpStatusCode.Created, responseData);
}
return response;
}));
}
public IHttpActionResult Create(ProductCategoryViewModel productCategoryVm)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
else
{
var newProductCategory = new ProductCategory();
newProductCategory.UpdateProductCategory(productCategoryVm);
newProductCategory.CreatedDate = DateTime.Now;
_productCategoryService.Add(newProductCategory);
_productCategoryService.Save();
var responseData = Mapper.Map <ProductCategory, ProductCategoryViewModel>(newProductCategory);
return(Ok(responseData));
}
}
