Nwidart\Modules\Laravel\LaravelDatabaseRepository

Complexity

Total Complexity

34

Size/Duplication

Total Lines	238
Duplicated Lines	5.04 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	createModule()	0	4	1
A	getModel()	0	4	1
A	scan()	0	17	4
A	has()	0	4	1
A	find()	0	13	3
A	collections()	0	4	1
A	getModulePath()	0	9	2
A	getByStatus()	12	12	3
A	formatCached()	0	12	2
A	getCached()	0	6	1
A	all()	0	9	2
A	create()	0	18	2
A	getModuleType()	0	13	5
A	getUsedNow()	0	9	2
A	migrateFileToDatabase()	0	20	4

<?php

namespace Nwidart\Modules\Laravel;

use Illuminate\Contracts\Filesystem\FileNotFoundException;
use Illuminate\Support\Facades\Schema;
use Illuminate\Support\Str;
use Nwidart\Modules\Collection;
use Nwidart\Modules\Contracts\ActivatorInterface;
use Nwidart\Modules\Contracts\DatabaseRepositoryInterface;
use Nwidart\Modules\Entities\ModuleEntity;
use Nwidart\Modules\Exceptions\ModuleNotFoundException;
use Nwidart\Modules\Generators\DatabaseModuleGenerator;
use Nwidart\Modules\Json;

class LaravelDatabaseRepository extends LaravelFileRepository implements DatabaseRepositoryInterface
{
    /**
     * @param mixed ...$args $app, $name, $path
     *
     * @return DatabaseModule
     */
    protected function createModule(...$args)
    {
        return new DatabaseModule(...$args);

The call to DatabaseModule::__construct() misses some required arguments starting with $name.

$args is of type array<integer,*>, but the function expects a object<Illuminate\Container\Container>.

    }

    /**
     * @return ModuleEntity
     */
    public function getModel()
    {
        return new ModuleEntity();
    }

    /**
     * Scan & get all available modules.
     */
    public function scan()
    {
        /**
         * @var ModuleEntity[] $rows
         */
        $rows = $this->getModel()->get();
        $modules = [];
        if (!empty($rows)) {
            foreach ($rows as $row) {
                if (file_exists($row->path)) {
                    $modules[$row->name] = $this->createModule($this->app, $row->name, $row->path);
                }
            }
        }

        return $modules;
    }

    /**
     * Determine whether the given module exist.
     *
     * @param $name
     *
     * @return bool
     */
    public function has($name): bool
    {
        return $this->getModel()->where('name', $name)->exists();
    }

    /**
     * @inheritDoc
     */
    public function find(string $name)
    {
        /** @var ModuleEntity $module */
        $module = $this->getModel()->where('name', $name)->first();
        if (!$module) {
            return null;
        }
        if (!file_exists($module->path)) {
            return null;
        }

        return $this->createModule($this->app, $module->name, $module->path);
    }

    /**
     * Get all modules as laravel collection instance.
     *
     * @param $status
     *
     * @return Collection
     */
    public function collections($status = 1): Collection
    {
        return new Collection($this->getByStatus($status));
    }

    /**
     * Get module path for a specific module.
     *
     * @param $name
     *
     * @return string
     */
    public function getModulePath($name)
    {
        $module = $this->find($name);
        if ($module) {
            return $module->getPath() . '/';
        }

        return $this->getPath() . '/' . Str::studly($name) . '/';
    }

    /**
     * Get modules by status.
     *
     * @param $status
     *
     * @return array
     */
    public function getByStatus($status): array
    {
        $modules = [];

        foreach ($this->all() as $name => $module) {
            if ($module->isStatus($status) == $status) {
                $modules[$name] = $module;
            }
        }

        return $modules;
    }

    /**
     * Format the cached data as array of modules.
     *
     * @param array $cached
     *
     * @return array
     */
    protected function formatCached($cached)
    {
        $modules = [];

        foreach ($cached as $moduleEntity) {
            $module = $this->createModule($this->app, $moduleEntity['name'], $moduleEntity['path']);
            $module->setAttributes($moduleEntity->toArray());
            $modules[$moduleEntity['name']] = $module;
        }

        return $modules;
    }

    /**
     * Get cached modules from database.
     *
     * @return ModuleEntity[]
     */
    public function getCached()
    {
        return $this->app['cache']->remember($this->config('cache.key'), $this->config('cache.lifetime'), function () {
            return $this->getModel()->all();
        });
    }

    public function all(): array
    {
        // Do not load or register if there are no modules table yet.
        if (!Schema::hasTable('modules')) {
            return [];
        }

        return parent::all();
    }

    public function create($params, $force = true, $isApi = true, $isPlain = true)
    {
        $moduleType = $this->getModuleType($isApi, $isPlain); // Custom later.
        /** @var DatabaseModuleGenerator $generator */
        $generator = with(new DatabaseModuleGenerator($params['name']));
        $code = $generator
            ->setFilesystem(app('files'))
            ->setModule($this)
            ->setConfig(app('config'))
            ->setActivator(app(ActivatorInterface::class))
            ->setForce($force)
            ->setType($moduleType)
            ->setActive($params['is_active'])
            ->setSilentOutput(true) // Don't use console output
            ->generate();

        return $code ? $this->find($params['name']) : false;
    }

    /**
     * Get module type .
     *
     * @param bool $isApi
     * @param bool $isPlain
     *
     * @return string
     */
    public function getModuleType($isApi = true, $isPlain = true)
    {
        if ($isPlain && $isApi) {
            return 'web';
        }
        if ($isPlain) {
            return 'plain';
        } elseif ($isApi) {
            return 'api';
        } else {
            return 'web';
        }
    }

    /**
     * Get module used for cli session.
     * @return string
     * @throws ModuleNotFoundException|FileNotFoundException
     */
    public function getUsedNow(): string
    {
        $module = $this->getFiles()->get($this->getUsedStoragePath());
        if (!$module) {
            return '';
        }

        return $this->findOrFail($module);
    }

    public function migrateFileToDatabase()
    {
        $paths = $this->getScanPaths();
        $modules = [];

        foreach ($paths as $key => $path) {
            $manifests = $this->getFiles()->glob("{$path}/module.json");

            is_array($manifests) || $manifests = [];

            foreach ($manifests as $manifest) {
                $json = Json::make($manifest);
                $data = $json->getAttributes();
                $data['path'] = str_replace('module.json', '', $json->getPath());
                $modules[] = $this->getModel()->create($data);
            }
        }

        return $modules;
    }
}