Auth_OpenID_SRegRequest Klassenreferenz

Abgeleitet von Auth_OpenID_SRegBase.

Zusammengehörigkeiten von Auth_OpenID_SRegRequest:

[Legende]

Öffentliche Methoden
	build ($required=null, $optional=null, $policy_url=null, $sreg_ns_uri=Auth_OpenID_SREG_NS_URI, $cls='Auth_OpenID_SRegRequest')
	fromOpenIDRequest ($request, $cls='Auth_OpenID_SRegRequest')
	parseExtensionArgs ($args, $strict=false)
	allRequestedFields ()
	wereFieldsRequested ()
	contains ($field_name)
	requestField ($field_name, $required=false, $strict=false)
	requestFields ($field_names, $required=false, $strict=false)
	getExtensionArgs ()
Datenfelder
	$ns_alias = 'sreg'

---

Ausführliche Beschreibung

Definiert in Zeile 169 der Datei SReg.php.

---

Dokumentation der Elementfunktionen

allRequestedFields

(

)

A list of all of the simple registration fields that were requested, whether they were required or optional.

Definiert in Zeile 287 der Datei SReg.php.

    {
        return array_merge($this->required, $this->optional);
    }

build	(	$	required = null,
		$	optional = null,
		$	policy_url = null,
		$	sreg_ns_uri = Auth_OpenID_SREG_NS_URI,
		$	cls = 'Auth_OpenID_SRegRequest'
	)

Initialize an empty simple registration request.

Definiert in Zeile 176 der Datei SReg.php.

    {
        $obj = new $cls();

        $obj->required = array();
        $obj->optional = array();
        $obj->policy_url = $policy_url;
        $obj->ns_uri = $sreg_ns_uri;

        if ($required) {
            if (!$obj->requestFields($required, true, true)) {
                return null;
            }
        }

        if ($optional) {
            if (!$obj->requestFields($optional, false, true)) {
                return null;
            }
        }

        return $obj;
    }

contains

(

$

field_name

)

Was this field in the request?

Definiert in Zeile 303 der Datei SReg.php.

    {
        return (in_array($field_name, $this->required) ||
                in_array($field_name, $this->optional));
    }

fromOpenIDRequest	(	$	request,
		$	cls = 'Auth_OpenID_SRegRequest'
	)

Create a simple registration request that contains the fields that were requested in the OpenID request with the given arguments

$request: The OpenID authentication request from which to extract an sreg request.

$cls: name of class to use when creating sreg request object. Used for testing.

Returns the newly created simple registration request

Definiert in Zeile 216 der Datei SReg.php.

    {

        $obj = call_user_func_array(array($cls, 'build'),
                 array(null, null, null, Auth_OpenID_SREG_NS_URI, $cls));

        // Since we're going to mess with namespace URI mapping, don't
        // mutate the object that was passed in.
        $m = $request->message;

        $obj->ns_uri = $obj->_getSRegNS($m);
        $args = $m->getArgs($obj->ns_uri);

        if ($args === null || Auth_OpenID::isFailure($args)) {
            return null;
        }

        $obj->parseExtensionArgs($args);

        return $obj;
    }

getExtensionArgs

(

)

Get a dictionary of unqualified simple registration arguments representing this request.

This method is essentially the inverse of C{L{parseExtensionArgs}}. This method serializes the simple registration request fields.

Erneute Implementation von Auth_OpenID_Extension.

Definiert in Zeile 389 der Datei SReg.php.

    {
        $args = array();

        if ($this->required) {
            $args['required'] = implode(',', $this->required);
        }

        if ($this->optional) {
            $args['optional'] = implode(',', $this->optional);
        }

        if ($this->policy_url) {
            $args['policy_url'] = $this->policy_url;
        }

        return $args;
    }

parseExtensionArgs	(	$	args,
		$	strict = false
	)

Parse the unqualified simple registration request parameters and add them to this object.

This method is essentially the inverse of getExtensionArgs. This method restores the serialized simple registration request fields.

If you are extracting arguments from a standard OpenID checkid_* request, you probably want to use fromOpenIDRequest, which will extract the sreg namespace and arguments from the OpenID request. This method is intended for cases where the OpenID server needs more control over how the arguments are parsed than that method provides.

$args == $message->getArgs($ns_uri); $request->parseExtensionArgs($args);

$args: The unqualified simple registration arguments

strict: Whether requests with fields that are not defined in the simple registration specification should be tolerated (and ignored)

Definiert in Zeile 262 der Datei SReg.php.

    {
        foreach (array('required', 'optional') as $list_name) {
            $required = ($list_name == 'required');
            $items = Auth_OpenID::arrayGet($args, $list_name);
            if ($items) {
                foreach (explode(',', $items) as $field_name) {
                    if (!$this->requestField($field_name, $required, $strict)) {
                        if ($strict) {
                            return false;
                        }
                    }
                }
            }
        }

        $this->policy_url = Auth_OpenID::arrayGet($args, 'policy_url');

        return true;
    }

requestField	(	$	field_name,
		$	required = false,
		$	strict = false
	)

Request the specified field from the OpenID user

$field_name: the unqualified simple registration field name

required: whether the given field should be presented to the user as being a required to successfully complete the request

strict: whether to raise an exception when a field is added to a request more than once

Definiert in Zeile 320 der Datei SReg.php.

    {
        if (!Auth_OpenID_checkFieldName($field_name)) {
            return false;
        }

        if ($strict) {
            if ($this->contains($field_name)) {
                return false;
            }
        } else {
            if (in_array($field_name, $this->required)) {
                return true;
            }

            if (in_array($field_name, $this->optional)) {
                if ($required) {
                    unset($this->optional[array_search($field_name,
                                                       $this->optional)]);
                } else {
                    return true;
                }
            }
        }

        if ($required) {
            $this->required[] = $field_name;
        } else {
            $this->optional[] = $field_name;
        }

        return true;
    }

requestFields	(	$	field_names,
		$	required = false,
		$	strict = false
	)

Add the given list of fields to the request

field_names: The simple registration data fields to request

required: Whether these values should be presented to the user as required

strict: whether to raise an exception when a field is added to a request more than once

Definiert in Zeile 366 der Datei SReg.php.

    {
        if (!is_array($field_names)) {
            return false;
        }

        foreach ($field_names as $field_name) {
            if (!$this->requestField($field_name, $required, $strict=$strict)) {
                return false;
            }
        }

        return true;
    }

wereFieldsRequested

(

)

Have any simple registration fields been requested?

Definiert in Zeile 295 der Datei SReg.php.

    {
        return count($this->allRequestedFields());
    }

---

Dokumentation der Datenelemente

$ns_alias = 'sreg'

Erneute Implementation von Auth_OpenID_Extension.

Definiert in Zeile 171 der Datei SReg.php.

---

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:

• Auth/OpenID/SReg.php