private void OrderPizza()
{
var order = new PizzaOrder((PizzaOrder.OrderDifficulty)Random.Range(0,
Enum.GetNames(typeof(PizzaOrder.OrderDifficulty)).Length));
Instance.ActiveOrders.Add(order.Customer.Fluff.Name, order);
}
//[ValidateAntiForgeryToken]
public ActionResult Create([Bind("Quantity,OrderId,Pizza")] PizzaOrder pizzaOrder)
{
if (ModelState.IsValid)
{
List <Pizza> selectedPizzas = new List <Pizza>();
var pizzas = Repo.GetAllPizzas();
var selectedIng = new List <Ingredients>();
var Ingredients = Repo.GetAllIngredients();
foreach (var item in pizzaOrder.Pizza)
{
selectedPizzas.Add(item);
}
PizzaOrder newPizzaOrder = new PizzaOrder
{
Quantity = pizzaOrder.Quantity,
OrderId = pizzaOrder.OrderId,
Pizza = selectedPizzas,
//Ingredients = selectedIng
};
// Store store = Repo.GetStoreById(1);
Repo.AddPizzaOrders(newPizzaOrder);
Repo.Save();
}
return(View(pizzaOrder));
//return View(pizzaOrder);
}
public IActionResult Order(OrderViewModel model)
{
Order order = new Order();
List <PizzaOrder> pizzas = new List <PizzaOrder>();
foreach (PizzaViewModel pizzaViewModel in model.Pizzas)
{
PizzaOrder pizzaOrder = new PizzaOrder()
{
Pizza = _pizzaOrderService.GetPizzaFromMenu(pizzaViewModel.Name, pizzaViewModel.Size),
Order = order
};
pizzaOrder.PizzaId = pizzaOrder.Pizza.Id;
pizzas.Add(pizzaOrder);
}
User user = new User()
{
Address = model.Address,
FirstName = model.FirstName,
LastName = model.LastName,
Phone = model.Phone
};
order.PizzaOrders = pizzas;
order.User = user;
_pizzaOrderService.MakeNewOrder(order);
return(View("_ThankYou"));
}
public void ChooseSize(int number)
{
PizzaSize size;
switch (number)
{
case 1:
size = PizzaSize.Small;
break;
case 2:
size = PizzaSize.Medium;
break;
case 3:
size = PizzaSize.Large;
break;
default:
size = PizzaSize.Medium;
break;
}
pb.ChooseSize(size);
_order = pb.GetResult();
}
//// GET: PizzaOrders/Details/5
public ActionResult Details(int id)
{
PizzaOrder pizzaOrder = Repo.GetPizzaOrderById(id);
return(View(pizzaOrder));
}
public static decimal FivePercentOffMoreThanFiftyDollars(PizzaOrder order)
{
decimal nonDiscounted = order.Pizzas.Sum(p => p.Price);
decimal discount = nonDiscounted >= 50 ? nonDiscounted * 0.05m : 0m;
return(discount);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Quantity,OrderId")] PizzaOrder pizzaOrder)
{
if (id != pizzaOrder.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(pizzaOrder);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PizzaOrderExists(pizzaOrder.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["OrderId"] = new SelectList(_context.Orders, "Id", "Id", pizzaOrder.OrderId);
return(View(pizzaOrder));
}
public decimal ComputePrice(PizzaOrder order)
{
decimal nonDiscounted = order.Pizzas.Sum(p => p.Price);
decimal discountValue = discountPolicy(order);
return(nonDiscounted - discountValue);
}
public static void Execute()
{
List <Pizza> pizzas = new List <Pizza>();
pizzas.Add(new Pizza {
Crust = Crust.Regular, Price = 100, Size = Size.Medium
});
pizzas.Add(new Pizza {
Crust = Crust.Stuffed, Price = 150, Size = Size.Medium
});
pizzas.Add(new Pizza {
Crust = Crust.Thin, Price = 50, Size = Size.Large
});
pizzas.Add(new Pizza {
Crust = Crust.Stuffed, Price = 150, Size = Size.Medium
});
pizzas.Add(new Pizza {
Crust = Crust.Regular, Price = 100, Size = Size.Large
});
PizzaOrder pizzaOrder = new PizzaOrder {
Pizzas = pizzas
};
PizzaOrderingSystem orderingSystem = new PizzaOrderingSystem(Policies.DiscountAllThePizzas());
decimal price = orderingSystem.ComputePrice(pizzaOrder);
Console.WriteLine($"Discounted Price: {price}");
}
/// <summary>
/// taking pizza order
/// </summary>
private static void TakeSingleOrder()
{
var order = new PizzaOrder()
{
CustomerName = "Alan Smith",
Type = "Hawaiian",
Size = "Large"
};
// Create a BrokeredMessage
var message = new BrokeredMessage(order)
{
Label = "PizzaOrder"
};
// Send the message...
var client = QueueClient.CreateFromConnectionString
(PizzaStationSettings.ConnectionString, PizzaStationSettings.QueueName);
Console.WriteLine("Sending order...");
client.Send(message);
Console.WriteLine("Done!");
client.Close();
}
public void RatedOrder(Guid id, int rating)
{
PizzaOrder dbPizzaOrder = db.PizzaOrders.Find(id);
dbPizzaOrder.Rating = rating;
db.SaveChanges();
}
public void CreateOrder(List <CartItemDto> cartItems, string userFk, string address)
{
ApplicationUser user = db.Users.Find(userFk);
PizzaOrder dbOrder = new PizzaOrder
{
OrderId = Guid.NewGuid(),
Address = address,
Status = OrderStatus.InProgress,
User = user,
TimeOfOrder = DateTime.Now,
Rating = 0
};
foreach (var item in cartItems)
{
dbOrder.Items.Add(new CartItem
{
CartItemId = Guid.NewGuid(),
Pizza = db.Pizzas.Find(item.Pizza.PizzaId),
PizzaSize = item.Pizza.Size,
Quantity = item.Quantity
});
}
user.PizzaOrders.Add(dbOrder);
db.PizzaOrders.Add(dbOrder);
db.SaveChanges();
}
static void SendPizzaOrder()
{
var order = new PizzaOrder()
{
CustomerName = "Alan Smith",
Type = "Hawaiian",
Size = "Large"
};
// Create a BrokeredMessage
var message = new BrokeredMessage(order)
{
Label = "PizzaOrder"
};
// What size is the message?
Console.WriteLine("Message size: " + message.Size);
// Send the message...
var client = QueueClient.CreateFromConnectionString
(Settings.ConnectionString, Settings.QueueName);
Console.Write("Sending order...");
client.Send(message);
Console.WriteLine("Done!");
client.Close();
// What size is the message now?
Console.WriteLine("Message size: " + message.Size);
}
static void SendPizzaOrderBatch()
{
// Create some data
string[] names = { "Pawan", "Ravish", "Vinay" };
string[] pizzas = { "Hawaiian", "Vegitarian", "Capricciosa", "Napolitana" };
// Create a queue client
var client = QueueClient.CreateFromConnectionString
(Settings.ConnectionString, Settings.QueueName);
// Send a batch of pizza orders
var taskList = new List <Task>();
for (int pizza = 0; pizza < pizzas.Length; pizza++)
{
for (int name = 0; name < names.Length; name++)
{
Console.WriteLine("{0} ordered {1}", names[name], pizzas[pizza]);
PizzaOrder order = new PizzaOrder()
{
CustomerName = names[name],
Type = pizzas[pizza],
Size = "Large"
};
var message = new BrokeredMessage(order);
taskList.Add(client.SendAsync(message));
}
}
//Console.WriteLine("Sending batch...");
Task.WaitAll(taskList.ToArray());
Console.WriteLine("Sent!");
}
public double GetTotalCost(int orderId)
{
List <Pizza> pizzas = new List <Pizza>();
PizzaOrder po = new PizzaOrder();
foreach (var item in ReadPizzaOrder())
{
if (item.Order == orderId)
{
foreach (var item2 in ReadPizza())
{
if (item2.PizzaId == item.Pizza)
{
pizzas.Add(item2);
}
}
}
}
double total = 0;
foreach (var p in pizzas)
{
total += double.Parse(p.Cost.ToString());
}
return(total);
}
/// <summary>
/// Method that creates and posts an order to the order table and post to the junction table in the server database.
/// It also gives the user an order number connected to the order they just placed.
/// </summary>
/// <param name="o"></param>
/// <returns></returns>
///
public async Task PostOrderToDB(Order o)
{
var myOrder = JsonConvert.SerializeObject(o);
HttpContent httpContent = new StringContent(myOrder);
httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var orderDB = await httpClient.PostAsync(orderUrl, httpContent);
var readDB = await orderDB.Content.ReadAsStringAsync();
int orderNo = int.Parse(readDB);
if (OrderList.Count > 0)
{
foreach (var item in OrderList)
{
var pOrder = new PizzaOrder(orderNo, item.PizzaID);
myOrder = JsonConvert.SerializeObject(pOrder);
httpContent = new StringContent(myOrder);
httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
await httpClient.PostAsync(pOrderUrl, httpContent);
}
}
OrderList.Clear();
MessageDialog msg = new MessageDialog($"Du har fått ordernummer: {orderNo}");
await msg.ShowAsync();
}
public List <PizzaOrder> GetUserOrderHistory(int userID)
{
List <PizzaOrder> userOrders = new List <PizzaOrder>();
int prevOrder = 0;
int currentOrder = 0;
var orderList = _dbConnection.PizzasInOrder.Include("Order").Include("Pizza").ToList().Where(
p => p.Order.UserId == userID).ToList();
if (orderList.Count == 0)
{
return(userOrders);
}
currentOrder = orderList[0].Order.OrderId;
foreach (var item in orderList)
{
currentOrder = item.Order.OrderId;
if (prevOrder == currentOrder)
{
continue;
}
PizzaOrder ord = new PizzaOrder(item.Order.LocationId, item.Order.UserId, item.Order.OrderId);
List <PlainPizza> orderPizzas = new List <PlainPizza>();
for (int i = 0; i < item.Order.PizzasInOrder.ToList().Count; i++)
{
ord.AddPizzaToOrder(new PlainPizza(item.Order.PizzasInOrder.ToList()[i].Pizza.PizzaCost,
item.Order.PizzasInOrder.ToList()[i].Pizza.PizzaDescription));
}
userOrders.Add(ord);
prevOrder = currentOrder;
}
return(userOrders);
}
public bool SubmitUserOrder(PizzaOrder newOrder)
{
try{
// submit order object into db
_dbConnection.OrderTable.Add(new OrderTable {
UserId = newOrder.UserID,
LocationId = newOrder.OrderShopLocationID,
OrderTotalCost = newOrder.GetTotalOrderCost(),
PizzaCount = newOrder.GetTotalPizzaCount()
});
_dbConnection.SaveChanges();
}catch (System.Exception ex) {
return(false);
}
try{
int currentOrderID = _dbConnection.OrderTable.ToList()
[_dbConnection.OrderTable.ToList().Count - 1].OrderId;
// submit pizzas to db and link to order
foreach (var pizza in newOrder.OrderItems)
{
int CurrentPizzaID = PizzaRecipesDataRetriever.GetInstance().AddPizzaToDB(pizza);
_dbConnection.PizzasInOrder.Add(new PizzasInOrder {
OrderId = currentOrderID,
PizzaId = CurrentPizzaID
});
_dbConnection.SaveChanges();
}
}catch (System.Exception ex) {
return(false);
}
return(true);
}
public PizzaOrder Update(PizzaOrder orderToUpdate)
{
var entity = db.PizzaOrders.Attach(orderToUpdate);
entity.State = EntityState.Modified;
return(orderToUpdate);
}
public async Task <IActionResult> PutPizzaOrder(int id, PizzaOrder pizzaOrder)
{
if (id != pizzaOrder.PizzaIdPizza)
{
return(BadRequest());
}
_context.Entry(pizzaOrder).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PizzaOrderExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
static async Task SendPizzaOrderAsync()
{
WriteLine("SendPizzaOrderAsync", ConsoleColor.Cyan);
var order = new PizzaOrder()
{
CustomerName = "Alan Smith",
Type = "Hawaiian",
Size = "Large"
};
// Serialize the order object
var jsonPizzaOrder = JsonConvert.SerializeObject(order);
// Create a Message
var message = new Message(Encoding.UTF8.GetBytes(jsonPizzaOrder))
{
Label = "PizzaOrder",
ContentType = "application/json"
};
// Send the message...
var client = new QueueClient(Settings.ConnectionString, Settings.QueueName);
Write("Sending order...", ConsoleColor.Green);
await client.SendAsync(message);
WriteLine("Done!", ConsoleColor.Green);
Console.WriteLine();
await client.CloseAsync();
}
public PizzaOrder Create(PizzaOrder entity)
{
IPizza pizza = null;
if (entity.Sabor == "calabresa")
{
pizza = new Calabresa();
}
if (entity.Sabor == "marguerita")
{
pizza = new Marguerita();
}
if (entity.Sabor == "portuguesa")
{
pizza = new Portuguesa();
}
if (entity.Tamando == "pequena")
{
pizza = new Pequena(pizza);
}
if (entity.Tamando == "média")
{
pizza = new Media(pizza);
}
if (entity.Tamando == "grande")
{
pizza = new Grande(pizza);
}
var personalizacoes = entity.Personalizacao.Split(",");
foreach (var item in personalizacoes)
{
if (item == "borda recheada")
{
pizza = new BordaRecheada(pizza);
}
if (item == "extra bacon")
{
pizza = new ExtraBacon(pizza);
}
if (item == "sem cebola")
{
pizza = new SemCebola(pizza);
}
}
entity.ValorTotal = pizza.Custo().Valor;
entity.TempoDePreparo = pizza.Custo().TempoDePreparo;
return(pizzaOrderRepository.Create(entity));
}
public async Task Pizza_fr_Script()
{
await VerifyFormScript(@"..\..\PizzaForm-fr.script",
"fr", () => PizzaOrder.BuildForm(), FormOptions.None, new PizzaOrder(), Array.Empty <EntityRecommendation>(),
"bonjour",
"2",
"moyen",
"4",
"?",
"1 2",
"retourner",
"c",
"non",
"fine",
"1",
"?",
"bovine, oignons, ice cream",
"oignons",
"statut",
"abc",
"1 state street",
"oui",
"1 2",
"non",
"2,5",
"25/2/1962 3pm",
"non",
"1234",
"123-4567",
"non",
"nappages",
"non epinards",
"oui"
);
}
private void AddRecord(Database db)
{
var pizza = new PizzaOrder
{
Id = PIZZA_ORDER_ID,
OrderNumber = new Random().Next(1000).ToString(),
CustomerName = "Haiping Chen",
CreatedTime = DateTime.UtcNow,
PizzaTypes = new List <PizzaType> {
new PizzaType {
Name = "Pizza Type 1", Amount = 10.99M
},
new PizzaType {
Name = "Pizza Type 2", Amount = 9.9M
}
}
};
if (db.Table <PizzaOrder>().Any(x => x.Id == PIZZA_ORDER_ID))
{
return;
}
db.DbTran(() => db.Table <PizzaOrder>().Add(pizza));
var order = db.Table <PizzaOrder>().Include(x => x.PizzaTypes).FirstOrDefault(x => x.Id == PIZZA_ORDER_ID);
Assert.IsNotNull(order.Id);
Assert.IsTrue(order.PizzaTypes.Count == 2);
}
public void CreateOrder()
{
timeUntilNextOrder = timeBetweenOrders + Random.Range(-orderRandomness, orderRandomness);
var latestOrder = new PizzaOrder()
{
orderId = pizzaOrderCounter, ingredients = new List <PizzaIngredient.PizzaInredientType>()
{
PizzaIngredient.PizzaInredientType.Cheese, PizzaIngredient.PizzaInredientType.Sauce
}
};
var numToppings = Random.Range(0, gameManager.MaxToppingsThisStage() + 1); // max is exclusive
for (var i = 0; i < numToppings; i++)
{
latestOrder.ingredients.Add(RandomTopping());
}
allOrders.Add(latestOrder);
pizzaOrderCounter++;
if (OnNewOrder != null)
{
OnNewOrder.Invoke(latestOrder.orderId);
}
}
public async Task Pizza_Entities_Script()
{
await VerifyFormScript(@"..\..\PizzaForm-entities.script",
"en-us", () => PizzaOrder.BuildForm(), FormOptions.None, new PizzaOrder(),
new Luis.Models.EntityRecommendation[] {
new Luis.Models.EntityRecommendation("Address", "abc", "DeliveryAddress"),
new Luis.Models.EntityRecommendation("Kind", "byo", "Kind"),
// This should be skipped because it is not active
new Luis.Models.EntityRecommendation("Signature", "Hawaiian", "Signature"),
new Luis.Models.EntityRecommendation("Toppings", "onions", "BYO.Toppings"),
new Luis.Models.EntityRecommendation("Toppings", "peppers", "BYO.Toppings"),
new Luis.Models.EntityRecommendation("Toppings", "ice", "BYO.Toppings"),
new Luis.Models.EntityRecommendation("NotFound", "OK", "Notfound")
},
"hi",
"1", // onions for topping clarification
"2",
"med",
// Kind "4",
"drink bread",
"thin",
"1",
"?",
// "beef, onion, ice cream",
"3",
"y",
"1 2",
"none",
"2.5",
"2/25/1962 3pm",
"no",
"123-4567",
"y"
);
}
public int MakeNewOrder(OrderViewModel orderVm)
{
var order = new Order();
var pizzas = new List <PizzaOrder>();
foreach (var pizzaVm in orderVm.Pizzas)
{
var pizzaOrder = new PizzaOrder()
{
Pizza = GetPizzaFromMenu(pizzaVm.Name, pizzaVm.Size),
Order = order
};
pizzaOrder.PizzaId = pizzaOrder.Pizza.Id;
pizzas.Add(pizzaOrder);
}
var user = new User
{
Address = orderVm.Address,
FirstName = orderVm.FirstName,
LastName = orderVm.LastName,
Phone = orderVm.Phone.Value
};
order.PizzaOrders = pizzas;
order.User = user;
return(_orderRepository.Insert(order));
}
public async Task Save(PizzaOrder item)
{
var pizzaOrder = await context.PizzaOrders.FirstAsync(x => x.Id == item.Id);
pizzaOrder.OrderFor = PersonFullName.Create(item.OrderFor.GivenName, item.OrderFor.SurName);
await context.SaveChangesAsync();
}
public static bool ValidateInput(PizzaOrder currentOrder, out string errorMessage)
{
errorMessage = "";
string nameError = "";
bool nameIsValid = false;
string addressError = "";
bool addressIsValid = false;
string zipCodeError = "";
bool zipCodeIsValid = false;
string phoneError = "";
bool phoneIsValid = false;
nameIsValid = validateName(currentOrder.Name, out nameError);
addressIsValid = validateAddress(currentOrder.Address, out addressError);
zipCodeIsValid = validateZipCode(currentOrder.ZipCode, out zipCodeError);
phoneIsValid = validatePhone(currentOrder.Phone, out phoneError);
if (!(nameIsValid && addressIsValid && zipCodeIsValid && phoneIsValid))
{
errorMessage = nameError + addressError + zipCodeError + phoneError;
return(false);
}
return(true);
}
public static void SaveOrder(PizzaOrder currentOrder)
{
PapaBobsDataEntities db = new PapaBobsDataEntities();
var dbOrders = db.Orders;
Order order = new Order();
order.OrderId = currentOrder.OrderId;
order.Name = currentOrder.Name;
order.Address = currentOrder.Address;
order.ZipCode = currentOrder.ZipCode;
order.Phone = currentOrder.Phone;
order.PaymentType = currentOrder.PaymentType;
order.TotalCost = currentOrder.TotalCost;
order.Size = currentOrder.Size;
order.Crust = currentOrder.Crust;
order.Sausage = currentOrder.Sausage;
order.Pepperoni = currentOrder.Pepperoni;
order.Onions = currentOrder.Onions;
order.GreenPeppers = currentOrder.GreenPeppers;
order.Completed = currentOrder.Completed;
dbOrders.Add(order);
db.SaveChanges();
}
static void Main(string[] args)
{
const string queueName = "PizzaOrders";
var connectionString = CloudConfigurationManager.GetSetting("PizzaOrderConnectionString");
var nameSpaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
if (!nameSpaceManager.QueueExists(queueName))
{
nameSpaceManager.CreateQueue(queueName);
}
var client = QueueClient.CreateFromConnectionString(connectionString, queueName);
var pizzaTypes = new List<string>
{
"Margherita",
"Funghi",
"Capricciosa",
"Quattro Stagioni",
"Vegetariana",
"Quattro Formaggi",
"Marinara",
"Peperoni",
"Napolitana",
"Hawaii",
"Maltija (Maltese)",
"Calzone (folded)",
"Rucola",
"Bolognese",
"Meat Feast",
"Kebabpizza",
"Mexicana"
};
var pizzaSizes = new List<string>
{
"Small",
"Medium",
"Large",
"Extra Large"
};
var random = new Random();
for (var i = 1; i <= 100; i++)
{
var order = new PizzaOrder
{
CustomerName = "Shravan" + i,
Type = pizzaTypes[random.Next(pizzaTypes.Count)],
Size = pizzaSizes[random.Next(pizzaSizes.Count)],
Quantity = random.Next(10)
};
var json = JsonConvert.SerializeObject(order);
var message = new BrokeredMessage(json)
{
Label = order.GetType().ToString(),
ContentType = "application/json"
};
Console.WriteLine("Sending Pizza Order: " + i);
client.SendAsync(message);
System.Threading.Thread.Sleep(500);
}
Console.WriteLine("Sending Messages Complete");
Console.ReadLine();
}
