public async Task <bool> Handle(CreateStockReadModelCommand request, CancellationToken cancellationToken)
{
IStockRepository stockRepository = _stockDbContext.StockRepository;
var stock = Stock.Create(request.ProductId, request.AvailableStockCount, request.LastStockActionId, request.LastStockUpdatedOn, _stockUniqueChecker, cancellationToken);
await stockRepository.AddAsync(stock, cancellationToken);
return(true);
}
private async Task UpdateCostAndStocks(int productId, int shopId)
{
var pureOrderStocks = await _orderStockRepo.GetPureOrderStocksByProdId(productId);
decimal?multipleSum = 0;
decimal?count = 0;
foreach (var item in pureOrderStocks)
{
multipleSum += item.curr_stocks * (item.OrderDetail?.cost ?? 0);
count += item.curr_stocks;
}
decimal?averageCost = 0;
if (count != 0)
{
averageCost = multipleSum / count;
}
var cost = _costRepo.GetByProdId(productId).FirstOrDefault();
if (cost != null)
{
cost.value = averageCost;
await _costRepo.UpdateCostValueAsync(cost);
}
else
{
var c = new Cost
{
prod_id = productId,
value = averageCost
};
await _costRepo.AddCostAsync(c);
}
var stockDal = _stockRepo.GetStockByShopAndProdIds(shopId, productId);
var orderStockShop = await _orderStockRepo.GetPureOrderStocksByProdAndShopIds(productId, shopId);
if (stockDal != null)
{
stockDal.count = orderStockShop.Sum(p => p.curr_stocks);
await _stockRepo.UpdateValueAsync(stockDal);
}
else
{
var stock = new Stock
{
prod_id = productId,
shop_id = shopId,
count = count
};
await _stockRepo.AddAsync(stock);
}
}
public async Task <StockDTO> CreateStockAsync(string title, IEnumerable <ProductDTO> products, CancellationToken cancellationToken = default)
{
var domainProducts = new List <Product>();
// convert product dto list into domain product list
products.ToList().ForEach(p => domainProducts.Add(p.Assemble()));
// create a new stock
var stock = new Domain.Stocks.Stock(title, domainProducts);
await _stockRepository.AddAsync(stock, cancellationToken);
await _stockRepository.SaveChangesAsync(cancellationToken);
return(stock.Assemble());
}
public async Task <IActionResult> PostAsync(Stock stock)
{
Stock created;
try {
created = await _stockRepository.AddAsync(stock);
} catch (ArgumentException e) {
_logger.LogInformation(e, "Attempted to add a stock with an already existing Id.");
return(BadRequest(e.Message));
} catch (DbUpdateException e) {
_logger.LogInformation(e, "Attempted to add a stock that violated database constraints.");
return(BadRequest(e.Message));
}
_logger.LogInformation("Successfully added stock.", created);
return(CreatedAtAction(nameof(GetByIdAsync), new { id = created.Id }, created));
}
public async Task <StockDto> CreateStock(StockCreateDto dto)
{
var stock = await _stockRepository.GetAllAsync(new StockFilterDto()
{
ProductId = dto.ProductId
});
if (stock?.FirstOrDefault() != null)
{
return(null);
}
var entity = dto.Adapt <Stock>();
await _stockRepository.AddAsync(entity);
var result = entity.Adapt <StockDto>();
return(result);
}
public async Task <ProductResponse> Create(ProductRequest input)
{
var Product = await _productRepository.AddAsync(new Product
{
Name = input.Name,
Description = input.Description,
Value = input.Value,
ProductCategoryId = input.ProductCategoryId
});
await _stockRepository.AddAsync(new Stock
{
ProductId = Product.Id,
Qty = input.Qty,
Description = $"{Product.Name}_Stock"
});
return(new ProductResponse {
Id = Product.Id
});
}
public async Task <ItemsInStockModel> AddAsync(ItemsInStockModel model)
{
return(await ItemsInStockRepository.AddAsync(model));
}
public async Task <StockEntity> Add(StockEntity item)
{
return(await _repository.AddAsync(item));
}
public async Task AddAsync(Stock entity)
{
await _stockRepository.AddAsync(entity);
}
public async Task AddStockAsync(Stock stock)
{
await repository.AddAsync(stock);
}
