public ProductReadDto AddNewProduct(ProductCreateDto productCreateDto)
{
var newProductModel = this._mapper.Map <Product>(productCreateDto);
this._repository.Add(newProductModel);
this._repository.SaveChanges();
var productReadDto = this._mapper.Map <ProductReadDto>(newProductModel);
return(productReadDto);
}
public ActionResult <ProductReadDto> createNewProduct(ProductCreateDto newProduct)
{
var product = _mapper.Map <Product>(newProduct);
_ProductRepo.createProduct(product);
_ProductRepo.saveChanges();
var productReadDto = _mapper.Map <ProductReadDto>(product);
return(CreatedAtRoute(nameof(getProductById), new { id = product.Id }, productReadDto));
}
public ActionResult <ProductReadDto> AddNewProduct([FromBody] ProductCreateDto productCreateDto)
{
var productReadDto = this._productService.AddNewProduct(productCreateDto);
if (productReadDto == null)
{
return(this.BadRequest());
}
return(this.CreatedAtRoute(new { Id = productReadDto.ProductId }, productReadDto));
}
public ActionResult <ProductReadDto> createProduct(ProductCreateDto productCreateDto)
{
var productModel = _mapper.Map <Product>(productCreateDto);
_repository.createProduct(productModel);
_repository.SaveChanges();
var productReadDto = _mapper.Map <ProductReadDto>(productModel);
return(CreatedAtRoute(nameof(getProductById), new { Id = productReadDto.Id }, productReadDto));
// return Ok(productReadDto);
}
public ActionResult <ProductReadDto> CreateNewProduct(ProductCreateDto productCreateDto)
{
var productModel = mapper.Map <Product>(productCreateDto);
productRepository.AddProduct(productModel);
productRepository.SaveChanges();
var productReadDto = mapper.Map <ProductReadDto>(productModel);
return(CreatedAtRoute(nameof(GetProductById), new { Id = productReadDto.productID }, productReadDto));
// return Ok(productReadDto);
}
public async Task <IActionResult> Update([FromBody] ProductCreateDto productCreateDto, [FromRoute] int productId)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var itemModel = dtoMapper.Map <ProductCreateDto, Product>(productCreateDto);
await productService.UpdateProduct(productId, itemModel);
return(Ok("Product has updated"));
}
public async Task <IActionResult> CreateProduct(ProductCreateDto createDto)
{
var product = new Product()
{
Id = Guid.NewGuid(),
Name = createDto.Name,
Price = createDto.Price,
IsBad = createDto.IsBad
};
await _productRepository.AddAsync(product);
return(Ok(product.Id));
}
public bool Create(ProductCreateDto productCreateDto)
{
try
{
_shopOnline.PRODUCT_REPOSITORY.CreateProduct(productCreateDto);
_shopOnline.SaveChanges();
}
catch (Exception ex)
{
return(false);
}
return(true);
}
public async Task <ActionResult <ProductCreateDto> > CreateProductAsync([FromForm] ProductCreateDto productCreateDto)
{
productCreateDto.ImageName = await SaveImage(productCreateDto.ImageFile);
var productModel = _mapper.Map <Products>(productCreateDto);
_repository.CreateProduct(productModel);
_repository.SaveChanges();
var productReadDto = _mapper.Map <ProductReadDto>(productModel);
return(Ok(productReadDto));
}
public async Task <ServiceResult <ProductDto> > AddProductAsync(ProductCreateDto productCreateDto)
{
var product = Map <Product>(productCreateDto);
await _webShopDatabase.ProductRepository.AddProductAsync(product);
if (await _webShopDatabase.CompleteAsync())
{
return(ReturnOk(Map <ProductDto>(product)));
}
return(ReturnError("SavingProductToDatabaseNotSucceed"));
}
public async Task <ActionResult <ProductToReturnDto> > CreateProduct(ProductCreateDto productToCreate)
{
var product = _mapper.Map <ProductCreateDto, Product>(productToCreate);
_unitOfWork.Repository <Product>().Add(product);
var result = await _unitOfWork.Complete();
if (result <= 0)
{
return(BadRequest(new ApiResponse(400, "Problem creating product")));
}
return(_mapper.Map <Product, ProductToReturnDto>(product));
}
public async Task <ActionResult> Create([FromForm] ProductCreateDto productCreateDto)
{
var mapperProduct = _mapper.Map <Product>(productCreateDto);
string folderName = Path.Combine("images", "shop");
string fileName = await productCreateDto.Photo.SaveImg(_env.WebRootPath, folderName);
mapperProduct.PictureUrl = fileName;
await _productRepository.CreateProductAsync(mapperProduct);
return(Ok(mapperProduct));
}
private Notification ValidateModel(ProductCreateDto model)
{
Notification notification = new Notification();
if (model == null || string.IsNullOrEmpty(model.Name) || model.CategoryId == 0)
{
notification.AddError("Invalid JSON data in request body");
return(notification);
}
return(notification);
}
public async Task<IActionResult> CreateAppointment(ProductCreateDto productCreateDto)
{
var product = _mapper.Map<Product>(productCreateDto);
await _unitOfWork.Products.AddAsync(product);
if (await _unitOfWork.SaveAsync())
{
var productToReturn = _mapper.Map<ProductDetailDto>(product);
return CreatedAtRoute("GetProduct", new { id = product.ProductId }, productToReturn);
}
throw new Exception("Creating product failed on save");
}
public ProductDto Create(ProductCreateDto model)
{
var entry = new Product
{
Name = model.Name,
Description = model.Description,
Price = model.Price
};
_context.Add(entry);
_context.SaveChanges();
return(_mapper.Map <ProductDto>(entry));
}
public async Task <ActionResult> AddProduct(ProductCreateDto productCreateDto)
{
//productCreateDto.Category = await _unitOfWork.CategoryRepository.GetCategoryByIdAsync(productCreateDto.Category.Id);
var productToCreate = _mapper.Map <Product>(productCreateDto);
_unitOfWork.ProductRepository.AddProduct(productToCreate);
await _unitOfWork.Complete();
//var productToRead = _mapper.Map<ProductDto>(productToCreate);
return(CreatedAtAction("GetProductById", new { productId = productToCreate.Id }, productToCreate));
}
public ActionResult <ProductReadDto> CreateProduct(ProductCreateDto productCreateDto)
{
var productModel = _mapper.Map <Product>(productCreateDto);
_repository.CreateProduct(productModel);
_repository.SaveChanges();
var productReadDto = _mapper.Map <ProductReadDto>(productModel);
return(CreatedAtRoute(
routeName: nameof(GetProductById),
routeValues: new { productReadDto.Id },
value: productReadDto));
}
public async Task <ActionResult <Product> > PostProduct([FromBody] ProductCreateDto product)
{
var newProductId = Guid.NewGuid();
var command = new ProductCreateCommand
{
Id = newProductId,
Name = product.Name,
Price = product.Price
};
await _mediator.Publish(command); // Publish not Send as We can't read Data with Command only with Query
return(await GetProduct(newProductId.ToString()));
}
public async Task <ProductDto> CreateAsync(ProductCreateDto model)
{
var entity = new Product
{
Name = model.Name,
Description = model.Description,
Price = model.Price
};
await _context.AddAsync(entity);
await _context.SaveChangesAsync();
return(_mapper.Map <ProductDto>(entity));
}
public async Task <ActionResult <ProductToReturnDto> > UpdateProduct(int id, ProductCreateDto productToUpdate)
{
var product = await _unitOfWork.Repository <Product>().GetByIdAsync(id);
_mapper.Map(productToUpdate, product);
_unitOfWork.Repository <Product>().Update(product);
var result = await _unitOfWork.Complete();
if (result <= 0)
{
return(BadRequest(new ApiResponse(400, "Problem updating product")));
}
return(_mapper.Map <Product, ProductToReturnDto>(product));
}
public async Task <ProductDto> CreateProduct(ProductCreateDto model)
{
var product = _mapper.Map <Product>(model);
product.ImagePath = await _upload.SaveFile(model.Image);
await _unitOfWork.Product.Add(product);
await _unitOfWork.Commit();
var mapped = _mapper.Map <ProductDto>(product); // CreatedAtRoute için
return(mapped);
}
public void PostCreate(ProductCreateDto model)
{
using (var db = new DBContext())
{
var product = new Domains.Product()
{
Title = model.Title,
ProductCode = model.ProductCode,
Description = model.Description
};
db.Products.Add(product);
db.SaveChanges();
}
}
public async Task <ProductDto> Create(ProductCreateDto model)
{
var result = new Product
{
Name = model.Name,
Description = model.Description,
Price = model.Price,
CategoryId = model.CategoryId
};
await _context.AddAsync(result);
await _context.SaveChangesAsync();
return(_mapper.Map <ProductDto>(result));
}
public async Task <IHttpActionResult> PostProduct(ProductCreateDto productDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Product product = new Product();
Mapper.Map(productDto, product);
product = await _productService.AddAsync(product);
return(CreatedAtRoute("ApiRoute", new { id = product.Id }, productDto));
}
public ActionResult <ProductReadDto> CreateProduct(ProductCreateDto productCreateDto)
{
if (_categoryRepo.GetCategoryById((int)productCreateDto.ProductCategoryId) == null)
{
return(NoContent());
}
var productModel = _mapper.Map <Product>(productCreateDto);
_repository.CreateProduct(productModel);
_repository.SaveChanges();
var productReadDto = _mapper.Map <ProductReadDto>(productModel);
return(CreatedAtRoute(nameof(GetProductById), new { Id = productReadDto }, productReadDto));
}
public async Task <IActionResult> CreateProduct([FromBody] ProductCreateDto dto)
{
if (!User.IsInRole(Role.Admin))
{
return(Forbid());
}
var response = await _productService.CreateProduct(dto);
if (response == null)
{
return(BadRequest(new { message = "Book Name and Book Code already exist." }));
}
return(Ok(response));
}
// [ValidationAspect(typeof(ProductCreateDtoValidator))]
//[TransactionScopeAspect]
public async Task <IResult> AddAsync(ProductCreateDto productCreateDto)
{
var productDto = await FillInData(productCreateDto);
await _productColorFabricBlendService.AddRangeAsync(productDto.ProductColorFabricBlends);
await _productVariantService.AddRangeAsync(productDto.ProductVariants);
await _productDal.AddAsync(productCreateDto.Product);
await _productDescriptionService.AddAsync(productCreateDto.ProductDescription);
await _productAttributeService.AddRangeAsync(productCreateDto.ProductAttributes);
return(new SuccessResult(Messages.ProductAdded));
}
public async Task <ActionResult <ProductDto> > AddProduct(ProductCreateDto productCreateDto)
{
if (productCreateDto == null || string.IsNullOrEmpty(productCreateDto.Name))
{
return(BadRequest());
}
var result = await _productService.AddProductAsync(productCreateDto);
if (result.HasError)
{
return(BadRequest(result.Exception));
}
return(Ok(result.Result));
}
public async Task <ActionResult <ProductReadDto> > AddNewProductAsync(ProductCreateDto productDto)
{
_logger.LogInformation(
$"Invoking {nameof(GetAllProductsByCategoryAsync)} method with arguments: productDto={JsonConvert.SerializeObject(productDto)}");
var newProduct = _mapper.Map <Product>(productDto);
var result = await _productService.SaveAsync(newProduct);
if (!result.Success)
{
return(BadRequest(new ErrorResource(result.Message)));
}
var productReadDto = _mapper.Map <ProductReadDto>(result.Resource);
return(CreatedAtRoute(nameof(GetProductByIdAsync), new { id = newProduct.Id }, _mapper.Map <ProductReadDto>(productReadDto)));
}
public ActionResult <ProductReadDto> CreateProduct(Guid brandId, ProductCreateDto productCreateDto)
{
Brand brand = _repository.GetBrandById(brandId);
if (brand == null)
{
return(NotFound());
}
Product createdProduct = _mapper.Map <Product>(productCreateDto);
_repository.AddProduct(brandId, createdProduct);
_repository.SaveChanges();
ProductReadDto productReadDto = _mapper.Map <ProductReadDto>(createdProduct);
return(CreatedAtRoute("GetProduct", new { brandId, productId = productReadDto.Id }, productReadDto));
}
