SilverStripe\Security\Authenticator

Complexity

Total Complexity

21

Size/Duplication

Total Lines	201
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	authenticate()	0	3	1
A	get_login_form()	0	3	1
A	get_cms_login_form()	0	3	1
A	supports_cms()	0	4	1
A	register()	0	4	1
B	register_authenticator()	0	22	5
A	unregister()	0	4	1
A	unregister_authenticator()	0	8	3
A	is_registered()	0	4	1
A	get_authenticators()	0	10	2
A	set_default_authenticator()	0	4	1
A	get_default_authenticator()	0	4	1
A	on_register()	0	4	1
A	on_unregister()	0	4	1

<?php

namespace SilverStripe\Security;

use SilverStripe\Core\Object;
use SilverStripe\Control\Controller;
use SilverStripe\Forms\Form;

/**
 * Abstract base class for an authentication method
 *
 * This class is used as a base class for the different authentication
 * methods like {@link MemberAuthenticator} or {@link OpenIDAuthenticator}.
 *
 * @author Markus Lanthaler <markus@silverstripe.com>
 */
abstract class Authenticator extends Object
{

    /**
     * This variable holds all authenticators that should be used
     *
     * @var array
     */
    private static $authenticators = array(MemberAuthenticator::class);

    /**
     * Used to influence the order of authenticators on the login-screen
     * (default shows first).
     *
     * @var string
     */
    private static $default_authenticator = MemberAuthenticator::class;


    /**
     * Method to authenticate an user
     *
     * @param array $RAW_data Raw data to authenticate the user
     * @param Form $form Optional: If passed, better error messages can be
     *                             produced by using
     *                             {@link Form::sessionMessage()}
     * @return bool|Member Returns FALSE if authentication fails, otherwise
     *                     the member object
     */
    public static function authenticate($RAW_data, Form $form = null)
    {
    }

    /**
     * Method that creates the login form for this authentication method
     *
     * @param Controller $controller The parent controller, necessary to create the
     *                   appropriate form action tag
     * @return Form Returns the login form to use with this authentication
     *              method
     */
    public static function get_login_form(Controller $controller)
    {
    }

    /**
     * Method that creates the re-authentication form for the in-CMS view
     *
     * @param Controller $controller
     */
    public static function get_cms_login_form(Controller $controller)
    {
    }

    /**
     * Determine if this authenticator supports in-cms reauthentication
     *
     * @return bool
     */
    public static function supports_cms()
    {
        return false;
    }


    public static function register($authenticator)
    {
        self::register_authenticator($authenticator);
    }


    /**
     * Register a new authenticator
     *
     * The new authenticator has to exist and to be derived from the
     * {@link Authenticator}.
     * Every authenticator can be registered only once.
     *
     * @param string $authenticator Name of the authenticator class to
     *                              register
     * @return bool Returns TRUE on success, FALSE otherwise.
     */
    public static function register_authenticator($authenticator)
    {
        $authenticator = trim($authenticator);

        if (class_exists($authenticator) == false) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

            return false;
        }

        if (is_subclass_of($authenticator, self::class) == false) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

            return false;
        }

        if (in_array($authenticator, self::$authenticators) == false) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

            if (call_user_func(array($authenticator, 'on_register')) === true) {
                array_push(self::$authenticators, $authenticator);
            } else {
                return false;
            }
        }

        return true;
    }

    public static function unregister($authenticator)
    {
        self::unregister_authenticator($authenticator);
    }

    /**
     * Remove a previously registered authenticator
     *
     * @param string $authenticator Name of the authenticator class to register
     * @return bool Returns TRUE on success, FALSE otherwise.
     */
    public static function unregister_authenticator($authenticator)
    {
        if (call_user_func(array($authenticator, 'on_unregister')) === true) {
            if (in_array($authenticator, self::$authenticators)) {
                unset(self::$authenticators[array_search($authenticator, self::$authenticators)]);
            }
        }
    }


    /**
     * Check if a given authenticator is registered
     *
     * @param string $authenticator Name of the authenticator class to check
     * @return bool Returns TRUE if the authenticator is registered, FALSE
     *              otherwise.
     */
    public static function is_registered($authenticator)
    {
        return in_array($authenticator, self::$authenticators);
    }


    /**
     * Get all registered authenticators
     *
     * @return array Returns an array with the class names of all registered
     *               authenticators.
     */
    public static function get_authenticators()
    {
        // put default authenticator first (mainly for tab-order on loginform)
        if ($key = array_search(self::$default_authenticator, self::$authenticators)) {
            unset(self::$authenticators[$key]);
            array_unshift(self::$authenticators, self::$default_authenticator);
        }

        return self::$authenticators;
    }

    /**
     * Set a default authenticator (shows first in tabs)
     *
     * @param string
     */
    public static function set_default_authenticator($authenticator)
    {
        self::$default_authenticator = $authenticator;
    }

    /**
     * @return string
     */
    public static function get_default_authenticator()
    {
        return self::$default_authenticator;
    }


    /**
     * Callback function that is called when the authenticator is registered
     *
     * Use this method for initialization of a newly registered authenticator.
     * Just overload this method and it will be called when the authenticator
     * is registered.
     * <b>If the method returns FALSE, the authenticator won't be
     * registered!</b>
     *
     * @return bool Returns TRUE on success, FALSE otherwise.
     */
    protected static function on_register()
    {
        return true;
    }

    /**
     * Callback function that is called when an authenticator is removed.
     *
     * @return bool
     */
    protected static function on_unregister()
    {
        return true;
    }
}