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(); } )); }