/// <summary>
/// Method responsible for update data.
/// </summary>
/// <param name="id"></param>
/// <param name="data"></param>
/// <returns></returns>
/// <exception cref="Core.DomainObjects.Exceptions.NotFoundException"></exception>
/// <exception cref="ApplicationException"></exception>
public async Task <ApplicationDataResult <ProductDto> > UpdateASync(Guid id, AddOrUpdateProductDto data)
{
ValidationResult validationResult = await _validatorProduct.ValidateAsync(data);
if (validationResult.IsValid is false)
{
return(FactoryFromValidationResult <ProductDto>(validationResult));
}
Product product = await _productRepository.FindAsync(id);
if (product is null)
{
throw ExceptionsFactory.FactoryNotFoundException <Product>(id);
}
Product result = await _productRepository.FindAsync(new ProductFilter { Description = data.Description });
if (result != null && result.Id != id)
{
throw ExceptionsFactory.FactoryApplicationException(ErrorMessages.ProductFound);
}
product.Update(data.Description, data.IsActive);
_productRepository.Update(product);
await _productRepository.UnitOfWork.CommitAsync();
return(FactoryResultFromData(_mapper.Map <ProductDto>(product)));
}
private void ValidateIfNotExistsItem(PurchaseItem item)
{
if (ExistsItem(item) is false)
{
throw ExceptionsFactory.FactoryNotFoundException <Purchase>(item.Id);
}
}
public async Task <ApplicationDataResult <PurchaseItemDto> > UpdateItemAsync(Guid purchaseId, Guid purchaseItemId,
AddOrUpdatePurchaseItemDto data)
{
ValidationResult validationResult = await _validatorPurchaseItem.ValidateAsync(data);
if (validationResult.IsValid is false)
{
return(FactoryFromValidationResult <PurchaseItemDto>(validationResult));
}
Purchase purchase = await _purchaseRepository.FindAsync(purchaseId);
PurchaseItem purchaseItem = purchase.FindItemById(purchaseItemId);
if (purchaseItem is null)
{
throw ExceptionsFactory.FactoryNotFoundException <PurchaseItem>(purchaseItemId);
}
Product product = await _productRepository.FindAsync(data.ProductId);
if (product is null)
{
throw ExceptionsFactory.FactoryNotFoundException <Product>(purchaseId);
}
purchaseItem.Update(data.Amount, data.Value, product);
await _purchaseService.UpdateItemAsync(purchase, purchaseItem);
return(FactoryResultFromData(_mapper.Map <PurchaseItemDto>(purchaseItem)));
}
private void ValidateIfNotExistsItem(OutputItem item)
{
if (ExistsItem(item) is false)
{
throw ExceptionsFactory.FactoryNotFoundException <Output>(item.Id);
}
}
public async Task <IList <PurchaseItemDto> > FindItensAsync(Guid purchaseId)
{
Purchase purchase = await _purchaseRepository.FindAsync(purchaseId);
if (purchase is null)
{
throw ExceptionsFactory.FactoryNotFoundException <Purchase>(purchaseId);
}
return(_mapper.Map <IList <PurchaseItemDto> >(purchase.Items));
}
public async Task <PurchaseItemDto> FindItemAsync(Guid purchaseId, Guid purchaseItemId)
{
Purchase purchase = await _purchaseRepository.FindAsync(purchaseId);
if (purchase is null)
{
throw ExceptionsFactory.FactoryNotFoundException <Purchase>(purchaseId);
}
return(_mapper.Map <PurchaseItemDto>(purchase.FindItemById(purchaseItemId)));
}
public async Task CloseAsync(Guid purchaseId)
{
Purchase purchase = await _purchaseRepository.FindAsync(purchaseId);
if (purchase is null)
{
throw ExceptionsFactory.FactoryNotFoundException <Purchase>(purchaseId);
}
await _purchaseService.CloseAsync(purchase);
}
public async Task RemoveAsync(Guid purchaseId)
{
Purchase purchase = await _purchaseRepository.FindAsync(purchaseId);
if (purchase is null)
{
throw ExceptionsFactory.FactoryNotFoundException <Purchase>(purchaseId);
}
_purchaseRepository.Remove(purchase);
await _purchaseRepository.UnitOfWork.CommitAsync();
}
/// <summary>
/// Method responsible for remove data.
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
/// <exception cref="Core.DomainObjects.Exceptions.NotFoundException"></exception>
public async Task RemoveASync(Guid id)
{
Product product = await _productRepository.FindAsync(id);
if (product is null)
{
throw ExceptionsFactory.FactoryNotFoundException <Product>(id);
}
_productRepository.Remove(product);
await _productRepository.UnitOfWork.CommitAsync();
}
public async Task RemoveItemAsync(Guid purchaseId, Guid purchaseItemId)
{
Purchase purchase = await _purchaseRepository.FindAsync(purchaseId);
if (purchase is null)
{
throw ExceptionsFactory.FactoryNotFoundException <Purchase>(purchaseId);
}
PurchaseItem purchaseItem = purchase.FindItemById(purchaseItemId);
if (purchaseItem is null)
{
throw ExceptionsFactory.FactoryNotFoundException <PurchaseItem>(purchaseItemId);
}
await _purchaseService.RemoveItemAsync(purchase, purchaseItem);
}
public async Task <ApplicationDataResult <PurchaseDto> > UpdateAsync(Guid purchaseId, AddOrUpdatePurchaseDto data)
{
ValidationResult validationResult = await _validatorPurchase.ValidateAsync(data);
if (validationResult.IsValid is false)
{
return(FactoryFromValidationResult <PurchaseDto>(validationResult));
}
Purchase purchase = await _purchaseRepository.FindAsync(purchaseId);
if (purchase is null)
{
throw ExceptionsFactory.FactoryNotFoundException <Purchase>(purchaseId);
}
purchase.Update(data.Description, data.Date);
_purchaseRepository.Update(purchase);
await _purchaseRepository.UnitOfWork.CommitAsync();
return(FactoryResultFromData(_mapper.Map <PurchaseDto>(purchase)));
}
