public async Task <IActionResult> Create([FromForm] CreateProductRequest model)
{
var createdProductUserId = int.Parse(HttpContext.GetUserIdFromRequest());
var productEntity = _mapper.Map <Product>(model);
var productTierEntity = _mapper.Map <ProductTier>(model);
var result = await _productService.CreateAsync(
productEntity,
productTierEntity,
createdProductUserId,
model.Images,
_appSettings.Value.ProductImageDir,
_env.ContentRootPath);
if (!result.IsSuccess)
{
return(BadRequest(new CreateProductFailedResponse
{
Errors = result.Errors
}));
}
var productResponse = _mapper.Map <ProductResponse>(productEntity);
var locationUri = _uriService.GetByIdUri(
ApiRoutes.Product.GetById.Replace("{productId}", productEntity.Id.ToString())
);
return(Created(locationUri,
new Response <ProductResponse>(productResponse)));
}
public async Task <IActionResult> Create([FromBody] CreateCategoryRequest model)
{
var createdCategoryUserId = int.Parse(HttpContext.GetUserIdFromRequest());
var categoryEntity = _mapper.Map <Category>(model);
var isCreateCategorySuccess = await _categoryService.CreateAsync(categoryEntity, createdCategoryUserId);
if (!isCreateCategorySuccess)
{
return(BadRequest(
new CreateCategoryFailResponse
{
Errors = new[] { "Tạo loại sản phẩm không thành công" }
}));
}
var categoryLocationUri = _uriService.GetByIdUri(
ApiRoutes.Category.GetById.Replace("{categoryId}", categoryEntity.Id.ToString()));
var categoryResponse = _mapper.Map <CategoryResponse>(categoryEntity);
return(Created(
categoryLocationUri,
new Response <CategoryResponse>(categoryResponse)));
}
public async Task <IActionResult> Create(
[FromBody] CreateRequestImportProductRequest createModel
)
{
var requestedUserId = int.Parse(HttpContext.GetUserIdFromRequest());
var requestImportDetails = _mapper.Map <IEnumerable <CreateRequestImportDetailRequest>, IEnumerable <RequestImportDetail> >(createModel.RequestImportDetails);
var result = await _requestImportProductService.CreateAsync(
requestImportDetails,
requestedUserId
);
if (result.IsSuccess == false)
{
return(BadRequest(result.Errors));
}
var requestImportProductResponse = _mapper.Map <RequestImportProductResponse>(
result.RequestImportProduct);
var locationUri = _uriService.GetByIdUri(
ApiRoutes.Product.GetById.Replace(
"{requestImportProductId}",
result.RequestImportProduct.Id.ToString())
);
return(Created(locationUri,
new Response <RequestImportProductResponse>(requestImportProductResponse)));
}
public async Task <IActionResult> Create(
[FromBody] CreateProductTierTransferReportRequest createModel
)
{
int requestedUserId = int.Parse(HttpContext.GetUserIdFromRequest());
var productTierTransferReportEntity = _mapper
.Map <ProductTierTransferReport>(createModel);
var createResult = await _productTierTransferReportService
.CreateAsync(
productTierTransferReportEntity,
requestedUserId);
if (createResult.IsSuccess == false)
{
return(BadRequest(createResult.Errors));
}
var locationUri = _uriService.GetByIdUri(
ApiRoutes.ProductTierTransferReport.GetById
.Replace(
"{productTierTransferReportId}",
productTierTransferReportEntity.Id.ToString())
);
var productTierTransferReportResponse = _mapper
.Map <ProductTierTransferReportResponse>(createResult.EntityReturn);
return(Created(locationUri,
new Response <ProductTierTransferReportResponse>(productTierTransferReportResponse)));
}
public async Task <IActionResult> Create([FromForm] CreateRatingRequest createModel)
{
var ratingEntity = _mapper.Map <Rating>(createModel);
var createdCustomerId = int.Parse(HttpContext.GetUserIdFromRequest());
var result = await _ratingService.CreateAsync(
ratingEntity,
createdCustomerId,
createModel.Images,
_appSettings.Value.RatingImageDir,
_env.ContentRootPath);
if (!result.IsSuccess)
{
return(BadRequest(result.Errors));
}
var ratingUri = _uriService.GetByIdUri(
ApiRoutes.Rating.GetById.Replace("{ratingId}", ratingEntity.Id.ToString()));
var ratingResponse = _mapper.Map <RatingResponse>(ratingEntity);
return(Created(
ratingUri,
new Response <RatingResponse>(ratingResponse)));
}
public async Task <IActionResult> Create(
[FromBody] CreateProductExportBillRequest createModel
)
{
var requestedUserId = int.Parse(HttpContext.GetUserIdFromRequest());
ProductExportBill productExportBill = new ProductExportBill
{
OrderId = createModel.OrderId
};
var productExportDetails = _mapper
.Map <IEnumerable <CreateProductExportDetailRequest>, IEnumerable <ProductExportDetail> >(
createModel.ProductExportDetails);
var result = await _productExportBillService.CreateAsync(
productExportBill,
productExportDetails,
requestedUserId
);
if (result.IsSuccess == false)
{
return(BadRequest(result.Errors));
}
var locationUri = _uriService.GetByIdUri(
ApiRoutes.ProductExportBill.GetById.Replace(
"{productExportBillId}",
result.EntityReturn.Id.ToString())
);
var productExportBillResponse = _mapper.Map <ProductExportBillResponse>(
result.EntityReturn);
return(Created(locationUri,
new Response <ProductExportBillResponse>(productExportBillResponse)));
}
public async Task <IActionResult> Create([FromBody] CreateStorageRequest createModel)
{
var storageEntity = _mapper.Map <Storage>(createModel);
var createdUserId = int.Parse(HttpContext.GetUserIdFromRequest());
var isCreateSuccess = await _storageService.CreateAsync(storageEntity, createdUserId);
if (!isCreateSuccess)
{
return(BadRequest("Tạo kho hàng không thành công, vui lòng thử lại"));
}
var storageUri = _uriService.GetByIdUri(
ApiRoutes.Storage.GetById.Replace("{storageId}", storageEntity.Id.ToString()));
var storageResponse = _mapper.Map <StorageResponse>(storageEntity);
return(Created(
storageUri,
new Response <StorageResponse>(storageResponse)));
}
public async Task <IActionResult> Create([FromBody] CreateAddressRequest createModel)
{
var addressEntity = _mapper.Map <Address>(createModel);
var createdCustomerId = int.Parse(HttpContext.GetUserIdFromRequest());
var isCreateSuccess = await _addressService.CreateAsync(addressEntity, createdCustomerId);
if (!isCreateSuccess)
{
return(BadRequest());
}
var addressUri = _uriService.GetByIdUri(
ApiRoutes.Address.GetById.Replace("{addressId}", addressEntity.Id.ToString()));
var addressResponse = _mapper.Map <AddressResponse>(addressEntity);
return(Created(
addressUri,
new Response <AddressResponse>(addressResponse)));
}
public async Task <IActionResult> Create([FromBody] CreateProductFavorRequest createModel)
{
var productFavorEntity = _mapper.Map <ProductFavorite>(createModel);
var createdCustomerId = int.Parse(HttpContext.GetUserIdFromRequest());
var isCreateSuccess = await _productFavorService
.CreateAsync(productFavorEntity, createdCustomerId);
if (!isCreateSuccess.IsSuccess)
{
return(BadRequest(isCreateSuccess.Errors));
}
var productFavorUri = _uriService.GetByIdUri(
ApiRoutes.ProductFavor.GetById.Replace("{productFavorId}", productFavorEntity.Id.ToString()));
var prodcutFavorResponse = _mapper.Map <ProductFavorResponse>(productFavorEntity);
return(Created(
productFavorUri,
new Response <ProductFavorResponse>(prodcutFavorResponse)));
}
public async Task <IActionResult> Create(
[FromForm] CreateImportBillRequest createModel
)
{
var requestedUserId = int.Parse(HttpContext.GetUserIdFromRequest());
ImportBill importBillEntity = new ImportBill
{
RequestImportProductId = createModel.RequestImportProductId
};
var importBillDetails = _mapper
.Map <IEnumerable <CreateImportBillDetailRequest>, IEnumerable <ImportBillDetail> >(
createModel.ImportBillDetails);
var result = await _importBillService.CreateAsync(
importBillEntity,
importBillDetails,
requestedUserId,
createModel.SupplierBillImage,
createModel.StorageManagerBillImage,
_appSettings.Value.ImportBillImageDir,
_env.ContentRootPath
);
if (result.IsSuccess == false)
{
return(BadRequest(result.Errors));
}
var locationUri = _uriService.GetByIdUri(
ApiRoutes.ImportBill.GetById.Replace(
"{importBillId}",
result.ImportBill.Id.ToString())
);
var importBillResponse = _mapper.Map <ImportBillResponse>(result.ImportBill);
return(Created(locationUri,
new Response <ImportBillResponse>(importBillResponse)));
}
public async Task <IActionResult> Create(
[FromBody] CreateOrderRequest createModel
)
{
var requestedUserId = int.Parse(HttpContext.GetUserIdFromRequest());
DateTime IdealShipTimeDate = string.IsNullOrEmpty(createModel.IdealShipTime) == false
? DateTime.ParseExact(createModel.IdealShipTime, "dd/MM/yyyy HH:mm:ss", CultureInfo.InvariantCulture)
: DateTime.UtcNow;
Order orderEntity = new Order
{
IdealShipTime = IdealShipTimeDate,
IsGift = createModel.IsGift,
Notes = createModel.Notes,
AddressId = createModel.AddressId,
PaymentMethodId = createModel.PaymentMethodId
};
var createResult = await _orderService.CreateAsync(
orderEntity,
requestedUserId,
_appSettings.Value.StripeSecretKey
);
if (createResult.IsSuccess == false)
{
return(BadRequest(createResult.Errors));
}
var orderResponse = _mapper.Map <OrderResponse>(orderEntity);
var locationUri = _uriService.GetByIdUri(
ApiRoutes.Order.GetById.Replace("{orderId}", orderEntity.Id.ToString())
);
return(Created(locationUri,
new Response <OrderResponse>(orderResponse)));
}
public async Task <IActionResult> Create([FromBody] AddProductToCartRequest model)
{
var requestedUserId = int.Parse(HttpContext.GetUserIdFromRequest());
var cartDetailEntity = _mapper.Map <CartDetail>(model);
var result = await _cartDetailService.AddProductToCartAsync(cartDetailEntity);
if (!result.IsSuccess)
{
return(BadRequest(new AddProductToCartFailedResponse
{
Errors = result.Errors
}));
}
var cartDetailResponse = _mapper.Map <CartDetailResponse>(result.CartDetail);
var locationUri = _uriService.GetByIdUri(
ApiRoutes.Product.GetById.Replace("{cartDetailId}", cartDetailEntity.Id.ToString())
);
return(Created(locationUri,
new Response <CartDetailResponse>(cartDetailResponse)));
}
