public async Task <IActionResult> CreateClient(Client entity)
{
var checkClient = from selectClient in RestaurantDomain.GetClient(entity.Username)
select selectClient;
var checkClientResult = await interpreter.Interpret(checkClient, Unit.Default);
return(await checkClientResult.MatchAsync <IActionResult>(
async (exists) =>
{
return BadRequest();
},
async (inexistent) =>
{
var expr = from createEntity in RestaurantDomain.CreateClient(entity)
let entityC = (createEntity as ClientCreated)?.ClientAgg
select createEntity;
var result = await interpreter.Interpret(expr, Unit.Default);
return await result.MatchAsync <IActionResult>(
async(created) =>
{
await interpreter.Interpret(Database.AddOrUpdateEntity(created.ClientAgg.Client), Unit.Default);
return (IActionResult)Ok(created.ClientAgg.Client);
},
async(notCreated) =>
{
return BadRequest();
});
}
));
}
public async Task <IActionResult> CreateMenu(String RestaurantName, [Bind("Name,MenuType,Visibility,Hours")] Menu entity)
{
var checkIfExists = from getRestaurant in RestaurantDomain.GetRestaurant(RestaurantName)
let restaurant = (getRestaurant as RestaurantSelected)?.RestaurantAgg.Restaurant
from getMenu in RestaurantDomain.GetMenu(entity.Name, restaurant.Id)
select getMenu;
var checkIfExistsResult = await interpreter.Interpret(checkIfExists, Unit.Default);
return(await checkIfExistsResult.MatchAsync <IActionResult>(
async exists =>
{
return BadRequest();
},
async inexistent =>
{
var expr = from getRestaurant in RestaurantDomain.GetRestaurant(RestaurantName)
let restaurant = (getRestaurant as RestaurantSelected)?.RestaurantAgg.Restaurant
from createEntity in RestaurantDomain.CreateAndPersistMenu(entity, restaurant)
let entityC = (createEntity as MenuCreated)?.Menu
select createEntity;
var result = await interpreter.Interpret(expr, Unit.Default);
return await result.MatchAsync <IActionResult>(
async(created) =>
{
//await interpreter.Interpret(Database.AddOrUpdateEntity(created.Menu.Menu), Unit.Default);
return (IActionResult)Ok(created.Menu.Menu);
},
async(notCreated) =>
{
return BadRequest();
});
}
));
}
public async Task <IActionResult> GetAllRestaurants()
{
var expr = from selectRestaurants in RestaurantDomain.GetAllRestaurants()
select selectRestaurants;
return(Ok(await interpreter.Interpret(expr, Unit.Default)));
}
public async Task <IActionResult> CreateRestaurant([Bind("Name")] Restaurant entity)
{
var checkIfExists = from selectRestaurant in RestaurantDomain.GetRestaurant(entity.Name)
select selectRestaurant;
var result = await interpreter.Interpret(checkIfExists, Unit.Default);
return(await result.MatchAsync <IActionResult>(
async (exists) =>
{
return BadRequest();
},
async (inexistent) =>
{
var expr = from createEntity in RestaurantDomain.CreateAndPersistRestaurant(entity)
let entityC = (createEntity as RestaurantCreated)?.RestaurantAgg
select createEntity;
var result = await interpreter.Interpret(expr, Unit.Default);
return await result.MatchAsync <IActionResult>(
async(created) =>
{
return (IActionResult)Ok(created.RestaurantAgg.Restaurant);
},
async(notCreated) =>
{
return BadRequest();
});
}
));
}
public async Task <IActionResult> GetClientOrders(int clientId)
{
var expr = from selectOrders in RestaurantDomain.GetAllClientOrders(clientId)
select selectOrders;
return(Ok(await interpreter.Interpret(expr, Unit.Default)));
}
public async Task <IActionResult> GetAllMenuItemsByListId(string ids)
{
var expr = from getMenuItem in RestaurantDomain.GetAllMenuItemsFromIdList(ids.Split(';').Select(n => Convert.ToInt32(n)).ToArray())
select getMenuItem;
return(Ok(await interpreter.Interpret(expr, Unit.Default)));
}
public async Task <IActionResult> GetMenus(string restaurantName)
{
var getRestaurantExpr =
from restaurantResult in RestaurantDomain.GetRestaurant(restaurantName)
select restaurantResult;
var restaurant = await _interpreter.Interpret(getRestaurantExpr, Unit.Default);
var getRestaurant =
from restaurantResult in RestaurantDomainEx.GetRestaurant(restaurantName)
select restaurantResult;
var restaurantAgg = await _interpreter.Interpret(getRestaurant, Unit.Default);
var getMenusExpr =
from menusRestaurant in RestaurantDomain.GetMenus(restaurantAgg.Restaurant)
select menusRestaurant;
var menus = await _interpreter.Interpret(getMenusExpr, Unit.Default);
/*var getMenus =
* from menusRestaurant in RestaurantDomainEx.GetMenus(restaurantAgg.Restaurant)
* select menusRestaurant;
* var menusList = await _interpreter.Interpret(getMenus, Unit.Default);*/
return(restaurant.Match(
found => (IActionResult)Ok(found.Agg.Restaurant.Menus),
notFound => NotFound()));
}
public async Task <IActionResult> Login(String username, String password)
{
var getAllMenuItemsExpr = from selectClient in RestaurantDomain.GetClient(username, password)
let client = (selectClient as ClientSelected)?.Client
select selectClient;
return(Ok(await interpreter.Interpret(getAllMenuItemsExpr, Unit.Default)));
}
public async Task <IActionResult> GetAllOrdersPopulated(String restaurantName)
{
var expr = from selectRestaurant in RestaurantDomain.GetRestaurant(restaurantName)
let restaurant = (selectRestaurant as RestaurantSelected)?.RestaurantAgg.Restaurant
from getAllOrdersPopulated in RestaurantDomain.PopulateOrder(restaurant, null, RestaurantDomain.GetAllOrders, RestaurantDomain.GetAllOrderItems, interpreter)
select getAllOrdersPopulated;
return((IActionResult)Ok(await interpreter.Interpret(expr, Unit.Default)));
}
public async Task CreateOrderTests(params object[] path)
{
var cmd = new CreateOrderCmdInputGen().Get(path.OfType <CreateOrderCmdInput>().First());
var expr = from order in RestaurantDomain.CreateOrder(cmd.Order)
select order;
var result = await TestExpr(expr, path);
}
public async Task <IActionResult> PostMenuItem(string name, string ingredients, string allergens, uint totalQuantity, decimal price, bool availability, int menuId)
{
var getMenu =
from menuResult in RestaurantDomainEx.GetMenu(menuId)
select menuResult;
var menuAgg = await _interpreter.Interpret(getMenu, Unit.Default);
return(Ok(RestaurantDomain.CreateMenuItem(menuAgg.Menu, name, ingredients, allergens, totalQuantity, price, availability)));
}
public async Task <IActionResult> GetAllOrders(String restaurantName)
{
var expr = from selectRestaurant in RestaurantDomain.GetRestaurant(restaurantName)
let restaurant = (selectRestaurant as RestaurantSelected)?.RestaurantAgg
from getAllOrders in RestaurantDomain.GetAllOrdersItems(restaurant.Restaurant.Id)
select getAllOrders;
return((IActionResult)Ok(await interpreter.Interpret(expr, Unit.Default)));
}
public async Task Run_CreateOp_Specs(params object[] path)
{
var cmd = new CreateOrderCmdInputGen().Get(path.OfType <CreateOrderCmdInput>().First());
var expr = from order in RestaurantDomain.CreateOrder(cmd.ClientId, cmd.RestaurantId, cmd.TableNumber,
cmd.ItemNames, cmd.ItemQuantities, cmd.ItemComments, cmd.TotalPrice, cmd.Status, cmd.PaymentStatus)
select order;
var result = await TestExpr(expr, path);
}
public async Task <IActionResult> GetAllMenuItems(String restaurantName, String menuName)
{
var getAllMenuItemsExpr = from selectRestaurant in RestaurantDomain.GetRestaurant(restaurantName)
let restaurant = (selectRestaurant as RestaurantSelected)?.RestaurantAgg
from selectMenu in RestaurantDomain.GetMenu(menuName, restaurant.Restaurant.Id)
let menu = (selectMenu as MenuSelected)?.MenuAgg
from getAllMenus in RestaurantDomain.GetAllMenuItems(menu.Menu.Id)
select getAllMenus;
return(Ok(await interpreter.Interpret(getAllMenuItemsExpr, Unit.Default)));
}
public async Task <IActionResult> GetMenus(string restaurantname)
{
var getRestaurantExpr = from restaurant in RestaurantDomain.GetRestaurant(restaurantname)
select restaurant;
var result = await _interpreter.Interpret(getRestaurantExpr, Unit.Default);
return(result.Match(
found => (IActionResult) new OkObjectResult(found.RestaurantAgg.Restaurant.Menus),
notFound => new NotFoundObjectResult(notFound.Reason)));
}
public async Task <IActionResult> GetRestaurant(string restaurantName)
{
var getRestaurantExpr =
from restaurantResult in RestaurantDomain.GetRestaurant(restaurantName)
select restaurantResult;
var restaurant = await _interpreter.Interpret(getRestaurantExpr, Unit.Default);
return(restaurant.Match(
found => (IActionResult)Ok(found.Agg.Restaurant),
notFound => NotFound()));
}
public async Task <IActionResult> GetClient(string clientId)
{
var getClientExpr =
from clientResult in RestaurantDomain.GetClient(clientId)
select clientResult;
var client = await _interpreter.Interpret(getClientExpr, Unit.Default);
return(client.Match(
found => (IActionResult)Ok(found.Agg.Client),
notFound => NotFound()));
}
public async Task <IActionResult> GetRestaurants()
{
var getRestaurantsExpr =
from restaurantResult in RestaurantDomain.GetRestaurants()
select restaurantResult;
var restaurants = await _interpreter.Interpret(getRestaurantsExpr, Unit.Default);
return(restaurants.Match(
found => (IActionResult)Ok(found.Restaurants),
notFound => NotFound()));
}
public async Task <IActionResult> GetAllRestaurants()
{
var getAllRestaurantsExpr = from restaurants in Database.Query <GetAllRestaurantsQuery, List <Restaurant> >(new GetAllRestaurantsQuery())
from restarauntsResult in RestaurantDomain.GetAllRestaurants(restaurants)
select restarauntsResult;
var result = await _interpreter.Interpret(getAllRestaurantsExpr, Unit.Default);
return(result.Match(
found => (IActionResult) new OkObjectResult(found.Restaurants),
notFound => new NotFoundObjectResult(notFound.Reason)));
}
public async Task <IActionResult> CreateMenu(string restaurantname, [FromBody] Menus menu)
{
var menuExpr = from restaurant in RestaurantDomain.GetRestaurant(restaurantname)
let restaurantFoundId = (restaurant as RestaurantFound)?.RestaurantAgg.Restaurant.Id
from persistedMenu in RestaurantDomain.CreateMenuAndPersist(menu, restaurantFoundId)
select persistedMenu;
var result = await _interpreter.Interpret(menuExpr, Unit.Default);
return(result.Match(
succesful => (IActionResult) new OkObjectResult(menu),
failed => new NotFoundObjectResult(failed.Reason)));
}
public async Task <IActionResult> CreateRestaurant([FromBody] Restaurant restaurant)
{
var createRestaurantExpr = from entity in RestaurantDomain.CreateRestaurant(restaurant.Name)
let entityRes = (entity as RestaurantCreated)?.RestaurantAgg
from r in Database.AddOrUpdate(entityRes.Restaurant)
select r;
var result = await _interpreter.Interpret(createRestaurantExpr, Unit.Default);
return(result.Match(
succesful => (IActionResult) new OkObjectResult(restaurant),
failed => new NotFoundObjectResult(failed.Reason)));
}
public async Task <IActionResult> GetOrderItems(int orderId)
{
var getOrderExpr =
from orderResult in RestaurantDomainEx.GetOrder(orderId)
select orderResult;
var order = await _interpreter.Interpret(getOrderExpr, Unit.Default);
var getOrderItemsExpr =
from orderItemsResult in RestaurantDomain.GetOrderItems(order.Order)
select orderItemsResult;
var orderItems = await _interpreter.Interpret(getOrderItemsExpr, Unit.Default);
return(orderItems.Match(
found => (IActionResult)Ok(found.OrderItems),
notFound => NotFound()));
}
public async Task <IActionResult> GetOrders(string clientId)
{
var getClientExpr =
from clientResult in RestaurantDomainEx.GetClient(clientId)
select clientResult;
var client1 = await _interpreter.Interpret(getClientExpr, Unit.Default);
var getOrdersExpr =
from ordersResult in RestaurantDomain.GetOrders(client1.Client.Id)
select ordersResult;
var orders = await _interpreter.Interpret(getOrdersExpr, Unit.Default);
return(orders.Match(
found => (IActionResult)Ok(found.Orders),
notFound => NotFound()));
}
public async Task <IActionResult> CreateMenuItem(string restaurantname, string menuname, [FromBody] MenuItems menuItem)
{
var menuExpr = from restaurant in RestaurantDomain.GetRestaurant(restaurantname)
let restaurantFound = (restaurant as RestaurantFound)?.RestaurantAgg.Restaurant
from menu in RestaurantDomain.GetSpecificMenu(restaurantFound, menuname)
let foundMenuId = (menu as SpecificMenuFound)?.Menu.Id
from menuitemPersisted in RestaurantDomain.CreateMenuItemAndPersist(menuItem, foundMenuId)
select menuitemPersisted;
var result = await _interpreter.Interpret(menuExpr, Unit.Default);
return(result.Match(
succesful => (IActionResult) new OkObjectResult(menuItem),
failed => new NotFoundObjectResult(failed.Reason)));
}
public async Task <IActionResult> GetOrders(string restaurantName)
{
var getRestaurant =
from restaurantResult in RestaurantDomainEx.GetRestaurant(restaurantName)
select restaurantResult;
var restaurantAgg = await _interpreter.Interpret(getRestaurant, Unit.Default);
var getOrdersExpr =
from ordersResult in RestaurantDomain.GetRestaurantOrders(restaurantAgg.Restaurant)
select ordersResult;
var orders = await _interpreter.Interpret(getOrdersExpr, Unit.Default);
return(orders.Match(
found => (IActionResult)Ok(found.Orders),
notFound => NotFound()));
}
public async Task <IActionResult> UpdateMenu(Menu menu)
{
var expr = from updateMenu in RestaurantDomain.UpdateAndPersistMenu(menu)
select updateMenu;
var result = await interpreter.Interpret(expr, Unit.Default);
return(await result.MatchAsync <IActionResult>(
async updated =>
{
return (IActionResult)Ok(updated.Menu);
},
async notUpdated =>
{
return BadRequest();
}
));
}
public async Task <IActionResult> SelectRestaurant(String name)
{
var expr = from selectRestaurant in RestaurantDomain.GetRestaurant(name)
let restaurant = (selectRestaurant as RestaurantSelected)?.RestaurantAgg
from populatedRestaurant in RestaurantDomain.PopulateRestaurant(restaurant, RestaurantDomain.GetAllMenus, RestaurantDomain.GetAllMenuItems, interpreter)
let newRestaurant = (populatedRestaurant as RestaurantPopulated)?.RestaurantAgg
select populatedRestaurant;
var exprResult = await interpreter.Interpret(expr, Unit.Default);
return(await exprResult.MatchAsync <IActionResult>(
async (selected) =>
{
return (IActionResult)Ok(JsonConvert.SerializeObject(selected.RestaurantAgg.Restaurant));
},
async (notSelected) => NotFound()
));
}
public async Task <IActionResult> UpdateOrder(Order order)
{
var expr = from updateOrder in RestaurantDomain.UpdateAndPersistOrder(order)
let item = (updateOrder as OrderUpdated)?.Order
select updateOrder;
var result = await interpreter.Interpret(expr, Unit.Default);
return(await result.MatchAsync <IActionResult>(
async updated =>
{
return (IActionResult)Ok(updated.Order);
},
async notUpdated =>
{
return BadRequest();
}
));
}
public async Task <IActionResult> GetMenu(int menuItemId)
{
var expr = from getMenuItem in RestaurantDomain.GetMenuItemById(menuItemId)
select getMenuItem;
var exprResult = await interpreter.Interpret(expr, Unit.Default);
return(await exprResult.MatchAsync <IActionResult>(
async (selected) => // Menu Item was successfully selected
{
return (IActionResult)Ok(selected.MenuItemAgg.MenuItem);
},
async (notSelected) => // Menu Item not selected
{
return NotFound();
}
));
}
public async Task <IActionResult> UpdateMenuItem(MenuItem menuItem)
{
var expr = from updateMenuItem in RestaurantDomain.UpdateAndPersistMenuItem(menuItem)
let item = (updateMenuItem as MenuItemUpdated)?.MenuItem
select updateMenuItem;
var result = await interpreter.Interpret(expr, Unit.Default);
return(await result.MatchAsync <IActionResult>(
async updated =>
{
return (IActionResult)Ok(updated.MenuItem);
},
async notUpdated =>
{
return BadRequest();
}
));
}
