LaravelFlare\Flare\Admin\AdminManager

Complexity

Total Complexity

22

Size/Duplication

Total Lines	179
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	getAdminMenu()	0	4	1
A	getAdminClasses()	0	12	2
A	getSubAdminClasses()	0	18	4
A	getAdminInstance()	0	8	2
A	registerRoutes()	0	4	1
A	registerSubRoutes()	0	14	4
A	registerAdminRoutes()	0	4	1
A	usableClass()	0	12	4
A	availableClass()	0	8	2

<?php

namespace LaravelFlare\Flare\Admin;

use Illuminate\Routing\Router;
use LaravelFlare\Flare\Permissions\Permissions;

class AdminManager
{
    /**
     * Base Class.
     *
     * The Base Class for Model Admin's
     */
    const BASE_CLASS = 'LaravelFlare\Flare\Admin\Admin';

    /**
     * Admin Config Key.
     *
     * Key which defined where in the Flare Admin Config to
     * load the Admin classes from.
     *
     * @var string
     */
    const ADMIN_KEY = 'admin';

    /**
     * __construct.
     */
    public function __construct()
    {
    }

    /**
     * Returns the array used for the Admin Menu.
     *
     * This is temporary but it shouldn't be a breaking
     * change when it is altered or removed.
     * 
     * @return 
     */
    public function getAdminMenu()
    {
        return $this->getAdminClasses();
    }

    /**
     * Gets Admin classes based on the current users permissions
     * which have been set. If a Admin class has not had the
     * Permissions provided, it will be displayed by default.
     * 
     * @return 
     */
    public function getAdminClasses()
    {
        $classCollection = [];

        if (!defined('static::ADMIN_KEY')) {
            return $classCollection;
        }

        $classCollection = $this->getSubAdminClasses(\Flare::config(static::ADMIN_KEY));

        return $classCollection;
    }

    /**
     * Takes an array of classes and returns the 
     * classes which are available with the 
     * current permissions/policy set.
     * 
     * @param array $classes
     * 
     * @return array
     */
    public function getSubAdminClasses(array $classes)
    {
        $classCollection = [];

        foreach ($classes as $key => $class) {
            if ($this->usableClass($key)) {
                $classCollection[] = [$key => $this->getSubAdminClasses($class)];
                continue;
            }

            if ($this->usableClass($class)) {
                $classCollection[] = $class;
                continue;
            }
        }

        return $classCollection;
    }

    /**
     * Returns an instance of the Admin.
     * 
     * @return Admin
     */
    public static function getAdminInstance()
    {
        if (!$requested = Admin::getRequested()) {
            return;
        }

        return new $requested();
    }

    /**
     * Register Admin Routes.
     *
     * Loops through all of the Admin classes in the collection
     * and registers their Admin Routes.
     */
    public function registerRoutes(Router $router)

The parameter $router is not used and could be removed.

    {
        $this->registerSubRoutes($this->getAdminClasses());
    }

    /**
     * Loops through an array of classes
     * and registers their Route recursively.
     * 
     * @param array $classes
     */
    public function registerSubRoutes(array $classes)
    {
        foreach ($classes as $key => $class) {
            if (is_array($class)) {
                if ($this->usableClass($key)) {
                    $this->registerAdminRoutes($key);
                }

                $this->registerSubRoutes($class);
                continue;
            }
            $this->registerAdminRoutes($class);
        }
    }

    /**
     * Registers an individual group of Admin routes.
     * 
     * @param string $class
     */
    public function registerAdminRoutes($class)
    {
        (new $class())->registerRoutes(app(\Illuminate\Routing\Router::class));
    }

    /**
     * Determines if a class is usable.
     * 
     * @param string $class
     * 
     * @return bool
     */
    private function usableClass($class)
    {
        if (!is_scalar($class) || !class_exists($class)) {
            return false;
        }

        if ($class == static::BASE_CLASS) {
            return false;
        }

        return true;
    }

    /**
     * Determines if a class is available for the current User.
     * 
     * @param string $class
     * 
     * @return bool
     */
    private function availableClass($class)

This method is not used, and could be removed.

    {
        if (!Permissions::check($class)) {
            return false;
        }

        return true;
    }
}