示例#1
0
        public IActionResult AddItem(AddMenuItemViewModel addMenuItem)
        {
            if (!ModelState.IsValid)
            {
                return(View(addMenuItem));
            }

            // check to see if the item already exists on the menu
            IList <CheeseMenu> existingItems = context.CheeseMenus
                                               .Where(cm => cm.CheeseID == addMenuItem.Cheese)
                                               .Where(cm => cm.MenuID == addMenuItem.menuID).ToList();

            if (existingItems.Count == 0)
            {
                CheeseMenu newMenuItem = new CheeseMenu()
                {
                    CheeseID = addMenuItem.Cheese,
                    MenuID   = addMenuItem.menuID
                };
                context.CheeseMenus.Add(newMenuItem);
                context.SaveChanges();
            }

            return(RedirectToAction("ViewMenu", new { id = addMenuItem.menuID }));      //  just display the menu to the user
        }
示例#2
0
        public IActionResult AddItem(AddMenuItemViewModel addMenuItemViewModel)
        {
            if (!ModelState.IsValid)
            {
                return(View(addMenuItemViewModel));
            }
            else
            {
                IList <CheeseMenu> existingItems = context.CheeseMenus
                                                   .Where(cm => cm.CheeseID == addMenuItemViewModel.CheeseID)
                                                   .Where(cm => cm.MenuID == addMenuItemViewModel.MenuID).ToList();
                if (existingItems.Count == 0)
                {
                    CheeseMenu cheeseMenu = new CheeseMenu();
                    cheeseMenu.CheeseID = addMenuItemViewModel.CheeseID;
                    cheeseMenu.MenuID   = addMenuItemViewModel.MenuID;
                    context.CheeseMenus.Add(cheeseMenu);
                    context.SaveChanges();

                    return(Redirect("/Menu/ViewMenu/" + cheeseMenu.MenuID));
                }
                else
                {
                    return(View(addMenuItemViewModel));
                }
            }
        }
        public IActionResult AddItem(AddMenuItemViewModel addMenuItemViewModel)
        {
            if (ModelState.IsValid)
            {
                var cheeseID = addMenuItemViewModel.CheeseID;
                var menuID   = addMenuItemViewModel.MenuID;

                IList <CheeseMenu> existingItems = context.CheeseMenus.Where(cm => cm.CheeseID == cheeseID).Where(cm => cm.MenuID == menuID).ToList();

                if (existingItems.Count == 0)
                {
                    CheeseMenu menuItem = new CheeseMenu
                    {
                        CheeseID = cheeseID,
                        MenuID   = menuID
                    };

                    context.CheeseMenus.Add(menuItem);
                    context.SaveChanges();
                }

                return(Redirect(string.Format("/Menu/ViewMenu/{0}", addMenuItemViewModel.MenuID)));
            }

            return(View(addMenuItemViewModel));
        }
示例#4
0
        public IActionResult AddItem(AddMenuItemViewModel addMenuItemViewModel)
        {
            if (ModelState.IsValid)
            {
                IList <CheeseMenu> existingItems = context.CheeseMenus
                                                   .Where(cm => cm.CheeseID == addMenuItemViewModel.CheeseID)
                                                   .Where(cm => cm.MenuID == addMenuItemViewModel.MenuID).ToList();

                Menu menu = context.Menus.Single(m => m.ID == addMenuItemViewModel.MenuID);

                Cheese cheese = context.Cheeses.Single(c => c.ID == addMenuItemViewModel.CheeseID);

                if (existingItems.Count < 1)
                {
                    CheeseMenu cheeseMenu = new CheeseMenu
                    {
                        Menu     = menu,
                        Cheese   = cheese,
                        MenuID   = addMenuItemViewModel.MenuID,
                        CheeseID = addMenuItemViewModel.CheeseID
                    };
                    context.CheeseMenus.Add(cheeseMenu);
                    context.SaveChanges();
                }

                return(Redirect("/Menu/ViewMenu/" + addMenuItemViewModel.MenuID));
            }

            return(View(addMenuItemViewModel));
        }
        public IActionResult AddItem(AddMenuItemViewModel addMenuItemViewModel)
        {
            if (ModelState.IsValid)
            {
                IList <CheeseMenu> existingItems = context.CheeseMenus
                                                   .Where(cm => cm.CheeseID == addMenuItemViewModel.CheeseID)
                                                   .Where(cm => cm.MenuID == addMenuItemViewModel.MenuID).ToList();

                if (existingItems.Count == 0)
                {
                    CheeseMenu newCheeseMenu = new CheeseMenu();
                    newCheeseMenu.MenuID   = addMenuItemViewModel.MenuID;
                    newCheeseMenu.CheeseID = addMenuItemViewModel.CheeseID;


                    context.CheeseMenus.Add(newCheeseMenu);
                    context.SaveChanges();

                    return(Redirect(string.Format("/Menu/ViewMenu/{0}", newCheeseMenu.MenuID)));
                }

                return(Redirect("/Menu"));
            }

            return(View(addMenuItemViewModel));
        }
        public IActionResult AddItem(AddMenuItemViewModel addMenuItemViewModel)
        {
            if (ModelState.IsValid)
            {
                var cheeseID = addMenuItemViewModel.CheeseID;
                var menuID   = addMenuItemViewModel.MenuID;

                IList <CheeseMenu> existingItems = context.CheeseMenus
                                                   .Where(cm => cm.CheeseID == addMenuItemViewModel.CheeseID)
                                                   .Where(cm => cm.MenuID == addMenuItemViewModel.MenuID)
                                                   .ToList();

                if (existingItems.Count() == 0)
                {
                    CheeseMenu menuItem = new CheeseMenu()
                    {
                        Menu   = context.Menus.Single(m => m.ID == addMenuItemViewModel.MenuID),
                        Cheese = context.Cheeses.Single(c => c.ID == addMenuItemViewModel.CheeseID)
                    };

                    context.CheeseMenus.Add(menuItem);
                    context.SaveChanges();
                    return(Redirect("/Menu/ViewMenu/" + menuItem.MenuID.ToString()));
                }
            }

            return(View(addMenuItemViewModel));
        }
示例#7
0
        public IActionResult AddItem(AddMenuItemViewModel addMenuItemViewModel)
        {
            if (ModelState.IsValid)
            {
                int menuID   = addMenuItemViewModel.menuID;
                int cheeseID = addMenuItemViewModel.cheeseID;

                IList <CheeseMenu> existingItems = context.CheeseMenus.Where(cm => cm.MenuID == menuID)
                                                   .Where(cm => cm.CheeseID == cheeseID).ToList();

                if (existingItems.Count == 0)
                {
                    CheeseMenu newCheeseMenu = new CheeseMenu();
                    newCheeseMenu.CheeseID = cheeseID;
                    newCheeseMenu.MenuID   = menuID;

                    context.CheeseMenus.Add(newCheeseMenu);
                    context.SaveChanges();
                }

                return(Redirect("/Menu/ViewMenu/" + menuID));
            }

            return(View(addMenuItemViewModel));
        }
        public IActionResult AddItem(AddMenuItemViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }
            else
            {
                IList <CheeseMenu> existingItems = context.CheeseMenus
                                                   .Where(cm => cm.CheeseID == model.CheeseID)
                                                   .Where(cm => cm.MenuID == model.MenuID).ToList();

                if (existingItems.Count == 0)
                {
                    //TODO clean this up
                    CheeseMenu cm = new CheeseMenu();
                    cm.CheeseID = model.CheeseID;
                    cm.MenuID   = model.MenuID;
                    context.CheeseMenus.Add(cm);
                    context.SaveChanges();
                    return(Redirect("/Menu/ViewMenu/" + model.MenuID.ToString()));
                }
            }
            return(View());
        }
        public IActionResult AddItem(int id)
        {
            Menu menu = context.Menus.Single(c => c.ID == id);
            AddMenuItemViewModel addMenuItemViewModel = new AddMenuItemViewModel(menu, context.Cheeses.ToList());

            return(View(addMenuItemViewModel));
        }
        public async Task <IActionResult> AddItem(AddMenuItemViewModel vm)
        {
            if (ModelState.IsValid)
            {
                var cheeseID = vm.CheeseID;
                var menuID   = vm.MenuID;

                IList <CheeseMenu> existingItems = await _context.CheeseMenus.Where(cm => cm.CheeseID == cheeseID).Where(cm => cm.MenuID == menuID).ToListAsync();

                if (existingItems.Count == 0)
                {
                    CheeseMenu item = new CheeseMenu
                    {
                        Cheese = await _context.Cheeses.SingleAsync(c => c.ID == cheeseID),
                        Menu   = await _context.Menus.SingleAsync(m => m.ID == menuID)
                    };

                    await _context.CheeseMenus.AddAsync(item);

                    await _context.SaveChangesAsync();
                }
                return(RedirectToAction(nameof(Details), new { id = menuID }));
            }
            return(View(vm));
        }
        public IActionResult AddItem(AddMenuItemViewModel addMenuItemViewModel)//passed in like aa bundle
        {
            if (ModelState.IsValid)
            {
                var cheeseID = addMenuItemViewModel.CheeseID;
                var menuID   = addMenuItemViewModel.MenuID;

                IList <CheeseMenu> existingItems = context.CheeseMenus
                                                   .Where(cm => cm.CheeseID == cheeseID)
                                                   .Where(cm => cm.MenuID == menuID).ToList();

                if (existingItems.Count == 0)
                {
                    CheeseMenu menuItem = new CheeseMenu
                    {
                        Cheese = context.Cheeses.Single(c => c.ID == cheeseID),
                        Menu   = context.Menus.Single(m => m.ID == menuID)
                    };

                    context.CheeseMenus.Add(menuItem);
                    context.SaveChanges();
                }
                //return Redirect("/CheeseMenu");
                return(Redirect(string.Format("/Menu/ViewMenu/{0}", addMenuItemViewModel.MenuID)));
            }
            return(View(addMenuItemViewModel));
        }
示例#12
0
        public IActionResult AddItem(AddMenuItemViewModel addMenuItemViewModel)
        {
            if (ModelState.IsValid)
            {
                int cheeseID = addMenuItemViewModel.CheeseID;
                int menuID   = addMenuItemViewModel.MenuID;

                // look for a CheeseMenu object with the given IDs
                IList <CheeseMenu> existingItems = context.CheeseMenus
                                                   .Where(cm => cm.CheeseID == cheeseID)
                                                   .Where(cm => cm.MenuID == menuID).ToList();

                if (existingItems.Count == 0)
                {
                    CheeseMenu cheeseMenu = new CheeseMenu()
                    {
                        MenuID   = menuID,
                        CheeseID = cheeseID
                    };

                    context.CheeseMenus.Add(cheeseMenu);
                    context.SaveChanges();
                }

                return(Redirect($"/Menu/ViewMenu/{menuID}"));
            }

            return(View(addMenuItemViewModel));
        }
        public IActionResult AddItem(AddMenuItemViewModel addMenuItemViewModel)
        {
            if (ModelState.IsValid)
            {
                var cheeseID = addMenuItemViewModel.CheeseID;
                var menuID   = addMenuItemViewModel.MenuID;

                IList <CheeseMenu> existingItems = context.CheeseMenu
                                                   .Where(cm => cm.CheeseID == cheeseID)
                                                   .Where(cm => cm.MenuID == menuID)
                                                   .ToList();

                if (existingItems.Count == 0)
                {
                    CheeseMenu menuItem = new CheeseMenu
                    {
                        Cheese = context.Cheeses.Single(c => c.ID == cheeseID),
                        Menu   = context.Menu.Single(m => m.ID == menuID)
                    };

                    context.CheeseMenu.Add(menuItem);
                    context.SaveChanges();

                    return(Redirect($"/Menu/ViewMenu/{menuItem.MenuID}"));
                }
                else
                {
                    return(Redirect($"/Menu/ViewMenu/{addMenuItemViewModel.MenuID}"));
                }
            }

            return(View(addMenuItemViewModel));
        }
示例#14
0
        public IActionResult AddItem(AddMenuItemViewModel addMenuItemViewModel)
        {
            if (ModelState.IsValid)
            {
                int cheeseID = addMenuItemViewModel.cheeseID;
                int menuID   = addMenuItemViewModel.menuID;

                IList <CheeseMenu> existingItems = context.CheeseMenus.Where(cm => cm.CheeseID == cheeseID).Where(cm => cm.MenuID == menuID).ToList();

                if (existingItems.Count == 0)
                {
                    CheeseMenu menuItem = new CheeseMenu
                    {
                        Cheese = context.Cheeses.Single(c => c.ID == cheeseID),
                        Menu   = context.Menus.Single(m => m.ID == menuID)
                    };
                    context.CheeseMenus.Add(menuItem);
                    context.SaveChanges();
                }
                string url = "/Menu/ViewMenu/" + addMenuItemViewModel.menuID;
                return(Redirect(url));
            }
            ;

            return(View(addMenuItemViewModel));
        }
        public IActionResult AddItem(AddMenuItemViewModel addMenuItemViewModel)
        {
            if (!ModelState.IsValid)
            {
                return(View(addMenuItemViewModel));
            }

            // Look for existing CheeseMenu objects that contain the given, primary key, CheeseID and MenuID pair (composite key)
            // If the list is empty then the new relationship can be created without SQL Errors
            // Meaning: The cheese object can be added to the given menu
            IList <CheeseMenu> existingItems = context.CheeseMenus
                                               .Where(cm => cm.CheeseID == addMenuItemViewModel.CheeseID)
                                               .Where(cm => cm.MenuID == addMenuItemViewModel.MenuID)
                                               .ToList();

            if (existingItems.Count != 0)
            {
                // TODO : Throw an error indicating that this relationship already exists
                return(RedirectToAction("AddItem", addMenuItemViewModel.MenuID));
            }

            CheeseMenu newCheeseMenu = new CheeseMenu
            {
                CheeseID = addMenuItemViewModel.CheeseID,
                MenuID   = addMenuItemViewModel.MenuID
            };

            context.CheeseMenus.Add(newCheeseMenu);
            context.SaveChanges();

            return(Redirect("/Menu/ViewMenu/" + addMenuItemViewModel.MenuID));
        }
示例#16
0
        public IActionResult AddItem(AddMenuItemViewModel viewModel)
        {
            if (ModelState.IsValid)
            {
                IList <CheeseMenu> existingItems = context.CheeseMenus
                                                   .Where(cm => cm.CheeseID == viewModel.CheeseID)
                                                   .Where(cm => cm.MenuID == viewModel.MenuID).ToList();

                if (!existingItems.Any())
                {
                    CheeseMenu cm = new CheeseMenu()
                    {
                        CheeseID = viewModel.CheeseID,
                        MenuID   = viewModel.MenuID
                                   //might need to add Cheese and Menu properties to this block
                    };
                    context.CheeseMenus.Add(cm);
                    context.SaveChanges();
                }

                return(Redirect("/Menu/ViewMenu/" + viewModel.MenuID));
            }

            return(View());
        }
        public IActionResult AddItem(AddMenuItemViewModel addMenuItemViewModel)
        {
            if (ModelState.IsValid)
            {
                // check if there is an existing relationship between Cheese and Menu in db
                var cheeseID = addMenuItemViewModel.CheeseID;
                var menuID   = addMenuItemViewModel.MenuID;

                IList <CheeseMenu> existingItems = context.CheeseMenus.Where(cm => cm.CheeseID == cheeseID)
                                                   .Where(cm => cm.MenuID == menuID).ToList();

                // if no existing items, add to CheeseMenu table
                if (existingItems.Count == 0)
                {
                    CheeseMenu newMenuItem = new CheeseMenu
                    {
                        CheeseID = cheeseID,
                        MenuID   = menuID
                    };

                    context.CheeseMenus.Add(newMenuItem);
                    context.SaveChanges();
                }
                return(Redirect("/Menu/ViewMenu/" + menuID));
            }
            return(View(addMenuItemViewModel));
        }
示例#18
0
        public IActionResult AddItem(AddMenuItemViewModel addMenuItemViewModel)
        {
            if (ModelState.IsValid)
            {
                IList <CheeseMenu> existingItems = context.CheeseMenus
                                                   .Where(cm => cm.CheeseID == addMenuItemViewModel.CheeseID)
                                                   .Where(cm => cm.MenuID == addMenuItemViewModel.MenuID).ToList();
                if (!existingItems.Any())
                {
                    CheeseMenu cheeseMenu = new CheeseMenu
                    {
                        MenuID = addMenuItemViewModel.MenuID,

                        CheeseID = addMenuItemViewModel.CheeseID,
                    };

                    context.CheeseMenus.Add(cheeseMenu);
                    context.SaveChanges();
                    return(Redirect("/Menu/ViewMenu/" + cheeseMenu.MenuID));
                }
            }

            Menu newMenu =
                context.Menus.Single(m => m.ID == addMenuItemViewModel.MenuID);
            AddMenuItemViewModel nVM = new AddMenuItemViewModel(context.Cheeses.ToList())
            {
                Menu   = newMenu,
                MenuID = newMenu.ID
            };

            return(View(nVM));
        }
        public IActionResult AddItem(AddMenuItemViewModel addMenuItemViewModel)
        //instructions AddItem create an instance of AddMenuItemViewModel
        {
            //with the given model object
            if (ModelState.IsValid)
            {
                var cheeseID = addMenuItemViewModel.CheeseID;
                var menuID   = addMenuItemViewModel.MenuID;
                //as well as all the list of Cheese Items from the database
                IList <CheeseMenu> existingItems = context.CheeseMenus
                                                   .Where(cm => cm.CheeseID == cheeseID)
                                                   .Where(cm => cm.MenuID == menuID).ToList();

                if (existingItems.Count == 0)
                {
                    CheeseMenu menuItem = new CheeseMenu()
                    {
                        Menu   = context.Menus.Single(m => m.ID == addMenuItemViewModel.MenuID),
                        Cheese = context.Cheeses.Single(c => c.ID == addMenuItemViewModel.CheeseID),
                    };

                    context.CheeseMenus.Add(menuItem);
                    context.SaveChanges();
                    return(Redirect("/Menu/ViewMenu/" + menuItem.MenuID.ToString()));
                }
            }
            return(View(addMenuItemViewModel));
        }
        public IActionResult AddItem(int id)
        {
            Menu myMenu = context.Menus.Single(x => x.ID == id);
            AddMenuItemViewModel viewModel = new AddMenuItemViewModel(myMenu, context.Cheeses);

            return(View(viewModel));
        }
 public IActionResult AddItem(AddMenuItemViewModel addMenuItemViewModel)
 {
     if (ModelState.IsValid)
     {
         IList <CheeseMenu> existingItems = context.CheeseMenus
                                            .Where(cm => cm.CheeseID == addMenuItemViewModel.CheeseID)
                                            .Where(cm => cm.MenuID == addMenuItemViewModel.MenuID).ToList();
         if (existingItems.Count == 0)
         {
             Cheese newCheese =
                 context.Cheeses.SingleOrDefault(c => c.ID == addMenuItemViewModel.CheeseID);
             CheeseMenu cheeseMenu = new CheeseMenu
             {
                 Menu     = addMenuItemViewModel.Menu,
                 MenuID   = addMenuItemViewModel.MenuID,
                 Cheese   = newCheese,
                 CheeseID = newCheese.ID
             };
             context.CheeseMenus.Add(cheeseMenu);
             context.SaveChanges();
             return(RedirectToAction("ViewMenu", new { id = cheeseMenu.MenuID }));
         }
         else
         {
             return(View(addMenuItemViewModel));
         }
     }
     else
     {
         return(View(addMenuItemViewModel));
     }
 }
        public IActionResult AddItem(AddMenuItemViewModel viewModel)
        {
            if (ModelState.IsValid)
            {
                IList <CheeseMenu> existingItems = context.CheeseMenus
                                                   .Where(x => x.CheeseID == viewModel.CheeseID)
                                                   .Where(x => x.MenuID == viewModel.MenuID)
                                                   .ToList();

                if (existingItems.Count == 0)
                {
                    CheeseMenu newCheeseMenu = new CheeseMenu()
                    {
                        CheeseID = viewModel.CheeseID,
                        MenuID   = viewModel.MenuID
                    };

                    context.CheeseMenus.Add(newCheeseMenu);
                    context.SaveChanges();
                }

                return(Redirect("/Menu/ViewMenu/" + viewModel.MenuID));
            }

            return(View(viewModel));
        }
示例#23
0
        public IActionResult AddItem(AddMenuItemViewModel addMenuItemViewModel)
        {
            if (ModelState.IsValid)
            {
                var cheese = addMenuItemViewModel.cheeseID;
                var menu   = addMenuItemViewModel.menuID;

                IList <CheeseMenu> existingItems = context.CheeseMenus
                                                   .Where(cm => cm.CheeseID == cheese)
                                                   .Where(cm => cm.MenuID == menu).ToList();

                if (existingItems.Count == 0)
                {
                    CheeseMenu menuItem = new CheeseMenu
                    {
                        Cheese = context.Cheeses.Single(c => c.ID == cheese),
                        Menu   = context.Menus.Single(c => c.ID == menu),
                    };

                    context.CheeseMenus.Add(menuItem);
                    context.SaveChanges();
                }
                return(Redirect("/Menu/ViewMenu/" + menu));
            }

            return(View(addMenuItemViewModel));
        }
 public IActionResult AddItem(AddMenuItemViewModel addMenuItemVM)
 {
     if (ModelState.IsValid)
     {
         var cheeseID = addMenuItemVM.cheeseID;
         var menuID   = addMenuItemVM.menuID;
         IList <CheeseMenu> existingItems = context.CheeseMenus
                                            .Where(cm => cm.CheeseID == cheeseID)
                                            .Where(cm => cm.MenuID == menuID).ToList();
         if (existingItems.Count == 0)
         {
             CheeseMenu newCheese = new CheeseMenu
             {
                 CheeseID = addMenuItemVM.cheeseID,
                 MenuID   = addMenuItemVM.menuID,
                 Menu     = context.Menus.Single(m => m.ID == addMenuItemVM.menuID),
                 Cheese   = context.Cheeses.Single(c => c.ID == addMenuItemVM.cheeseID)
             };
             context.Add(newCheese);
             context.SaveChanges();
         }
         else
         {
             return(View(addMenuItemVM));
         }
     }
     return(Redirect("/Menu/ViewMenu/" + addMenuItemVM.menuID));
 }
示例#25
0
        public IActionResult AddItem(AddMenuItemViewModel addMenuItemViewModel)
        {
            if (ModelState.IsValid)
            {
                IList <CheeseMenu> existingItems = context.CheeseMenus
                                                   .Where(cm => cm.CheeseID == addMenuItemViewModel.CheeseID)
                                                   .Where(cm => cm.MenuID == addMenuItemViewModel.MenuID).ToList();

                if (existingItems.Count == 0)
                {
                    CheeseMenu newMenuItem = new CheeseMenu
                    {
                        Cheese = context.Cheeses.Single(c => c.ID == addMenuItemViewModel.CheeseID),
                        Menu   = context.Menus.Single(m => m.ID == addMenuItemViewModel.MenuID)
                    };

                    context.CheeseMenus.Add(newMenuItem);
                    context.SaveChanges();

                    return(Redirect("/Menu/ViewMenu/" + newMenuItem.MenuID));
                }
                return(Redirect("/Menu/ViewMenu/" + addMenuItemViewModel.MenuID));
            }

            return(View(addMenuItemViewModel));
        }
        public IActionResult AddItem(int id)
        {
            Menu menu = context.Menus
                        .Single(c => c.ID == id);

            List <Cheese> cheeses = context.Cheeses
                                    .Include(c => c.CheeseMenu)
                                    .ToList();

            /*IList<CheeseMenu> items = context.CheeseMenus
             *  .Include(item => item.Cheese)
             *  .Where(c => c.MenuID != id)
             *  .ToList();*/


            /*context.Entry(menu)
             *  .Collection(c => c.CheeseMenu)
             *  .Query()
             *  .Where(c => c.MenuID != id)
             *  .Load();
             *
             *
             *
             *
             *
             * IList<CheeseMenu> availableCheeses = context.CheeseMenus
             *  .Include(item => item.Cheese)
             *  .Where(c => c.MenuID != menu.ID )
             *  .ToList();*/

            AddMenuItemViewModel addMenuItemViewModel = new AddMenuItemViewModel(menu, cheeses);

            return(View(addMenuItemViewModel));
        }
        public IActionResult AddItem(AddMenuItemViewModel addMenuItemViewModel)
        {
            if (ModelState.IsValid)
            {
                var cheeseID = addMenuItemViewModel.CheeseID;
                var menuID   = addMenuItemViewModel.MenuID;

                IList <CheeseMenu> existingItems = context
                                                   .CheeseMenus
                                                   .Where(cm => cm.CheeseID == cheeseID)
                                                   .Where(cm => cm.MenuID == menuID)
                                                   .ToList();

                if (existingItems.Count == 0)
                {
                    CheeseMenu menuItem = new CheeseMenu
                    {
                        Cheese = context.Cheeses.Single(c => c.ID == cheeseID),
                        Menu   = context.Menus.Single(m => m.ID == menuID)
                    };

                    context.CheeseMenus.Add(menuItem);
                    context.SaveChanges();
                }

                return(Redirect(String.Format("/Menu/ViewMenu/{0}", addMenuItemViewModel.MenuID)));
                // http://localhost:62469/Menu/AddItem/Menu/ViewMenu/1
            }
            return(View(addMenuItemViewModel));
        }
        public IActionResult AddItem(AddMenuItemViewModel addItemtoMenu)
        {
            if (ModelState.IsValid)
            {
                IList <CheeseMenu> existingItems = context.CheeseMenus.Where(cm => cm.CheeseID == addItemtoMenu.cheeseID).Where(cm => cm.MenuID == addItemtoMenu.menuID).ToList();
                if (existingItems.Count == 0)
                {
                    CheeseMenu newCheeseM = new CheeseMenu
                    {
                        MenuID   = addItemtoMenu.menuID,
                        CheeseID = addItemtoMenu.cheeseID,
                    };

                    context.CheeseMenus.Add(newCheeseM);
                    context.SaveChanges();


                    //int numba = newCheeseM.MenuID;
                    //return RedirectToAction("ViewMenu", "Menu", new { id = numba });
                    //return Redirect("ViewMenu/" + newCheeseM.MenuID);
                    return(Redirect(string.Format("/Menu/ViewMenu/{0}", newCheeseM.MenuID)));
                }

                int numbaa = addItemtoMenu.menuID;
                return(RedirectToAction("ViewMenu", "Menu", new { id = numbaa }));
                //  return Redirect("ViewMenu/" + addItemtoMenu.menuID);
            }

            return(View(addItemtoMenu));
        }
        public IActionResult AddItem(int id)
        {
            Menu menu = context.Menus.SingleOrDefault(m => m.ID == id);
            AddMenuItemViewModel model = new AddMenuItemViewModel(menu, context.Cheeses.ToList());

            return(View(model));
        }
示例#30
0
        public IActionResult AddItem(AddMenuItemViewModel addMenuItemViewModel)
        {
            if (ModelState.IsValid)
            {
                var productID = addMenuItemViewModel.ProductID;
                var menuID    = addMenuItemViewModel.MenuID;

                IList <ProductMenu> existingItems = context.ProductMenus
                                                    .Where(cm => cm.ProductID == productID)
                                                    .Where(cm => cm.MenuID == menuID).ToList();

                if (existingItems.Count == 0)
                {
                    ProductMenu menuItem = new ProductMenu
                    {
                        Product = context.Products.Single(c => c.ID == productID),
                        Menu    = context.Menus.Single(m => m.ID == menuID)
                    };

                    context.ProductMenus.Add(menuItem);
                    context.SaveChanges();
                }
                ViewBag.title = "Add Item to Menu: ";
                return(Redirect(string.Format("/Menu/ViewMenu/{0}", addMenuItemViewModel.MenuID)));
            }

            return(View(addMenuItemViewModel));
        }