Terranet\Administrator\Providers\ContainersServiceProvider

Complexity

Total Complexity

40

Size/Duplication

Total Lines	253
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes

0

32 Methods

Rating	Name	Duplication	Size	Complexity
A	hp$0 ➔ readonly()	0	7	2
A	hp$0 ➔ setReadonly()	0	5	1
A	hp$0 ➔ __construct()	0	3	1
A	registerAdminAnnotations()	0	9	1
A	hp$0 ➔ registerAdminActions()	0	5	2
A	registerAdminConfig()	0	6	1
	registerAdminFinder()	0	16	?
A	register()	0	10	2
A	hp$0 ➔ registerAdminTranslations()	0	51	2
	registerAdminActions()	0	5	?
	registerAdminSchema()	0	10	?
	registerAdminModel()	0	7	?
	registerAdminTemplate()	0	12	?
A	hp$0 ➔ registerAdminForm()	0	5	2
	registerAdminTranslations()	0	51	?
	registerAdminResource()	0	12	?
A	hp$0 ➔ registerAdminModel()	0	7	3
A	hp$0 ➔ registerAdminTemplate()	0	12	3
A	hp$0 ➔ registerAdminSchema()	0	10	2
A	hp$0 ➔ registerAdminResource()	0	12	5
A	hp$0 ➔ registerAdminWidgets()	0	8	2
A	hp$0 ➔ registerAdminSortable()	0	7	4
	registerAdminSortable()	0	7	?
A	hp$0 ➔ registerAdminBreadcrumbs()	0	7	2
	registerAdminWidgets()	0	8	?
A	hp$0 ➔ registerAdminColumns()	0	5	2
	registerAdminFilter()	0	8	?
	registerAdminBreadcrumbs()	0	7	?
A	hp$0 ➔ registerAdminFilter()	0	8	4
	registerAdminForm()	0	5	?
A	hp$0 ➔ registerAdminFinder()	0	16	3
	registerAdminColumns()	0	5	?

<?php

namespace Terranet\Administrator\Providers;

use Doctrine\Common\Annotations\AnnotationRegistry;
use Doctrine\Common\Annotations\SimpleAnnotationReader;
use Illuminate\Config\Repository as Config;
use Illuminate\Support\ServiceProvider;
use Terranet\Administrator\Collection\Mutable;
use Terranet\Administrator\Contracts\Module;
use Terranet\Administrator\Contracts\Module\Filtrable;
use Terranet\Administrator\Contracts\Module\Sortable;
use Terranet\Administrator\Contracts\Services\Finder;
use Terranet\Administrator\Contracts\Services\TemplateProvider;
use Terranet\Administrator\Dashboard\Manager;
use Terranet\Administrator\Exception;
use Terranet\Administrator\Filter;
use Terranet\Administrator\Schema;
use Terranet\Administrator\Services\Sorter;
use Terranet\Administrator\Services\Template;
use Terranet\Localizer\Locale;

class ContainersServiceProvider extends ServiceProvider
{
    protected $containers = [
        'AdminConfig' => 'scaffold.config',
        'AdminResource' => 'scaffold.module',
        'AdminModel' => 'scaffold.model',
        'AdminWidgets' => 'scaffold.widgets',
        'AdminSchema' => 'scaffold.schema',
        'AdminSortable' => 'scaffold.sortable',
        'AdminFilter' => 'scaffold.filter',
        'AdminColumns' => 'scaffold.columns',
        'AdminActions' => 'scaffold.actions',
        'AdminTemplate' => 'scaffold.template',
        'AdminForm' => 'scaffold.form',
        'AdminFinder' => 'scaffold.finder',
        'AdminBreadcrumbs' => 'scaffold.breadcrumbs',
        'AdminTranslations' => 'scaffold.translations',
        'AdminAnnotations' => 'scaffold.annotations',
    ];

    public function register()
    {
        foreach (array_keys($this->containers) as $container) {
            $method = "register{$container}";

            \call_user_func_array([$this, $method], []);
        }

        $this->app->bind(Module::class, function ($app) {
            return $app['scaffold.module'];
        });
    }

    protected function registerAdminAnnotations()
    {
        $this->app->singleton('scaffold.annotations', function () {
            AnnotationRegistry::registerUniqueLoader('class_exists');

The function Doctrine\Common\Annotations\AnnotationRegistry::registerUniqueLoader() has been deprecated: this method is deprecated and will be removed in doctrine/annotations 2.0

            $reader = new SimpleAnnotationReader();
            $reader->addNamespace("\\Terranet\\Administrator\\Annotations");

            return $reader;
        });
    }

    protected function registerAdminConfig()
    {
        $this->app->singleton('scaffold.config', function ($app) {
            $config = $app['config']['administrator'];

            return new Config((array) $config);
        });
    }

    protected function registerAdminTranslations()
    {
        // Draft: Mui configuration
        // Goal: sometimes there is a case when few content managers (admins) override the same translatable content (files, db, etc...)
        // This service allows to make some locales readonly:
        //  1. they are available in UI in order to preserve the context
        //  2. they are protected from saving process
        // Making locale(s) Readonly remains for Dev's side: the recommended way - use a custom Middleware.
        // ex.: app('scaffold.translations')->setReadonly([1, 2, 3])
        $this->app->singleton('scaffold.translations', function ($app) {
            $service = new class()
            {
                protected $readonly = [];

                public function __construct()
                {
                    $this->setReadonly(config('administrator.translations.readonly', []));
                }

                /**
                 * Set ReadOnly locales.
                 *
                 * @param array $readonly
                 *
                 * @return self
                 */
                public function setReadonly(array $readonly = []): self
                {
                    $this->readonly = (array) $readonly;

                    return $this;
                }

                /**
                 * Check if a Locale is ReadOnly.
                 *
                 * @param $locale
                 *
                 * @return bool
                 */
                public function readonly($locale)
                {
                    if ($locale instanceof Locale) {
                        $locale = $locale->id();
                    }

                    return \in_array((int) $locale, $this->readonly, true);
                }
            };

            return $service;
        });
    }

    protected function registerAdminResource()
    {
        $this->app->singleton('scaffold.module', function ($app) {
            if (\in_array($app['router']->currentRouteName(), ['scaffold.settings.edit', 'scaffold.settings.update'], true)) {
                return $app['scaffold.module.settings'];
            }

            if (($router = $app['router']->current()) &&
                ($module = $router->parameter('module')) &&
                array_has($app, $key = "scaffold.module.{$module}")
            ) {
                return array_get($app, $key);
            }
        });
    }

    protected function registerAdminModel()
    {
        $this->app->singleton('scaffold.model', function ($app) {
            if (($finder = app('scaffold.finder'))
                && ($id = $app['router']->current()->parameter('id'))
            ) {
                return $finder->find($id);
            }
        });
    }

    protected function registerAdminWidgets()
    {
        $this->app->singleton('scaffold.widgets', function () {
            if (($module = app('scaffold.module'))) {
                return $module->widgets(new Manager());

The method widgets() does not exist on Illuminate\Foundation\Application.

            }

            return new Manager();
        });
    }

    protected function registerAdminSchema()
    {
        $this->app->singleton('scaffold.schema', function ($app) {
            if ($schema = $app['db']->connection()->getDoctrineSchemaManager()) {
                // fix dbal missing types
                $platform = $schema->getDatabasePlatform();
                $platform->registerDoctrineTypeMapping('enum', 'string');
                $platform->registerDoctrineTypeMapping('set', 'string');

                return new Schema($schema);
            }
        });
    }

    protected function registerAdminSortable()
    {
        $this->app->singleton('scaffold.sortable', function ($app) {
            if ($module = $app['scaffold.module']) {
                return new Sorter(
                    $module instanceof Sortable ? $module->sortable() : [],
                    method_exists($module, 'sortDirection') ? $module->sortDirection() : 'desc'
                );
            }
        });
    }

    protected function registerAdminColumns()
    {
        $this->app->singleton('scaffold.columns', function ($app) {
            if ($module = $app['scaffold.module']) {
                return $module->columns();
            }
        });
    }

    protected function registerAdminActions()
    {
        $this->app->singleton('scaffold.actions', function ($app) {
            if ($module = $app['scaffold.module']) {
                return $module->actionsManager();
            }
        });
    }

    protected function registerAdminTemplate()
    {
        $this->app->singleton('scaffold.template', function ($app) {
            // check for resource template
            $handler = ($module = $app['scaffold.module']) ? $module->template() : Template::class;
            $handler = new $handler();

            if (!$handler instanceof TemplateProvider) {
                throw new Exception('Templates handler must implement '.TemplateProvider::class.' contract');
            }

            return $handler;
        });
    }

    protected function registerAdminForm()
    {
        $this->app->singleton('scaffold.form', function ($app) {
            if ($module = $app['scaffold.module']) {
                return $module->form();
            }
        });
    }

    protected function registerAdminFilter()
    {
        $this->app->singleton('scaffold.filter', function ($app) {
            if ($module = $app['scaffold.module']) {
                $filters = $module instanceof Filtrable ? $module->filters() : null;
                $scopes = $module instanceof Filtrable ? $module->scopes() : null;

                return new Filter($app['request'], $filters, $scopes);

It seems like $scopes can also be of type array; however, parameter $scopes of Terranet\Administrator\Filter::__construct() does only seem to accept Terranet\Administrator\Collection\Mutable|null, maybe add an additional type check?

It seems like $filters can also be of type array; however, parameter $filters of Terranet\Administrator\Filter::__construct() does only seem to accept Terranet\Administrator\Collection\Mutable|null, maybe add an additional type check?

            }
        });
    }

    protected function registerAdminFinder()
    {
        $this->app->singleton('scaffold.finder', function ($app) {
            if ($module = $app['scaffold.module']) {
                // in order to register sortable columns,
                // resolve columns service before finder.
                $app->make('scaffold.columns');

                $finder = $module->finder();
                $finder = new $finder($module);

                if (!$finder instanceof Finder) {
                    throw new Exception('Items Finder must implement '.Finder::class.' contract');
                }

                return $finder;
            }
        });
    }

    protected function registerAdminBreadcrumbs()
    {
        $this->app->singleton('scaffold.breadcrumbs', function ($app) {
            if ($module = $app['scaffold.module']) {
                $provider = $module->breadcrumbs();

                return new $provider($app->make('breadcrumbs'), $app->make('scaffold.module'));
            }
        });
    }
}