Cortex\Foundation\Providers\ArtisanServiceProvider

Complexity

Total Complexity

29

Size/Duplication

Total Lines	423
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	28

Importance

Changes

0

27 Methods

Rating	Name	Duplication	Size	Complexity
A	registerConfigMakeCommand()	0	6	1
A	registerConsoleMakeCommand()	0	6	1
A	registerControllerMakeCommand()	0	6	1
A	registerDatatableMakeCommand()	0	6	1
A	registerEventMakeCommand()	0	6	1
A	registerFactoryMakeCommand()	0	6	1
A	registerJobMakeCommand()	0	6	1
A	registerListenerMakeCommand()	0	6	1
A	registerMailMakeCommand()	0	6	1
A	registerMiddlewareMakeCommand()	0	6	1
A	registerMigrateMakeCommand()	0	13	1
A	registerModelMakeCommand()	0	6	1
A	registerModuleMakeCommand()	0	6	1
A	registerNotificationMakeCommand()	0	6	1
A	registerPolicyMakeCommand()	0	6	1
A	registerProviderMakeCommand()	0	6	1
A	registerRequestMakeCommand()	0	6	1
A	registerResourceMakeCommand()	0	6	1
A	registerRuleMakeCommand()	0	6	1
A	registerSeederMakeCommand()	0	6	1
A	registerTransformerMakeCommand()	0	6	1
A	register()	0	5	3
A	registerChannelMakeCommand()	0	6	1
A	registerEventGenerateCommand()	0	6	1
A	registerExceptionMakeCommand()	0	6	1
A	registerServeCommand()	0	6	1
A	registerVendorPublishCommand()	0	6	1

<?php

declare(strict_types=1);

namespace Cortex\Foundation\Providers;

use Cortex\Foundation\Console\Commands\ServeCommand;
use Illuminate\Console\Scheduling\ScheduleRunCommand;
use Cortex\Foundation\Console\Commands\JobMakeCommand;
use Cortex\Foundation\Console\Commands\MailMakeCommand;
use Cortex\Foundation\Console\Commands\RuleMakeCommand;
use Cortex\Foundation\Console\Commands\EventMakeCommand;
use Cortex\Foundation\Console\Commands\ModelMakeCommand;
use Illuminate\Console\Scheduling\ScheduleFinishCommand;
use Cortex\Foundation\Console\Commands\ConfigMakeCommand;
use Cortex\Foundation\Console\Commands\ModuleMakeCommand;
use Cortex\Foundation\Console\Commands\PolicyMakeCommand;
use Cortex\Foundation\Console\Commands\SeederMakeCommand;
use Cortex\Foundation\Console\Commands\ChannelMakeCommand;
use Cortex\Foundation\Console\Commands\ConsoleMakeCommand;
use Cortex\Foundation\Console\Commands\FactoryMakeCommand;
use Cortex\Foundation\Console\Commands\MigrateMakeCommand;
use Cortex\Foundation\Console\Commands\RequestMakeCommand;
use Cortex\Foundation\Console\Commands\ListenerMakeCommand;
use Cortex\Foundation\Console\Commands\ProviderMakeCommand;
use Cortex\Foundation\Console\Commands\ResourceMakeCommand;
use Cortex\Foundation\Console\Commands\DataTableMakeCommand;
use Cortex\Foundation\Console\Commands\EventGenerateCommand;
use Cortex\Foundation\Console\Commands\ExceptionMakeCommand;
use Cortex\Foundation\Console\Commands\VendorPublishCommand;
use Cortex\Foundation\Console\Commands\ControllerMakeCommand;
use Cortex\Foundation\Console\Commands\MiddlewareMakeCommand;
use Cortex\Foundation\Console\Commands\TransformerMakeCommand;
use Cortex\Foundation\Console\Commands\NotificationMakeCommand;
use Illuminate\Foundation\Providers\ArtisanServiceProvider as BaseArtisanServiceProvider;

class ArtisanServiceProvider extends BaseArtisanServiceProvider
{
    /**
     * Indicates if loading of the provider is deferred.
     *
     * @var bool
     */
    protected $defer = true;

    /**
     * The commands to be registered.
     *
     * @var array
     */
    protected $commands = [
        'CacheClear' => 'command.cache.clear',
        'CacheForget' => 'command.cache.forget',
        'ClearCompiled' => 'command.clear-compiled',
        //'ClearResets' => 'command.auth.resets.clear',
        'ConfigCache' => 'command.config.cache',
        'ConfigClear' => 'command.config.clear',
        'Down' => 'command.down',
        'Environment' => 'command.environment',
        'KeyGenerate' => 'command.key.generate',
        'Migrate' => 'command.migrate',
        'MigrateFresh' => 'command.migrate.fresh',
        'MigrateInstall' => 'command.migrate.install',
        'MigrateRefresh' => 'command.migrate.refresh',
        'MigrateReset' => 'command.migrate.reset',
        'MigrateRollback' => 'command.migrate.rollback',
        'MigrateStatus' => 'command.migrate.status',
        'PackageDiscover' => 'command.package.discover',
        'Preset' => 'command.preset',
        'QueueFailed' => 'command.queue.failed',
        'QueueFlush' => 'command.queue.flush',
        'QueueForget' => 'command.queue.forget',
        'QueueListen' => 'command.queue.listen',
        'QueueRestart' => 'command.queue.restart',
        'QueueRetry' => 'command.queue.retry',
        'QueueWork' => 'command.queue.work',
        'RouteCache' => 'command.route.cache',
        'RouteClear' => 'command.route.clear',
        'RouteList' => 'command.route.list',
        'Seed' => 'command.seed',
        'ScheduleFinish' => ScheduleFinishCommand::class,
        'ScheduleRun' => ScheduleRunCommand::class,
        'StorageLink' => 'command.storage.link',
        'Up' => 'command.up',
        'ViewClear' => 'command.view.clear',
    ];

    /**
     * The commands to be registered.
     *
     * @var array
     */
    protected $devCommands = [
        //'AppName' => 'command.app.name',
        //'AuthMake' => 'command.auth.make',
        //'CacheTable' => 'command.cache.table',
        'ConfigMake' => 'command.config.make',
        'ChannelMake' => 'command.channel.make',
        'ConsoleMake' => 'command.console.make',
        'ControllerMake' => 'command.controller.make',
        'DatatableMake' => 'command.datatable.make',
        'EventGenerate' => 'command.event.generate',
        'EventMake' => 'command.event.make',
        'ExceptionMake' => 'command.exception.make',
        'FactoryMake' => 'command.factory.make',
        'JobMake' => 'command.job.make',
        'ListenerMake' => 'command.listener.make',
        'MailMake' => 'command.mail.make',
        'MiddlewareMake' => 'command.middleware.make',
        'MigrateMake' => 'command.migrate.make',
        'ModelMake' => 'command.model.make',
        'ModuleMake' => 'command.module.make',
        'NotificationMake' => 'command.notification.make',
        //'NotificationTable' => 'command.notification.table',
        'PolicyMake' => 'command.policy.make',
        'ProviderMake' => 'command.provider.make',
        //'QueueFailedTable' => 'command.queue.failed-table',
        //'QueueTable' => 'command.queue.table',
        'RequestMake' => 'command.request.make',
        'ResourceMake' => 'command.resource.make',
        'RuleMake' => 'command.rule.make',
        'SeederMake' => 'command.seeder.make',
        //'SessionTable' => 'command.session.table',
        'Serve' => 'command.serve',
        'TestMake' => 'command.test.make',
        'TransformerMake' => 'command.transformer.make',
        'VendorPublish' => 'command.vendor.publish',
    ];

    /**
     * Register the service provider.
     *
     * @return void
     */
    public function register(): void
    {
        ! $this->app->runningInConsole() || $this->registerCommands($this->commands);
        ! $this->app->runningInConsole() || $this->registerCommands($this->devCommands);
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerConfigMakeCommand(): void
    {
        $this->app->singleton('command.config.make', function ($app) {
            return new ConfigMakeCommand($app['files']);
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerChannelMakeCommand()
    {
        $this->app->singleton('command.channel.make', function ($app) {
            return new ChannelMakeCommand($app['files']);
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerConsoleMakeCommand(): void
    {
        $this->app->singleton('command.console.make', function ($app) {
            return new ConsoleMakeCommand($app['files']);
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerEventGenerateCommand()
    {
        $this->app->singleton('command.event.generate', function () {
            return new EventGenerateCommand();
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerControllerMakeCommand(): void
    {
        $this->app->singleton('command.controller.make', function ($app) {
            return new ControllerMakeCommand($app['files']);
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerDatatableMakeCommand(): void
    {
        $this->app->singleton('command.datatable.make', function ($app) {
            return new DataTableMakeCommand($app['files']);
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerEventMakeCommand(): void
    {
        $this->app->singleton('command.event.make', function ($app) {
            return new EventMakeCommand($app['files']);
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerExceptionMakeCommand()
    {
        $this->app->singleton('command.exception.make', function ($app) {
            return new ExceptionMakeCommand($app['files']);
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerFactoryMakeCommand(): void
    {
        $this->app->singleton('command.factory.make', function ($app) {
            return new FactoryMakeCommand($app['files']);
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerJobMakeCommand(): void
    {
        $this->app->singleton('command.job.make', function ($app) {
            return new JobMakeCommand($app['files']);
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerListenerMakeCommand(): void
    {
        $this->app->singleton('command.listener.make', function ($app) {
            return new ListenerMakeCommand($app['files']);
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerMailMakeCommand(): void
    {
        $this->app->singleton('command.mail.make', function ($app) {
            return new MailMakeCommand($app['files']);
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerMiddlewareMakeCommand(): void
    {
        $this->app->singleton('command.middleware.make', function ($app) {
            return new MiddlewareMakeCommand($app['files']);
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerMigrateMakeCommand(): void
    {
        $this->app->singleton('command.migrate.make', function ($app) {
            // Once we have the migration creator registered, we will create the command
            // and inject the creator. The creator is responsible for the actual file
            // creation of the migrations, and may be extended by these developers.
            $creator = $app['migration.creator'];

            $composer = $app['composer'];

            return new MigrateMakeCommand($creator, $composer);
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerModelMakeCommand(): void
    {
        $this->app->singleton('command.model.make', function ($app) {
            return new ModelMakeCommand($app['files']);
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerModuleMakeCommand(): void
    {
        $this->app->singleton('command.module.make', function ($app) {
            return new ModuleMakeCommand($app['files']);
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerNotificationMakeCommand(): void
    {
        $this->app->singleton('command.notification.make', function ($app) {
            return new NotificationMakeCommand($app['files']);
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerPolicyMakeCommand(): void
    {
        $this->app->singleton('command.policy.make', function ($app) {
            return new PolicyMakeCommand($app['files']);
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerProviderMakeCommand(): void
    {
        $this->app->singleton('command.provider.make', function ($app) {
            return new ProviderMakeCommand($app['files']);
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerRequestMakeCommand(): void
    {
        $this->app->singleton('command.request.make', function ($app) {
            return new RequestMakeCommand($app['files']);
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerResourceMakeCommand(): void
    {
        $this->app->singleton('command.resource.make', function ($app) {
            return new ResourceMakeCommand($app['files']);
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerRuleMakeCommand(): void
    {
        $this->app->singleton('command.rule.make', function ($app) {
            return new RuleMakeCommand($app['files']);
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerSeederMakeCommand(): void
    {
        $this->app->singleton('command.seeder.make', function ($app) {
            return new SeederMakeCommand($app['files'], $app['composer']);
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerTransformerMakeCommand(): void
    {
        $this->app->singleton('command.transformer.make', function ($app) {
            return new TransformerMakeCommand($app['files']);
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerServeCommand()
    {
        $this->app->singleton('command.serve', function () {
            return new ServeCommand();
        });
    }

    /**
     * Register the command.
     *
     * @return void
     */
    protected function registerVendorPublishCommand()
    {
        $this->app->singleton('command.vendor.publish', function ($app) {
            return new VendorPublishCommand($app['files']);
        });
    }
}