Esempio n. 1
0
        public void SeedRolePermissions(List <RoleSeedModel> roleSeedModels)
        {
            List <RoleEntity> roles = _context.Roles
                                      .Include(x => x.Permissions)
                                      .ThenInclude(x => x.Permission)
                                      .ToList();

            List <PermissionEntity> permissions = _context.Permissions.ToList();

            List <PermissionRoleEntity> permissionRoleEntities = new List <PermissionRoleEntity>();

            foreach (RoleSeedModel role in roleSeedModels)
            {
                RoleEntity roleEntity = roles
                                        .Where(x => x.NormalizedName == role.Name.ToUpper())
                                        .SingleOrDefault();

                if (roleEntity == null)
                {
                    _logger.LogCritical($"No role Role. Name {role.Name}");
                    throw new Exception($"No Role.");
                }

                foreach (string permission in role.Permissions)
                {
                    bool exists = roleEntity.Permissions
                                  .Where(x => x.Permission.Name.ToUpper() == permission.ToUpper())
                                  .Any();
                    if (exists)
                    {
                        continue;
                    }

                    PermissionEntity permissionEntity = permissions
                                                        .Where(x => x.Name.ToUpper() == permission.ToUpper())
                                                        .SingleOrDefault();
                    if (permissionEntity == null)
                    {
                        _logger.LogCritical($"Missing role permission. Role: {role.Name}, Permission {permission}");
                        throw new Exception("Missing role permission");
                    }

                    PermissionRoleEntity permissionRoleEntity = new PermissionRoleEntity(
                        permissionEntity.Id,
                        roleEntity.Id);

                    permissionRoleEntities.Add(permissionRoleEntity);
                }
            }

            _context.PermissionRole.AddRange(permissionRoleEntities);
            int addPermissionRoleChanges = _context.SaveChanges();

            if (addPermissionRoleChanges != permissionRoleEntities.Count())
            {
                _logger.LogCritical($"Failed to seed role permissions");
                throw new Exception("Failed to seed role permissions");
            }
        }
Esempio n. 2
0
        private Result Remove(BaseSpecification <PermissionRoleEntity> baseSpecification)
        {
            PermissionRoleEntity permissionRole = _permissionRoleRepository.SingleOrDefault(baseSpecification);

            if (permissionRole == null)
            {
                _logger.LogError($"No PermissionRole.");
                return(Result.Fail("no_permission_role", "No Permission Role"));
            }

            bool removResult = _permissionRoleRepository.Remove(permissionRole);

            if (!removResult)
            {
                _logger.LogError($"Failed to remove PermissionRole.");
                return(Result.Fail("failed_to_remove_permission_role", "Failed to remove Permission Role"));
            }

            return(Result.Ok());
        }
Esempio n. 3
0
        public Result Add(string roleId, AddRolePermissionRequest addRolePermission)
        {
            ValidationResult validationResult = _addRolePermissionValidator.Validate(addRolePermission);

            if (!validationResult.IsValid)
            {
                _logger.LogWarning($"Invalid {nameof(addRolePermission)} model");
                return(Result.Fail(validationResult.Errors));
            }

            BaseSpecification <RoleEntity> roleExistSpecification = new BaseSpecification <RoleEntity>();

            roleExistSpecification.AddFilter(x => x.Id == roleId);

            bool roleExist = _roleRepository.Exist(roleExistSpecification);

            if (!roleExist)
            {
                _logger.LogError($"No Role. RoleId {roleId}");
                return(Result.Fail("no_role", "No Role"));
            }

            BaseSpecification <PermissionEntity> permissionExistSpecification = new BaseSpecification <PermissionEntity>();

            permissionExistSpecification.AddFilter(x => x.Id == addRolePermission.PermissionId);

            bool groupRoleExist = _permissionRepository.Exist(permissionExistSpecification);

            if (!groupRoleExist)
            {
                _logger.LogError($"No Permission. PermissionId {addRolePermission.PermissionId}");
                return(Result.Fail("no_group_role", "No GroupRole"));
            }

            BaseSpecification <PermissionRoleEntity> permissionRoleExistSpecification = new BaseSpecification <PermissionRoleEntity>();

            permissionRoleExistSpecification.AddFilter(x => x.RoleId == roleId);
            permissionRoleExistSpecification.AddFilter(x => x.PermissionId == addRolePermission.PermissionId);

            bool groupRoleIntermediateExist = _permissionRoleRepository.Exist(permissionRoleExistSpecification);

            if (groupRoleIntermediateExist)
            {
                _logger.LogError($"PermissionRole already exist.");
                return(Result.Fail("permission_role_already_exist", "Permission Role already exist"));
            }

            PermissionRoleEntity permissionRole = new PermissionRoleEntity(
                roleId: roleId,
                permissionId: addRolePermission.PermissionId);

            bool addResult = _permissionRoleRepository.Add(permissionRole);

            if (!addResult)
            {
                _logger.LogError($"Failed to add PermissionRole. RoleId {roleId}, PermissionId {addRolePermission.PermissionId}");
                return(Result.Fail("failed_to_add_permission_role", "Failed to add Permission Role"));
            }

            return(Result.Ok());
        }