Example #1
0
        public virtual async Task <MenuItemDto> UpdateAsync(Guid id, MenuItemUpdateInput input)
        {
            var menuItem = await MenuItemRepository.GetAsync(id);

            if (input.PageId.HasValue)
            {
                MenuManager.SetPageUrl(menuItem, await PageRepository.GetAsync(input.PageId.Value));
            }
            else
            {
                menuItem.SetUrl(input.Url);
            }

            menuItem.SetDisplayName(input.DisplayName);
            menuItem.IsActive  = input.IsActive;
            menuItem.Icon      = input.Icon;
            menuItem.Target    = input.Target;
            menuItem.ElementId = input.ElementId;
            menuItem.CssClass  = input.CssClass;
            menuItem.SetConcurrencyStampIfNotNull(input.ConcurrencyStamp);

            await MenuItemRepository.UpdateAsync(menuItem);

            return(ObjectMapper.Map <MenuItem, MenuItemDto>(menuItem));
        }
 public HomeController(ILogger <HomeController> logger, ApplicationDbContext _db,
                       MenuItemRepository menu)
 {
     _logger   = logger;
     db        = _db;
     this.menu = menu;
 }
 public OrdersController()
 {
     _ordersRepository     = new OrdersRepository();
     _menuItemRepository   = new MenuItemRepository();
     _orderItemsRepository = new OrderItemsRepository();
     _validator            = new OrdersRequestValidator();
 }
Example #4
0
        public async Task <ActionResult> AddImageAsync(HttpPostedFileBase file, int itemid)
        {
            if (file != null && file.ContentLength > 0)
            {
                try
                {
                    string path = Path.Combine(Server.MapPath("~/Content/assets/img/"),
                                               Path.GetFileName(file.FileName));
                    file.SaveAs(path);

                    MenuItemRepository rep = new MenuItemRepository(sqlConnection);
                    MenuItemModel      md  = await rep.GetItemById(itemid);

                    md.Image    = file.FileName;
                    md.Modified = DateTime.UtcNow;
                    await rep.UpdateItem(md);

                    ViewBag.Message = "File uploaded successfully";
                }
                catch (Exception ex)
                {
                    ViewBag.Message = "ERROR:" + ex.Message.ToString();
                }
            }
            else
            {
                ViewBag.Message = "You have not specified a file.";
            }
            return(Redirect("/Menu/Edit/" + itemid.ToString()));
        }
Example #5
0
        public ActionResult EditMenuItem(int id, EditMenuItemViewModel model)
        {
            var context            = new AppSecurityContext();
            var menuRepository     = new MenuRepository(context);
            var menuItemRepository = new MenuItemRepository(context);

            try
            {
                if (ModelState.IsValid)
                {
                    var menuItem = mapper.Map <AppMenuItem>(model);
                    menuItemRepository.Update(menuItem);
                    context.SaveChanges();
                    return(RedirectToAction("menuItems", new { id = model.MenuKey }));
                }
            }
            catch (Exception ex)
            {
                ViewBag.Error = ex.Message;
            }



            model.AvailablePermissions = PopulatePermissions(model.PermissionId);
            model.AvailableMenuItems   = PopulateMenuItems(model.ParentId);

            var itemSelf = model.AvailableMenuItems.Where(x => x.Value == id.ToString());

            if (itemSelf != null && itemSelf.Count() > 0)
            {
                var itemForRemove = itemSelf.SingleOrDefault();
                model.AvailablePermissions.ToList().Remove(itemForRemove);
            }
            return(View(model));
        }
Example #6
0
 public UnitOfWork(XdContext context)
 {
     _context            = context;
     AddressInformations = new AddressInformationRepository(_context);
     AppUsers            = new AppUserRepository(_context);
     AppUserRoles        = new AppUserRoleRepository(_context);
     Contacts            = new ContactRepository(_context);
     Credentials         = new CredentialsRepository(_context);
     DbTypes             = new DbTypeRepository(_context);
     Entities            = new EntityRepository(_context);
     EntityTypes         = new EntityTypeRepository(_context);
     Fields = new FieldRepository(_context);
     FieldRequirementLevels = new FieldRequirementLevelRepository(_context);
     FieldTypes             = new FieldTypeRepository(_context);
     Forms           = new FormRepository(_context);
     FormTypes       = new FormTypeRepository(_context);
     Genders         = new GenderRepository(_context);
     MaritalStatuses = new MaritalStatusRepository(_context);
     MenuItems       = new MenuItemRepository(_context);
     Roles           = new RoleRepository(_context);
     Tabs            = new TabRepository(_context);
     Titles          = new TitleRepository(_context);
     Views           = new ViewRepository(_context);
     ViewTypes       = new ViewTypeRepository(_context);
 }
Example #7
0
    public virtual async Task <MenuItemDto> CreateAsync(MenuItemCreateInput input)
    {
        var menuItem = new MenuItem(
            GuidGenerator.Create(),
            input.DisplayName,
            input.Url.IsNullOrEmpty() ? "#" : input.Url,
            input.IsActive,
            input.ParentId,
            input.Icon,
            input.Order,
            input.Target,
            input.ElementId,
            input.CssClass,
            CurrentTenant.Id
            );

        if (input.PageId.HasValue)
        {
            MenuManager.SetPageUrl(menuItem, await PageRepository.GetAsync(input.PageId.Value));
        }

        await MenuItemRepository.InsertAsync(menuItem);

        return(ObjectMapper.Map <MenuItem, MenuItemDto>(menuItem));
    }
        public ActionResult EditMenuItem(int id) //Id del item
        {
            var context            = new AppSecurityContext();
            var menuRepository     = new MenuRepository(context);
            var menuItemRepository = new MenuItemRepository(context);

            var menuItem = menuItemRepository.Find(id);
            var model    = mapper.Map <EditMenuItemViewModel>(menuItem);

            model.MenuKey              = menuItem.AppMenuKey;
            model.MenuName             = menuItem.AppMenu.Name;
            model.AvailablePermissions = PopulatePermissions(model.PermissionId);
            model.AvailableMenuItems   = PopulateMenuItems(model.ParentId);

            model.AvailablePermissions = PopulatePermissions(model.PermissionId);
            model.AvailableMenuItems   = PopulateMenuItems(model.ParentId);

            var itemSelf = model.AvailableMenuItems.Where(x => x.Value == id.ToString());

            if (itemSelf != null && itemSelf.Count() > 0)
            {
                var itemForRemove = itemSelf.SingleOrDefault();
                model.AvailablePermissions.ToList().Remove(itemForRemove);
            }

            return(View(model));
        }
        public MenuController()
        {
            this._menuRepository = new MenuRepository();
            this._menuItemRepository = new MenuItemRepository();

            this._menuMapper = new MenuMapper();
            this._menuItemMapper = new MenuItemMapper();
        }
        public void AddToMenu_ShouldGetCorrectBoolean()
        {
            MenuItem           cafe       = new MenuItem();
            MenuItemRepository repository = new MenuItemRepository();
            bool addResult = repository.AddItemsToMenu(cafe);

            Assert.IsTrue(addResult);
        }
Example #11
0
        public virtual async Task <ListResultDto <MenuItemDto> > GetListAsync()
        {
            var menuItems = await MenuItemRepository.GetListAsync();

            return(new ListResultDto <MenuItemDto>(
                       ObjectMapper.Map <List <MenuItem>, List <MenuItemDto> >(menuItems)
                       ));
        }
 public void Arrange()
 {
     _repo = new MenuItemRepository();
     _cafe = new MenuItem(1, "BurgerBuddy", "One Burger with another burger as its buddy.", 3.15M, new List <string> {
         "Meat", "Bun", "Cheese slice"
     });
     _repo.AddItemsToMenu(_cafe);
 }
Example #13
0
 public void Arrange()
 {
     _repo    = new MenuItemRepository();
     _newItem = new MenuItem(5, "Hard Taco Meal", "2 Hard Tacos", new List <string> {
         "tortilla", "meat", " cheese"
     }, 3.45);
     _repo.AddMenuItems(_newItem); // adding the menuItem newItem to the repository so the repository can preform the methods
 }
Example #14
0
        public async Task <ActionResult> DeleteIngredientAsync(AddIngredientToItemModel model)
        {
            MenuItemRepository rep = new MenuItemRepository(sqlConnection);
            await rep.DeleteIngredientToMenuItem(model);


            return(null);
        }
Example #15
0
 public UnitOfWork(ApplicationDbContext db)
 {
     _db = db;
     ApplicationUserRepository = new ApplicationUserRepository(_db);
     MenuItemRepository = new MenuItemRepository(_db);
     FoodTypeRepository = new FoodTypeRepository(_db);
     CategoryRepository = new CategoryRepository(_db);
 }
Example #16
0
        public void ActivateMenuItems(List<string> menuItemList)
        {
            MenuItemRepository menuItemRepository = new MenuItemRepository(new ApplicationDbContext());

            foreach (var menuItem in menuItemList)
            {
                menuItemRepository.Activate(Convert.ToInt32(menuItem));
            }
        }
Example #17
0
        public void DectivateMenuItems(List <string> menuItemList)
        {
            MenuItemRepository menuItemRepository = new MenuItemRepository(new ApplicationDbContext());

            foreach (var menuItem in menuItemList)
            {
                menuItemRepository.DeActivate(Convert.ToInt32(menuItem));
            }
        }
Example #18
0
        public async Task <ActionResult> EditItem(MenuItemModel model)
        {
            MenuItemRepository rep = new MenuItemRepository(sqlConnection);

            model.Modified = DateTime.UtcNow;
            await rep.UpdateItem(model);

            return(Redirect("/"));
        }
Example #19
0
        public async Task <ActionResult> Add()
        {
            MenuItemRepository rep = new MenuItemRepository(sqlConnection);
            EditMenuItemModel  md  = new EditMenuItemModel();

            md.ItemCatergories = await rep.GetItemCatergories(User.Identity.GetUserId());


            return(View(md));
        }
        public SelectList PopulateMenuItems(object selectedItem = null)
        {
            var context     = new AppSecurityContext();
            var repository  = new MenuItemRepository(context);
            var permissions = repository.GetAll().OrderBy(x => x.Name).ToList();

            permissions.Insert(0, new AppMenuItem {
                Id = null, Name = "Sin padre"
            });
            return(new SelectList(permissions, "Id", "Name", selectedItem));
        }
        public void GetMenu_ShouldReturnCorrectCollection()
        {
            MenuItem           cafe       = new MenuItem();
            MenuItemRepository repository = new MenuItemRepository();

            repository.AddItemsToMenu(cafe);
            List <MenuItem> menu         = repository.GetAllMenuItems();
            bool            menuHasItems = menu.Contains(cafe);

            Assert.IsTrue(menuHasItems);
        }
        public void AddItemToMenu_ShouldReturnCorrectBool()
        {
            //Arrange
            MenuItem           item       = new MenuItem();
            MenuItemRepository repository = new MenuItemRepository();

            //Act
            bool addResult = repository.AddItemToMenu(item);

            //Assert
            Assert.IsTrue(addResult);
        }
        public void Arrange()
        {
            _menuItem = new MenuItem(
                1,
                "Turkish Coffee",
                "Authentic Turkish Coffee",
                new List <string> {
                "1 cup water (cold)",
                "1 tablespoon extra finely ground coffee (powder consistency)",
                "1/8 teaspoon ground cardamom (or 1 cardamom pod, crushed)",
                "Optional: 1 teaspoon sugar (or more, to taste)"
            },
                10.5m
                );

            _repository = new MenuItemRepository();

            _repository.AddMenuItem(_menuItem);
            _repository.AddMenuItem(
                new MenuItem(
                    2,
                    "Pumpkin Spice Latte",
                    "Pumpkin spice latte is the fall drink we love (or sometimes just love to hate).",
                    new List <string> {
                "1 cup milk",
                "2 tablespoons unsweetened pumpkin puree.",
                "1 tablespoon sugar, or to taste.",
                "1 teaspoon ground cinnamon.",
                "1/2 teaspoon ground ginger.",
                "1/4 teaspoon ground nutmeg.",
                "1/8 teaspoon ground cloves.",
                "1/2 teaspoon vanilla",
                "1/2 cup brewed espresso (or very strongly brewed coffee).",
                "Sweetened whipped cream, for topping"
            },
                    12.5m
                    )
                );
            _repository.AddMenuItem(
                new MenuItem(
                    3,
                    "Cafe Late",
                    "An Italian-style cafe latte",
                    new List <string> {
                "1 tablespoon coffee",
                "1 fluid ounce water",
                "Optional: 1 1/2 fluid ounces (or 1 shot) of flavored simple syrup",
                "3 fluid ounces milk (or more)"
            },
                    8.5m
                    )
                );
        }
        public void GetMenu_ShouldGetCorrectBool()
        {
            MenuItem           menuItem   = new MenuItem();
            MenuItemRepository repository = new MenuItemRepository();

            repository.AddItemToMenu(menuItem);

            List <MenuItem> directory = repository.GetMenu();

            bool directoryHasMenuItem = directory.Contains(menuItem);

            Assert.IsTrue(directoryHasMenuItem);
        }
        public void Arrange()
        {
            _repo = new MenuItemRepository();

            List <string> ingredients = new List <string>();

            ingredients.Add("Pepperoni");
            ingredients.Add("Sausage");
            ingredients.Add("Tomato");

            _menuItem = new MenuItem(1, "Pizza", "The best pizza in the whole world!", ingredients, 5.00m);

            _repo.AddItemToMenu(_menuItem);
        }
Example #26
0
        public ActionResult MenuItems(string id)
        {
            var context            = new AppSecurityContext();
            var menuRepository     = new MenuRepository(context);
            var menuItemRepository = new MenuItemRepository(context);
            var menu  = menuRepository.Find(id);
            var items = menuItemRepository.GetItemsByMenuKey(id);
            var model = new MenuItemListViewModel();

            model.MenuItems = mapper.Map <ICollection <MenuItemViewModel> >(items);
            model.MenuKey   = menu.Key;
            model.MenuName  = menu.Name;
            return(View(model));
        }
Example #27
0
    public async Task <List <MenuItemDto> > GetListAsync()
    {
        var cachedMenu = await DistributedCache.GetOrAddAsync(
            MenuApplicationConsts.MainMenuCacheKey,
            async() =>
        {
            var menuItems = await MenuItemRepository.GetListAsync();

            if (menuItems == null)
            {
                return(new());
            }

            return(ObjectMapper.Map <List <MenuItem>, List <MenuItemDto> >(menuItems));
        });
        public void AddToList_ShouldGetNotNull()
        {
            // Arrange --> Setting up the playing field
            MenuItem foodItem = new MenuItem();

            foodItem.MealNumber = 1;
            MenuItemRepository repository = new MenuItemRepository();

            // Act --> Get/run the code we want to test
            repository.AddItemToMenu(foodItem);
            MenuItem foodItemFromDirectory = repository.GetMenuItemBytMealNumber(1);

            // Assert --> Use the assert class to verify the expected outcome
            Assert.IsNotNull(foodItemFromDirectory);
        }
Example #29
0
        public ActionResult _SideBar()
        {
            IEnumerable<MenuItemViewModel> model = new List<MenuItemViewModel>();
            MenuItemRepository inventoryRepository = new MenuItemRepository(new ApplicationDbContext());

            var firstOrDefault = new ApplicationDbContext().Users.FirstOrDefault(cus => cus.UserName == User.Identity.Name);
            if (firstOrDefault !=
                null)
            {
                var customerId = firstOrDefault.Id;
                model = inventoryRepository.GetAll(customerId);
                return PartialView(model);
            }

            return PartialView(model);
        }
Example #30
0
        /// <summary>
        /// Devuelve las opciones de menú que corresponden al usuario según sus permisos
        /// </summary>
        /// <param name="context">Contexto de OWIN</param>
        /// <returns>Colección de permisos</returns>
        public static ICollection <BitMenuItem> GetUserMenu(this IOwinContext context)
        {
            var user = (ClaimsIdentity)HttpContext.Current.User.Identity;

            if (!user.IsAuthenticated)
            {
                return(new List <BitMenuItem>());
            }

            var userId = user.Claims.SingleOrDefault(x => x.Type == ClaimTypes.NameIdentifier).Value;
            BitSecurityContext securityContext = context.Get <BitSecurityContext>();
            var id         = Guid.Parse(userId);
            var repository = new MenuItemRepository(securityContext);

            return(repository.GetMenuByUsuarioId(id));
        }
Example #31
0
        public async Task <ActionResult> Edit(long ModelId)
        {
            MenuItemRepository       rep   = new MenuItemRepository(sqlConnection);
            MenuIngredientRepository igrep = new MenuIngredientRepository(sqlConnection);
            EditMenuItemModel        md    = new EditMenuItemModel();

            md.MenuItem = await rep.GetItemById(ModelId);

            md.ItemCatergories = await rep.GetItemCatergories(User.Identity.GetUserId());

            md.AvailableIngredients = await igrep.GetItems(User.Identity.GetUserId());

            md.CurrentIngredients = await rep.GetCurrentItemIngredients(ModelId);

            return(View(md));
        }
Example #32
0
        public ActionResult EditMenuItem(int id) //Id del item
        {
            var context            = new AppSecurityContext();
            var menuRepository     = new MenuRepository(context);
            var menuItemRepository = new MenuItemRepository(context);

            var menuItem = menuItemRepository.Find(id);
            var model    = mapper.Map <EditMenuItemViewModel>(menuItem);

            model.MenuKey              = menuItem.AppMenuKey;
            model.MenuName             = menuItem.AppMenu.Name;
            model.AvailablePermissions = PopulatePermissions(model.PermissionId);
            model.AvailableMenuItems   = PopulateMenuItems(model.ParentId, id);


            return(View(model));
        }
Example #33
0
        // GET: Menu
        public async Task <ActionResult> Index()
        {
            if (User.Identity.IsAuthenticated == false)
            {
                Response.Redirect("Account/Login");
            }

            string userId = User.Identity.GetUserId();

            MenuItemRepository murep     = new MenuItemRepository(sqlConnection);
            HomeIndexModel     homeIndex = new HomeIndexModel();

            homeIndex.MenuItems = await murep.GetItems(userId);


            return(View(homeIndex));
        }
Example #34
0
 public ActionResult AddMenuItem(MenuItemViewModel model)
 {
     if (ModelState.IsValid)
     {
         MenuItemRepository inventoryRepository = new MenuItemRepository(new ApplicationDbContext());
         string customerId = null;
         var firstOrDefault = new ApplicationDbContext().Users.FirstOrDefault(cus => cus.UserName == User.Identity.Name);
         if (firstOrDefault !=
             null)
         {
             customerId = firstOrDefault.Id;
         }
         model.CustomerId = customerId;
         model.IsActive = true;
         inventoryRepository.Create(model);
         return RedirectToAction("MenuItems");
     }
     return View(model);
 }
Example #35
0
        public ActionResult UnactiveMenuItems()
        {
            IEnumerable<MenuItemViewModel> model = new List<MenuItemViewModel>();
            MenuItemRepository inventoryRepository = new MenuItemRepository(new ApplicationDbContext());
            string customerId = null;
            var firstOrDefault = new ApplicationDbContext().Users.FirstOrDefault(cus => cus.UserName == User.Identity.Name);
            if (firstOrDefault !=
                null)
            {
                customerId = firstOrDefault.Id;
                model = inventoryRepository.GetAllUnactive(customerId);
                return View(model);
            }

            return View(model);
        }
 public MenuItemController()
 {
     this.repo = new MenuItemRepository();
 }