Example #1
0
 public void UpdatePermission(AjaxEditPermissionViewModel ajaxEditPermissionViewModel)
 {
     using (var unitOfWork = UnitOfWorkManager.NewUnitOfWork())
     {
         try
         {
             if (Request.IsAjaxRequest())
             {
                 var mappedItem = new CategoryPermissionForRole
                 {
                     Category       = _categoryService.Get(ajaxEditPermissionViewModel.Category),
                     MembershipRole =
                         _roleService.GetRole(ajaxEditPermissionViewModel.MembershipRole),
                     Permission =
                         _permissionService.Get(ajaxEditPermissionViewModel.Permission),
                     IsTicked = ajaxEditPermissionViewModel.HasPermission
                 };
                 _categoryPermissionForRoleService.UpdateOrCreateNew(mappedItem);
             }
             unitOfWork.Commit();
         }
         catch (Exception ex)
         {
             unitOfWork.Rollback();
             LoggingService.Error(ex);
             throw;
         }
     }
 }
        public void Delete_Check_CategoryPermissionForRoles_Are_Deleted()
        {
            var permissionRepository = Substitute.For <IPermissionRepository>();
            var categoryPermissionForRoleRepository = Substitute.For <ICategoryPermissionForRoleRepository>();
            var permissionService = new PermissionService(permissionRepository, categoryPermissionForRoleRepository);

            var permission = new Permission {
                Name = "Ghost Rider", Id = Guid.NewGuid()
            };
            var catePermOne = new CategoryPermissionForRole {
                Id = Guid.NewGuid()
            };
            var catePermTwo = new CategoryPermissionForRole {
                Id = Guid.NewGuid()
            };
            var catepermrole = new List <CategoryPermissionForRole> {
                catePermOne, catePermTwo
            };

            categoryPermissionForRoleRepository.GetByPermission(permission.Id).Returns(catepermrole);


            permissionService.Delete(permission);

            categoryPermissionForRoleRepository.Received().Delete(Arg.Is <CategoryPermissionForRole>(x => x.Id == catePermOne.Id));
            categoryPermissionForRoleRepository.Received().Delete(Arg.Is <CategoryPermissionForRole>(x => x.Id == catePermTwo.Id));
        }
 public void Update(CategoryPermissionForRole item)
 {
     // Check there's not an object with same identifier already in context
     if (_context.CategoryPermissionForRole.Local.Select(x => x.Id == item.Id).Any())
     {
         throw new ApplicationException("Object already exists in context - you do not need to call Update. Save occurs on Commit");
     }
     _context.Entry(item).State = EntityState.Modified;
 }
Example #4
0
        private static PermissionForRole MapCategoryPermission(CategoryPermissionForRole cp)
        {
            var pfr = new PermissionForRole
            {
                Category       = cp.Category,
                IsTicked       = cp.IsTicked,
                MembershipRole = cp.MembershipRole,
                Permission     = cp.Permission
            };

            return(pfr);
        }
        /// <summary>
        /// Check the category permission for role actually exists
        /// </summary>
        /// <param name="categoryPermissionForRole"></param>
        /// <returns></returns>
        public CategoryPermissionForRole CheckExists(CategoryPermissionForRole categoryPermissionForRole)
        {
            if (categoryPermissionForRole.Permission != null &&
                categoryPermissionForRole.Category != null &&
                categoryPermissionForRole.MembershipRole != null)
            {
                return(_categoryPermissionForRoleService.GetByPermissionRoleCategoryId(categoryPermissionForRole.Permission.Id,
                                                                                       categoryPermissionForRole.MembershipRole.Id,
                                                                                       categoryPermissionForRole.Category.Id));
            }

            return(null);
        }
Example #6
0
        /// <summary>
        /// Either updates a CPFR if exists or creates a new one
        /// </summary>
        /// <param name="categoryPermissionForRole"></param>
        public void UpdateOrCreateNew(CategoryPermissionForRole categoryPermissionForRole)
        {
            // Firstly see if this exists already
            var permission = CheckExists(categoryPermissionForRole);

            // if it exists then just update it
            if (permission != null)
            {
                permission.IsTicked = categoryPermissionForRole.IsTicked;
            }
            else
            {
                Add(categoryPermissionForRole);
            }
        }
        /// <summary>
        /// Either updates a CPFR if exists or creates a new one
        /// </summary>
        /// <param name="categoryPermissionForRole"></param>
        public void UpdateOrCreateNew(CategoryPermissionForRole categoryPermissionForRole)
        {
            // Firstly see if this exists already
            var permission = CheckExists(categoryPermissionForRole);

            // if it exists then just update it
            if (permission != null)
            {
                permission.IsTicked = categoryPermissionForRole.IsTicked;
            }
            else
            {
                Add(categoryPermissionForRole);
            }
        }
        public void UpdatePermission(AjaxEditPermissionViewModel ajaxEditPermissionViewModel)
        {
            using (var unitOfWork = UnitOfWorkManager.NewUnitOfWork())
            {
                try
                {
                    if (Request.IsAjaxRequest())
                    {
                        if (ajaxEditPermissionViewModel.Category == Guid.Empty)
                        {
                            // If category is empty guid then this is a global permission

                            var gpr = new GlobalPermissionForRole
                            {
                                MembershipRole =
                                    _roleService.GetRole(ajaxEditPermissionViewModel.MembershipRole),
                                Permission =
                                    _permissionService.Get(ajaxEditPermissionViewModel.Permission),
                                IsTicked = ajaxEditPermissionViewModel.HasPermission
                            };
                            _globalPermissionForRoleService.UpdateOrCreateNew(gpr);
                        }
                        else
                        {
                            // We have a category so it's a category permission

                            var mappedItem = new CategoryPermissionForRole
                            {
                                Category       = _categoryService.Get(ajaxEditPermissionViewModel.Category),
                                MembershipRole =
                                    _roleService.GetRole(ajaxEditPermissionViewModel.MembershipRole),
                                Permission =
                                    _permissionService.Get(ajaxEditPermissionViewModel.Permission),
                                IsTicked = ajaxEditPermissionViewModel.HasPermission
                            };
                            _categoryPermissionForRoleService.UpdateOrCreateNew(mappedItem);
                        }
                    }
                    unitOfWork.Commit();
                }
                catch (Exception ex)
                {
                    unitOfWork.Rollback();
                    LoggingService.Error(ex);
                    throw;
                }
            }
        }
        /// <summary>
        /// Check the category permission for role actually exists
        /// </summary>
        /// <param name="categoryPermissionForRole"></param>
        /// <returns></returns>
        public CategoryPermissionForRole CheckExists(CategoryPermissionForRole categoryPermissionForRole)
        {
            if (categoryPermissionForRole.Permission != null &&
                categoryPermissionForRole.Category != null &&
                categoryPermissionForRole.MembershipRole != null)
            {
                return(_context.CategoryPermissionForRole
                       .Include(x => x.MembershipRole)
                       .Include(x => x.Category)
                       .FirstOrDefault(x => x.Category.Id == categoryPermissionForRole.Category.Id &&
                                       x.Permission.Id == categoryPermissionForRole.Permission.Id &&
                                       x.MembershipRole.Id == categoryPermissionForRole.MembershipRole.Id));
            }

            return(null);
        }
Example #10
0
        /// <summary>
        /// Check the category permission for role actually exists
        /// </summary>
        /// <param name="categoryPermissionForRole"></param>
        /// <returns></returns>
        public CategoryPermissionForRole CheckExists(CategoryPermissionForRole categoryPermissionForRole)
        {
            var cacheKey = string.Concat(CacheKeys.CategoryPermissionForRole.StartsWith, "CheckExists-", categoryPermissionForRole.Id);

            return(_cacheService.CachePerRequest(cacheKey, () =>
            {
                if (categoryPermissionForRole.Permission != null &&
                    categoryPermissionForRole.Category != null &&
                    categoryPermissionForRole.MembershipRole != null)
                {
                    return _context.CategoryPermissionForRole
                    .Include(x => x.MembershipRole)
                    .Include(x => x.Category)
                    .FirstOrDefault(x => x.Category.Id == categoryPermissionForRole.Category.Id &&
                                    x.Permission.Id == categoryPermissionForRole.Permission.Id &&
                                    x.MembershipRole.Id == categoryPermissionForRole.MembershipRole.Id);
                }

                return null;
            }));
        }
        /// <summary>
        /// Check the category permission for role actually exists
        /// </summary>
        /// <param name="categoryPermissionForRole"></param>
        /// <returns></returns>
        public CategoryPermissionForRole CheckExists(CategoryPermissionForRole categoryPermissionForRole)
        {
            var cacheKey = string.Concat(CacheKeys.CategoryPermissionForRole.StartsWith, "CheckExists-", categoryPermissionForRole.Id);
            return _cacheService.CachePerRequest(cacheKey, () =>
            {
                if (categoryPermissionForRole.Permission != null &&
                    categoryPermissionForRole.Category != null &&
                    categoryPermissionForRole.MembershipRole != null)
                {

                    return _context.CategoryPermissionForRole
                            .Include(x => x.MembershipRole)
                            .Include(x => x.Category)
                            .FirstOrDefault(x => x.Category.Id == categoryPermissionForRole.Category.Id &&
                                                 x.Permission.Id == categoryPermissionForRole.Permission.Id &&
                                                 x.MembershipRole.Id == categoryPermissionForRole.MembershipRole.Id);
                }

                return null;
            });
        }
Example #12
0
 /// <summary>
 /// Add new category permission for role
 /// </summary>
 /// <param name="categoryPermissionForRole"></param>
 public CategoryPermissionForRole Add(CategoryPermissionForRole categoryPermissionForRole)
 {
     return(_context.CategoryPermissionForRole.Add(categoryPermissionForRole));
 }
Example #13
0
 public void Delete(CategoryPermissionForRole categoryPermissionForRole)
 {
     _context.CategoryPermissionForRole.Remove(categoryPermissionForRole);
 }
 /// <summary>
 /// Saves/Updates CPFR
 /// </summary>
 /// <param name="categoryPermissionForRole"></param>
 public void Save(CategoryPermissionForRole categoryPermissionForRole)
 {
     _categoryPermissionForRoleService.Update(categoryPermissionForRole);
 }
 /// <summary>
 /// Add new category permission for role
 /// </summary>
 /// <param name="categoryPermissionForRole"></param>
 public void Add(CategoryPermissionForRole categoryPermissionForRole)
 {
     _categoryPermissionForRoleService.Add(categoryPermissionForRole);
 }
 public void Delete(CategoryPermissionForRole categoryPermissionForRole)
 {
     _context.CategoryPermissionForRole.Remove(categoryPermissionForRole);
 }
 /// <summary>
 /// Add new category permission for role
 /// </summary>
 /// <param name="categoryPermissionForRole"></param>
 public CategoryPermissionForRole Add(CategoryPermissionForRole categoryPermissionForRole)
 {
     return _context.CategoryPermissionForRole.Add(categoryPermissionForRole);
 }