public async Task <JsonResult> GetMenuByRoleId()
        {
            if (User.Identity.IsAuthenticated)
            {
                var user = await UserManager.FindByEmailAsync(User.Identity.Name);

                var userRoles = await UserManager.GetRolesAsync(user.Id);

                var roleId = await _roleManager.FindByNameAsync(userRoles.FirstOrDefault().ToString());

                var dbModel = await Bll.DB_Menu().ListByAsync(roleId.Id);

                var result = new ResultItemList <MenuViewModel>();
                result.exceptionMessage = dbModel.exceptionMessage;
                foreach (var item in dbModel.resultItem)
                {
                    result.data.Add(new MenuViewModel {
                        Id         = item.Id,
                        Name       = item.Name,
                        Icon       = item.Icon,
                        Action     = item.Action,
                        Controller = item.Controller,
                        Nested     = item.Nested,
                        Rank       = item.Rank
                    });
                }
                return(Json(result, JsonRequestBehavior.AllowGet));
            }
            else
            {
                return(Json(null, JsonRequestBehavior.AllowGet));
            }
        }
        public async Task <ActionResult> SubMenu(string id)
        {
            var dbResult = await Bll.DB_Menu().ListSubMenuAsync(id);

            if (!String.IsNullOrEmpty(dbResult.exceptionMessage))
            {
                return(HttpNotFound());
            }
            else
            {
                var result = new List <MenuViewModel>();
                foreach (var item in dbResult.resultItem)
                {
                    result.Add(new MenuViewModel
                    {
                        Id         = item.Id,
                        Action     = item.Action,
                        Controller = item.Controller,
                        Icon       = item.Icon,
                        Name       = item.Name,
                        Nested     = item.Nested,
                        Rank       = item.Rank
                    });
                }
                ViewBag.Id = id;
                return(View(result));
            }
        }
        public async Task <ActionResult> Create()
        {
            var roles = await Bll.DB_AspNetRoles().ListAsync();

            if (!String.IsNullOrEmpty(roles.exceptionMessage))
            {
                return(HttpNotFound());
            }
            var menus = await Bll.DB_Menu().ListMainMenuAsync();

            if (!String.IsNullOrEmpty(menus.exceptionMessage))
            {
                return(HttpNotFound());
            }
            var result = new ProtectionViewModel();

            foreach (var item in roles.resultItem)
            {
                result.roles.Add(new RoleViewModel {
                    Id   = item.Id,
                    Name = item.Name
                });
            }
            foreach (var item in menus.resultItem)
            {
                result.menu.Add(new MenuViewModel {
                    Id   = item.Id,
                    Name = item.Name
                });
            }
            return(View(result));
        }
        public async Task <ActionResult> Delete(string id, string locationId, MenuViewModel model)
        {
            var request = await Bll.DB_Menu().DeletePoint(id, locationId);

            if (request.success)
            {
                //this.ClearCache();
                return(RedirectToAction("Index"));
            }
            ModelState.AddModelError("", "Erişim Noktası Silinemedi");
            return(View(model));
        }
        public async Task <ActionResult> Delete(string id, MenuViewModel model)
        {
            var dbModel = await Bll.DB_Menu().Delete(id);

            if (dbModel.success)
            {
                //this.ClearCache();
                return(RedirectToAction("Index"));
            }
            ModelState.AddModelError("", "Menü Silinemedi");
            return(View(model));
        }
        public async Task <ActionResult> Delete(string id, string locationId)
        {
            var db = await Bll.DB_Menu().FindByIdAsync(locationId);

            if (!String.IsNullOrEmpty(db.exceptionMessage))
            {
                return(HttpNotFound());
            }
            if (db.resultItem != null)
            {
                var result = new MenuViewModel();
                result.Id   = db.resultItem.Id;
                result.Name = db.resultItem.Name;
                return(View(result));
            }
            return(HttpNotFound());
        }
        public async Task <ActionResult> Delete(string id)
        {
            var dbModel = await Bll.DB_Menu().FindByIdAsync(id);

            if (dbModel.resultItem != null)
            {
                var result = new MenuViewModel();
                result.Id         = id;
                result.Name       = dbModel.resultItem.Name;
                result.Action     = dbModel.resultItem.Action;
                result.Controller = dbModel.resultItem.Controller;
                return(View(result));
            }
            else
            {
                return(HttpNotFound());
            }
        }
        public async Task <ActionResult> Create(ProtectionCreateModel model)
        {
            if (ModelState.IsValid)
            {
                var request = await Bll.DB_Menu().AddPoint(new DataAccessLayer.AdoModel.RoleMenu
                {
                    Id      = Guid.NewGuid().ToString(),
                    Menu_Id = model.menu_id,
                    Role_Id = model.role_id
                });

                if (request.success)
                {
                    //this.ClearCache();
                    return(RedirectToAction("Index"));
                }
            }
            var roles = await Bll.DB_AspNetRoles().ListAsync();

            var menus = await Bll.DB_Menu().ListMainMenuAsync();

            var result = new ProtectionViewModel();

            foreach (var item in roles.resultItem)
            {
                result.roles.Add(new RoleViewModel
                {
                    Id   = item.Id,
                    Name = item.Name
                });
            }
            foreach (var item in menus.resultItem)
            {
                result.menu.Add(new MenuViewModel
                {
                    Id   = item.Id,
                    Name = item.Name
                });
            }
            return(View(result));
        }
        public async Task <ActionResult> CreateSubMenu(string id)
        {
            var dbResult = await Bll.DB_Menu().ListMainMenuAsync();

            if (!String.IsNullOrEmpty(dbResult.exceptionMessage))
            {
                return(HttpNotFound());
            }
            else
            {
                var result = new SubMenuCreateModel();
                foreach (var item in dbResult.resultItem.Where(x => x.Nested == "0").ToList())
                {
                    result.mainMenu.Add(new MenuViewModel
                    {
                        Id   = item.Id,
                        Name = item.Name
                    });
                }
                return(View(result));
            }
        }
        public async Task <ActionResult> Edit(string id, MenuViewModel model)
        {
            if (ModelState.IsValid)
            {
                var dbModel = await Bll.DB_Menu().Edit(id, new DataAccessLayer.AdoModel.Menu
                {
                    Id         = id,
                    Action     = model.Action,
                    Controller = model.Controller,
                    Icon       = model.Icon,
                    Name       = model.Name,
                    Rank       = model.Rank
                });

                if (dbModel.success)
                {
                    //this.ClearCache();
                    return(RedirectToAction("Index"));
                }
            }
            ModelState.AddModelError("", "Menü Düzenlenemedi!");
            return(View(model));
        }
        public async Task <ActionResult> Point(string id)
        {
            var dbModel = await Bll.DB_Menu().ListByAsync(id);

            if (!String.IsNullOrEmpty(dbModel.exceptionMessage))
            {
                return(HttpNotFound());
            }
            var result = new List <MenuViewModel>();

            foreach (var item in dbModel.resultItem)
            {
                result.Add(new MenuViewModel
                {
                    Id         = item.Id,
                    Name       = item.Name,
                    Controller = item.Controller,
                    Action     = item.Action,
                    Icon       = item.Icon
                });
            }
            ViewBag.Id = id;
            return(View(result));
        }
        public async Task <ActionResult> Create(MenuViewModel model)
        {
            if (ModelState.IsValid)
            {
                var dbResult = await Bll.DB_Menu().Add(new DataAccessLayer.AdoModel.Menu
                {
                    Id         = Guid.NewGuid().ToString(),
                    Name       = model.Name,
                    Icon       = model.Icon,
                    Controller = model.Controller,
                    Action     = model.Action,
                    Nested     = "0",
                    Rank       = model.Rank
                });

                if (dbResult.success)
                {
                    //this.ClearCache();
                    return(RedirectToAction("Index"));
                }
            }
            ModelState.AddModelError("", "Yeni Menü Oluşturulamadı!");
            return(View(model));
        }
        public async Task <ActionResult> CreateSubMenu(string id, MenuViewModel model)
        {
            if (ModelState.IsValid)
            {
                var dbModel = await Bll.DB_Menu().Add(new DataAccessLayer.AdoModel.Menu
                {
                    Id         = Guid.NewGuid().ToString(),
                    Action     = model.Action,
                    Controller = model.Controller,
                    Icon       = model.Icon,
                    Name       = model.Name,
                    Nested     = model.Nested,
                    Rank       = model.Rank
                });

                if (dbModel.success)
                {
                    //this.ClearCache();
                    return(RedirectToAction("Index"));
                }
            }
            ModelState.AddModelError("", "Yeni Alt Menü Oluşturulamadı!");
            var dbResult = await Bll.DB_Menu().ListMainMenuAsync();

            var result = new SubMenuCreateModel();

            foreach (var item in dbResult.resultItem.Where(x => x.Nested == "0").ToList())
            {
                result.mainMenu.Add(new MenuViewModel
                {
                    Id   = item.Id,
                    Name = item.Name
                });
            }
            return(View(result));
        }
        public async Task <ActionResult> Index()
        {
            var result  = new List <MenuViewModel>();
            var dbModel = await Bll.DB_Menu().ListMainMenuAsync();

            if (!String.IsNullOrEmpty(dbModel.exceptionMessage))
            {
                ModelState.AddModelError("", "Bir Hata Oluştu!");
            }
            foreach (var item in dbModel.resultItem)
            {
                result.Add(new MenuViewModel
                {
                    Id         = item.Id,
                    Name       = item.Name,
                    Controller = item.Controller,
                    Action     = item.Action,
                    Icon       = item.Icon,
                    Nested     = item.Nested,
                    Rank       = item.Rank
                });
            }
            return(View(result));
        }