/// <summary>
///
/// </summary>
/// <returns></returns>
public async Task <IQueryable <Models.Product> > GetAllAsync()
{
try
{
using (var conn = await _dbConnectionStrategy.CreateConnectionAsync(Models.DatabaseType.Sqlite))
{
var query = @"
select p.Id as ProductId, p.Name as ProductName, p.Description as ProductDesc, cast(p.Price as real) as Price, cast(p.DeliveryPrice as real) as DeliveryPrice,
po.Id as OptionId, po.Name as OptionName, po.Description as OptionDesc
from Products p inner join ProductOptions po on p.Id = po.ProductId
";
var result = await conn.QueryAsync <ProductDataAccessModel>(query);
var products = _productMapper.Map(result.AsList());
return(products?.AsQueryable());
}
}
catch (Exception ex)
{
_logger.LogError($"An error occurred when trying to get all products. Exception: {ex}");
throw ex;
}
}
public async Task <ProductModel> Handle(CreateProductCommand productToCreate, CancellationToken cancellationToken)
{
var product = _productMapper.Map(productToCreate);
var createdProduct = await _unitOfWork.Products.AddAsync(product);
await _unitOfWork.SaveAsync();
return(_productMapper.Map(createdProduct));
}
public async Task Write(IEnumerable <Product> collection)
{
var entities = _mapper.Map(collection);
await _context.Products.AddRangeAsync(entities);
await _context.SaveChangesAsync();
}
public async Task <IActionResult> PatchProduct([HttpTrigger(AuthorizationLevel.Function, "patch", Route = "v1/products/{id}")]
HttpRequest req,
Guid id, ILogger log)
{
var pipeline = _builder.UseFunction(async() =>
{
var patch = await GetJsonBodyAsync <JsonPatchDocument <UpdateProductCommand> >(req);
var supportedOps = new[] { OperationType.Replace };
patch.IncludedPatchOps(supportedOps);
var restrictedPaths = Array.Empty <string>();
patch.ExcludedPatchPaths(restrictedPaths);
var productModel = await _mediator.Send(new GetProductByIdQuery(id));
var patchModel = _mapper.Map(productModel);
patch.ApplyTo(patchModel);
await _mediator.Send(patchModel);
return(new NoContentResult());
});
return(await pipeline.RunAsync(req.HttpContext));
}
public async Task <IActionResult> Patch(Guid id, [FromBody] JsonPatchDocument <UpdateProductCommand> patch)
{
var supportedOps = new[] { OperationType.Replace };
patch.IncludedPatchOps(supportedOps);
var restrictedPaths = Array.Empty <string>();
patch.ExcludedPatchPaths(restrictedPaths);
var productModel = await _mediator.Send(new GetProductByIdQuery(id));
var patchModel = _mapper.Map(productModel);
patch.ApplyTo(patchModel, ModelState);
if (!ModelState.IsValid || !TryValidateModel(patchModel))
{
throw new BadRequestException(ModelState.ToFormattedErrors().Join());
}
await _mediator.Send(patchModel);
return(NoContent());
}
protected override async Task Handle(UpdateProductCommand productToUpdate, CancellationToken cancellationToken)
{
var product = _productMapper.Map(productToUpdate);
await _unitOfWork.Products.UpdateAsync(product);
await _unitOfWork.SaveAsync();
}
public async Task <ProductDto> Handle(CreateProductCommand request, CancellationToken cancellationToken = default)
{
var product = new Database.Entities.Product(request.Name, request.Number, request.Quantity, 0);
await _context.AddAsync(product, cancellationToken);
var result = await _context.SaveChangesAsync(cancellationToken);
return(result == 1 ? _productMapper.Map(product) : null);
}
public async Task <ProductDto> Get(Guid productId)
{
var product = await _productRepository.Get(productId);
if (product == null)
{
return(null);
}
return(_productMapper.Map(product));
}
public async Task <IEnumerable <AddProductListItemViewModel> > GetAddableProducts(Guid userId)
{
var userProducts = await this._productRepository.GetByOwner(userId);
var personalizedProductModels = await this._personalizedProductRepository.GetByUser(userId);
var kits = await _packListsRepository.GetByUser(userId);
kits = kits.Where(x => x.Kit).ToList();
return(await _productMapper.Map(userProducts, personalizedProductModels, kits));
}
public async Task <ProductModel> Handle(GetProductByIdQuery request, CancellationToken cancellationToken)
{
var product = await _unitOfWork.Products.FindAsync(request.ProductId);
if (product == null)
{
throw new NotFoundException($"{nameof(Product)}: {request.ProductId} not found.");
}
return(_productMapper.Map(product));
}
public async Task <Product?> FindAsync(long id)
{
var productDb = await productRepository.FindAsync(id).ConfigureAwait(false);
if (productDb is null)
{
return(null);
}
return(productMapper.Map(productDb));
}
public async Task <ProductDto> Handle(UpdateProductCommand request, CancellationToken cancellationToken = default)
{
var product = await _context.Products.SingleOrDefaultAsync(x => x.Id == request.Id, cancellationToken);
if (product == null)
{
return(null);
}
_context.Update(product.Update(request.Name, request.Number, request.Quantity, request.Price));
var result = await _context.SaveChangesAsync(cancellationToken);
return(result == 1 ? _productMapper.Map(product) : null);
}
public IEnumerable <Product> GetByFileName(string fileName)
{
var products = new List <Product>();
using (Stream input = loader.Load(fileName))
{
var reader = XmlReader.Create(input);
while (reader.Read())
{
if (reader.Name != "product")
{
continue;
}
var product = mapper.Map(reader);
products.Add(product);
}
}
return(products);
}
public IEnumerable <Product> GetProducts(string sourceIndicator)
{
var products = new List <Product>();
using (Stream stream = sourceProvider.Load(sourceIndicator))
{
var reader = sourceReader.Create(stream);
while (reader.Read())
{
var product = productMapper.Map(reader);
if (product != null)
{
products.Add(product);
}
}
}
return(products);
}
public async Task <ProductDto> Handle(GetProductByIdQuery request, CancellationToken cancellationToken = default) => _productMapper.Map(await _context.Products.SingleOrDefaultAsync(x => x.Id == request.Id, cancellationToken));
public async Task <List <ProductDto> > Handle(GetAllProductsQuery request, CancellationToken cancellationToken = default)
{
return(_productMapper.Map(await _context.Products.ToListAsync(cancellationToken)));
}
public async Task <IList <ProductModel> > Handle(GetProductsQuery request, CancellationToken cancellationToken)
{
var products = await _unitOfWork.Products.GetAsync();
return(_productMapper.Map(products));
}
public IEnumerable <ProductDto> GetProducts()
{
return(_productService.GetProducts().Select(x => _productMapper.Map(x)));
}
public async Task AddAsync(Product product)
{
var productDb = productMapper.Map(product);
await productRepository.InsertAsync(productDb).ConfigureAwait(false);
}
