SimpleSAML\Utils\Config\Metadata Class Reference

Collaboration diagram for SimpleSAML\Utils\Config\Metadata:

Static Public Member Functions
static	getContact ($contact)
	Parse and sanitize a contact from an array. More...
static	getDefaultEndpoint (array $endpoints, array $bindings=null)
	Find the default endpoint in an endpoint array. More...
static	isHiddenFromDiscovery (array $metadata)
	Determine if an entity should be hidden in the discovery service. More...

Static Public Attributes
static	$ENTITY_CATEGORY = 'http://macedir.org/entity-category'
static	$HIDE_FROM_DISCOVERY = 'http://refeds.org/category/hide-from-discovery'
static	$VALID_CONTACT_OPTIONS
static	$VALID_CONTACT_TYPES

Detailed Description

Definition at line 10 of file Metadata.php.

Member Function Documentation

getContact()

static SimpleSAML\Utils\Config\Metadata::getContact (   $contact )

static

Parse and sanitize a contact from an array.

Accepts an array with the following elements:

• contactType The type of the contact (as string). Mandatory.
• emailAddress Email address (as string), or array of email addresses. Optional.
• telephoneNumber Telephone number of contact (as string), or array of telephone numbers. Optional.
• name Full name of contact, either as <GivenName> <SurName>, or as <SurName>, <GivenName>. Optional.
• surName Surname of contact (as string). Optional.
• givenName Given name of contact (as string). Optional.
• company Company name of contact (as string). Optional.

The following values are allowed as "contactType":

• technical
• support
• administrative
• billing
• other

If given a "name" it will try to decompose it into its given name and surname, only if neither givenName nor surName are present. It works as follows:

• "surname1 surname2, given_name1 given_name2" givenName: "given_name1 given_name2" surname: "surname1 surname2"
• "given_name surname" givenName: "given_name" surname: "surname"

otherwise it will just return the name as "givenName" in the resulting array.

Parameters

array

$contact

The contact to parse and sanitize.

Returns

array An array holding valid contact configuration options. If a key 'name' was part of the input array, it will try to decompose the name into its parts, and place the parts into givenName and surName, if those are missing.

Exceptions

InvalidArgumentException If $contact is neither an array nor null, or the contact does not conform to valid configuration rules for contacts.

Definition at line 101 of file Metadata.php.

    {
        if (!(is_array($contact) || is_null($contact))) {
            throw new \InvalidArgumentException('Invalid input parameters');
        }
 
        // check the type
        if (!isset($contact['contactType']) || !in_array($contact['contactType'], self::$VALID_CONTACT_TYPES, true)) {
            $types = join(', ', array_map(
                function ($t) {
                    return '"'.$t.'"';
                },
                self::$VALID_CONTACT_TYPES
            ));
            throw new \InvalidArgumentException('"contactType" is mandatory and must be one of '.$types.".");
        }
 
        // check attributes is an associative array
        if (isset($contact['attributes'])) {
            if (empty($contact['attributes']) 
                || !is_array($contact['attributes']) 
                || count(array_filter(array_keys($contact['attributes']), 'is_string')) === 0
            ) {
                throw new \InvalidArgumentException('"attributes" must be an array and cannot be empty.');
            }
        }
 
        // try to fill in givenName and surName from name
        if (isset($contact['name']) && !isset($contact['givenName']) && !isset($contact['surName'])) {
            // first check if it's comma separated
            $names = explode(',', $contact['name'], 2);
            if (count($names) === 2) {
                $contact['surName'] = preg_replace('/\s+/', ' ', trim($names[0]));
                $contact['givenName'] = preg_replace('/\s+/', ' ', trim($names[1]));
            } else {
                // check if it's in "given name surname" format
                $names = explode(' ', preg_replace('/\s+/', ' ', trim($contact['name'])));
                if (count($names) === 2) {
                    $contact['givenName'] = preg_replace('/\s+/', ' ', trim($names[0]));
                    $contact['surName'] = preg_replace('/\s+/', ' ', trim($names[1]));
                } else {
                    // nothing works, return it as given name
                    $contact['givenName'] = preg_replace('/\s+/', ' ', trim($contact['name']));
                }
            }
        }
 
        // check givenName
        if (isset($contact['givenName']) && (
                empty($contact['givenName']) || !is_string($contact['givenName'])
            )
        ) {
            throw new \InvalidArgumentException('"givenName" must be a string and cannot be empty.');
        }
 
        // check surName
        if (isset($contact['surName']) && (
                empty($contact['surName']) || !is_string($contact['surName'])
            )
        ) {
            throw new \InvalidArgumentException('"surName" must be a string and cannot be empty.');
        }
 
        // check company
        if (isset($contact['company']) && (
                empty($contact['company']) || !is_string($contact['company'])
            )
        ) {
            throw new \InvalidArgumentException('"company" must be a string and cannot be empty.');
        }
 
        // check emailAddress
        if (isset($contact['emailAddress'])) {
            if (empty($contact['emailAddress']) ||
                !(is_string($contact['emailAddress']) || is_array($contact['emailAddress']))
            ) {
                throw new \InvalidArgumentException('"emailAddress" must be a string or an array and cannot be empty.');
            }
            if (is_array($contact['emailAddress'])) {
                foreach ($contact['emailAddress'] as $address) {
                    if (!is_string($address) || empty($address)) {
                        throw new \InvalidArgumentException('Email addresses must be a string and cannot be empty.');
                    }
                }
            }
        }
 
        // check telephoneNumber
        if (isset($contact['telephoneNumber'])) {
            if (empty($contact['telephoneNumber']) ||
                !(is_string($contact['telephoneNumber']) || is_array($contact['telephoneNumber']))
            ) {
                throw new \InvalidArgumentException(
                    '"telephoneNumber" must be a string or an array and cannot be empty.'
                );
            }
            if (is_array($contact['telephoneNumber'])) {
                foreach ($contact['telephoneNumber'] as $address) {
                    if (!is_string($address) || empty($address)) {
                        throw new \InvalidArgumentException('Telephone numbers must be a string and cannot be empty.');
                    }
                }
            }
        }
 
        // make sure only valid options are outputted
        return array_intersect_key($contact, array_flip(self::$VALID_CONTACT_OPTIONS));
    }

References $names, $t, and SimpleSAML\Utils\Config\Metadata\$VALID_CONTACT_TYPES.

getDefaultEndpoint()

static SimpleSAML\Utils\Config\Metadata::getDefaultEndpoint ( array  $endpoints, array  $bindings = null  )

static

Find the default endpoint in an endpoint array.

Parameters

array	$endpoints	An array with endpoints.
array	$bindings	An array with acceptable bindings. Can be null if any binding is allowed.

Returns

array|NULL The default endpoint, or null if no acceptable endpoints are used.

Author

Olav Morken, UNINETT AS olav..nosp@m.mork.nosp@m.en@un.nosp@m.inet.nosp@m.t.no

Definition at line 221 of file Metadata.php.

    {
        $firstNotFalse = null;
        $firstAllowed = null;
 
        // look through the endpoint list for acceptable endpoints
        foreach ($endpoints as $ep) {
            if ($bindings !== null && !in_array($ep['Binding'], $bindings, true)) {
                // unsupported binding, skip it
                continue;
            }
 
            if (array_key_exists('isDefault', $ep)) {
                if ($ep['isDefault'] === true) {
                    // this is the first endpoint with isDefault set to true
                    return $ep;
                }
                // isDefault is set to false, but the endpoint is still usable as a last resort
                if ($firstAllowed === null) {
                    // this is the first endpoint that we can use
                    $firstAllowed = $ep;
                }
            } else {
                if ($firstNotFalse === null) {
                    // this is the first endpoint without isDefault set
                    $firstNotFalse = $ep;
                }
            }
        }
 
        if ($firstNotFalse !== null) {
            // we have an endpoint without isDefault set to false
            return $firstNotFalse;
        }
 
        /* $firstAllowed either contains the first endpoint we can use, or it contains null if we cannot use any of the
         * endpoints. Either way we return its value.
         */
        return $firstAllowed;
    }

References $bindings.

Referenced by SimpleSAML_Configuration\getDefaultEndpoint(), and SimpleSAML\Module\saml\Auth\Process\FilterScopes\process().

Here is the caller graph for this function:

isHiddenFromDiscovery()

static SimpleSAML\Utils\Config\Metadata::isHiddenFromDiscovery ( array  $metadata )

static

Determine if an entity should be hidden in the discovery service.

This method searches for the "Hide From Discovery" REFEDS Entity Category, and tells if the entity should be hidden or not depending on it.

See also

https://refeds.org/category/hide-from-discovery

Parameters

array

$metadata

An associative array with the metadata representing an entity.

Returns

boolean True if the entity should be hidden, false otherwise.

Definition at line 275 of file Metadata.php.

    {
        \SimpleSAML\Logger::maskErrors(E_ALL);
        $hidden = in_array(self::$HIDE_FROM_DISCOVERY, $metadata['EntityAttributes'][self::$ENTITY_CATEGORY], true);
        \SimpleSAML\Logger::popErrorMask();
        return $hidden === true;
    }

References $metadata, SimpleSAML\Logger\maskErrors(), and SimpleSAML\Logger\popErrorMask().

Here is the call graph for this function:

Field Documentation

$ENTITY_CATEGORY

SimpleSAML\Utils\Config\Metadata::$ENTITY_CATEGORY = 'http://macedir.org/entity-category'

static

Definition at line 18 of file Metadata.php.

$HIDE_FROM_DISCOVERY

SimpleSAML\Utils\Config\Metadata::$HIDE_FROM_DISCOVERY = 'http://refeds.org/category/hide-from-discovery'

static

Definition at line 26 of file Metadata.php.

$VALID_CONTACT_OPTIONS

SimpleSAML\Utils\Config\Metadata::$VALID_CONTACT_OPTIONS

static

Initial value:

= array(
        'contactType',
        'emailAddress',
        'givenName',
        'surName',
        'telephoneNumber',
        'company',
        'attributes',
    )

Definition at line 39 of file Metadata.php.

$VALID_CONTACT_TYPES

SimpleSAML\Utils\Config\Metadata::$VALID_CONTACT_TYPES

static

Initial value:

= array(
        'technical',
        'support',
        'administrative',
        'billing',
        'other',
    )

Definition at line 54 of file Metadata.php.

Referenced by SimpleSAML\Utils\Config\Metadata\getContact().

---

The documentation for this class was generated from the following file:

• libs/composer/vendor/simplesamlphp/simplesamlphp/lib/SimpleSAML/Utils/Config/Metadata.php