public void SubtotalShouldBeTheSumOfAllAddedItems(double[] prices)
{
double total = 0;
var order = new Order();
foreach (var price in prices)
{
total += price;
order.Add(new MocKOrderItem()
{
Price = price
});
}
Assert.Equal(total, order.Subtotal);
}
public void SubtotalShouldBeTheSumofOrderItemPrices(double[] prices)
{
var order = new Order();
double total = 0;
foreach (var price in prices)
{
total += price;
order.Add(new MockOrderItem()
{
Price = price
});
}
Assert.Equal(total, order.Subtotal);
}
public void OrderPropertiesChange()
{
var order = new Order();
var drink = new WarriorWater();
double tax = .1;
order.SalesTaxRate = tax;
order.Add(drink);
drink.Size = Size.Large;
Assert.Equal(order.Subtotal, drink.Price);
Assert.True(order.Tax == drink.Price * order.SalesTaxRate);
Assert.True(order.Total == drink.Price + drink.Price * order.SalesTaxRate);
Assert.True(drink.Calories == 0);
}
public void seekCommodityTest()
{
Order o1 = new Order(1024, "闫");
OrderItem d1 = new OrderItem(9, 11, "椅子"); //价格 数目 商品名称
OrderItem d2 = new OrderItem(1, 11, "苹果");
OrderItem d3 = new OrderItem(2, 5, "香蕉");
o1.Add(d1);
o1.Add(d2);
o1.Add(d3);
Order o2 = new Order(224, "王");
OrderItem d4 = new OrderItem(10, 11, "鸡肉");
OrderItem d5 = new OrderItem(20, 2, "猪肉");
o2.Add(d4);
o2.Add(d5);
Order o3 = new Order(516, "张");
OrderItem d6 = new OrderItem(50, 1, "手机");
OrderItem d7 = new OrderItem(15, 10, "瓜子");
OrderItem d8 = new OrderItem(1, 110, "苹果");
o3.Add(d6);
o3.Add(d7);
o3.Add(d8);
OrderService orderService = new OrderService();
orderService.add(o1);
orderService.add(o2);
orderService.add(o3);
orderService.seekCommodity("苹果");
Assert.Fail();
}
public void ShouldBeAbleToCheackTheSubtotalOfItemsIsPrice(double[] Prices)
{
var order = new Order();
double total = 0;
foreach (var price in Prices)
{
total += price;
order.Add(new MocOrderItem()
{
Price = price
});
}
Assert.Equal(total, order.Subtotal);
}
private static void Test()
{
Console.WriteLine("Branch aszatkowski");
Console.WriteLine("Hello Marcin");
byte x = 255;
checked
{
x++;
x++;
}
Console.WriteLine(x);
// ICustomerRepository customerRepository = new FakeCustomerRepository();
// var customers = customerRepository.GetByPesel("64645645");
Product product = new Product
{
Name = "Keyboard",
Color = "Black",
UnitPrice = 1000,
};
Order order = new Order
{
NumberOrder = "ZAM 001",
};
order.Add(product);
ICanDiscountStrategy canDiscountStrategy = new HappyHoursCanDiscountStrategy(
from: TimeSpan.Parse("09:30"),
to: TimeSpan.Parse("17:00"),
minimumAmount: 100m
);
ICalculateDiscountStrategy calculateDiscountStrategy = new FixedCalculateDiscountStrategy(10);
IDiscountCalculator orderCalculator
= new DiscountCalculator(canDiscountStrategy, calculateDiscountStrategy);
decimal discount = orderCalculator.CalculateDiscount(order);
Console.WriteLine(discount);
}
public void ShouldFirePropertiesWhenPriceChanged()
{
Order order = new Order();
MockEntreeImplementation mockEntree1 = new MockEntreeImplementation(1, 1);
order.Add(mockEntree1);
Assert.PropertyChanged(order, "Total", () => {
mockEntree1.ChangePrice(1.00);
});
Assert.PropertyChanged(order, "Tax", () => {
mockEntree1.ChangePrice(1.00);
});
Assert.PropertyChanged(order, "Subtotal", () => {
mockEntree1.ChangePrice(1.00);
});
}
public void SubtotalShouldBeTheSumOfOrderItemPrices(double[] Prices)
{
double total = 0;
var order = new Order();
foreach (var price in Prices)
{
total += price;
//initializing object and field in one line.
order.Add(new MockOrderItem()
{
Price = price
});
}
Assert.Equal(total, order.Subtotal);
}
//Get Subtotal- Must be as expected based on added items
public void SubtotalIsSumOfOrderItemsPrices(double[] Prices)
{
var order = new Order();
double total = 0.00;
foreach (var price in Prices)
{
total += price;
order.Add(new MockOrderItem()
{
Price = price
});
}
Assert.Equal(total, order.Subtotal);
}
// Get the price - needs to be right for the items we've added
public void SubtotalShouldBeTheSumOfOrderItemPrices(IEnumerable <double> prices)
{
var order = new Order();
double total = 0;
foreach (var price in prices)
{
order.Add(new MockOrderItem()
{
Price = price
});
total += price;
}
Assert.Equal(order.Subtotal, total);
}
// Add to both the Database and the ObservableCollection
public void AddOrder()
{
OrderModel p = new OrderModel
{
OrderNome = OrderNome,
OrderProduto = OrderProduto,
OrderQuantidade = OrderQuantidade,
OrderTotal = PriceCalc().ToString()
};
OrderNome = string.Empty;
OrderProduto = string.Empty;
OrderQuantidade = string.Empty;
SaveOrder(p);
Order.Add(p);
}
public void OneFoodToStringTest()
{
Order order = Order.getInstance();
order.ResetCondiments();
Food dough = new Dough();
dough.Id = 0;
dough.Name = "Normal dough";
dough.Description = "This is a regular dough where we add all the ingridients what is needed to a good pizza dough";
dough.Price = 1.99;
order.Add(dough);
string actual = order.ToString();
string expected = "0/1,99/Normal dough/This is a regular dough where we add all the ingridients what is needed to a good pizza dough;";
Assert.AreEqual(expected, actual);
}
private void RestaurantMenu_SelectedIndexChanged(object sender, EventArgs e)
{
if (YourOrder.Items.Count < 8 && RestaurantMenu.SelectedItems.Count > 0)
{
var selectedRow = RestaurantMenu.SelectedItems[0];
YourOrder.Items.Add((ListViewItem)selectedRow.Clone());
selectedRow.Selected = false;
//order.Cost += Convert.ToDouble(selectedRow.SubItems[1].Text);
Order.Add(StaticAccessor.DB.GetFoodItem(Convert.ToInt32(selectedRow.SubItems[3].Text)));
Mementos.Add(Order.CreateMemento());
TotalCostLabel.Text = "" + StaticAccessor.DoubleToMoneyString(Order.Cost);
if (YourOrder.Items.Count >= 8)
{
MessageBox.Show(@"You've reached the item limit.");
}
}
}
public async Task WhenFirstAidIsAddedWithoutLearnSkiIsAdded_FirstAidIsCharged()
{
var order = new Order()
{
OrderType = OrderType.DigitalProductPurchase
};
order.Add(new Item()
{
Category = ItemCategory.Video, Name = Constants.ItemNames.FirstAidVideoName, DefaultUnitPrice = 5
}, 1);
Assert.IsTrue(order.CartItems.TryGetValue(Constants.ItemNames.FirstAidVideoName, out var firstAidVideoName));
Assert.AreEqual(5, firstAidVideoName.LineTotal);
await(new DigitalProductPurchaseHandler(specialRuleRepositoryMock.Object)).ProcessAsync(order);
Assert.AreEqual(5, firstAidVideoName.LineTotal);
}
public async Task WhenLearnToSkiIsOrderedNotInCart_FirstAidIsNotAdded()
{
var order = new Order()
{
OrderType = OrderType.DigitalProductPurchase
};
order.Add(new Item()
{
Category = ItemCategory.Video, Name = "Random Video"
}, 4);
await(new DigitalProductPurchaseHandler(specialRuleRepositoryMock.Object)).ProcessAsync(order);
Assert.AreEqual(1, order.CartItems.Count);
Assert.IsTrue(order.CartItems.TryGetValue("Random Video", out var learnToSkiVideoItem));
Assert.AreEqual(4, learnToSkiVideoItem.Quantity);
}
public async Task WhenOrderMembershipEmailIsMissing_Throws()
{
var order = new Order()
{
OrderType = OrderType.MembershipPurchase
};
var activateMembershipItem = new MembershipItem()
{
Category = ItemCategory.Membership, Name = Constants.ItemNames.MembershipActivation, DefaultUnitPrice = 5, MembershipEmail = string.Empty, MembershipId = Guid.NewGuid()
};
order.Add(activateMembershipItem, 1);
var sut = new MembershipPurchaseHandler(membershipRepositoryMock.Object, this.emailClientMock.Object);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await sut.ProcessAsync(order));
}
public void AddFoodTestWithNegativPrice()
{
Order order = Order.getInstance();
Food dough = new Dough();
dough.Price = -1.0;
Exception exception = null;
try
{
bool result = order.Add(dough);
}
catch (NegativePriceException e) {
exception = e;
}
Assert.AreNotEqual(exception, null);
}
private static Order CreateOrderWith1Product(string orderDate, decimal unitPrice)
{
Product product = new Product
{
Name = "Keyboard",
Color = "Black",
UnitPrice = unitPrice,
};
Order order = new Order
{
CreateDate = DateTime.Parse(orderDate),
NumberOrder = "ZAM 001",
};
order.Add(product);
return(order);
}
// Upon start, update the content of all three ObservableCollections
public GuestBookViewModel()
{
DataTable ClienteDataTable = new DataTable();
ClienteDataTable.Load(ClientesDataReader());
for (int i = 0; i < ClienteDataTable.Rows.Count; i++)
{
PersonModel p = new PersonModel
{
Nome = ClienteDataTable.Rows[i][1].ToString(),
ID = ClienteDataTable.Rows[i][0].ToString()
};
People.Add(p);
}
DataTable ProdutoDataTable = new DataTable();
ProdutoDataTable.Load(ProdutosDataReader());
for (int i = 0; i < ProdutoDataTable.Rows.Count; i++)
{
LojaModel p = new LojaModel
{
Produto = ProdutoDataTable.Rows[i][0].ToString(),
Info = ProdutoDataTable.Rows[i][1].ToString(),
Valor = ProdutoDataTable.Rows[i][2].ToString()
};
Loja.Add(p);
}
DataTable VendasDataTable = new DataTable();
VendasDataTable.Load(VendasDataReader());
for (int i = 0; i < VendasDataTable.Rows.Count; i++)
{
OrderModel p = new OrderModel
{
OrderNome = VendasDataTable.Rows[i][0].ToString(),
OrderProduto = VendasDataTable.Rows[i][1].ToString(),
OrderQuantidade = VendasDataTable.Rows[i][2].ToString(),
OrderTotal = VendasDataTable.Rows[i][0].ToString()
};
Order.Add(p);
}
}
public async Task <IHttpActionResult> Post(IEnumerable <CartItemData> items)
{
try
{
IEnumerable <int> ids = items.Select(x => x.ProductId);
IEnumerable <Product> products = productRepo.Entities.Where(x => ids.Contains(x.Id));
Order order = new Order(Guid.Parse(UserHelper.CurrentUser.Id));
items.ForEach(x => order.Add(products.Where(p => p.Id == x.ProductId).First(), x.Quontity));
await orderRepo.SaveOrUpdateAcync(order);
return(Ok());
}
catch (Exception ex)
{
return(InternalServerError());
}
}
public void AddFoodTestWithoutDescription()
{
Order order = Order.getInstance();
Food dough = new Dough();
dough.Description = "";
Exception exception = null;
try
{
bool result = order.Add(dough);
}
catch (NoDescriptionException e)
{
exception = e;
}
Assert.AreNotEqual(exception, null);
}
static void Main()
{
Console.WriteLine("Enter Cliente data");
Console.Write("Name: ");
string name = Console.ReadLine();
Console.Write("Email: ");
string email = Console.ReadLine();
Console.Write("Birth date (dd/mm/yyyy): ");
DateTime birthday = DateTime.Parse(Console.ReadLine());
Client client = new Client(name, email, birthday);
Console.WriteLine();
Console.WriteLine("Enter Order data");
Console.Write("(PedingPayment/Processing/Shipped/Delivered): ");
OrderStatus status = Enum.Parse <OrderStatus>(Console.ReadLine());
Order order = new Order(DateTime.Now, status, client);
Console.Write("How many itens to this order: ");
int qtd = int.Parse(Console.ReadLine());
for (int i = 0; i < qtd; i++)
{
Console.WriteLine($"Enter {i+1}º item data");
Console.Write("Product Name: ");
string prodName = Console.ReadLine();
Console.Write("Product Price: ");
double prodPrice = double.Parse(Console.ReadLine(), CultureInfo.InvariantCulture);
Console.Write("Quantity: ");
int prodQtd = int.Parse(Console.ReadLine());
Product product = new Product(prodName, prodPrice);
OrderItem orderItem = new OrderItem(prodQtd, prodPrice, product);
order.Add(orderItem);
} // end foreach
Console.WriteLine();
Console.WriteLine("ORDER SUMMARY:");
Console.WriteLine(order);
}
public override ConsensusCommand GetAEDPoSConsensusCommand()
{
var miningInterval = MiningInterval;
var offset =
_consensusBehaviour == AElfConsensusBehaviour.UpdateValueWithoutPreviousInValue && Order == 1
? miningInterval
: Order.Add(MinersCount).Sub(1).Mul(miningInterval);
var arrangedMiningTime = MiningTimeArrangingService.ArrangeMiningTimeBasedOnOffset(CurrentBlockTime, offset);
return(new ConsensusCommand
{
Hint = new AElfConsensusHint {
Behaviour = _consensusBehaviour
}.ToByteString(),
ArrangedMiningTime = arrangedMiningTime,
MiningDueTime = arrangedMiningTime.AddMilliseconds(miningInterval),
LimitMillisecondsOfMiningBlock = DefaultBlockMiningLimit
});
}
public void ShouldNotifyTotalsChangedWhenItemPriceChanged()
{
var o = new Order();
var e = new MockEntree(0, 0);
o.Add(e);
Assert.PropertyChanged(o, nameof(Order.Subtotal), () =>
{
e.SetPrice(1.00);
});
Assert.PropertyChanged(o, nameof(Order.Tax), () =>
{
e.SetPrice(1.00);
});
Assert.PropertyChanged(o, nameof(Order.Total), () =>
{
e.SetPrice(1.00);
});
}
private const int CPU_PURCHASE_COUNT = 10000000; // 1 million
static void Main(string[] args)
{
CpuProductFlyweightFactory cpuProductFactory = new CpuProductFlyweightFactory();
CpuOrderItemFactory cpuOrderItemFactory = new CpuOrderItemFactory(cpuProductFactory);
List <Order> orders = new List <Order>();
for (int i = 0; i < CPU_PURCHASE_COUNT; i++)
{
Order order = new Order();
CpuSeries cpuSeries = GetRandomCpuSeries();
OrderItem cpu = cpuOrderItemFactory.Create(cpuSeries, 1);
order.Add(cpu);
orders.Add(order);
}
Console.ReadKey();
}
public void ChangingItemPriceRaisesPropertyChanged()
{
Order x = new Order();
AretinoAppleJuice a = new AretinoAppleJuice();
x.Add(a);
Assert.PropertyChanged(x, "Subtotal", () =>
{
a.Size = Size.Large;
});
Assert.PropertyChanged(x, "Tax", () =>
{
a.Size = Size.Medium;
});
Assert.PropertyChanged(x, "Total", () =>
{
a.Size = Size.Small;
});
}
///Use a greedy algorithm to fulfill the order
private OrderFulfillment FulfillWithGreedyMultipleShipments(Order order, WarehouseNetwork warehouseNetwork)
{
var orderFulfillment = new OrderFulfillment();
// <comment for reviewers only:> This is a semi-hacky way to get around "Collection was modified; enumeration operation may not execute." exceptions. It is safe here as long as I know this is the only code modifying the collection
var orderKeys = new List <string>(order.Keys);
foreach (var warehouse in warehouseNetwork)
{
var partialOrder = new Order();
foreach (var itemName in orderKeys)
{
if (!warehouse.Inventory.ContainsKey(itemName))
{
continue;
}
var orderItemQuantity = order[itemName];
var warehouseItemCount = warehouse.Inventory[itemName];
var amountCanFullfill = Math.Min(orderItemQuantity, warehouseItemCount);
if (amountCanFullfill > 0)
{
partialOrder.Add(itemName, amountCanFullfill);
//No need to update warehouse inventory directly here
//Do need to update order quantity remaining to fulfill, BUT the KeyValuePair object in C# is immutable... need to update the order dictionary itself
order[itemName] -= amountCanFullfill;
}
}
if (partialOrder.Count > 0)
{
orderFulfillment.Add(warehouse.Name, partialOrder);
}
}
return(orderFulfillment);
}
public void PropertyChangedInRemovedItemShouldNotInvokePropertyChanged()
{
var order = new Order();
var item1 = new MockOrderItem()
{
Price = 1.0
};
order.Add(item1);
order.Remove(item1);
// A bit of a hack to assert that the PropertyChanged assertion fails
Assert.Throws <PropertyChangedException>(() =>
{
Assert.PropertyChanged(order, "Subtotal", () =>
{
item1.Price = 2.0;
});
});
}
public static void MergeOrderByComposite()
{
var order1 = new Order("cust-1");
order1.Add(new OrderItem("111", "Item-1", 10));
//some delay and other orders.....
var order2 = new Order("cust-1");
order2.Add(new OrderItem("444", "Item-4", 10));
order2.Add(new OrderItem("555", "Item-5", 60));
var finalOrder = new Order("cust-1");
finalOrder.Add(order1);
finalOrder.Add(order2);
Console.WriteLine($"Order Total: {finalOrder.GetTotal()}");
}
public void Process_Should_Not_Execute_Rule()
{
IBussinessRuleEngine ruleEngine = new BusinessRuleEngine();
IRule rule = new PhysicalProductRule();
var order = new Order(Guid.NewGuid(), new Agent {
Name = "Test"
});
var product = new Product();
order.Add(new OrderLine(product, 1));
var ruleMock = new Mock <IRule>();
ruleMock.Setup(x => x.IsApplicable(product)).Returns(false);
ruleMock.Setup(x => x.Apply()).Returns("Applied Rule");
ruleEngine.AddRule(ruleMock.Object);
ruleEngine.Process(order);
ruleMock.Verify(x => x.IsApplicable(product), Times.Once);
ruleMock.Verify(x => x.Apply(), Times.Never);
}
/// <summary>
/// Récupère les meetings d'un chemin possible dans l'arbre de manière récursive
/// </summary>
/// <param name="parents"></param>
/// <param name="child"></param>
private void getParent(Order parents, Node child)
{
parents.Add(child);
if (child.Parent == null)
return;
getParent(parents, child.Parent);
}
