public void MergeOrders_OrdersTagged_ShouldSkipMerge()
{
var kola = MenuItemBuilder.Create("Kola").AddPortion("Adet", 5).Build();
var ticket = TicketBuilder.Create(TicketType.Default, Department.Default)
.AddOrder().ForMenuItem(kola).Do(2)
.Build();
ticket.Orders[0].ToggleOrderTag(new OrderTagGroup {
Name = "Service"
}, new OrderTag {
Name = "Pause"
}, 0, "");
ticket.MergeOrdersAndUpdateOrderNumbers(1);
Assert.AreEqual(2, ticket.Orders.Count);
}
public void MergeMultipleOrders_DifferentOrderQuantities_ShouldSkipMerge()
{
var kola = MenuItemBuilder.Create("Kola").WithId(1).AddPortion("Adet", 5).Build();
var pizza = MenuItemBuilder.Create("Pizza").WithId(2).AddPortion("Adet", 5).Build();
var ticket = TicketBuilder.Create(TicketType.Default, Department.Default)
.AddOrder().ForMenuItem(kola).Do()
.AddOrder().ForMenuItem(kola).Do()
.AddOrder().ForMenuItem(kola).WithQuantity(2).Do()
.AddOrder().ForMenuItem(pizza).Do()
.AddOrder().ForMenuItem(pizza).Do()
.Build();
ticket.MergeOrdersAndUpdateOrderNumbers(1);
Assert.AreEqual(4, ticket.Orders.Count);
}
public void TicketBuilder_AddsOrderWithMultipleMenuItems_OrdersAdded3()
{
var context = TicketBuilderTestContext.GetDefaultContext();
var ticket = TicketBuilder.Create(context.TicketType, context.Department)
.AddOrder()
.CreateMenuItem("Hamburger").AddPortion("Adet", 10).Do()
.Do()
.AddOrder()
.CreateMenuItem("Tost").AddPortion("Adet", 4).Do()
.WithQuantity(2)
.Do()
.Build();
Assert.AreEqual(10 + (4 * 2), ticket.GetSum());
}
public void CanCalculateDoubleOrdersMultipleTax()
{
var ticket = TicketBuilder.Create(TicketType, Department.Default)
.AddOrderFor(Beer).WithTaxTemplates(GetTaxTemplates(Beer.Id)).Do()
.AddOrderFor(Pizza).WithTaxTemplates(GetTaxTemplates(Pizza.Id)).WithPrice(5).Do()
.Build();
const decimal expTax = 2.18m + 1;
const decimal expStTax = 1.95m + 1;
const decimal expLcTax = 0.23m;
Assert.AreEqual(expTax, ticket.GetTaxTotal());
Assert.AreEqual(ticket.GetSum() - expTax, ticket.TransactionDocument.AccountTransactions.Single(x => x.AccountTransactionTypeId == TicketType.SaleTransactionType.Id).Amount);
Assert.AreEqual(expLcTax, ticket.TransactionDocument.AccountTransactions.Single(x => x.AccountTransactionTypeId == 2).Amount);
Assert.AreEqual(expStTax, ticket.TransactionDocument.AccountTransactions.Single(x => x.AccountTransactionTypeId == 3).Amount);
}
private void ViewHiden(IEditTicketView sender)
{
if (!isHiding)
{
if (!isSaved)
{
isHiding = true;
View.Show();
sender.AskForSaving();
View.Hide();
isHiding = false;
}
currentTicketBuilder = null;
isSaved = true;
}
}
public void CanReadInventory()
{
var workspace = PrepareMenu("sd4.txt");
var testContext = new WarehouseTestContext();
CreateWarehouseTestContext(testContext, workspace);
var inventoryTransaction1 = new InventoryTransactionDocument();
inventoryTransaction1.Add(testContext.PurchaseTransactionType, testContext.DonerEti, 16, 10, "KG", 1000);
inventoryTransaction1.Add(testContext.PurchaseTransactionType, testContext.Pide, 1, 50, "Adet", 2);
inventoryTransaction1.Add(testContext.PurchaseTransactionType, testContext.Yogurt, 4, 30, "KG", 1000);
inventoryTransaction1.Add(testContext.PurchaseTransactionType, testContext.ZeytinYagi, 5, 5, "Litre", 100);
workspace.Add(inventoryTransaction1);
inventoryTransaction1.TransactionItems.ToList().ForEach(workspace.Add);
Assert.AreEqual(4, inventoryTransaction1.TransactionItems.Count);
Assert.AreEqual(10, InventoryService.GetInventory(testContext.DonerEti, testContext.LocalWarehouse));
Assert.AreEqual(50, InventoryService.GetInventory(testContext.Pide, testContext.LocalWarehouse));
Assert.AreEqual(30, InventoryService.GetInventory(testContext.Yogurt, testContext.LocalWarehouse));
Assert.AreEqual(5, InventoryService.GetInventory(testContext.ZeytinYagi, testContext.LocalWarehouse));
inventoryTransaction1.Add(testContext.PurchaseTransactionType, testContext.DonerEti, 16, 15, "KG", 1000);
inventoryTransaction1.TransactionItems.ToList().ForEach(workspace.Add);
Assert.AreEqual(25, InventoryService.GetInventory(testContext.DonerEti, testContext.LocalWarehouse));
var ticket = TicketBuilder.Create(TicketType.Default, testContext.Department).Build();
workspace.Add(ticket);
ticket.AddOrder(AccountTransactionType.Default, testContext.Department, "Emre", testContext.Iskender, null, testContext.Iskender.Portions[0], "", null);
ticket.AddOrder(AccountTransactionType.Default, testContext.Department, "Emre", testContext.Iskender, null, testContext.Iskender.Portions[0], "", null);
ticket.AddOrder(AccountTransactionType.Default, testContext.Department, "Emre", testContext.Iskender, null, testContext.Iskender.Portions[0], "", null);
Assert.AreEqual(25 - ((120m * 3) / 1000m), InventoryService.GetInventory(testContext.DonerEti, testContext.LocalWarehouse));
RestartWorkperiod(workspace);
ticket = TicketBuilder.Create(TicketType.Default, testContext.Department).Build();
workspace.Add(ticket);
ticket.AddOrder(AccountTransactionType.Default, testContext.Department, "Emre", testContext.Iskender, null, testContext.Iskender.Portions[0], "", null);
ticket.AddOrder(AccountTransactionType.Default, testContext.Department, "Emre", testContext.Iskender, null, testContext.Iskender.Portions[0], "", null);
ticket.AddOrder(AccountTransactionType.Default, testContext.Department, "Emre", testContext.Iskender, null, testContext.Iskender.Portions[0], "", null);
Assert.AreEqual(25 - ((120m * 6) / 1000m), InventoryService.GetInventory(testContext.DonerEti, testContext.LocalWarehouse));
Assert.AreEqual(50 - (2 * 6) / 2, InventoryService.GetInventory(testContext.Pide, testContext.LocalWarehouse));
Assert.AreEqual((-10m * 6) / 100, InventoryService.GetInventory(testContext.Tuz, testContext.LocalWarehouse));
Assert.AreEqual(0, InventoryService.GetInventory(testContext.Kekik, testContext.LocalWarehouse));
}
private async Task <IActionResult> Password(string email, string password)
{
var user = await Mediator.Send(new LoginUser { Email = email, Password = password });
var ticket = new TicketBuilder()
.AddClaim(OpenIdConnectConstants.Claims.Role, Role.User, "access_token")
.AddClaim(OpenIdConnectConstants.Claims.Subject, user.Id, "access_token")
.AddClaim(OpenIdConnectConstants.Claims.Name, user.Name, "id_token")
.AddClaim(ClaimTypes.Name, user.Name, "id_token")
.SetScopes(
OpenIdConnectConstants.Scopes.OpenId,
OpenIdConnectConstants.Scopes.Profile,
OpenIdConnectConstants.Scopes.OfflineAccess)
.GetTicket();
return(SignIn(ticket.Principal, ticket.Properties, ticket.AuthenticationScheme));
}
public void CanCalculateMultipleOrderExcludedTaxWhenDiscountExists()
{
var calculationType = CalculationTypeBuilder.Create("Discount")
.WithAccountTransactionType(DiscountTransactionType)
.WithAmount(10)
.DecreaseAmount()
.Build();
var ticket = TicketBuilder.Create(TicketType, Department.Default)
.TaxExcluded()
.AddOrderFor(Pizza).WithTaxTemplates(GetTaxTemplates(Pizza.Id)).Do(2)
.AddCalculation(calculationType)
.Build();
Assert.AreEqual(22.50, ticket.GetSum());
Assert.AreEqual(22.50, ticket.TransactionDocument.AccountTransactions.Where(x => x.TargetAccountTypeId == 3).Sum(x => x.Amount) - ticket.TransactionDocument.AccountTransactions.Where(x => x.SourceAccountTypeId == 3).Sum(x => x.Amount));
}
public void OrderMerge_CanCompareOrdersWithDifferentOrderTags_ReturnsFalse()
{
var kola = MenuItemBuilder.Create("Kola").WithId(1).AddPortion("Adet", 5).Build();
var ticket = TicketBuilder.Create(TicketType.Default, Department.Default)
.AddOrder().ForMenuItem(kola).Do()
.AddOrder().ForMenuItem(kola).Do()
.Build();
ticket.Orders[0].ToggleOrderTag(new OrderTagGroup {
Name = "Service"
}, new OrderTag {
Name = "Pause"
}, 0, "");
var equals = OrderMerger.CanMergeOrders(ticket.Orders[0], ticket.Orders[1]);
Assert.False(equals);
}
public void TicketBuilder_AddsOrderWithMultipleMenuItems_OrdersAdded1()
{
var context = TicketBuilderTestContext.GetDefaultContext();
var hamburger = MenuItemBuilder.Create("Hamburger").AddPortion("Adet", 10).Build();
var tost = MenuItemBuilder.Create("Tost").AddPortion("Adet", 4).Build();
var order1 = OrderBuilder.Create(context.TicketType.SaleTransactionType, context.Department)
.ForMenuItem(hamburger);
var order2 = OrderBuilder.Create(context.TicketType.SaleTransactionType, context.Department)
.ForMenuItem(tost).WithQuantity(2);
var ticket = TicketBuilder.Create(context.TicketType, context.Department)
.AddOrder(order1)
.AddOrder(order2)
.Build();
Assert.AreEqual(10 + (4 * 2), ticket.GetSum());
}
public void CanCalculateDiscountTax()
{
var ticket = TicketBuilder.Create(TicketType, Department.Default)
.AddOrderFor(Beer).WithTaxTemplates(GetTaxTemplates(Beer.Id)).Do()
.AddCalculation(new CalculationType {
Name = "Discount", AccountTransactionType = DiscountTransactionType, Amount = 10, DecreaseAmount = true
}).Build();
var expStTax = decimal.Round((9 * 25) / 128m, 2);
var expLcTax = decimal.Round((9 * 3) / 128m, 2);
var expTax = expStTax + expLcTax;
Assert.AreEqual(9, ticket.GetSum());
Assert.AreEqual(expTax, ticket.GetTaxTotal());
Assert.AreEqual(expLcTax, ticket.TransactionDocument.AccountTransactions.Single(x => x.AccountTransactionTypeId == 2).Amount);
Assert.AreEqual(expStTax, ticket.TransactionDocument.AccountTransactions.Single(x => x.AccountTransactionTypeId == 3).Amount);
Assert.AreEqual(0, ticket.TransactionDocument.AccountTransactions.Sum(x => x.AccountTransactionValues.Sum(y => y.Debit - y.Credit)));
Assert.AreEqual(9, ticket.TransactionDocument.AccountTransactions.Where(x => x.TargetAccountTypeId == 3).Sum(x => x.Amount) - ticket.TransactionDocument.AccountTransactions.Where(x => x.SourceAccountTypeId == 3).Sum(x => x.Amount));
}
private static Ticket PrepareTestTicket()
{
var hamburger = MenuItemBuilder.Create("Hamburger").WithId(1).WithGroupCode("Food").WithProductTag("Tag1").AddPortion("Small", 5).Build();
var pizza = MenuItemBuilder.Create("Pizza").WithId(2).WithGroupCode("Food").WithProductTag("Tag1").AddPortion("Small", 10).Build();
var cola = MenuItemBuilder.Create("Coke").WithId(3).WithGroupCode("Drink").AddPortion("Small", 2).Build();
using (var w = WorkspaceFactory.Create())
{
w.Add(hamburger);
w.Add(pizza);
w.Add(cola);
}
var ticket = TicketBuilder.Create(TicketType.Default, Department.Default)
.AddOrderFor(hamburger).Do()
.AddOrderFor(pizza).Do()
.AddOrderFor(cola).Do()
.Build();
return(ticket);
}
private static void CompleteTunnel([NotNull] TicketBuilder ticket, [NotNull] IDateRange range)
{
if (ticket == null)
{
throw new ArgumentNullException(nameof(ticket));
}
if (range == null)
{
throw new ArgumentNullException(nameof(range));
}
if (ticket.EstimatedPeriod.Start == default)
{
ticket.EstimatedPeriod.Start = range.Start;
}
if (ticket.EstimatedPeriod.End == default)
{
ticket.EstimatedPeriod.End = range.End;
}
foreach (var child in ticket.Children)
{
CompleteTunnel(child, ticket.EstimatedPeriod);
}
}
public void CanCalculateSampleCase1()
{
// http://forum2.sambapos.com/index.php/topic,1481.0.html
var tax8 = TaxTemplateBuilder.Create("%8 Tax").WithRate(8)
.CreateAccountTransactionType().WithId(2).Do()
.WithRounding(0)
.Build();
var tax18 = TaxTemplateBuilder.Create("%18 Tax").WithRate(18)
.CreateAccountTransactionType().WithId(3).Do()
.WithRounding(0)
.Build();
var ticket = TicketBuilder.Create(TicketType, Department.Default).TaxIncluded()
.AddOrderFor(Product).WithTaxTemplate(tax8).WithPrice(6).WithQuantity(16).Do()
.AddOrderFor(Product).WithTaxTemplate(tax8).WithPrice(10).WithQuantity(3).Do()
.AddOrderFor(Product).WithTaxTemplate(tax8).WithPrice(10).WithQuantity(3).Do()
.AddOrderFor(Product).WithTaxTemplate(tax8).WithPrice(3).WithQuantity(10).Do()
.AddOrderFor(Product).WithTaxTemplate(tax18).WithPrice(9).WithQuantity(1).Do()
.AddOrderFor(Product).WithTaxTemplate(tax8).WithPrice(7).WithQuantity(1).Do()
.AddOrderFor(Product).WithTaxTemplate(tax8).WithPrice(18).WithQuantity(3).Do()
.AddOrderFor(Product).WithTaxTemplate(tax8).WithPrice(5).WithQuantity(2).Do()
.AddOrderFor(Product).WithTaxTemplate(tax8).WithPrice(5).WithQuantity(2).Do()
.AddOrderFor(Product).WithTaxTemplate(tax8).WithPrice(28).WithQuantity(3).Do()
.AddOrderFor(Product).WithTaxTemplate(tax8).WithPrice(32).WithQuantity(3).Do()
.AddOrderFor(Product).WithTaxTemplate(tax8).WithPrice(10).WithQuantity(2).Do()
.AddOrderFor(Product).WithTaxTemplate(tax8).WithPrice(10).WithQuantity(2).Do()
.AddOrderFor(Product).WithTaxTemplate(tax18).WithPrice(9).WithQuantity(1).Do()
.AddOrderFor(Product).WithTaxTemplate(tax18).WithPrice(105).WithQuantity(2).Do()
.Build();
Assert.AreEqual(715, ticket.GetSum());
Assert.AreEqual(34.78 + 36.07, ticket.GetTaxTotal());
Assert.AreEqual(36.07, ticket.TransactionDocument.AccountTransactions.Single(x => x.AccountTransactionTypeId == 2).Amount);
Assert.AreEqual(34.78, ticket.TransactionDocument.AccountTransactions.Single(x => x.AccountTransactionTypeId == 3).Amount);
}
private async Task <IActionResult> PasswordBusiness(string username, string password)
{
var(id, role, storeId) = await Mediator.Send(new AuthStoreUser { Username = username, Password = password });
var builder = new TicketBuilder()
.AddClaim(OpenIdConnectConstants.Claims.Role, role, "access_token")
.AddClaim(OpenIdConnectConstants.Claims.Subject, id, "id_token")
.AddClaim(OpenIdConnectConstants.Claims.Name, username, "id_token")
.AddClaim(ClaimTypes.Role, role, "id_token")
.AddClaim(ClaimTypes.Name, username, "id_token")
.SetScopes(
OpenIdConnectConstants.Scopes.OpenId,
OpenIdConnectConstants.Scopes.Profile,
OpenIdConnectConstants.Scopes.OfflineAccess);
if (storeId != null)
{
builder.AddClaim("store_id", storeId, "id_token");
}
var ticket = builder.GetTicket();
return(SignIn(ticket.Principal, ticket.Properties, ticket.AuthenticationScheme));
}
public void CanHandleMultipleCostCalculation()
{
var workspace = PrepareMenu("sd7.txt");
var testContext = new WarehouseTestContext();
CreateWarehouseTestContext(testContext, workspace);
var missingItem = testContext.IskenderRecipe.RecipeItems.Last();
testContext.IskenderRecipe.RecipeItems.Remove(missingItem);
workspace.CommitChanges();
var ticket = TicketBuilder.Create(TicketType.Default, testContext.Department).Build();
workspace.Add(ticket);
ticket.AddOrder(AccountTransactionType.Default, testContext.Department, "Emre", testContext.Iskender, null, testContext.Iskender.Portions[0], "", null);
RestartWorkperiod(workspace);
testContext.IskenderRecipe.RecipeItems.Add(missingItem);
workspace.CommitChanges();
ticket = TicketBuilder.Create(TicketType.Default, testContext.Department).Build();
workspace.Add(ticket);
ticket.AddOrder(AccountTransactionType.Default, testContext.Department, "Emre", testContext.Iskender, null, testContext.Iskender.Portions[0], "", null);
RestartWorkperiod(workspace);
}
public ActionResult BuyTicket(long id)
{
Ticket ticket = new TicketBuilder()
.SetEventId(id)
.Build();
if (TempData["user"] != null)
{
var userJson = JsonConvert.DeserializeObject(TempData["user"].ToString());
JToken token = JObject.Parse(userJson.ToString());
ticket.SetUserId((long)token.SelectToken("Id"));
User user = new UserBuilder()
.SetId((long)token.SelectToken("Id"))
.SetUsername((string)token.SelectToken("Username"))
.Build();
TempData["user"] = JsonConvert.SerializeObject(user);
}
if (ticket.GetUserId() == 0)
{
return(StatusCode(404));
}
ticketService.CreateTicket(ticket);
return(RedirectToAction("UserTickets"));
}
public QuestionGroupPastedArgs(TicketBuilder ticketBuilder)
{
TicketBuilder = ticketBuilder;
}
public void CanFilterUnneededConsumptionItems()
{
var workspace = PrepareMenu("sd6.txt");
var testContext = new WarehouseTestContext();
CreateWarehouseTestContext(testContext, workspace);
testContext.Yogurt.Warehouse = "No Warehouse";
var inventoryTransaction1 = new InventoryTransactionDocument();
inventoryTransaction1.Add(testContext.PurchaseTransactionType, testContext.Yogurt, 4, 30, "KG", 1000);
workspace.Add(inventoryTransaction1);
inventoryTransaction1.TransactionItems.ToList().ForEach(workspace.Add);
var pc = InventoryService.GetCurrentPeriodicConsumption();
var whc = pc.WarehouseConsumptions.Single(x => x.WarehouseId == testContext.LocalWarehouse.Id);
Assert.True(whc.PeriodicConsumptionItems.Any(x => x.InventoryItemId == testContext.Yogurt.Id));
Assert.AreEqual(30, InventoryService.GetInventory(testContext.Yogurt, testContext.LocalWarehouse));
var ticket = TicketBuilder.Create(TicketType.Default, testContext.Department).Build();
workspace.Add(ticket);
var order = ticket.AddOrder(AccountTransactionType.Default, testContext.Department, "Emre", testContext.Iskender, null, testContext.Iskender.Portions[0], "", null);
order.Quantity = 600;
Assert.AreEqual(0, InventoryService.GetInventory(testContext.Yogurt, testContext.LocalWarehouse));
RestartWorkperiod(workspace);
pc = InventoryService.GetCurrentPeriodicConsumption();
whc = pc.WarehouseConsumptions.Single(x => x.WarehouseId == testContext.LocalWarehouse.Id);
Assert.True(whc.PeriodicConsumptionItems.All(x => x.InventoryItemId != testContext.Yogurt.Id));
RestartWorkperiod(workspace);
RestartWorkperiod(workspace);
pc = InventoryService.GetCurrentPeriodicConsumption();
whc = pc.WarehouseConsumptions.Single(x => x.WarehouseId == testContext.LocalWarehouse.Id);
Assert.True(whc.PeriodicConsumptionItems.All(x => x.InventoryItemId != testContext.Yogurt.Id));
RestartWorkperiod(workspace);
ticket = TicketBuilder.Create(TicketType.Default, testContext.Department).Build();
workspace.Add(ticket);
order = ticket.AddOrder(AccountTransactionType.Default, testContext.Department, "Emre", testContext.Iskender, null, testContext.Iskender.Portions[0], "", null);
order.Quantity = 600;
Assert.AreEqual(-30, InventoryService.GetInventory(testContext.Yogurt, testContext.LocalWarehouse));
RestartWorkperiod(workspace);
Assert.AreEqual(-30, InventoryService.GetInventory(testContext.Yogurt, testContext.LocalWarehouse));
var inventoryTransaction2 = new InventoryTransactionDocument();
inventoryTransaction2.Add(testContext.PurchaseTransactionType, testContext.Yogurt, 4, 30, "KG", 1000);
workspace.Add(inventoryTransaction2);
inventoryTransaction2.TransactionItems.ToList().ForEach(workspace.Add);
Assert.AreEqual(0, InventoryService.GetInventory(testContext.Yogurt, testContext.LocalWarehouse));
RestartWorkperiod(workspace);
pc = InventoryService.GetCurrentPeriodicConsumption();
whc = pc.WarehouseConsumptions.Single(x => x.WarehouseId == testContext.LocalWarehouse.Id);
Assert.True(whc.PeriodicConsumptionItems.All(x => x.InventoryItemId != testContext.Yogurt.Id));
Assert.AreEqual(0, InventoryService.GetInventory(testContext.Yogurt, testContext.LocalWarehouse));
testContext.Yogurt.Warehouse = testContext.BarWarehouse.Name;
RestartWorkperiod(workspace);
pc = InventoryService.GetCurrentPeriodicConsumption();
var bwhc = pc.WarehouseConsumptions.Single(x => x.WarehouseId == testContext.BarWarehouse.Id);
Assert.True(bwhc.PeriodicConsumptionItems.Any(x => x.InventoryItemId == testContext.Yogurt.Id));
Assert.AreEqual(0, InventoryService.GetInventory(testContext.Yogurt, testContext.LocalWarehouse));
Assert.AreEqual(0, InventoryService.GetInventory(testContext.Yogurt, testContext.BarWarehouse));
whc = pc.WarehouseConsumptions.Single(x => x.WarehouseId == testContext.LocalWarehouse.Id);
Assert.True(whc.PeriodicConsumptionItems.All(x => x.InventoryItemId != testContext.Yogurt.Id));
InventoryService.AddMissingItems(whc);
Assert.True(whc.PeriodicConsumptionItems.Any(x => x.InventoryItemId == testContext.Yogurt.Id));
InventoryService.FilterUnneededItems(pc);
Assert.True(whc.PeriodicConsumptionItems.All(x => x.InventoryItemId != testContext.Yogurt.Id));
InventoryService.AddMissingItems(whc);
Assert.True(whc.PeriodicConsumptionItems.Any(x => x.InventoryItemId == testContext.Yogurt.Id));
var pci = whc.PeriodicConsumptionItems.Single(x => x.InventoryItemId == testContext.Yogurt.Id);
pci.PhysicalInventory = 10;
workspace.Add(pci);
InventoryService.FilterUnneededItems(pc);
Assert.True(whc.PeriodicConsumptionItems.Any(x => x.InventoryItemId == testContext.Yogurt.Id));
Assert.AreEqual(10, InventoryService.GetInventory(testContext.Yogurt, testContext.LocalWarehouse));
}
public void TestPurchase()
{
var workspace = PrepareMenu("sd2.txt");
var testContext = new WarehouseTestContext();
CreateWarehouseTestContext(testContext, workspace);
var transaction = new InventoryTransactionDocument();
workspace.Add(transaction);
transaction.Add(testContext.PurchaseTransactionType, testContext.DonerEti, 16, 10, "KG", 1000);
transaction.Add(testContext.PurchaseTransactionType, testContext.Pide, 1, 50, "Adet", 2);
transaction.Add(testContext.PurchaseTransactionType, testContext.Yogurt, 4, 30, "KG", 1000);
transaction.TransactionItems.ToList().ForEach(workspace.Add);
var transactionTotal = transaction.TransactionItems.Sum(x => x.Price * x.Quantity);
Assert.AreEqual(transactionTotal, (16 * 10) + (50 * 1) + (30 * 4));
var ticket = TicketBuilder.Create(TicketType.Default, testContext.Department).Build();
workspace.Add(ticket);
ticket.AddOrder(AccountTransactionType.Default, testContext.Department, "Emre", testContext.Iskender, null, testContext.Iskender.Portions[0], "", null);
ticket.AddOrder(AccountTransactionType.Default, testContext.Department, "Emre", testContext.Iskender, null, testContext.Iskender.Portions[0], "", null);
var transaction2 = new InventoryTransactionDocument();
workspace.Add(transaction2);
transaction2.Add(testContext.PurchaseTransactionType, testContext.DonerEti, 15, 10, "KG", 1000);
transaction2.TransactionItems.ToList().ForEach(workspace.Add);
var pc = InventoryService.GetCurrentPeriodicConsumption();
workspace.Add(pc);
var whc = pc.WarehouseConsumptions.Single(x => x.WarehouseId == testContext.LocalWarehouse.Id);
var etpc = whc.PeriodicConsumptionItems.Single(x => x.InventoryItemId == testContext.DonerEti.Id);
Assert.IsNotNull(etpc);
Assert.AreEqual(0, etpc.InStock);
Assert.AreEqual(20, etpc.Purchase);
Assert.AreEqual(0.24m, etpc.Consumption);
Assert.AreEqual(15.5m, etpc.Cost);
var yogurtpc = whc.PeriodicConsumptionItems.Single(x => x.InventoryItemId == testContext.Yogurt.Id);
Assert.IsNotNull(yogurtpc);
Assert.AreEqual(0, yogurtpc.InStock);
Assert.AreEqual(30, yogurtpc.Purchase);
Assert.AreEqual(0.1m, yogurtpc.Consumption);
var pidepc = whc.PeriodicConsumptionItems.Single(x => x.InventoryItemId == testContext.Pide.Id);
Assert.IsNotNull(pidepc);
Assert.AreEqual(0, pidepc.InStock);
Assert.AreEqual(50, pidepc.Purchase);
Assert.AreEqual(2, pidepc.Consumption);
RestartWorkperiod(workspace);
pc = InventoryService.GetCurrentPeriodicConsumption();
whc = pc.WarehouseConsumptions.Single(x => x.WarehouseId == testContext.LocalWarehouse.Id);
etpc = whc.PeriodicConsumptionItems.Single(x => x.InventoryItemId == testContext.DonerEti.Id);
Assert.AreEqual(20 - 0.24m, etpc.InStock);
Assert.AreEqual(0, etpc.Purchase);
Assert.AreEqual(0, etpc.Consumption);
transaction = new InventoryTransactionDocument();
workspace.Add(transaction);
const int etAlimMiktari = 50;
var ti = transaction.Add(testContext.PurchaseTransactionType, testContext.DonerEti, 12, etAlimMiktari, "KG", 1000);
transaction.TransactionItems.ToList().ForEach(workspace.Add);
ticket = TicketBuilder.Create(TicketType.Default, testContext.Department).Build();
workspace.Add(ticket);
ticket.AddOrder(AccountTransactionType.Default, testContext.Department, "Emre", testContext.Iskender, null, testContext.Iskender.Portions[0], "", null);
ticket.AddOrder(AccountTransactionType.Default, testContext.Department, "Emre", testContext.Iskender, null, testContext.Iskender.Portions[0], "", null);
pc = InventoryService.GetCurrentPeriodicConsumption();
workspace.Add(pc);
whc = pc.WarehouseConsumptions.Single(x => x.WarehouseId == testContext.LocalWarehouse.Id);
var etpc2 = whc.PeriodicConsumptionItems.Single(x => x.InventoryItemId == testContext.DonerEti.Id);
Assert.IsNotNull(etpc2);
Assert.AreEqual(etpc2.InStock, etpc.GetInventoryPrediction());
Assert.AreEqual(etpc2.Purchase, etAlimMiktari);
Assert.AreEqual(etpc2.GetInventoryPrediction(), etpc.GetInventoryPrediction() + etAlimMiktari - 0.24m);
var cost = ((etpc.Cost * etpc.GetInventoryPrediction()) + (ti.Price * ti.Quantity)) / (etpc2.InStock + etpc2.Purchase);
cost = decimal.Round(cost, 2);
Assert.AreEqual(etpc2.Cost, cost);
RestartWorkperiod(workspace);
transaction = new InventoryTransactionDocument();
workspace.Add(transaction);
ti = transaction.Add(testContext.PurchaseTransactionType, testContext.DonerEti, 10, etAlimMiktari, "KG", 1000);
transaction.TransactionItems.ToList().ForEach(workspace.Add);
ticket = TicketBuilder.Create(TicketType.Default, testContext.Department).Build();
workspace.Add(ticket);
ticket.AddOrder(AccountTransactionType.Default, testContext.Department, "Emre", testContext.Iskender, null, testContext.Iskender.Portions[0], "", null);
ticket.AddOrder(AccountTransactionType.Default, testContext.Department, "Emre", testContext.Iskender, null, testContext.Iskender.Portions[0], "", null);
pc = InventoryService.GetCurrentPeriodicConsumption();
workspace.Add(pc);
whc = pc.WarehouseConsumptions.Single(x => x.WarehouseId == testContext.LocalWarehouse.Id);
var etpc3 = whc.PeriodicConsumptionItems.Single(x => x.InventoryItemId == testContext.DonerEti.Id);
Assert.IsNotNull(etpc3);
Assert.AreEqual(etpc3.InStock, etpc2.GetInventoryPrediction());
Assert.AreEqual(etpc3.Purchase, etAlimMiktari);
Assert.AreEqual(etpc3.GetInventoryPrediction(), etpc2.GetInventoryPrediction() + etAlimMiktari - 0.24m);
cost = ((etpc2.Cost * etpc2.GetInventoryPrediction()) + (ti.Price * ti.Quantity)) / (etpc3.InStock + etpc3.Purchase);
cost = decimal.Round(cost, 2);
Assert.AreEqual(etpc3.Cost, cost);
}
public StructChangedArgs(QuestionGroupBuilder group, TicketBuilder ticket)
{
Group = group;
Ticket = ticket;
}
