public async Task <IActionResult> Create([FromForm] ProductInputModel inputModel)
{
if (inputModel == null)
{
return(BadRequest());
}
var product = inputModel.ToEntity();
if (null != inputModel.Photo)
{
string imagePath = await _fs.Create(inputModel.Photo.OpenReadStream(),
FileTypes.ProductPhoto,
_fs.CreateDefaultFileName(inputModel.Photo.FileName));
product.Photo = imagePath;
}
product = _store.Create(product);
var outputModel = ProductOutputModel.FromEntity(product);
return(CreatedAtRoute("ViewProduct",
new { id = outputModel.Id }, outputModel));
}
public async Task ProductInputModelIsValidAndProductNotExistAtDb_ProductAdded_ReturnsProductAddedAtSuccessMessage()
{
//arrange
var product = new Product("Skol lata", 2.39M);
var company = new Company("Vendinha da esquina");
var productInputModel = new ProductInputModel("Skol lata", 2.39M, Guid.NewGuid())
{
CompanyId = Guid.NewGuid()
};
var productOutput = new ProductOutputModel(Guid.NewGuid(), "Skol lata", 2.39M)
{
Type = "Cerveja"
};
mockProductRepository.Setup(x => x.Any(It.IsAny <Expression <Func <Product, bool> > >(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(false));
mockProductRepository.Setup(x => x.Add(It.IsAny <Product>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(product));
mockMapper.Setup(x => x.Map <Product>(It.IsAny <ProductInputModel>())).Returns(product);
mockMapper.Setup(x => x.Map <ProductOutputModel>(It.IsAny <Product>())).Returns(productOutput);
mockUserService.Setup(x => x.Get(It.IsAny <Expression <Func <Company, bool> > >(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(company));
var productService = GenerateProductServiceIntance();
//act
var result = await productService.AddProduct(productInputModel, new CancellationToken());
//assert
Assert.NotNull(result);
Assert.Equal(result.Name, productOutput.Name);
Assert.Equal(result.Price, productOutput.Price);
Assert.True(result.Type.Equals("Cerveja"));
}
public async Task <IActionResult> Post(ProductInputModel model)
{
var product = model.ToProduct();
var addResult = await _productDataRepository.AddProductAsync(product);
if (addResult.IsSuccess)
{
return(CreatedAtAction(nameof(Get), new { id = product.Id }, ProductOutputModel.FromProduct(product)));
}
if (addResult.IsDuplicate)
{
var existingUrl = Url.Action(nameof(Get),
ControllerContext.ActionDescriptor.ControllerName,
new { id = product.Id },
Request.Scheme,
Request.Host.ToUriComponent());
HttpContext.Response.Headers.Add("Location", existingUrl);
return(StatusCode(StatusCodes.Status409Conflict));
}
ModelState.AddValidationResultErrors(addResult.ValidationResult.Errors);
return(ValidationProblem());
}
public ActionResult <ProductOutputModel> Get(long id)
{
Product product = _store.GetById(id);
if (null == product)
{
return(NoContent());
}
return(ProductOutputModel.FromEntity(product));
}
// GET: Products/Details/5
public IActionResult Details(int?id)
{
Product product = FetchOrDefault(id);
if (null == product)
{
return(NotFound());
}
return(View(ProductOutputModel.FromEntity(product)));
}
public async Task <ActionResult <ProductOutputModel> > Get([Required] Guid id)
{
var product = await _productDataRepository.GetByIdAsync(id);
if (product is null)
{
return(NotFound());
}
return(ProductOutputModel.FromProduct(product));
}
public async Task <ActionResult> Upload(string productName,
string productShortName,
double productPrice,
int brandexId,
int?pharmnetId,
int?phoenixId,
string sopharmaId,
int?stingId)
{
if (productName != null &&
productShortName != null &&
productPrice != 0 &&
brandexId != 0)
{
var newProduct = new ProductInputModel
{
Name = productName,
ShortName = productShortName,
Price = productPrice,
BrandexId = brandexId,
PharmnetId = pharmnetId,
PhoenixId = phoenixId,
SopharmaId = sopharmaId,
StingId = stingId
};
if (await this.productsService.CreateProduct(newProduct) != "")
{
var outputProduct = new ProductOutputModel
{
Name = productName,
ShortName = productShortName,
Price = productPrice,
BrandexId = brandexId
};
return(this.View(outputProduct));
}
else
{
return(Redirect("Index"));
}
}
else
{
return(Redirect("Index"));
}
}
public IActionResult Create([FromForm] ProductInputModel inputModel)
{
if (!ModelState.IsValid)
{
return(View(inputModel));
}
var product = inputModel.ToEntity();
product = _store.Create(product);
var outputModel = ProductOutputModel.FromEntity(product);
return(RedirectToAction(nameof(Index)));
}
public IActionResult Create([FromBody] ProductInputModel inputModel)
{
if (inputModel == null)
{
return(BadRequest());
}
var product = inputModel.ToEntity();
product = _store.Create(product);
var outputModel = ProductOutputModel.FromEntity(product);
var result = CreatedAtRoute("ViewProduct",
new { id = outputModel.Id }, outputModel);
return(result);
}
public DataAgent <ProductOutputModel> DeleteProduct(long productId)
{
var dto = _productRepo.DeleteProduct(productId);
var result = new ProductOutputModel();
if (dto.ContainsData)
{
result = _mapper.Map <ProductOutputModel>(dto.Data);
var productInStoresDeleted = _productRepo.DeleteProductFromStore(productId);
if (!productInStoresDeleted.ContainsData)
{
return(new DataAgent <ProductOutputModel> {
ResponseMessage = productInStoresDeleted.ResponseMessage
});
}
}
return(new DataAgent <ProductOutputModel> {
Data = result, ResponseMessage = dto.ResponseMessage
});
}
public async Task <IActionResult> GetAll([FromQuery] PaginationFIlters paginationFilter)
{
try
{
var model = productService.GetProductAsync(paginationFilter);
Response.Headers.Add("X-Pagination", model.GetHeader().ToJson());
var outputModel = new ProductOutputModel
{
Paging = model.GetHeader(),
ProductResponses = model.List.Select(x => ToOutputModel(x)).ToList()
};
return(Ok(outputModel));
}
catch (Exception ex)
{
logger.LogError(ex.Message + ":" + ex.StackTrace);
throw;
}
}
public async Task <IActionResult> GetProducts(int?pageNumber = 1)
{
PagingParams pagingParams = new PagingParams
{
PageNumber = pageNumber.Value,
PageSize = Int32.Parse(_config.GetSection("AppSettings:PageSize").Value)
};
//var productFromRepo = await _productRepo.GetDataPaging(pagingParams);
// get related data
var productFromDB = await _context.Product.Include(s => s.ProductCategory).ToListAsync();
var pageList = new PagedList <Product>(productFromDB.AsQueryable(), pagingParams.PageNumber, pagingParams.PageSize);
// var product = _mapper.Map<IEnumerable<ProductDto>>(productFromRepo.List);
var product = _mapper.Map <IEnumerable <ProductDto> >(pageList.List);
var outputModel = new ProductOutputModel
{
Paging = pageList.GetHeader(),
Items = product.ToList()
};
return(Ok(outputModel));
}
public async Task <ActionResult <ProductOutputModel[]> > GetAll()
{
var products = await _productDataRepository.GetProductsAsync();
return(products.Select(p => ProductOutputModel.FromProduct(p)).ToArray());
}
