public EmployeeController(LiveInterpreterAsync interpreter)
{
this._interpreter = interpreter;
}
public static async Task Main(string[] args)
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddOperations(typeof(RestaurantAgg).Assembly);
serviceCollection.AddOperations(typeof(MenuAgg).Assembly);
serviceCollection.AddOperations(typeof(AddOrUpdateEntityOp).Assembly);
serviceCollection.AddTransient(typeof(IOp <,>), typeof(QueryOp <,>));
serviceCollection.AddDbContext <OrderAndPayContext>(ServiceLifetime.Singleton);
var serviceProvider = serviceCollection.BuildServiceProvider();
var interpreter = new LiveInterpreterAsync(serviceProvider);
//Selecting the restaurant
var expr = from selectRestaurant in RestaurantDomain.GetRestaurant("McDonalds")
let restaurant = (selectRestaurant as RestaurantAgg)?.Restaurant
select selectRestaurant;
var exprResult = await interpreter.Interpret(expr, Unit.Default);
var finalExpr = await exprResult.MatchAsync(
async (persisted) => // Restaurant Successfully selected
{
// Populates the RestaurantAgg model with the data from two functions, using a LiveAsyncInterpreter.
// This function will firstly populate the ICollection<Menu> Menus by calling GetAllMenus, with all the menus from the database that have the restaurant's id
// After the ICollection<Menu> will be filled, for each entity it will call the GetAllMenuItems function to populate the menu
await RestaurantDomain.PopulateRestaurantModel(persisted.RestaurantAgg, RestaurantDomain.GetAllMenus, RestaurantDomain.GetAllMenuItems, interpreter);
//// Selects a menu with a specific name
var selectMenuExpr = from selectMenu in RestaurantDomain.GetMenu("Chicken", persisted.RestaurantAgg.Restaurant.Id)
let menu = (selectMenu as MenuSelected)?.MenuAgg
select selectMenu;
var selectMenuRes = await interpreter.Interpret(selectMenuExpr, Unit.Default);
var selectMenuResult = await selectMenuRes.MatchAsync(
async(selected) => // Menu was successfully selected
{
selected.MenuAgg.Menu.Hours = "8-13";
var updateRestaurantExprUnique = from updateRestauruant in RestaurantDomain.UpdateAndPersistMenu(selected.MenuAgg.Menu)
let updatem = (updateRestauruant as MenuUpdated)?.Menu
select updateRestauruant;
var updateRestaurantFin = await interpreter.Interpret(updateRestaurantExprUnique, Unit.Default);
var matchh = updateRestaurantFin.Match(
updated =>
{
return(updated);
},
notUpdated =>
{
return(notUpdated);
}
);
//var getAllMenuItems = from getAllMenus in RestaurantDomain.GetAllMenuItems(10)
// select getAllMenus;
//var getAllMenusResult = await interpreter.Interpret(getAllMenuItems, Unit.Default);
return(selected);
},
async(notSelected) => // Menu not selected
{
return(notSelected);
}
);
return(persisted);
},
async (notPersisted) => // Restaurant not selected
{
return(notPersisted);
}
);
Console.WriteLine("Hello World!");
}
public ClientController(LiveInterpreterAsync interpreter)
{
_interpreter = interpreter;
}
// Populates the RestaurantAgg model with the data from two functions, using a LiveAsyncInterpreter.
// This function will firstly populate the ICollection<Menu> Menus by calling GetAllMenus, with all the menus from the database that have the restaurant's id
// After the ICollection<Menu> will be filled, for each entity it will call the GetAllMenuItems function to populate the menu
public static IO <IPopulateRestaurantResult> PopulateRestaurant(RestaurantAgg restaurantAgg, Func <int, IO <ICollection <Menu> > > getAllMenus, Func <int, IO <ICollection <MenuItem> > > getAllMenuItems, LiveInterpreterAsync interpreter) =>
NewIO <PopulateRestaurantOp.PopulateRestaurantCmd, IPopulateRestaurantResult>(new PopulateRestaurantOp.PopulateRestaurantCmd(restaurantAgg, getAllMenus, getAllMenuItems, interpreter));
public static async Task PopulateRestaurantModel(RestaurantAgg restaurantAgg, Func <int, IO <ICollection <Menu> > > getAllMenus, Func <int, IO <ICollection <MenuItem> > > getAllMenuItems, LiveInterpreterAsync interpreter)
{
var expression = from allMenus in getAllMenus(restaurantAgg.Restaurant.Id)
select allMenus;
var result = await interpreter.Interpret(expression, Unit.Default);
restaurantAgg.Menus = result;
foreach (var menu in restaurantAgg.Menus)
{
var expressionMenuItem = from allMenuItems in getAllMenuItems(menu.Id)
select allMenuItems;
var resultMenuItem = await interpreter.Interpret(expressionMenuItem, Unit.Default);
menu.MenuItem = resultMenuItem;
}
}
public static IO <IPopulateOrderResult> PopulateOrder(Restaurant restaurant, ICollection <Order> orders, Func <int, IO <ICollection <Order> > > getAllOrders, Func <int, IO <ICollection <OrderItems> > > getAllOrderItems, LiveInterpreterAsync interpreter) => NewIO <PopulateOrderOp.PopulateOrderCmd, IPopulateOrderResult>(new PopulateOrderOp.PopulateOrderCmd(restaurant, orders, getAllOrders, getAllOrderItems, interpreter));
static async Task Main(string[] args)
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddOperations(typeof(RestaurantAgg).Assembly);
serviceCollection.AddOperations(typeof(ClientAgg).Assembly);
serviceCollection.AddOperations(typeof(EmployeeAgg).Assembly);
serviceCollection.AddOperations(typeof(MenuAgg).Assembly);
serviceCollection.AddOperations(typeof(MenuItemAgg).Assembly);
serviceCollection.AddOperations(typeof(OrderAgg).Assembly);
serviceCollection.AddOperations(typeof(OrderItemAgg).Assembly);
serviceCollection.AddOperations(typeof(AddOrUpdateOp).Assembly);
serviceCollection.AddTransient(typeof(IOp <,>), typeof(QueryOp <,>));
serviceCollection.AddDbContext <OrderAndPayContext>(ServiceLifetime.Singleton);
serviceCollection.AddOperations(typeof(OrderAndPayContext).Assembly);
var serviceProvider = serviceCollection.BuildServiceProvider();
var interpreter = new LiveInterpreterAsync(serviceProvider);
/*
* //Adding a Restaurant
* var exprRestaurant =
* from restaurantResult in RestaurantDomainEx.CreateRestaurantAndPersist("Restaurant_7", "address")
* let restaurant = (restaurantResult as RestaurantCreated)?.Restaurant
*
* /*from menuResult1 in RestaurantDomainEx.CreateMenuAndPersist("Pasta", restaurant.Restaurant)
* let menu1 = (menuResult1 as MenuCreated)?.Menu
* from menuResult2 in RestaurantDomainEx.CreateMenuAndPersist("Pizza", restaurant.Restaurant)
* let menu2 = (menuResult2 as MenuCreated)?.Menu
*
* from menuItemResult1 in RestaurantDomainEx.CreateMenuItemAndPersist(menu1.Menu, "Carbonara", "ingredients", "allergens", 100, 27.00, true)
* let menuItem1 = (menuItemResult1 as MenuItemCreated)?.MenuItem
* from menuItemResult2 in RestaurantDomainEx.CreateMenuItemAndPersist(menu1.Menu, "Spaghetti", "ingredients", "allergens", 150, 25.00, true)
* let menuItem2 = (menuItemResult2 as MenuItemCreated)?.MenuItem
* from menuItemResult3 in RestaurantDomainEx.CreateMenuItemAndPersist(menu1.Menu, "Macaroni", "ingredients", "allergens", 200, 21.00, true)
* let menuItem3 = (menuItemResult3 as MenuItemCreated)?.MenuItem
* from menuItemResult4 in RestaurantDomainEx.CreateMenuItemAndPersist(menu2.Menu, "Pizza", "ingredients", "allergens", 1, 30.00, true)
* let menuItem4 = (menuItemResult4 as MenuItemCreated)?.MenuItem
*
* from clientResult in RestaurantDomainEx.CreateClientAndPersist("Fifth", "Client", "*****@*****.**", "07xxxxxxxx", "xxxxxxxxxxxxxxxx", "fifth.client", "client05")
* let client = (clientResult as ClientCreated)?.Client
*
* from cartItemResult1 in RestaurantDomain.AddToCart("sessionClient05", menuItem4.MenuItem, 1, "special requests")
* let cartItem1 = (cartItemResult1 as AddToCartSuccessful)?.CartItem
* from cartItemResult2 in RestaurantDomain.AddToCart("sessionClient05", menuItem2.MenuItem, 2, "special requests")
* let cartItem2 = (cartItemResult2 as AddToCartSuccessful)?.CartItem
* from cartItemResult3 in RestaurantDomain.AddToCart("sessionClient05", menuItem3.MenuItem, 3, "special requests")
* let cartItem3 = (cartItemResult3 as AddToCartSuccessful)?.CartItem
*
* from orderResult in RestaurantDomainEx.PlaceOrder(client.Client, restaurant.Restaurant, 140.00, 5)
* let order = (orderResult as OrderPlaced)?.Order
*
* from orderItemResult1 in RestaurantDomainEx.CreateOrderItem(cartItem1, order.Order)
* //from orderItemResult2 in RestaurantDomainEx.CreateOrderItem(cartItem2, order.Order)
* //from orderItemResult3 in RestaurantDomainEx.CreateOrderItem(cartItem3, order.Order)
*
* select restaurantResult;
*
* var resultRestaurant = await interpreter.Interpret(exprRestaurant, Unit.Default);
*
*
* //Adding a Client
* var exprClient =
* from clientResult in RestaurantDomainEx.CreateClientAndPersist("Third", "Client", "*****@*****.**", "07xxxxxxxx", "xxxxxxxxxxxxxxxx", "third.client", "client03")
* let client = (clientResult as ClientCreated)?.Client
* select clientResult;
*
* var resultClient = await interpreter.Interpret(exprClient, Unit.Default);
*
*
* //Adding an Employee
* var exprEmployee =
* from employeeResult in RestaurantDomainEx.CreateEmployeeAndPersist("Employee", "01", "*****@*****.**", "07xxxxxxxx", "Chef", "Chef01", "password", 4)
* let employee = (employeeResult as EmployeeCreated)?.Employee
* select employeeResult;
*
* var resultEmployee = await interpreter.Interpret(exprEmployee, Unit.Default);
*/
// Testing Queries
var exprFindRestaurant =
from restaurantResult in RestaurantDomainEx.GetRestaurant("Restaurant_1")
select restaurantResult;
var restaurant = await interpreter.Interpret(exprFindRestaurant, Unit.Default);
var exprFindClient =
from clientResult in RestaurantDomainEx.GetClient("second.client")
select clientResult;
var client = await interpreter.Interpret(exprFindClient, Unit.Default);
var exprFindEmployee =
from employeeResult in RestaurantDomainEx.GetEmployee(restaurant.Restaurant.Id, "waiter01")
select employeeResult;
var employee = await interpreter.Interpret(exprFindEmployee, Unit.Default);
var exprFindMenus =
from menusResult in RestaurantDomainEx.GetMenus(restaurant.Restaurant)
select menusResult;
var menus = await interpreter.Interpret(exprFindMenus, Unit.Default);
Console.WriteLine(restaurant.Restaurant.Name);
Console.WriteLine(client.Client.ClientId);
Console.WriteLine(employee.Employee.EmployeeId);
foreach (Menu m in menus)
{
Console.WriteLine(m.Name);
}
}
public PopulateOrderCmd(Restaurant restaurant, ICollection <Order> orders, Func <int, IO <ICollection <Order> > > getAllOrders, Func <int, IO <ICollection <OrderItems> > > getAllOrderItems, LiveInterpreterAsync interpreter)
{
Restaurant = restaurant;
Orders = orders;
GetAllOrderItems = getAllOrderItems;
GetAllOrders = getAllOrders;
this.interpreter = interpreter;
}
static async Task Main(string[] args)
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddOperations(typeof(Restaurant).Assembly);
var serviceProvider = serviceCollection.BuildServiceProvider();
var exprRestaurant01 =
from restaurantResult in RestaurantDomain.CreateRestaurant("McDonalds", "Piata Victoriei")
let restaurant = (restaurantResult as RestaurantCreated)?.Restaurant
from MenuResult1 in RestaurantDomain.CreateMenu(restaurant, "Burgers")
let Menu1 = (MenuResult1 as MenuCreated)?.Menu
from newMenu1Item01 in RestaurantDomain.CreateMenuItem(Menu1, "McChicken", 5.00, 100, "list of ingredients", "list of allergens", MenuItemState.Available)
from newMenu1Item02 in RestaurantDomain.CreateMenuItem(Menu1, "BigMac", 10.00, 100, "list of ingredients", "list of allergens", MenuItemState.Available)
from newMenu1Item03 in RestaurantDomain.CreateMenuItem(Menu1, "Cheeseburger", 5.50, 100, "list of ingredients", "list of allergens", MenuItemState.Available)
from MenuResult2 in RestaurantDomain.CreateMenu(restaurant, "Beverages")
let Menu2 = (MenuResult2 as MenuCreated)?.Menu
from newMenu2Item01 in RestaurantDomain.CreateMenuItem(Menu2, "Coca-Cola", 5.00, 100, "list of ingredients", "list of allergens", MenuItemState.Available)
from newMenu2Item02 in RestaurantDomain.CreateMenuItem(Menu2, "Sprite", 5.00, 100, "list of ingredients", "list of allergens", MenuItemState.Available)
from newMenu2Item03 in RestaurantDomain.CreateMenuItem(Menu2, "Apple Juice", 7.00, 100, "list of ingredients", "list of allergens", MenuItemState.Available)
from Employee01 in RestaurantDomain.CreateEmployee("Waiter", "01", "*****@*****.**", "07xxxxxxxx", "waiter01", restaurant)
from Employee02 in RestaurantDomain.CreateEmployee("Chef", "01", "*****@*****.**", "07xxxxxxxx", "chef01", restaurant)
select restaurantResult;
var exprRestaurant02 =
from restaurantResult in RestaurantDomain.CreateRestaurant("3F", "Piata Victoriei")
let restaurant = (restaurantResult as RestaurantCreated)?.Restaurant
from MenuResult1 in RestaurantDomain.CreateMenu(restaurant, "Soups")
let Menu1 = (MenuResult1 as MenuCreated)?.Menu
from newMenu1Item01 in RestaurantDomain.CreateMenuItem(Menu1, "Chicken Soup", 12.00, 150, "list of ingredients", "list of allergens", MenuItemState.Available)
from newMenu1Item02 in RestaurantDomain.CreateMenuItem(Menu1, "Beef Soup", 10.00, 100, "list of ingredients", "list of allergens", MenuItemState.Available)
from MenuResult2 in RestaurantDomain.CreateMenu(restaurant, "Beverages")
let Menu2 = (MenuResult2 as MenuCreated)?.Menu
from newMenu2Item01 in RestaurantDomain.CreateMenuItem(Menu2, "Coca-Cola", 5.00, 300, "list of ingredients", "list of allergens", MenuItemState.Available)
from newMenu2Item02 in RestaurantDomain.CreateMenuItem(Menu2, "Sprite", 5.00, 200, "list of ingredients", "list of allergens", MenuItemState.Available)
from newMenu2Item03 in RestaurantDomain.CreateMenuItem(Menu2, "Pepsi", 5.00, 200, "list of ingredients", "list of allergens", MenuItemState.Available)
from Employee01 in RestaurantDomain.CreateEmployee("Waiter", "01", "*****@*****.**", "07xxxxxxxx", "waiter01", restaurant)
from Employee02 in RestaurantDomain.CreateEmployee("Chef", "01", "*****@*****.**", "07xxxxxxxx", "chef01", restaurant)
select restaurantResult;
var exprClient01 =
from clientResult in RestaurantDomain.CreateClient("First", "Client", "*****@*****.**", "07xxxxxxxx", "xxxx xxxx xxxx xxxx", "client01")
let client = (clientResult as ClientCreated)?.Client
select clientResult;
var exprClient02 =
from clientResult in RestaurantDomain.CreateClient("Second", "Client", "*****@*****.**", "07xxxxxxxx", "xxxx xxxx xxxx xxxx", "client02")
let client = (clientResult as ClientCreated)?.Client
select clientResult;
var interpreter = new LiveInterpreterAsync(serviceProvider);
var resultRestaurant01 = await interpreter.Interpret(exprRestaurant01, Unit.Default);
var finalResultRestaurant01 = resultRestaurant01.Match(OnRestaurantCreated, OnRestaurantNotCreated);
Assert.True(finalResultRestaurant01);
var resultRestaurant02 = await interpreter.Interpret(exprRestaurant02, Unit.Default);
var finalResultRestaurant02 = resultRestaurant02.Match(OnRestaurantCreated, OnRestaurantNotCreated);
Assert.True(finalResultRestaurant02);
/*var resultClient01 = await interpreter.Interpret(exprClient01, Unit.Default);
* var finalResultClient01 = resultClient01.Match<bool>(OnClientCreated, OnClientNotCreated);
* Assert.True(finalResultClient01);
*
* var resultClient02 = await interpreter.Interpret(exprClient02, Unit.Default);
* var finalResultClient02 = resultClient02.Match<bool>(OnClientCreated, OnClientNotCreated);
* Assert.True(finalResultClient02);*/
//MENU
Console.WriteLine("Welcome to Order And Pay");
Console.WriteLine("Please choose one from the following commands:");
Console.WriteLine("1. Show restaurant");
//Console.WriteLine("2. Get menus");
//Console.WriteLine("3. Add to cart");
Console.WriteLine("0. Exit");
int k;
while ((k = Console.Read()) != 0)
{
switch (k)
{
case 49:
{
foreach (var r in Storage.RestaurantsList)
{
Console.WriteLine(r.Name);
}
break;
}
case 48:
return;
// Console.WriteLine("Command does not exists!");
//return;
}
}
}
static async Task Main(string[] args)
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddOperations(typeof(Restaurant).Assembly);
serviceCollection.AddOperations(typeof(User).Assembly);
var serviceProvider = serviceCollection.BuildServiceProvider();
var expr =
from restaurantResult in RestaurantDomain.CreateRestaurant("mcdonalds")
let restaurant = (restaurantResult as RestaurantCreated)?.Restaurant
from newMenu in RestaurantDomain.CreateMenu(restaurant, "burgers", MenuType.Meat)
select restaurantResult;
var interpreter = new LiveInterpreterAsync(serviceProvider);
var result = await interpreter.Interpret(expr, Unit.Default);
var finalResult = result.Match(OnRestaurantCreated, OnRestaurantNotCreated);
Assert.True(finalResult);
// User expression
var userExpr =
from userResult in RestaurantDomain.CreateUser("Hanz", "HanzPassword", 45)
let user = (userResult as UserCreated)?.User
select userResult;
var userRez = await interpreter.Interpret(userExpr, Unit.Default);
var userFinalResult = userRez.Match(OnUserCreated, OnUserNotCreated);
Assert.True(userFinalResult);
//MenuItem expression
var menuItemExpresion =
from menuItemResult in RestaurantDomain.CreateMenuItem(
"Pizza", 13.5m, MenuItemValues.getIngredients(), MenuItemValues.getAlergens(), MenuItemValues.getMenu())
let menuItem = (menuItemResult as MenuItemCreated)?.MenuItem
select menuItemResult;
var menuItemRez = await interpreter.Interpret(menuItemExpresion, Unit.Default);
var manuItemFinalResult = menuItemRez.Match(OnMenuItemCreated, OnMenuItemNotCreated);
Assert.True(manuItemFinalResult);
//Employee expression
var employeeExpr =
from employeeResult in RestaurantDomain.CreateEmployee("Hanz", "Bauer", 30, "Timisoara nr.45",
500m, Domain.Models.Gender.Male, Domain.Models.Position.Manager, new Restaurant("Papanasii"))
let employee = (employeeResult as EmployeeCreated)?.Employee
select employeeResult;
var employeeRez = await interpreter.Interpret(employeeExpr, Unit.Default);
var employeeFinalResult = employeeRez.Match(OnEmployeeCreated, OnEmployeeNotCreated);
Assert.True(employeeFinalResult);
Console.WriteLine("Hello World!");
}
