LeKoala\Admini\AdminiRootController

Complexity

Total Complexity

19

Size/Duplication

Total Lines	158
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	add_rule_for_controller()	0	16	4
A	get_admin_route()	0	5	2
A	force_redirect()	0	7	2
A	rules()	0	10	2
A	get_current_admin_route()	0	14	3
A	handleRequest()	0	24	4
A	get_template_global_variables()	0	4	1
A	admin_url()	0	3	1

<?php

namespace LeKoala\Admini;

use SilverStripe\Control\Director;
use SilverStripe\Control\Controller;
use SilverStripe\Core\Config\Config;
use SilverStripe\Control\HTTPRequest;
use SilverStripe\Control\HTTPResponse;
use SilverStripe\Core\Injector\Injector;
use SilverStripe\View\TemplateGlobalProvider;

class AdminiRootController extends Controller implements TemplateGlobalProvider
{

    /**
     * Fallback admin URL in case this cannot be infered from Director.rules
     *
     * @var string
     * @config
     */
    private static $url_base = 'admini';

The private property $url_base is not used, and could be removed.

    /**
     * Convenience function to return the admin route config.
     * Looks for the {@link Director::$rules} for the current admin Controller.
     *
     * @return string
     */
    public static function get_admin_route()
    {
        $rules = Director::config()->get('rules');
        $adminRoute = array_search(__CLASS__, $rules);
        return $adminRoute ?: static::config()->get('url_base');
    }

    /**
     * Returns the root admin URL for the site with trailing slash
     *
     * @return string
     */
    public static function admin_url()
    {
        return self::get_admin_route() . '/';
    }

    /**
     * Useful when used alongside regular admin
     *
     * @return string
     */
    public static function get_current_admin_route()
    {
        $route = self::get_admin_route();
        if (Controller::has_curr()) {
            $curr = Controller::curr();
            $request = $curr->getRequest()->getURL();
            $firstSegment = explode("/", $request)[0] ?? null;

            // Force route to admin if it's the current segment
            if ($firstSegment == "admin") {
                $route = $firstSegment;
            }
        }
        return $route;
    }

    public static function force_redirect($segment, $fallbackRoute = null)
    {
        if ($fallbackRoute === null) {
            $fallbackRoute = self::get_current_admin_route();
        }
        header('Location: ' . $fallbackRoute . '/' . $segment);
        exit();
    }

    /**
     * @var string
     * @config
     * The LeftAndMain child that will be used as the initial panel to display if none is selected (i.e. if you
     * visit /admin)
     */
    private static $default_panel = SecurityAdmin::class;

The private property $default_panel is not used, and could be removed.

    /**
     * @var array
     * @internal
     *
     * Holds an array of url_pattern => controller k/v pairs, the same as Director::rules. However this is built
     * dynamically from introspecting on all the classes that derive from LeftAndMain.
     *
     * Don't access this directly - always access via the rules() accessor below, which will build this array
     * the first time it's accessed
     */
    private static $adminRules = null;

    /**
     * Gets a list of url_pattern => controller k/v pairs for each LeftAndMain derived controller
     */
    public static function rules()
    {
        if (self::$adminRules === null) {

The condition self::adminRules === null is always false.

            self::$adminRules = array();

            // Map over the array calling add_rule_for_controller on each
            $classes = CMSMenu::get_cms_classes(null, true, CMSMenu::URL_PRIORITY);
            array_map(array(__CLASS__, 'add_rule_for_controller'), $classes);
        }
        return self::$adminRules;
    }

    /**
     * Add the appropriate k/v pair to self::$rules for the given controller.
     *
     * @param string $controllerClass Name of class
     */
    protected static function add_rule_for_controller($controllerClass)
    {
        $config = Config::forClass($controllerClass);
        $urlSegment = $config->get('url_segment');
        $urlRule    = $config->get('url_rule');

        if ($urlSegment) {
            // Make director rule
            if ($urlRule[0] == '/') {
                $urlRule = substr($urlRule, 1);
            }
            $rule = $urlSegment . '//' . $urlRule;

            // ensure that the first call to add_rule_for_controller for a rule takes precedence
            if (!isset(self::$adminRules[$rule])) {
                self::$adminRules[$rule] = $controllerClass;
            }
        }
    }

    public function handleRequest(HTTPRequest $request): HTTPResponse
    {
        // If this is the final portion of the request (i.e. the URL is just /admin), direct to the default panel
        if ($request->allParsed()) {
            $segment = Config::forClass($this->config()->get('default_panel'))
                ->get('url_segment');

            $this->redirect(Controller::join_links(self::admin_url(), $segment, '/'));
            return $this->getResponse();
        }

        // Otherwise
        $rules = self::rules();
        foreach ($rules as $pattern => $controller) {
            if (($arguments = $request->match($pattern, true)) !== false) {

The assignment to $arguments is dead and can be removed.

                /** @var LeftAndMain $controllerObj */
                $controllerObj = Injector::inst()->create($controller);
                return $controllerObj->handleRequest($request);
            }
        }

        // Fall back to methods defined on LeftAndMain
        $controllerObj = Injector::inst()->create(LeftAndMain::class);
        return $controllerObj->handleRequest($request);
    }

    /**
     * @return array Returns an array of strings of the method names of methods on the call that should be exposed
     * as global variables in the templates.
     */
    public static function get_template_global_variables()
    {
        return array(
            'adminiURL' => 'admin_url'
        );
    }
}