Register commands

@return void
334091
protected function registerCommands()
    {
        $this->app->bind('command.log-reader.delete', 'Jackiedo\LogReader\Console\Commands\LogReaderDeleteCommand');
        $this->app->bind('command.log-reader.detail', 'Jackiedo\LogReader\Console\Commands\LogReaderDetailCommand');
        $this->app->bind('command.log-reader.file-list', 'Jackiedo\LogReader\Console\Commands\LogReaderFileListCommand');
        $this->app->bind('command.log-reader.get', 'Jackiedo\LogReader\Console\Commands\LogReaderGetCommand');
        $this->app->bind('command.log-reader.remove-file', 'Jackiedo\LogReader\Console\Commands\LogReaderRemoveFileCommand');

        $this->commands('command.log-reader.delete');
        $this->commands('command.log-reader.detail');
        $this->commands('command.log-reader.file-list');
        $this->commands('command.log-reader.get');
        $this->commands('command.log-reader.remove-file');
    }
220800
public function register()
    {

        // Package commands available for laravel or lumen higher than 5.1

        if(version_compare($this->app->version(), '5.1', ">=") or starts_with($this->app->version(), "Lumen")) {

            if ($this->app->runningInConsole()) {

                // Registering commands

                $this->commands([
                    ListIndicesCommand::class,
                    CreateIndexCommand::class,
                    UpdateIndexCommand::class,
                    DropIndexCommand::class,
                    ReindexCommand::class
                ]);

            }
        }

        $this->app->bind('es', function () {
            return new Connection();
        });
    }
80779
protected function registerCommands()
    {
        $this->app->singleton('cms.commands.user-create', CreateUser::class);
        $this->app->singleton('cms.commands.user-delete', DeleteUser::class);

        $this->commands([
            'cms.commands.user-create',
            'cms.commands.user-delete',
        ]);

        return $this;
    }
702697
protected function registerCommands(array $commands)
	{
		if (!$this->app->runningInConsole()) {
			return;
		}

		foreach ($commands as $key => $command) {
			if (is_numeric($key)) {
				$key = Str::lower(str_replace("\\", '.', $command));
			}

			$method = "register{$command}";

			try {
				if (method_exists($this, $method)) {
					call_user_func_array([$this, $method], [$key]);
				} else {
					$this->app->singleton($key, function ($app) use ($command) {
						return $app->make($command);
					});
				}
				$this->commands($key);
			} catch (\Exception $e) {
				throw $e;
			}
		}
	}
36857
protected function registerMakeCommand()
    {
        $this->app->singleton('command.repository.make', function ($app) {
            $prefix = $app['config']['repository.prefix'];
            $suffix = $app['config']['repository.suffix'];
            $contract = $app['config']['repository.contract'];
            $namespace = $app['config']['repository.namespace'];
            $creator = $app['repository.creator'];
            $files = $app['files'];

            return new RepositoryMakeCommand($creator, $prefix, $suffix, $contract, $namespace, $files);
        });

        $this->commands('command.repository.make');
    }
33783
protected function registerCommand()
    {
        $this->app->singleton(
            'command.laroute.generate',
            function ($app) {
                $config     = $app['config'];
                $routes     = new Routes($app['router']->getRoutes(), $config->get('laroute.filter', 'all'), $config->get('laroute.action_namespace', ''));
                $generator  = $app->make('Lord\Laroute\Generators\GeneratorInterface');

                return new LarouteGeneratorCommand($config, $routes, $generator);
            }
        );

        $this->commands('command.laroute.generate');
    }
68443
protected function registerCommands()
    {
        $this->app->singleton('command.settings.table', function ($app) {
            return new SettingsTableCommand($app['files'], $app['composer']);
        });

        $this->commands('command.settings.table');
    }
944137
protected function registerCommands()
    {
        $this->app->singleton('cms.commands.models.cache-information', Commands\CacheModelInformation::class);
        $this->app->singleton('cms.commands.models.clear-information-cache', Commands\ClearModelInformationCache::class);
        $this->app->singleton('cms.commands.models.show-information', Commands\ShowModelInformation::class);
        $this->app->singleton('cms.commands.models.write-information', Commands\WriteModelInformation::class);

        $this->commands([
            'cms.commands.models.cache-information',
            'cms.commands.models.clear-information-cache',
            'cms.commands.models.show-information',
            'cms.commands.models.write-information',
        ]);

        return $this;
    }
199565
protected function registerCommands()
    {
        $namespace    =    __NAMESPACE__ . '\\Commands\\';
        $keyPrefix    =    'lockdown.commands.';
        $commands    =    [
            $keyPrefix . 'assign-perm-user'  =>    'AssignPermissionToUser',
            $keyPrefix . 'assign-role-perm'  =>    'AssignPermissionToRole',
            $keyPrefix . 'assign-role-user'  =>    'AssignRoleToUser',
            $keyPrefix . 'create-perm'       =>    'CreatePermission',
            $keyPrefix . 'create-role'       =>    'CreateRole',
            $keyPrefix . 'delete-permission' =>    'DeletePermission',
            $keyPrefix . 'delete-role'       =>    'DeleteRole',
            $keyPrefix . 'remove-perm-user'  =>    'RemovePermissionFromUser',
            $keyPrefix . 'remove-role-perm'  =>    'RemovePermissionFromRole',
            $keyPrefix . 'remove-role-user'  =>    'RemoveRoleFromUser',
            $keyPrefix . 'show-permissions'  =>    'ShowPermissions',
            $keyPrefix . 'show-roles'        =>    'ShowRoles',
        ];

        foreach ($commands as $key => $class) {
            $this->app->bind(
                $key,
                function ($app) use ($class, $namespace) {
                    $classNamespaceFull    =    $namespace . $class;
                    return new $classNamespaceFull($app['lockdown']);
                }
            );
        }

        $this->commands(array_keys($commands));
    }
140824
protected function registerCommands(array $commands)
    {
        foreach (array_keys($commands) as $command) {
            call_user_func([$this, "register{$command}Command"]);
        }

        $this->commands(array_values($commands));
    }
720241
protected function registerCommands()
    {
        $this->application->addCommands([
            new BuildCommand($this->viewFactory, $this->filesystem),
            new PostCommand($this->viewFactory, $this->filesystem)
        ]);
    }
955511
public function registerCommands()
    {
        $this->app['command.cpanel.install'] = $this->app->share(function()
        {
            return new InstallCommand();
        });

        $this->app['command.cpanel.user'] = $this->app->share(function()
        {
            return new UserSeedCommand();
        });

        $this->commands('command.cpanel.install','command.cpanel.user');
    }
1295859
protected function registerCommands()
    {
        $this->app->singleton('revisions.migration', function ($app) {
            return new RevisionsTableCommand($app['files'], $app['composer']);
        });
        $this->app->singleton('revisions.upgrade5_3', function ($app) {
            return new RevisionsUpgradeCommand($app['files'], $app['composer']);
        });

        $this->commands([
            'revisions.migration',
            'revisions.upgrade5_3',
        ]);
    }
1129763
public function register()
    {
        // Here we register commands for artisan
        $this->app->singleton('command.closuretable', function ($app) {
            return new ClosureTableCommand;
        });

        $this->app->singleton('command.closuretable.make', function ($app) {
            return $app['Franzose\ClosureTable\Console\MakeCommand'];
        });

        $this->commands('command.closuretable', 'command.closuretable.make');
    }
856381
protected function registerCommands(array $commands)
    {
        foreach ($commands as $command) {
            if ( ! $command instanceof SymfonyCommand) {
                $command = $this->container[$command];
            }

            $this->container['console']->add($command);
        }
    }
237569
public function registerCommands()
    {
        foreach ($this->commandsStack as $key => $command) {
            $this->resolveConsoleCommand('\\'.$command);
        }

        return $this;
    }
170236
protected function registerCommands()
    {
        if ($this->app->runningInConsole()) {
            $this->commands([
                Console\InstallCommand::class,
                Console\AssetsCommand::class,
                Console\HorizonCommand::class,
                Console\ListCommand::class,
                Console\PurgeCommand::class,
                Console\PauseCommand::class,
                Console\ContinueCommand::class,
                Console\StatusCommand::class,
                Console\SupervisorCommand::class,
                Console\SupervisorsCommand::class,
                Console\TerminateCommand::class,
                Console\TimeoutCommand::class,
                Console\WorkCommand::class,
            ]);
        }

        $this->commands([Console\SnapshotCommand::class]);
    }