core/app/Console/Commands/InstallModule.php

<?php

namespace App\Console\Commands;

use App\Models\Module;
use Illuminate\Console\Command;
use Illuminate\Contracts\Filesystem\FileNotFoundException;
use Illuminate\Support\Facades\File;
use Symfony\Component\Console\Exception\InvalidArgumentException;
use Symfony\Component\Routing\Exception\MissingMandatoryParametersException;

class InstallModule extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'install-module {name}';
    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Custom installation of CMS module. Name given as directory name in /modules.';
    protected $moduleName;
    protected $modulesPath;

    /**
     * Create a new command instance.
     *
     * @return void
     */
    public function __construct()
    {
        parent::__construct();
        $this->modulesPath = config('modules.paths.modules');
    }

    /**
     * Execute the console command.
     *
     * @return mixed
     */
    public function handle()
    {
        $this->moduleName = $name = $this->argument('name');

        // invalid module name provided
        if (!is_dir($this->modulesPath . DIRECTORY_SEPARATOR . $name)) {
            throw new InvalidArgumentException('Invalid module ' . $name . '. No directory under ' . $this->modulesPath . DIRECTORY_SEPARATOR . $name . ' found!');
        }

        // get config
        $config = $this->loadConfig();

        // check if it is valid
        $this->checkMandatoryFields($config);

        // all mandatory fields are present, we can write it into database and create modules.json
        $this->installModule($config);

        // inform user
        $this->line('Module ' . $name . ' successfuly installed');
    }

    /**
     * Load config from Config/config.php in module files. We cannot use config() because the file have not published
     * yet.
     *
     * @return array
     * @throws FileNotFoundException
     */
    private function loadConfig()
    {
        $basePath = $this->modulesPath . DIRECTORY_SEPARATOR . $this->moduleName . DIRECTORY_SEPARATOR;
        $path = $basePath . 'Config' . DIRECTORY_SEPARATOR . 'config.php';

        // check if module has Config/config.php file
        if (!file_exists($path)) {
            $path = $basePath . 'info.php';

            // does module has info.php? If not, throw error, because we have no info about this module
            if (!file_exists($path)) {
                throw new FileNotFoundException('Missing config file. Create /Config/config.php or /info.php (for module with submodules) in ' . $basePath);
            }
        }

        // we cannot rely on config() helper, because this module does not have to be published
        $config = @include($path);

        return $config;
    }

    /**
     * Checks if config contains all mandatory entries.
     *
     * @param $config
     */
    private function checkMandatoryFields($config)
    {
        $fields = ['name'];
        foreach ($fields as $field) {
            if (!isset($config[$field])) {
                throw new MissingMandatoryParametersException('Missing *' . $field . '* in config file! Cannot install ' . $this->moduleName);
            }
        }
    }

    /**
     * Installs module into database.
     *
     * This method calls Module::install, which handles specific installation of module. In this way we should be able
     * to install any module even with some other database structures.
     *
     * @param $config
     *
     * @return Module
     * @throws \ErrorException
     * @throws \Exception
     */
    private function installModule($config)
    {
        $name = isset($config['translatedName']) ? $config['translatedName'] : $config['name'];
        $description = isset($config['translatedDescription']) ? $config['translatedDescription'] : null;
        $alias = isset($config['alias']) ? $config['alias'] : null;
        $handler = isset($config['handler']) ? $config['handler'] : null;
        $providers = isset($config['providers']) ? $config['providers'] : [];

        // check if module is not installed yet
        $exists = Module::where('handler', $handler)
                        ->where('name', $config['name'])
                        ->exists();

        if (!isset($config['hasSubmodules']) || !$config['hasSubmodules']) {
            if ($exists) {
                throw new \Exception('Module ' . $config['name'] . ' already exists in database.');
            }

            // insert module into database
            $settings = [
                'staticName' => $this->moduleName,
                'providers'  => $providers,
                'aliases'    => isset($config['aliases']) ? $config['aliases'] : [],
                'order'      => isset($config['order']) ? $config['order'] : 0,
                'files'      => isset($config['files']) ? $config['files'] : []
            ];

            $module = Module::install($name, $alias, $description, $handler, $settings);
        }

        // try to install submodules
        if (isset($config['hasSubmodules']) && $config['hasSubmodules']) {
            $this->installSubmodules($this->modulesPath . DIRECTORY_SEPARATOR . $this->moduleName);
        }
    }

    /**
     * Crawl all subdirectories in module and try to install submodules
     *
     * @param $path string path to module base directory
     */
    private function installSubmodules($path)
    {
        $submodules = File::directories($path);

        foreach ($submodules as $submodulePath) {
            $submodule = str_replace($this->modulesPath . DIRECTORY_SEPARATOR, '', $submodulePath);

            $this->call('install-module', ['name' => $submodule]);
        }
    }
}