public async Task <IActionResult> PostAsync([FromBody] Sale sale)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var existingCustomer = await _customerRepo.FindByIdAsync(sale.CustomerId);
if (existingCustomer == null)
{
return(NotFound(new List <string> {
"Customer Not Found"
}));
}
var existingProduct = await _productRepo.FindByIdAsync(sale.ProductId);
if (existingProduct == null)
{
return(NotFound(new List <string> {
"Product Not Found"
}));
}
var existingStore = await _storeRepo.FindByIdAsync(sale.StoreId);
if (existingStore == null)
{
return(NotFound(new List <string> {
"Store Not Found"
}));
}
try
{
await _saleRepo.AddAsync(sale);
await _saleRepo.SaveChangeAsync();
// var returnedResource = Mapper.Map<Sale, SaleReturnResource>(sale);
var returnedResource = new SaleReturnResource
{
SaleId = sale.SaleId,
DateSold = sale.DateSold,
Customer = sale.customer.Name,
Store = sale.store.Name,
Product = sale.product.Name
};
return(Ok(returnedResource));
}
catch (Exception ex)
{
return(BadRequest(new List <string> {
ex.Message
}));
}
}
public async Task <SaleResponse> SaveAsync(Sale sale)
{
try{
await saleRepository.AddAsync(sale);
await unitOfWork.CompleteAsync();
return(new SaleResponse(sale));
}
catch (Exception ex) {
return(new SaleResponse($"Error while saving sale! Message:{ex.Message}"));
}
}
public async Task <SaleResponse> SaveAsync(Sale sale)
{
try
{
await _saleRepository.AddAsync(sale);
await _unitOfWork.CompleteAsync();
return(new SaleResponse(sale));
}
catch (Exception ex)
{
return(new SaleResponse($"An error ocurred while saving the Sale: {ex.Message}"));
}
}
public async Task <ActionResult <Sale> > CreateSaleAsync([FromBody] Sale sale)
{
if (!ModelState.IsValid)
{
return(BadRequest(new ApiResult <Customer>()
{
StatusCode = "400",
Errors = ModelState.Values
.SelectMany(v => v.Errors)
.Select(v => v.ErrorMessage)
.ToArray()
}));
}
var product = await _productService.GetAsync(sale.ProductId);
if (product == null)
{
return(NotFound(new ApiResult <Sale>()
{
StatusCode = "404", Errors = new string[] { "Product not found" }
}));
}
var customer = await _customerRepository.GetAsync(sale.CustomerId);
if (customer == null)
{
return(NotFound(new ApiResult <Sale>()
{
StatusCode = "404", Errors = new string[] { "Customer not found" }
}));
}
sale.Cost = sale.Amount * product.Cost;
await _saleRepository.AddAsync(sale);
var result = new ApiResult <Sale>()
{
StatusCode = "200"
};
return(Ok(result));
}
public async Task <ActionResult <bool> > AddAsync(SaleDTO sale)
{
try
{
var result = await _sale.AddAsync(_mapper.Map <Sale>(CalculateTotalValue(sale)));
if (result == null)
{
return(BadRequest());
}
return(true);
}
catch (System.Exception)
{
return(BadRequest());
}
}
public async Task <Result> AddAsync(SaleAddClientModel dto)
{
var result = new Result();
// customer
var existCustomer = await GetCustomer(dto);
// sale-person
var existPerson = await GetSalePerson(dto);
var newSale = await GetExistSaleAsync(dto, existCustomer.Id, existPerson.Id);
if (newSale == null)
{
// sale
newSale = dto.Create();
newSale.CustomerId = existCustomer.Id;
newSale.SalePersonId = existPerson.Id;
var createSale = await _saleRepository.AddAsync(newSale);
await _saleRepository.CompleteAsync();
// sale event
var sale_added_event = AbstractDomainEvent <SaleAddClientModel> .Create(_serviceProvider);
await sale_added_event.RaiseAsync(createSale);
// order
var order = new Order()
{
SaleId = createSale.Id
};
var createdOrder = await _orderRepository.AddAsync(order);
await _orderRepository.CompleteAsync();
//sale event
var orderAddedEvent = AbstractDomainEvent <OrderAddClientModel> .Create(_serviceProvider);
await orderAddedEvent.RaiseAsync(createdOrder);
// product
dto.ProductIds.ForEach(p =>
{
var existProducts = _productRepository.Find(x => x.ProductId == p);
var existProduct = existProducts.FirstOrDefault();
if (existProduct == null)
{
_productRepository.Add(dto.Product(p));
}
// order-product
var orderProduct = dto.CreateOrderProduct(createdOrder.Id, existProduct.Id);
var createOrderProduct = _orderProductRepository.Add(orderProduct);
});
await _productRepository.CompleteAsync();
await _orderProductRepository.CompleteAsync();
result.Value = newSale.ToString();
}
else
{
result.IsError = true;
result.Message = "Sale does exist";
result.StatuCode = 400;
}
return(result);
}
