AuthenticationRequest.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Auth;

use Message;

abstract class AuthenticationRequest {

    const OPTIONAL = 0;

    const REQUIRED = 1;

    const PRIMARY_REQUIRED = 2;

    public $action = null;

    public $required = self::REQUIRED;

    public $returnToUrl = null;

    public $username = null;

    public function getUniqueId() {
        return get_called_class();
    }

    abstract public function getFieldInfo();

    public function getMetadata() {
        return [];
    }

    public function loadFromSubmission( array $data ) {
        $fields = array_filter( $this->getFieldInfo(), function ( $info ) {
            return $info['type'] !== 'null';
        } );
        if ( !$fields ) {
            return false;
        }

        foreach ( $fields as $field => $info ) {
            // Checkboxes and buttons are special. Depending on the method used
            // to populate $data, they might be unset meaning false or they
            // might be boolean. Further, image buttons might submit the
            // coordinates of the click rather than the expected value.
            if ( $info['type'] === 'checkbox' || $info['type'] === 'button' ) {
                $this->$field = isset( $data[$field] ) && $data[$field] !== false
                    || isset( $data["{$field}_x"] ) && $data["{$field}_x"] !== false;
                if ( !$this->$field && empty( $info['optional'] ) ) {
                    return false;
                }
                continue;
            }

            // Multiselect are too, slightly
            if ( !isset( $data[$field] ) && $info['type'] === 'multiselect' ) {
                $data[$field] = [];
            }

            if ( !isset( $data[$field] ) ) {
                return false;
            }
            if ( $data[$field] === '' || $data[$field] === [] ) {
                if ( empty( $info['optional'] ) ) {
                    return false;
                }
            } else {
                switch ( $info['type'] ) {
                    case 'select':
                        if ( !isset( $info['options'][$data[$field]] ) ) {
                            return false;
                        }
                        break;

                    case 'multiselect':
                        $data[$field] = (array)$data[$field];
                        $allowed = array_keys( $info['options'] );
                        if ( array_diff( $data[$field], $allowed ) !== [] ) {
                            return false;
                        }
                        break;
                }
            }

            $this->$field = $data[$field];
        }

        return true;
    }

    public function describeCredentials() {
        return [
            'provider' => new \RawMessage( '$1', [ get_called_class() ] ),
            'account' => new \RawMessage( '$1', [ $this->getUniqueId() ] ),
        ];
    }

    public static function loadRequestsFromSubmission( array $reqs, array $data ) {
        return array_values( array_filter( $reqs, function ( $req ) use ( $data ) {
            return $req->loadFromSubmission( $data );
        } ) );
    }

    public static function getRequestByClass( array $reqs, $class, $allowSubclasses = false ) {
        $requests = array_filter( $reqs, function ( $req ) use ( $class, $allowSubclasses ) {
            if ( $allowSubclasses ) {
                return is_a( $req, $class, false );
            } else {
                return get_class( $req ) === $class;
            }
        } );
        return count( $requests ) === 1 ? reset( $requests ) : null;
    }

    public static function getUsernameFromRequests( array $reqs ) {
        $username = null;
        $otherClass = null;
        foreach ( $reqs as $req ) {
            $info = $req->getFieldInfo();
            if ( $info && array_key_exists( 'username', $info ) && $req->username !== null ) {
                if ( $username === null ) {
                    $username = $req->username;
                    $otherClass = get_class( $req );
                } elseif ( $username !== $req->username ) {
                    $requestClass = get_class( $req );
                    throw new \UnexpectedValueException( "Conflicting username fields: \"{$req->username}\" from "
                        . "$requestClass::\$username vs. \"$username\" from $otherClass::\$username" );
                }
            }
        }
        return $username;
    }

    public static function mergeFieldInfo( array $reqs ) {
        $merged = [];

        // fields that are required by some primary providers but not others are not actually required
        $primaryRequests = array_filter( $reqs, function ( $req ) {
            return $req->required === AuthenticationRequest::PRIMARY_REQUIRED;
        } );
        $sharedRequiredPrimaryFields = array_reduce( $primaryRequests, function ( $shared, $req ) {
            $required = array_keys( array_filter( $req->getFieldInfo(), function ( $options ) {
                return empty( $options['optional'] );
            } ) );
            if ( $shared === null ) {
                return $required;
            } else {
                return array_intersect( $shared, $required );
            }
        }, null );

        foreach ( $reqs as $req ) {
            $info = $req->getFieldInfo();
            if ( !$info ) {
                continue;
            }

            foreach ( $info as $name => $options ) {
                if (
                    // If the request isn't required, its fields aren't required either.
                    $req->required === self::OPTIONAL
                    // If there is a primary not requiring this field, no matter how many others do,
                    // authentication can proceed without it.
                    || $req->required === self::PRIMARY_REQUIRED
                        && !in_array( $name, $sharedRequiredPrimaryFields, true )
                ) {
                    $options['optional'] = true;
                } else {
                    $options['optional'] = !empty( $options['optional'] );
                }

                $options['sensitive'] = !empty( $options['sensitive'] );

                if ( !array_key_exists( $name, $merged ) ) {
                    $merged[$name] = $options;
                } elseif ( $merged[$name]['type'] !== $options['type'] ) {
                    throw new \UnexpectedValueException( "Field type conflict for \"$name\", " .
                        "\"{$merged[$name]['type']}\" vs \"{$options['type']}\""
                    );
                } else {
                    if ( isset( $options['options'] ) ) {
                        if ( isset( $merged[$name]['options'] ) ) {
                            $merged[$name]['options'] += $options['options'];
                        } else {
                            // @codeCoverageIgnoreStart
                            $merged[$name]['options'] = $options['options'];
                            // @codeCoverageIgnoreEnd
                        }
                    }

                    $merged[$name]['optional'] = $merged[$name]['optional'] && $options['optional'];
                    $merged[$name]['sensitive'] = $merged[$name]['sensitive'] || $options['sensitive'];

                    // No way to merge 'value', 'image', 'help', or 'label', so just use
                    // the value from the first request.
                }
            }
        }

        return $merged;
    }

    public static function __set_state( $data ) {
        $ret = new static();
        foreach ( $data as $k => $v ) {
            $ret->$k = $v;
        }
        return $ret;
    }
}