public void Add(ProductCreationDto dto)
{
if (dto == null)
{
throw new Exception("No query parameters");
}
if (dto.CategoryIds == null || !dto.CategoryIds.Any())
{
throw new Exception("Category list is empty");
}
var newProduct = dto.ToEntity();
var productType = _unitOfWork.Types.Get(dto.ProductTypeId);
var unit = _unitOfWork.Units.Get(dto.UnitId);
newProduct.Unit = unit ?? throw new Exception("Wrong unit");
newProduct.Type = productType ?? throw new Exception("Wrong product type");
foreach (var categoryId in dto.CategoryIds)
{
var category = _unitOfWork.Categories.Get(categoryId);
if (category == null)
{
throw new Exception("Wrong category");
}
newProduct.Categories.Add(new ProductCategory
{
Category = category,
Product = newProduct
});
}
newProduct.Created = DateTimeOffset.UtcNow;
_unitOfWork.Products.Add(newProduct);
_unitOfWork.Save();
}
public ActionResult <ProductConfirmationDto> CreateProduct([FromBody] ProductCreationDto productDto, [FromHeader] string key)
{
try
{
if (!auth.AuthorizeUser(key))
{
return(StatusCode(StatusCodes.Status401Unauthorized, "Authorization failed!"));
}
Product product = mapper.Map <Product>(productDto);
productRepository.CreateProduct(product);
productRepository.SaveChanges();
logger.Log(LogLevel.Information, contextAccessor.HttpContext.TraceIdentifier, "", "New product created", null);
string location = linkGenerator.GetPathByAction("GetProductById", "Product", new { productId = product.ItemId });
return(Created(location, mapper.Map <ProductConfirmationDto>(product)));
}
catch (Exception ex)
{
logger.Log(LogLevel.Error, contextAccessor.HttpContext.TraceIdentifier, "", "There is error while creating product", null);
return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message));
}
}
public async Task <IActionResult> CreateProduct([FromBody] ProductCreationDto productInfo)
{
//TODO: Create Product Validation
await this.productsService.CreateProductAsync(productInfo);
return(this.Ok());
}
public async Task <IActionResult> UpdateProduct(ProductCreationDto dto)
{
try
{
var update = new ProductCreationDto
{
Code = dto.Code,
Name = dto.Name,
Description = dto.Description,
//ProductPhoto = dto.ProductPhoto,
DiscountStock = dto.DiscountStock,
Discontinued = dto.Discontinued,
ShowBrand = dto.ShowBrand,
Slow = dto.Slow,
BrandId = dto.BrandId,
CategoryId = dto.CategoryId,
Price1 = dto.Price1,
Stock1 = dto.Stock1,
ImageUrl = dto.ImageUrl
};
await _productRepository.Update(dto);
return(Ok(update));
}
catch (Exception e)
{
return(NotFound("This Product cannot be changed"));
}
}
/// <summary>
/// 创建商品
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <ProductDto> CreateAsync(ProductCreationDto input)
{
var product = await _productMgr.CreateAsync(input.Sku, input.Price, input.Name, input.Unit, input.Describe);
await _productRepo.InsertAsync(product);
return(_mapper.Map <ProductDto>(product));
}
public static Product ToEntity(this ProductCreationDto dto)
{
return(new Product
{
Code = dto.Code,
DeliveryDate = dto.DeliveryDate,
Description = dto.Description,
IsAvailable = dto.IsAvailable,
Price = dto.Price
});
}
public async Task <ProductDto> CreateProduct(ProductCreationDto productDto)
{
var product = _mapper.Map <Product>(productDto);
_unitOfWork.Product.CreateProduct(product);
await _unitOfWork.SaveAsync();
product = await _unitOfWork.Product.GetProductAsync(product.ID, false);
return(_mapper.Map <ProductDto>(product));
}
public async Task <IActionResult> CreateProduct([FromBody] ProductCreationDto product)
{
var productEntity = _mapper.Map <Product>(product);
_repository.Product.CreateProduct(productEntity);
await _repository.SaveAsync();
var createdProduct = _mapper.Map <ProductDto>(productEntity);
return(CreatedAtRoute("ProductById", new { id = createdProduct.productId }, createdProduct));
}
public async Task <IActionResult> DeleteProduct(ProductCreationDto dto)
{
try
{
await _productRepository.Delete(dto);
return(Ok());
}
catch (Exception e)
{
return(NotFound("This Product cannot be delete"));
}
}
public IActionResult Add([FromBody] ProductCreationDto request)
{
try
{
_service.Add(request);
return(Ok());
}
catch (Exception e)
{
_logger.LogError(-1, e, String.Format(LogErrorText, e.Message));
return(BadRequest(String.Format(BadRequestText, "adding product")));
}
}
/// <inheritdoc />
public void SaveEdit(long id, ProductCreationDto edited)
{
using (var unitOfWork = this.unitOfWorkFactory.CreateUnitOfWork())
{
var repository = unitOfWork.CreateEntityRepository <Product>();
var product = repository.FindById(id);
product.Description = edited.Description;
product.Price = edited.Price;
product.Title = edited.Title;
repository.Update(product);
unitOfWork.Save();
}
}
public async Task CreateProductAsync(ProductCreationDto productInfo)
{
Product newProduct = new Product()
{
Name = productInfo.Name,
Price = productInfo.Price,
ImageUrl = productInfo.ImageUrl,
};
await this.dbContext.AddAsync(newProduct);
await this.dbContext.SaveChangesAsync();
}
public async Task <IActionResult> AddProduct(ProductCreationDto product)
{
var productCreation = _mapper.Map <Product>(product);
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
if (userId == null || userId == "")
{
return(Unauthorized());
}
productCreation.ShopID = await _shop.ShopIdByUserId(userId);
await _product.AddProduct(productCreation);
return(CreatedAtRoute("GetProduct", new { id = productCreation.ProductID }, _mapper.Map <ProductReturnDto>(productCreation)));
}
public IActionResult Post([FromBody] ProductCreationDto product)
{
var user = _userService.GetById(int.Parse(User.Identity.Name));
if (user == null)
{
return(Unauthorized());
}
_productRepository.AddProduct(product, user);
if (!_productRepository.Save())
{
throw new Exception("Failed to create product");
}
return(Ok());
}
public void AddProduct(ProductCreationDto productDto, User creator)
{
if (creator == null)
{
throw new AppException("User not found");
}
var product = new Product {
Name = productDto.Name,
Description = productDto.Description,
AddedBy = creator,
TimeEstimate = productDto.TimeEstimate,
Requirements = JsonConvert.SerializeObject(productDto.Requirements),
Instructions = CreateInstructions(productDto.Instructions),
ProductImage = productDto.ProductImage != null?ConvertBase64ToBinary(productDto.ProductImage) : null
};
_context.Products.Add(product);
}
public async Task <IActionResult> CreateProduct([FromBody] ProductCreationDto productDto)
{
try
{
if (productDto == null)
{
_logger.LogError("product sent from client is empty");
return(BadRequest("product object is empty"));
}
if (!ModelState.IsValid)
{
_logger.LogError("invalid model state for product");
return(UnprocessableEntity());
}
//gets the instance of the logged in user
ClaimsPrincipal user = this.User;
string Store = user.Claims.Where(c => c.Type == "Store")
.Select(x => x.Value).FirstOrDefault();
string seller = user.Claims.Where(c => c.Type == ClaimTypes.NameIdentifier)
.Select(x => x.Value).FirstOrDefault();
var product = _mapper.Map <Products>(productDto);
product.SellerId = seller;
product.Store = Store;
_repository.Products.CreateProduct(product);
await _repository.SaveAsync();
return(CreatedAtRoute("ProductById", new { ProductId = product.ProductsId }, product));
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(StatusCode(500, "internal server error"));
}
}
public void CanAddProduct()
{
_context.Users.Add(_testUser);
Assert.DoesNotThrow(() => {
var instructions = new Collection <InstructionCreationDto>();
var requirements = new Collection <string>();
var product = new ProductCreationDto {
Name = "Test product",
Description = "A test product",
TimeEstimate = "5 hours",
Requirements = requirements,
Instructions = instructions,
ProductImage = null
};
_productRepository.AddProduct(product, _testUser);
});
}
public async Task <IActionResult> CreateProduct(ProductCreationDto dto)
{
var newProduct = new ProductCreationDto
{
Code = dto.Code,
Name = dto.Name,
Description = dto.Description,
//ProductPhoto = dto.ProductPhoto,
DiscountStock = dto.DiscountStock,
Discontinued = dto.Discontinued,
ShowBrand = dto.ShowBrand,
Slow = dto.Slow,
BrandId = dto.BrandId,
CategoryId = dto.CategoryId,
Price1 = dto.Price1,
Stock1 = dto.Stock1,
ImageUrl = dto.ImageUrl
};
await _productRepository.Create(newProduct);
return(Ok(dto));
}
public async Task <ActionResult <ProductDto> > CreateAsync([FromBody] ProductCreationDto input)
{
return(await _productSrv.CreateAsync(input));
}
public void Update(int id, ProductCreationDto productCreationDto)
{
var productEntity = _mapper.Map <Product>(productCreationDto);
_productService.Update(id, productEntity);
}
public SimpleProductDto Create(ProductCreationDto productCreationDto)
{
var productEntity = _mapper.Map <Product>(productCreationDto);
return(_mapper.Map <SimpleProductDto>(_productService.Create(productEntity)));
}
public ActionResult Update(int id, [FromBody] ProductCreationDto productCreationDto)
{
_productAppService.Update(id, productCreationDto);
return(NoContent());
}
public async Task <IActionResult> CreateProduct([FromBody] ProductCreationDto productDto)
{
var createdProduct = await _productService.CreateProduct(productDto);
return(CreatedAtRoute("GetProduct", new { id = createdProduct.ID }, createdProduct));
}
public ActionResult <SimpleProductDto> Create([FromBody] ProductCreationDto productCreationDto)
{
return(_productAppService.Create(productCreationDto));
}
