private static void UpdateConsumption(PeriodicConsumption pc, IWorkspace workspace)
{
var sales = GetSales(AppServices.MainDataContext.CurrentWorkPeriod);
foreach (var sale in sales)
{
var lSale = sale;
var recipe = workspace.Single <Recipe>(x => x.Portion.Name == lSale.PortionName && x.Portion.MenuItemId == lSale.MenuItemId);
if (recipe != null)
{
var cost = 0m;
foreach (var recipeItem in recipe.RecipeItems.Where(x => x.InventoryItem != null && x.Quantity > 0))
{
var item = recipeItem;
var pci = pc.PeriodicConsumptionItems.Single(x => x.InventoryItem.Id == item.InventoryItem.Id);
pci.Consumption += (item.Quantity * sale.Total) / pci.UnitMultiplier;
Debug.Assert(pci.Consumption > 0);
cost += recipeItem.Quantity * (pci.Cost / pci.UnitMultiplier);
}
pc.CostItems.Add(new CostItem {
Name = sale.MenuItemName, Portion = recipe.Portion, CostPrediction = cost, Quantity = sale.Total
});
}
}
}
public void CalculateCost(PeriodicConsumption pc, WorkPeriod workPeriod)
{
var sales = GetSales(workPeriod);
foreach (var sale in sales)
{
var lSale = sale;
var recipe = Dao.Single <Recipe>(x => x.Portion.Name == lSale.PortionName && x.Portion.MenuItemId == lSale.MenuItemId, x => x.Portion, x => x.RecipeItems, x => x.RecipeItems.Select(y => y.InventoryItem));
if (recipe != null)
{
var totalcost = recipe.FixedCost;
foreach (var recipeItem in recipe.RecipeItems.Where(x => x.InventoryItem != null && x.Quantity > 0))
{
var item = recipeItem;
var pci = pc.PeriodicConsumptionItems.SingleOrDefault(x => x.InventoryItem.Id == item.InventoryItem.Id);
if (pci != null && pci.GetPredictedConsumption() > 0)
{
var cost = recipeItem.Quantity * (pci.Cost / pci.UnitMultiplier);
cost = (pci.GetConsumption() * cost) / pci.GetPredictedConsumption();
totalcost += cost;
}
}
var ci = pc.CostItems.SingleOrDefault(x => x.Portion.Id == recipe.Portion.Id);
if (ci != null)
{
ci.Cost = decimal.Round(totalcost, 2);
}
}
}
}
public void CalculateCost(PeriodicConsumption pc, WorkPeriod workPeriod)
{
foreach (var warehouseConsumption in pc.WarehouseConsumptions)
{
var recipes = GetSales(workPeriod, warehouseConsumption.WarehouseId).Select(sale => _inventoryDao.GetRecipe(sale.PortionName, sale.MenuItemId));
pc.UpdateFinalCost(recipes.ToList(), warehouseConsumption.WarehouseId);
}
}
private void UpdateConsumption(PeriodicConsumption pc, int warehouseId)
{
var sales = GetSales(_applicationState.CurrentWorkPeriod, warehouseId);
foreach (var sale in sales)
{
var portionName = sale.PortionName;
var menuItemId = sale.MenuItemId;
var recipe = _inventoryDao.GetRecipe(portionName, menuItemId);
pc.UpdateConsumption(recipe, sale.Total, warehouseId);
pc.CreateCostItem(recipe, sale.MenuItemName, sale.Total, warehouseId);
}
}
private void Filter(PeriodicConsumption pc, IEnumerable <InventoryItem> inventoryItems, bool keepMappedItems)
{
foreach (var warehouseConsumption in pc.WarehouseConsumptions)
{
var warehouse = _cacheService.GetWarehouses().Single(x => x.Id == warehouseConsumption.WarehouseId);
var items =
warehouseConsumption.PeriodicConsumptionItems.Where(
x => x.InStock == 0 && x.Consumption == 0 && x.Added == 0 && x.Removed == 0 && x.PhysicalInventory == null);
var removingItems = keepMappedItems ? items.Where(x => !ShouldKeep(x, inventoryItems, warehouse)).ToList() : items.ToList();
if (removingItems.Any())
{
removingItems.ForEach(x => warehouseConsumption.PeriodicConsumptionItems.Remove(x));
}
}
}
private PeriodicConsumption CreateNewPeriodicConsumption(IWorkspace workspace)
{
var pc = new PeriodicConsumption
{
WorkPeriodId = _applicationState.CurrentWorkPeriod.Id,
Name = _applicationState.CurrentWorkPeriod.StartDate + " - " +
_applicationState.CurrentWorkPeriod.EndDate,
StartDate = _applicationState.CurrentWorkPeriod.StartDate,
EndDate = _applicationState.CurrentWorkPeriod.EndDate
};
CreatePeriodicConsumptionItems(pc, workspace);
UpdateConsumption(pc, workspace);
CalculateCost(pc, _applicationState.CurrentWorkPeriod);
return(pc);
}
private PeriodicConsumption CreateNewPeriodicConsumption()
{
var wids = _cacheService.GetWarehouses().Select(x => x.Id).ToList();
var previousPc = GetPreviousPeriodicConsumption();
var pc = PeriodicConsumption.Create(_applicationState.CurrentWorkPeriod, wids);
var inventoryItems = _inventoryDao.GetInventoryItems().ToList();
foreach (var wid in wids)
{
var transactionItems = GetTransactionItems(wid).ToList();
pc.CreatePeriodicConsumptionItems(wid, inventoryItems, previousPc, transactionItems);
UpdateConsumption(pc, wid);
CalculateCost(pc, _applicationState.CurrentWorkPeriod);
}
return(pc);
}
private static PeriodicConsumption CreateNewPeriodicConsumption(IWorkspace workspace)
{
var pc = new PeriodicConsumption
{
WorkPeriodId = AppServices.MainDataContext.CurrentWorkPeriod.Id,
Name = AppServices.MainDataContext.CurrentWorkPeriod.StartDate + " - " +
AppServices.MainDataContext.CurrentWorkPeriod.EndDate,
StartDate = AppServices.MainDataContext.CurrentWorkPeriod.StartDate,
EndDate = AppServices.MainDataContext.CurrentWorkPeriod.EndDate
};
CreatePeriodicConsumptionItems(pc, workspace);
UpdateConsumption(pc, workspace);
CalculateCost(pc, AppServices.MainDataContext.CurrentWorkPeriod);
return(pc);
}
private static void CreatePeriodicConsumptionItems(PeriodicConsumption pc, IWorkspace workspace)
{
var previousPc = GetPreviousPeriodicConsumption(workspace);
var transactionItems = GetTransactionItems();
foreach (var inventoryItem in workspace.All <InventoryItem>())
{
var iItem = inventoryItem;
var pci = new PeriodicConsumptionItem {
InventoryItem = inventoryItem
};
pci.UnitMultiplier = pci.InventoryItem.TransactionUnitMultiplier > 0 ? pci.InventoryItem.TransactionUnitMultiplier : 1;
pc.PeriodicConsumptionItems.Add(pci);
var previousCost = 0m;
if (previousPc != null)
{
var previousPci = previousPc.PeriodicConsumptionItems.SingleOrDefault(x => x.InventoryItem.Id == iItem.Id);
if (previousPci != null)
{
pci.InStock =
previousPci.PhysicalInventory != null
? previousPci.PhysicalInventory.GetValueOrDefault(0)
: previousPci.GetInventoryPrediction();
}
if (previousPci != null)
{
previousCost = previousPci.Cost * pci.InStock;
}
}
var tim = transactionItems.Where(x => x.InventoryItem.Id == iItem.Id);
pci.Purchase = tim.Sum(x => x.Quantity * x.Multiplier) / pci.UnitMultiplier;
var totalPrice = tim.Sum(x => x.Price * x.Quantity);
if (pci.InStock > 0 || pci.Purchase > 0)
{
pci.Cost = pci.InStock > 0
? decimal.Round((totalPrice + previousCost) / (pci.InStock + pci.Purchase), 2)
: decimal.Round(totalPrice / pci.Purchase, 2);
}
}
}
public void SavePeriodicConsumption(PeriodicConsumption pc)
{
Dao.Save(pc);
}
public void FilterUnneededItems(PeriodicConsumption pc)
{
var inventoryItems = _inventoryDao.GetInventoryItems();
Filter(pc, inventoryItems, false);
}
