Foundation\Providers\BootstrapServiceProvider

Complexity

Total Complexity

15

Size/Duplication

Total Lines	111
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	register()	0	11	1
A	loadCommands()	0	3	1
A	loadBootstrapService()	0	6	2
A	loadConfigs()	0	8	2
A	loadV1Routes()	0	20	2
A	loadPolicies()	0	2	1
A	overrideSeedCommand()	0	6	1
A	loadFactories()	0	5	3
A	loadMigrations()	0	4	2

<?php

namespace Foundation\Providers;

use Foundation\Console\SeedCommand;
use Foundation\Services\BootstrapRegistrarService;
use Illuminate\Database\Eloquent\Factory;
use Illuminate\Foundation\Support\Providers\EventServiceProvider as ServiceProvider;
use Illuminate\Routing\Router;
use Route;

/**
 * Class BootstrapServiceProvider.
 */
class BootstrapServiceProvider extends ServiceProvider
{
    /**
     * @var BootstrapRegistrarService
     */
    protected $bootstrapService;

    public function register()
    {
        $this->loadBootstrapService();
        $this->loadCommands();
        $this->loadPolicies();
        $this->loadV1Routes();
        $this->loadConfigs();
        $this->loadFactories();
        $this->loadMigrations();

        $this->overrideSeedCommand();
    }

    public function loadBootstrapService()
    {
        $this->bootstrapService = new BootstrapRegistrarService();

        if (!$this->app->environment('production')) {
            $this->bootstrapService->cache();
        }
    }

    private function loadCommands()
    {
        $this->commands($this->bootstrapService->getCommands());
    }

    private function loadV1Routes()
    {
        foreach ($this->bootstrapService->getRoutes() as $route) {
            $apiDomain = strtolower(env('API_URL'));
            $apiDomain = str_replace('http://', '', $apiDomain);
            $apiDomain = str_replace('https://', '', $apiDomain);
            $moduleNamespace = $route[1];
            $moduleName = explode('\\', $moduleNamespace)[1];
            $controllerNamespace = $moduleNamespace . '\\' . 'Http\\Controllers';
            $modelNameSpace = $moduleNamespace . '\\' . 'Entities\\' . $moduleName;
            $filepath = $route[0];
            Route::group([
                'prefix' => 'v1',
                'namespace' => $controllerNamespace,
                'domain' => $apiDomain,
                'middleware' => ['api'],
            ], function (Router $router) use ($filepath) {
                require $filepath;
            });
            Route::model(strtolower($moduleName), $modelNameSpace);
        }
    }

    /**
     * Register config.
     *
     * @return void
     */
    protected function loadConfigs()
    {
        foreach ($this->bootstrapService->getConfigs() as $route) {
            $this->publishes([
                $route[0] => config_path($route[1]),
            ], 'config');
            $this->mergeConfigFrom(
                $route[0], basename($route[1], '.php')
            );
        }
    }

    /**
     * Register additional directories of factories.
     *
     * @return void
     */
    public function loadFactories()
    {
        foreach ($this->bootstrapService->getFactories() as $factoryPath) {
            if (!$this->app->environment('production')) {
                app(Factory::class)->load($factoryPath);
            }
        }
    }

    /**
     * Register additional directories of migrations.
     *
     * @return void
     */
    public function loadMigrations()
    {
        foreach ($this->bootstrapService->getMigrations() as $migrationPath) {
            $this->loadMigrationsFrom($migrationPath);
        }
    }

    private function loadPolicies()
    {
        //TODO
    }

    private function overrideSeedCommand()
    {
        $app = $this->app;
        $service = $this->bootstrapService;
        $this->app->extend('command.seed', function () use ($app, $service) {
            return new SeedCommand($app['db'], $service);
        });
    }
}