Allow or deny some operation for specified user or role.
Inheritance: Entity, IPermissionModel
        /// <summary>
        /// Saves the resource permissions.
        /// </summary>
        /// <param name="model">The model.</param>
        /// <param name="type">The type.</param>
        public bool ApplyPermissions(PermissionsModel model, Type type)
        {
            var result = true;
            var roleService = ServiceLocator.Current.GetInstance<IRoleService>();
            var permissionsService = ServiceLocator.Current.GetInstance<IPermissionService>();
            var entityTypeService = ServiceLocator.Current.GetInstance<IEntityTypeService>();

            var permissibleItem = MvcApplication.PermissibleObjects.FirstOrDefault(
               perm =>
               perm.GetType() ==
               type);
            
            if (permissibleItem != null)
            {
                var operations =
                    permissibleItem.Operations.Where(
                        operation =>
                        operation.OperationLevel != PermissionOperationLevel.Type).ToList();

                var roles = roleService.GetAll();
                var permissions = permissionsService.GetResourcePermissions(type, model.EntityId, false);
                var entityType = entityTypeService.GetByType(type);

                foreach (var role in roles)
                {
                    var rolePermission = permissions.Where(permission => permission.Role == role).FirstOrDefault();
                    if (rolePermission == null)
                    {
                        rolePermission = new Permission
                                             {
                                                 Role = role,
                                                 EntityId = model.EntityId,
                                                 EntityType = entityType,
                                             };
                    }

                    foreach (var operation in operations)
                    {
                        if (model.Actions == null || !model.Actions.Contains(String.Format("{0}_{1}", role.Id, operation.Key)))
                        {
                            rolePermission.Permissions = rolePermission.Permissions & (~operation.Key);
                        }
                        else
                        {
                            rolePermission.Permissions = rolePermission.Permissions | operation.Key;
                        }
                    }
                    result = result && permissionsService.Save(rolePermission);
                }
            }

            return result;
        }
        /// <summary>
        /// Applies the role permissions.
        /// </summary>
        /// <param name="model">The model.</param>
        public static void ApplyRolePermissions(PermissionOperationsModel model)
        {
            var permissionService = ServiceLocator.Current.GetInstance<IPermissionService>();
            var permissions = permissionService.GetPermission(model.RoleId, model.ResourceId, null);

            if (permissions == null)
            {
                permissions = new Permission
                {
                    Role =
                    {
                        Id = model.RoleId
                    },
                    EntityType =
                    {
                        Id = model.ResourceId
                    },
                };
                if (model.OperationIds != null)
                {
                    foreach (var operation in model.OperationIds)
                    {
                        permissions.Permissions = permissions.Permissions | operation;
                    }
                }
            }
            else
            {
                var objectTypeService = ServiceLocator.Current.GetInstance<IEntityTypeService>();
                var resourceType = objectTypeService.Find(model.ResourceId);
                if (resourceType != null)
                {
                    var operations = GetResourceOperations(resourceType, model.Area);

                    foreach (var operation in operations)
                    {
                        if (model.OperationIds == null || !model.OperationIds.Contains(operation.Key))
                        {
                            permissions.Permissions = permissions.Permissions & (~operation.Key);
                        }
                        else
                        {
                            permissions.Permissions = permissions.Permissions | operation.Key;
                        }
                    }
                }
            }

            permissionService.Save(permissions);
        }