Returns the denied ids which match the given action and resource type

@param string|array $action
@param string|\BeatSwitch\Lock\Resources\Resource $resourceType
@return array
192123
public function denied($action, $resourceType)
    {
        $this->assertLockInstanceIsSet();

        return $this->lock->denied($action, $resourceType);
    }
1186246
def get_resource_ids(stack_resources, resource_type)
        resource_ids = {}
        stack_resources.each do |resource|
          if resource["ResourceType"] == resource_type
            key = resource["LogicalResourceId"]
            value = resource["PhysicalResourceId"]
            resource_ids[key] = value
          end
        end
        return resource_ids
      end
83834
public function hasResourceParams($controller, $action = null)
    {
        $this->buildAcl();
        $resource = $this->buildResource($controller, $action);
        return parent::hasResource($resource);
    }
1267210
public function getResponders($action)
    {
        if (!is_string($action) || empty($action)) {
            throw new \InvalidArgumentException('The action name is invalid');
        }

        return $this->responders[$action];
    }
822689
protected function checkAuth($action,$resource)
	{
		return true; // remove after testing
		try {
			$userModel  = new User();
			$auth       = new BasicAuthenticator($userModel);
			$user       = $auth->currentUser();
			if ($user instanceof UserInterface) {
				$authorizer = new Authorizer( $user );
				$result     = $authorizer->can( $action, $resource );
			} else {
				$result = false;
			}
		} catch (\Exception $e) {
			\error_log($e->getMessage());
			$result = false;
		}
		return $result;
	}
1266674
public function can($action, $resource, $resourceValue = null)
    {
        if (is_object($resource)) {
            $resourceValue = $resource;
            $resource = get_classname($resourceValue);
        } elseif (is_array($resource)) {
            // Nested resources can be passed through an associative array, this way conditions which are
            // dependent upon the association will work when using a class.
            $resourceValue = head(array_values($resource));
            $resource = head(array_keys($resource));
        }

        // The conditional callback (Closure) is only evaluated when an actual instance object is present.
        // It is not evaluated when checking permissions on the class name (such as in the 'index' action).
        $skipConditions = false;
        if (is_string($resource) && ! is_object($resourceValue) && $this->hasCondition($action, $resource)) {
            $skipConditions = true;
        }

        $self = $this;
        $rules = $this->getRulesFor($action, $resource);

        if (! $rules->isEmpty()) {
            $allowed = array_reduce($rules->all(), function ($result, $rule) use ($self, $resourceValue, $skipConditions) {
                if ($skipConditions) {
                    return $rule->getBehavior(); // Short circuit
                } else {
                    if ($rule->isRestriction()) {
                        // 'deny' rules override prior rules.
                        $result = $result && $rule->isAllowed($self, $resourceValue);
                    } else {
                        // 'allow' rules do not override prior rules but instead are logically or'ed.
                        // Unlike Authority default behavior.
                        $result =  $result || $rule->isAllowed($self, $resourceValue);
                    }
                }

                return $result;
            }, false);
        } else {
            $allowed = false;
        }

        return $allowed;
    }
1271722
public function deny($action, $resource = null, $resourceId = null, $conditions = [])
    {
        $this->assertLockInstanceIsSet();

        $this->lock->deny($action, $resource, $resourceId, $conditions);
    }
965871
public function listAllowedByClass($resourceClass, string $action = ''): array
    {
        $permissions = $this->groupPermissions->getResourcePermissionsByClass($resourceClass);
        $permitted = [];
        foreach ($permissions as $permission) {
            if (!$action || $permission->can($action)) {
                $permitted[] = $permission->getResourceId();
            }
        }

        return array_unique($permitted);
    }
943442
public static function getObjectUsers($action, $objectType, $objectId)
    {
        global $PPHP;
        $db = $PPHP['db'];

        $out = $db->selectList(
            "
            SELECT userId FROM acl_users
            WHERE action=? AND objectType=? AND objectId=?
            ORDER BY userId ASC
            ",
            array(
                $action,
                $objectType,
                $objectId
            )
        );
        return (is_array($out) ? $out : array());
    }
1165642
public static function getActionUrl($action = 'index', $params = [])
    {
        $params = is_array($params) ? $params : ['id' => $params];

        return array_merge([implode('/', ['', static::moduleId(), static::controllerId(), $action])], $params);
    }
560762
public boolean checkResource(RequiredOrientResource resource, Action action)
	{
		if(!resource.action().equals(action.getName())) return true;
		OSecurityUser user = OrientDbWebSession.get().getEffectiveUser();
		if(user==null) return false;
		int iOperation = OrientPermission.combinedPermission(resource.permissions());
		ORule.ResourceGeneric value = OSecurityHelper.getResourceGeneric(resource.value());
		String specific = resource.specific();
		if(Strings.isEmpty(specific)) specific = null;
		if(user.checkIfAllowed(value, specific, iOperation)!=null) return true;
		while(!Strings.isEmpty(specific=Strings.beforeLastPathComponent(specific, '.')))
		{
			if(user.checkIfAllowed(value, specific+"."+ODatabaseSecurityResources.ALL, iOperation)!=null) return true;
		}
		return false;
	}
125757
public function all(ResourceType $resourceType): array
    {
        if (empty($this->actions)) {
            $this->load();
        }

        // get all actions implemented for the resource
        $actions = array_filter($this->actions, function (MenuAction $action) use ($resourceType) {
            return empty($action->getResourceType()) || $resourceType->getId() === $action->getResourceType()->getId();
        });

        return array_values($actions);
    }
494478
public function can($action, $resource = null, $resourceId = null)
    {
        $this->assertLockInstanceIsSet();

        return $this->lock->can($action, $resource, $resourceId);
    }
999629
public function can($action, $resource = null, $resourceId = null)
    {
        $actions = (array) $action;
        $resource = $this->convertResourceToObject($resource, $resourceId);
        $permissions = $this->getPermissions();

        foreach ($actions as $action) {
            if ($aliases = $this->getAliasesForAction($action)) {
                if ($this->can($aliases, $resource) && $this->resolveRestrictions($permissions, $action, $resource)) {
                    return true;
                }
            }

            if (! $this->resolvePermissions($action, $resource)) {
                return false;
            }
        }

        return true;
    }
1223419
public function isGranted($resource, $action = 'view')
    {
        return $this->aclOperator->isAccessGranted($resource, $this->getPermission($action));
    }
1082393
public function getIdsAction($actionsNameAndType)
    {
        $sql = "SELECT MIN(idaction) as idaction, type, name FROM " . Common::prefixTable('log_action')
             . " WHERE";
        $bind = array();

        $i = 0;
        foreach ($actionsNameAndType as $actionNameType) {
            $name = $actionNameType['name'];

            if (empty($name)) {
                continue;
            }

            if ($i > 0) {
                $sql .= " OR";
            }

            $sql .= " " . $this->getSqlConditionToMatchSingleAction() . " ";

            $bind[] = $name;
            $bind[] = $name;
            $bind[] = $actionNameType['type'];
            $i++;
        }

        $sql .= " GROUP BY type, hash, name";

        // Case URL & Title are empty
        if (empty($bind)) {
            return false;
        }

        $actionIds = $this->getDb()->fetchAll($sql, $bind);

        return $actionIds;
    }
508730
protected function attrsForApi($action) {
		$ret = array();
		$desc = $this->description->actions->{$action}->input->parameters;
		
		foreach($this->attrs as $k => $v) {
			if(!isSet($desc->{$k}))
				continue;
			
			$param = $desc->{$k};
			
			switch($param->type) {
				case 'Resource':
					$ret[$k] = $v->{ $param->{'value_id'} };
					break;
				
				default:
					$ret[$k] = $v;
			}
		}
		
		return $ret;
	}