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)); }