public async Task <ActionResult> CreateProductAsync(ProductCreateDTO productDto)
{
var newProduct = _mapper.Map <Product>(productDto);
var createdProduct = await _productService.AddProductAsync(newProduct);
return(Ok(createdProduct));
}
public async Task <ActionResult <ProductDTO> > Post([FromBody] ProductCreateDTO dto)
{
var claimRole = User.Claims.First(c => c.Type == ClaimTypes.Role);
if (!claimRole.Value.Equals(UserRoleEnum.Producer.ToString()))
{
return(Forbid());
}
var(created, message) = await _productRepository.CreateAsync(dto);
if (created == null && message.Equals("Error"))
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
else if (created == null && message.Equals("No wallet address"))
{
return(BadRequest("The user has no wallet address"));
}
else if (created == null)
{
return(BadRequest());
}
return(CreatedAtAction(nameof(Get), new { id = created.ProductId }, created));
}
public async Task <ActionResult <ProductReadDTO> > CreateProduct([FromBody] ProductCreateDTO productCreateDto)
{
if (productCreateDto == null)
{
return(BadRequest());
}
var model = new Product
(
productCreateDto.Name,
productCreateDto.Price,
productCreateDto.Color,
productCreateDto.Description,
productCreateDto.CategoryId
);
await _productService.AddProduct(model);
var productReadDto = new ProductReadDTO
{
ProductId = model.ProductId,
Name = model.Name,
Price = model.Price,
Color = model.Color,
Description = model.Description
};
return(CreatedAtRoute(nameof(GetProduct), new { Id = productReadDto.ProductId }, productReadDto));
}
public void Create(ProductCreateDTO item)
{
var product = _mapper.Map <Product>(item);
_context.Add(product);
_context.SaveChanges();
}
public async Task Post_with_database_error_returns_InternalServerError()
{
var dto = new ProductCreateDTO();
var repository = new Mock <IProductRepository>();
repository.Setup(s => s.CreateAsync(It.IsAny <ProductCreateDTO>())).ReturnsAsync((null, "Error"));
var logger = new Mock <ILogger <ProductsController> >();
var controller = new ProductsController(repository.Object, logger.Object);
// Needs HttpContext to mock it.
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var cp = MockClaimsSecurity(42, UserRoleEnum.Producer.ToString());
//Update the HttpContext to use mocked claim
controller.ControllerContext.HttpContext.User = cp.Object;
var post = await controller.Post(dto);
var result = post.Result as StatusCodeResult;
Assert.Equal(StatusCodes.Status500InternalServerError, result.StatusCode);
}
public async Task <IActionResult> Post([FromBody] ProductCreateDTO product)
{
if ((await _unitOfWork.ProductRepository.Get(x => x.Barecode == product.Barecode)) != null)
{
return(BadRequest("Product with this barecode already exists!"));
}
if (!(await IsAllowedToPostOrPutProduct(product.CategoryId)))
{
return(Unauthorized("You are not allowed to add product to this category"));
}
var productEntity = _mapper.Map <Product>(product);
_unitOfWork.ProductRepository.Add(productEntity);
try
{
if (await _unitOfWork.SaveAll())
{
return(CreatedAtRoute("GetProduct", new { id = productEntity.Id }, _mapper.Map <ProductVM>(productEntity)));
}
}
catch (Exception ex)
{
return(StatusCode(500));
}
return(BadRequest("Error during adding new product"));
}
public async Task <IActionResult> Create([FromBody] ProductCreateDTO productDTO)
{
var location = GetControllerActionName();
try
{
logger.LogInfo($"{location}: Create Product");
if (productDTO == null)
{
logger.LogWarn($"{location}: Product object is empty");
return(BadRequest(ModelState));
}
if (!ModelState.IsValid)
{
logger.LogWarn($"{location}: Product object is incomplete");
return(BadRequest(ModelState));
}
var product = mapper.Map <Product>(productDTO);
var isSuccess = await productRepository.Create(product);
if (!isSuccess)
{
InternalError($"{location}: Create Product failed");
}
logger.LogInfo($"{location}: Create Product successful");
return(Created("Create", new { product }));
}
catch (Exception e)
{
return(InternalError($"{location}: {e.Message} - {e.InnerException}"));
}
}
public async Task <IActionResult> Create([FromBody] ProductCreateDTO productDTO)
{
var location = GetControllerActionNames();
try
{
_logger.LogInfo($"{location}: Create Attempted");
if (productDTO == null)
{
_logger.LogWarn($"{location}: Empty Request was submitted");
return(BadRequest(ModelState));
}
if (!ModelState.IsValid)
{
_logger.LogWarn($"{location}: Data was Incomplete");
return(BadRequest(ModelState));
}
var product = _mapper.Map <Product>(productDTO);
var isSuccess = await _businessLogic.Add(product);
if (!isSuccess.IsSuccess)
{
return(InternalError($"{location}: Creation failed"));
}
_logger.LogInfo($"{location}: Creation was successful");
return(Created("Create", new { product }));
}
catch (Exception e)
{
return(InternalError($"{location}: {e.Message} - {e.InnerException}"));
}
}
public async Task <IActionResult> Create(ProductCreateDTO createDTO)
{
if (ModelState.IsValid)
{
Product product = new Product
{
CategoryId = createDTO.CategoryId,
Stock = createDTO.Stock,
Description = createDTO.Description,
IsPublish = createDTO.IsPublish,
Price = createDTO.Price,
Title = createDTO.Title
};
product.ImageName = await _fileWorker.AddFileToPathAsync(createDTO.Image, "img");
if (product.IsPublish)
{
product.PublishDate = DateTime.Now;
}
await _repository.CreateAsync(product);
await _context.SaveChangesAsync();
return(LocalRedirect("/admin/products/index"));
}
SetCategories();
return(View(createDTO));
}
public async Task <ActionResult> CreateProduct([FromBody] ProductCreateDTO productCreate)
{
var product = mapper.Map <Product>(productCreate);
await productsDbHandler.CreateAsync(product);
var productDTO = mapper.Map <ProductDTO>(product);
return(CreatedAtRoute("getProduct", new { id = product.Id }, productDTO));
}
public async Task <ActionResult> Update(int id, [FromBody] ProductCreateDTO productCreate)
{
var product = mapper.Map <Product>(productCreate);
product.Id = id;
await productsDbHandler.UpdateAsync(product);
return(NoContent());
}
public async Task <bool> CreateProduct(ProductCreateDTO dto) //this is a signature for a method. Return type, name, and parameters
{
var rao = _mapper.Map <ProductCreateRAO>(dto);
if (await _repository.CreateProduct(rao))
{
return(true);
}
throw new NotImplementedException(); //here is the actual implementation. It is what happens BETWEEN the curly braces
}
public async Task <bool> CreateProduct(ProductCreateDTO dto)
{
var rao = _mapper.Map <ProductCreateRAO>(dto);
if (await _repository.CreateProduct(rao))
{
return(true);
}
return(false);
}
public void Create(ProductCreateDTO productCreateDTO)
{
CreateProductCommand command = new CreateProductCommand
{
Name = productCreateDTO.Name,
BrandName = productCreateDTO.BrandName,
Count = productCreateDTO.Count,
Price = productCreateDTO.Price
};
productCreate.Handle(command);
}
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 IActionResult AddNewProduct([FromBody] Product product)
{
_productRepository.AddProduct(product);
ProductCreateDTO productDTO = new ProductCreateDTO();
productDTO.ProductId = product.ProductId;
productDTO.ProductName = product.ProductName;
productDTO.ProductPrice = product.ProductPrice;
productDTO.DateCreated = product.DateCreated;
return(Ok(new Response <ProductCreateDTO>(productDTO)));
}
public IActionResult AddProduct(ProductCreateDTO product)
{
try
{
ProductRepository.Add(product);
return(Ok("Data inserted"));
}
catch (ValidationException)
{
return(BadRequest());
}
}
public async Task Post_given_valid_DTO_creates_and_returns_ProductDTO()
{
var id = 1;
var dto = new ProductCreateDTO
{
Title = "Test",
UserId = 42,
Price = 42,
Rank = 1,
};
var expected = new ProductDTO
{
ProductId = id,
Title = "Test",
UserId = 42,
Price = 42,
Available = true,
Rank = 1,
};
var expectedMessage = "Created";
var repository = new Mock <IProductRepository>();
repository.Setup(s => s.CreateAsync(It.IsAny <ProductCreateDTO>())).ReturnsAsync((expected, expectedMessage));
var logger = new Mock <ILogger <ProductsController> >();
var controller = new ProductsController(repository.Object, logger.Object);
// Needs HttpContext to mock it.
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var cp = MockClaimsSecurity(id, UserRoleEnum.Producer.ToString());
//Update the HttpContext to use mocked claim
controller.ControllerContext.HttpContext.User = cp.Object;
var post = await controller.Post(dto);
var result = post.Result as CreatedAtActionResult;
var resultValue = result.Value as ProductDTO;
repository.Verify(s => s.CreateAsync(dto));
Assert.Equal("Get", result.ActionName);
Assert.Equal(expected.ProductId, result.RouteValues["id"]);
Assert.Equal(expected.ProductId, resultValue.ProductId);
Assert.Equal(expected.Rank, resultValue.Rank);
}
public async Task <ProductDTO> Create(ProductCreateDTO model)
{
var entry = new Product
{
Name = model.Name,
Description = model.Description,
Price = model.Price
};
await _context.Products.AddAsync(entry);
await _context.SaveChangesAsync();
return(_mapper.Map <ProductDTO>(entry));
}
public void Create(ProductCreateDTO productCreateDTO)
{
var productId = Guid.NewGuid();
var productToCreate = new Product
{
Id = productId,
BrandName = productCreateDTO.BrandName,
Name = productCreateDTO.Name,
Count = productCreateDTO.Count,
Price = productCreateDTO.Price
};
productRepository.Create(productToCreate);
}
public void Create(ProductCreateDTO productCreateDTO)
{
productCreate.Create(productCreateDTO);
var entry = new Activity
{
Id = Guid.NewGuid(),
CreatedOn = DateTime.Now,
Operation = "CreateProduct",
Data = JsonConvert.SerializeObject(productCreateDTO)
};
//Persist the Activity
}
public ActionResult <ProductReadDto> Create(ProductCreateDTO productCreateDTO)
{
var productToCreate = mapper.Map <Product>(productCreateDTO);
var result = productService.Create(productToCreate);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var productReadDto = mapper.Map <ProductReadDto>(result.Product);
return(CreatedAtRoute(nameof(GetProducts), new { id = productReadDto.Id }, productReadDto));
}
/// <summary>
///
/// </summary>
/// <param name="product"></param>
/// <returns></returns>
public ProductDTO Add(ProductCreateDTO product)
{
Product addedProduct = new Product()
{
Id = Guid.NewGuid(),
Name = product.Name,
Quantity = product.Quantity,
Price = product.Price,
Description = product.Description
};
Context.Products.Add(addedProduct);
Context.SaveChanges();
return(Mapper.Map <ProductDTO>(addedProduct));
}
[HttpPut("{id}")] // PUT api/products/{id}
public async Task <IActionResult> UpdateProduct(int id, ProductCreateDTO productCreateDTO)
{
var productModelFromRepo = await _repository.GetProductByIdAsync(id);
if (productModelFromRepo is null)
{
return(NotFound());
}
_mapper.Map(productCreateDTO, productModelFromRepo);
_repository.UpdateProduct(productModelFromRepo);
await _repository.SaveChangesAsync();
return(NoContent());
}
[HttpPost] // POST api/products
public async Task <ActionResult <ProductReadDTO> > CreateProduct(ProductCreateDTO productCreateDTO)
{
if (productCreateDTO is null)
{
throw new ArgumentNullException(nameof(productCreateDTO));
}
var productModel = _mapper.Map <Product>(productCreateDTO);
_repository.CreateProduct(productModel);
await _repository.SaveChangesAsync();
var productReadDto = _mapper.Map <ProductReadDTO>(productModel);
return(CreatedAtRoute(nameof(GetProductById), new { Id = productReadDto.ProductId }, productReadDto));
}
public async Task <IHttpActionResult> PostProduct(ProductCreateDTO productData)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Product product = new Product
{
name = productData.name,
description = productData.description,
//sku = productData.sku,
type = productData.type
};
db.Products.Add(product);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = product.id }, product));
}
public async Task <ActionResult <ProductRefDTO> > AddProduct([FromBody] ProductCreateDTO productCreationDTO)
{
object?[] values =
{
productCreationDTO.Username,
productCreationDTO.ProductDetails?.Name,
productCreationDTO.ProductDetails?.Category,
};
if (values.Contains(null))
{
return(BadRequest("Missing parameter values"));
}
Result <Product> productResult = await MarketProductsService.AddProduct
(
productCreationDTO.ProductDetails !.ToProductData(),
productCreationDTO.StoreId,
productCreationDTO.Username
);
if (productResult == null)
{
return(InternalServerError());
}
if (productResult.IsErr)
{
return(string.IsNullOrWhiteSpace(productResult.Mess) ?
InternalServerError() :
InternalServerError(productResult.Mess));
}
Product product = productResult.Ret;
return(new ProductRefDTO
{
Id = product.Id,
Name = product.Name,
});
}
public async Task Post_given_invalid_User_Role_returns_Forbidden()
{
var dto = new ProductCreateDTO();
var userRole = UserRoleEnum.Receiver.ToString();
var repository = new Mock <IProductRepository>();
var logger = new Mock <ILogger <ProductsController> >();
var controller = new ProductsController(repository.Object, logger.Object);
// Needs HttpContext to mock it.
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var cp = MockClaimsSecurity(42, userRole);
//Update the HttpContext to use mocked claim
controller.ControllerContext.HttpContext.User = cp.Object;
var post = await controller.Post(dto);
Assert.IsType <ForbidResult>(post.Result);
}
public void Create(ProductCreateDTO productDTO) => throw new NotImplementedException();
/// <summary>
/// Create product from ProductCreateDTO and return a ProductDTO
/// </summary>
public async Task <(ProductDTO created, string message)> CreateAsync(ProductCreateDTO dto)
{
if (dto == null)
{
return(null, "Empty DTO");
}
var producerUser = await(from p in _context.Users
where p.Id == dto.UserId
select new
{
p.Producer.WalletAddress
}).FirstOrDefaultAsync();
if (producerUser == null)
{
return(null, "Producer not found");
}
else if (string.IsNullOrEmpty(producerUser.WalletAddress))
{
return(null, "No wallet address");
}
var product = new Product
{
Title = dto.Title,
UserId = dto.UserId,
Price = dto.Price,
Description = dto.Description,
Country = dto.Country,
Location = dto.Location,
Available = true,
Rank = dto.Rank,
Created = DateTime.UtcNow
};
try
{
var createdProduct = _context.Products.Add(product);
await _context.SaveChangesAsync();
}
catch (Exception)
{
return(null, "Error");
}
var productDTO = new ProductDTO
{
ProductId = product.Id,
Title = dto.Title,
UserId = dto.UserId,
Price = dto.Price,
Country = dto.Country,
Description = dto.Description,
Location = dto.Location,
Available = product.Available,
Rank = dto.Rank,
};
return(productDTO, "Created");
}
