public async Task <int> AddProductAsync(int productHeaderId, NewProductDto newProduct)
{
var product = new Product()
{
Code = newProduct.Code,
ExtraDescription = newProduct.ExtraDescription,
Price = newProduct.Price,
SpecialPrice = newProduct.SpecialPrice,
CreateDate = DateTime.Now,
SizeId = newProduct.Size.Id,
ColorPrimaryId = newProduct.ColorPrimary.Id,
ColorSecondaryId = newProduct.ColorSecondary.Id,
ProductHeaderId = productHeaderId,
IsActive = true
};
await _dbContext.Products.AddAsync(product);
if (await _dbContext.SaveChangesAsync() > 0)
{
return(product.Id);
}
return(0);
}
public async Task <IActionResult> Post([FromBody] NewProductDto newProduct)
{
var createdProduct = await _productsService.Create(newProduct);
var productUri = CreateResourceUri(createdProduct.Id);
return(Created(productUri, createdProduct));
}
public ProductDto Update(string id, NewProductDto newProduct)
{
var product = _context.Products.First(x => x.Id == id);
product.UpdateValues(newProduct);
_context.SaveChanges();
return(MapToDto(product));
}
private Product MapToData(NewProductDto newProduct)
{
return(new Product
{
Category = newProduct.Category,
Name = newProduct.Name
});
}
private Product CreateProductPoco(NewProductDto newItem)
{
var creationDate = _timeService.GetCurrentTime();
var product = _mapper.Map <Product>(newItem);
product.LastModified = creationDate;
product.Created = creationDate;
return(product);
}
public static Product MapNewProduct(this NewProductDto newProductDto) =>
new Product
{
Sku = newProductDto.Sku,
Name = newProductDto.Name,
Description = newProductDto.Description,
Price = newProductDto.Price,
NumberAvailable = newProductDto.NumberAvailable,
};
public void Put(string id, [FromBody] NewProductDto value)
{
var product = _productsService.GetById(id);
if (product != null)
{
_productsService.Update(id, value);
}
}
public ActionResult Put(Guid id, [FromBody] NewProductDto product)
{
if (product == null || id == null || id == Guid.Empty)
{
return(BadRequest());
}
var updated = _productsService.Update(id.ToString(), product);
return(Ok(updated));
}
public ProductDto Add(NewProductDto newProduct)
{
var product = MapToData(newProduct);
_context.Products.Add(product);
_context.SaveChanges();
var addedDto = MapToDto(product);
return(addedDto);
}
public ProductDto Update(NewProductDto updatedProduct, string id)
{
var product = MapToData(updatedProduct);
product.Id = id;
_context.Products.Update(product);
_context.SaveChanges();
var updatedDto = MapToDto(product);
return(updatedDto);
}
public ProductDto Update(string id, NewProductDto newProduct)
{
var product = MapToData(newProduct);
product.Id = id;
_context.Entry(product).State = EntityState.Modified;
_context.SaveChanges();
return(MapToDto(product));
}
public async Task <IActionResult> AddProduct([FromBody] NewProductDto newProductDto)
{
var addedProductDto = await _productManagingService.AddNewProduct(newProductDto);
if (addedProductDto == null)
{
return(BadRequest());
}
return(Ok(addedProductDto));
}
public async Task <ActionResult <ProductDto> > Post([FromForm] NewProductDto productDto)
{
if (ModelState.IsValid)
{
var product = await _productService.AddProductAsync(productDto, HttpContext.Request);
return(CreatedAtAction("Get", new { id = product.Id }, product));
}
return(BadRequest(ModelState));
}
public ActionResult Put(string id, [FromBody] NewProductDto newProduct)
{
var product = _productsService.Get(id);
if (product == null)
{
return(NotFound(id));
}
return(Ok(_productsService.Update(id, newProduct)));
}
public ActionResult <ProductDto> Put(string id, [FromBody] NewProductDto product)
{
ProductDto result = _productsService.EditProduct(id, product);
if (result != null)
{
return(Ok(result));
}
return(NotFound("Product not found"));
}
public ProductDto Update(string id, NewProductDto newProduct)
{
var product = _context.Products.FirstOrDefault(x => x.Id == id);
if (product != null)
{
product.Category = newProduct.Category;
product.Name = newProduct.Name;
_context.SaveChanges();
}
return(MapToDto(product));
}
public ProductDto Update(string id, NewProductDto value)
{
var product = _context.Products.FirstOrDefault(p => p.Id == id);
if (product == null)
{
return(null);
}
product.Name = value.Name;
product.Category = value.Category;
_context.SaveChanges();
return(MapToDto(product));
}
public async Task <ProductDto> AddProductAsync(NewProductDto productDto, HttpRequest httpRequest)
{
var product = productDto.MapNewProduct();
if (productDto.PictureToUpload.Length > 0)
{
product.PictureUri = await _fileService.SaveFileAsync(productDto.PictureToUpload, httpRequest);
}
await _productRepository.AddAsync(product);
return(product.MapProductDto());
}
public async Task <IActionResult> Post([FromBody] NewProductDto newProduct)
{
var productToAdd = _mapper.Map <Product>(newProduct);
_productsRepo.Add(productToAdd);
if (await _productsRepo.SaveAll())
{
return(CreatedAtRoute("GetProduct", new { id = productToAdd.Id }, productToAdd));
}
throw new Exception("Creating the product failed on save.");
}
public async Task <ActionResult> Put(string id, [FromBody] NewProductDto updatedProduct)
{
var result = await _productsService.Update(id, updatedProduct);
if (result)
{
return(Ok());
}
else
{
return(BadRequest("The product specified does not exist!"));
}
}
/// <summary>
/// Adds the new product.
/// </summary>
/// <param name="newProductDto">The new product dto.</param>
/// <returns></returns>
/// <exception cref="System.NotImplementedException"></exception>
public async Task <PartialProductDto> AddNewProduct(NewProductDto newProductDto)
{
// Creating new product
var product = _mapper.Map <NewProductDto, Product>(newProductDto);
// Stub
product.ProductNumber = DateTime.Now.ToString(CultureInfo.CurrentCulture);
product.SafetyStockLevel = 100;
product.ReorderPoint = 75;
product.DaysToManufacture = 4;
product.ProductLine = "R";
product.Class = "L";
product.Style = "U";
product.WeightUnitMeasureCode = "LB";
product.SizeUnitMeasureCode = "CM";
product.SellStartDate = DateTime.Now;
// Creating new productmodel
var productModel = new ProductModel()
{
Name = newProductDto.ModelName
};
// Creating new productPhotos
var productPhoto = new ProductPhoto()
{
LargePhoto = newProductDto.LargePhoto
};
// Creating new product description
var productDescription = new ProductDescription()
{
Description = newProductDto.Description
};
// Getting english culture object
var culture = await _cultureRepository.GetCulture("en");
try
{
var addedProduct = await _productTransactions.AddProduct(product, productModel, productDescription, productPhoto, culture);
var addedProductDto = _mapper.Map <Product, PartialProductDto>(addedProduct);
return(addedProductDto);
}
catch (Exception)
{
return(null);
}
}
public async Task <IActionResult> Post([FromBody] NewProductDto product)
{
try
{
var createProduct = new CreateProduct(Guid.NewGuid(), product.ProductName, product.Quantity);
await _mediator.Send(createProduct);
return(Ok(new { message = "Product created" }));
}
catch (Exception ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public async Task <ActionResult <Product> > CreateProduct([FromBody] NewProductDto product)
{
logger.LogInformation("Creating a new Product");
var result = Product.Create(product.Name, product.Description, product.Price);
if (result.IsSuccess)
{
productRepository.AddProduct(result.Value);
await productRepository.SaveChangesAsync();
return(Ok(result.Value));
}
return(BadRequest(result.ValidationResults));
}
public async Task <ProductDto> Create(NewProductDto newItem)
{
if (newItem == null)
{
throw new ArgumentNullException(nameof(newItem));
}
var product = CreateProductPoco(newItem);
await _repository.Create(product);
var productDto = _mapper.Map <ProductDto>(product);
return(productDto);
}
public void Create(NewProductDto dto)
{
var entity = new Product
{
ProductName = dto.Name,
UnitPrice = dto.Price,
UnitsInStock = dto.Stock,
QuantityPerUnit = dto.PackageInfo,
CategoryID = dto.CategoryId,
SupplierID = dto.SupplierId
};
repo.Add(entity);
repo.Save();
}
public Task <ProductDto> Add(NewProductDto newProduct)
{
var tcs = new TaskCompletionSource <ProductDto>();
Task.Run(() =>
{
var product = MapToData(newProduct);
_context.Products.Add(product);
_context.SaveChanges();
var addedDto = MapToDto(product);
tcs.SetResult(addedDto);
});
return(tcs.Task);
}
public ActionResult <ProductDto> Create([FromBody] NewProductDto data)
{
try
{
var product = _mapper.Map <NewProductDto, Product>(data);
var newProduct = _service.CreateProduct(product);
var result = _mapper.Map <Product, ProductDto>(newProduct);
return(CreatedAtAction(nameof(Get), new { id = newProduct.Id }, result));
}
catch (ArgumentException)
{
return(BadRequest());
}
}
public async Task <IActionResult> Put(int id, NewProductDto product)
{
var productFromRepo = await _productsRepo.GetProduct(id);
productFromRepo.Name = product.Name;
productFromRepo.Category = product.Category;
if (await _productsRepo.SaveAll())
{
return(NoContent());
}
throw new Exception($"Updating product with {id} failed on save");
}
public ActionResult Put(string id, [FromBody] ProductDto product)
{
ProductDto updatedProduct = _productsService.Update(id, product);
if (updatedProduct == null)
{
NewProductDto newProduct = new NewProductDto
{
Name = product.Name,
Category = product.Category
};
_productsService.Add(newProduct);
}
return(Ok("The product with id:" + id + "was updated succesfully!"));
}
public ProductDto EditProduct(string id, NewProductDto productToEdit)
{
Product productFromDb = _context.Products.FirstOrDefault(x => x.Id == id);
if (productFromDb != null)
{
productFromDb.Name = productToEdit.Name;
productFromDb.Category = productToEdit.Category;
_context.SaveChanges();
return(MapToDto(productFromDb));
}
return(null);
}
