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