Foundation\Generator\Managers\GeneratorManager

Complexity

Total Complexity

29

Size/Duplication

Total Lines	328
Duplicated Lines	0 %

Test Coverage

Coverage

96.61%

Importance

Changes

0

28 Methods

Rating	Name	Duplication	Size	Complexity
A	module()	0	3	1
A	call()	0	3	1
A	createMigration()	0	8	1
A	createAttribute()	0	6	1
A	createFactory()	0	6	1
A	createModel()	0	8	1
A	createException()	0	6	1
A	createComposer()	0	3	1
A	createNotification()	0	6	1
A	createService()	0	6	1
A	createTest()	0	7	1
A	createSeeder()	0	6	1
A	__construct()	0	4	1
A	createController()	0	6	1
A	createServiceProvider()	0	6	1
A	createPermission()	0	6	1
A	createCommand()	0	7	1
A	createPolicy()	0	6	1
A	createRequest()	0	6	1
A	createListener()	0	8	1
A	createRule()	0	6	1
A	createMiddleware()	0	6	1
A	createServiceContract()	0	6	1
A	alterOptions()	0	6	2
A	createJob()	0	7	1
A	createTransformer()	0	7	1
A	createRoute()	0	6	1
A	createEvent()	0	6	1

<?php
/**
 * Created by PhpStorm.
 * User: arthur
 * Date: 10.03.19
 * Time: 18:30
 */

namespace Foundation\Generator\Managers;


use Illuminate\Support\Str;

/**
 * Class GeneratorManager
 * @package Foundation\Generator\Managers
 */
class GeneratorManager
{

    /**
     * @var string
     */
    protected $moduleName;

    /**
     * @var bool
     */
    protected $overwrite;

    /**
     * GeneratorManager constructor.
     * @param string $module
     */
    protected function __construct(string $module, bool $overwrite = false)
    {
        $this->moduleName = $module;
        $this->overwrite = $overwrite;
    }

    /**
     * @param string $moduleName
     * @return GeneratorManager
     */
    public static function module(string $moduleName, bool $overwrite = false)
    {
        return new GeneratorManager($moduleName, $overwrite);
    }

    protected function call(string $commandName, $options)
    {
        \Artisan::call("larapi:make:$commandName", $this->alterOptions($options));
    }

    /**
     * @param $options
     * @return mixed
     */
    protected function alterOptions($options)
    {
        $options['module'] = Str::studly($this->moduleName);
        if ($this->overwrite)
            $options['--overwrite'] = null;
        return $options;
    }

    /**
     * @param string $migrationName
     * @param string $tableName
     * @param bool $mongo
     */
    public function createMigration(string $migrationName, string $tableName, bool $mongo = false)
    {
        $options = [
            "name" => $migrationName,
            "--table" => $tableName,
            "--mongo" => $mongo
        ];
        $this->call('migration', $options);
    }

    /**
     * @param string $controllerName
     */
    public function createController(string $controllerName)
    {
        $options = [
            "name" => $controllerName,
        ];
        $this->call('controller', $options);
    }

    /**
     * @param string $modelName
     */
    public function createAttribute(string $attributeName)
    {
        $options = [
            "name" => $attributeName,
        ];
        $this->call('attribute', $options);
    }

    /**
     * @param string $serviceName
     */
    public function createService(string $serviceName)
    {
        $options = [
            "name" => $serviceName,
        ];
        $this->call('service', $options);
    }

    /**
     * @param string $serviceName
     */
    public function createServiceContract(string $serviceContractName)
    {
        $options = [
            "name" => $serviceContractName,
        ];
        $this->call('service-contract', $options);
    }

    /**
     * @param string $policyName
     */
    public function createPolicy(string $policyName)
    {
        $options = [
            "name" => $policyName,
        ];
        $this->call('policy', $options);
    }

    /**
     * @param string $eventName
     */
    public function createEvent(string $eventName)
    {
        $options = [
            "name" => $eventName,
        ];
        $this->call('event', $options);
    }

    /**
     * @param string $notificationName
     */
    public function createNotification(string $notificationName)
    {
        $options = [
            "name" => $notificationName,
        ];
        $this->call('notification', $options);
    }

    /**
     * @param string $providerName
     */
    public function createServiceProvider(string $providerName)
    {
        $options = [
            "name" => $providerName,
        ];
        $this->call('provider', $options);
    }

    /**
     * @param string $seederName
     */
    public function createSeeder(string $seederName)
    {
        $options = [
            "name" => $seederName,
        ];
        $this->call('seeder', $options);
    }

    /**
     * @param string $middlewareName
     */
    public function createMiddleware(string $middlewareName)
    {
        $options = [
            "name" => $middlewareName,
        ];
        $this->call('middleware', $options);
    }

    /**
     * @param string $requestName
     */
    public function createRequest(string $requestName)
    {
        $options = [
            "name" => $requestName,
        ];
        $this->call('request', $options);
    }

    /**
     * @param string $ruleName
     */
    public function createRule(string $ruleName)
    {
        $options = [
            "name" => $ruleName,
        ];
        $this->call('rule', $options);
    }

    /**
     * @param string $exceptionName
     */
    public function createException(string $exceptionName)
    {
        $options = [
            "name" => $exceptionName,
        ];
        $this->call('exception', $options);
    }

    /**
     * @param string $permissionName
     */
    public function createPermission(string $permissionName)
    {
        $options = [
            "name" => $permissionName,
        ];
        $this->call('permission', $options);
    }

    /**
     * @param string $version
     */
    public function createRoute(string $version)
    {
        $options = [
            '--versioning' => $version
        ];
        $this->call('route', $options);
    }

    /**
     * @param string $moduleName
     */
    public function createComposer()
    {
        $this->call('composer', []);
    }

    /**
     * @param string $testName
     * @param string $type
     */
    public function createTest(string $testName, string $type)
    {
        $options = [
            "name" => $testName,
            "--type" => $type
        ];
        $this->call('test', $options);
    }

    /**
     * @param string $modelName
     */
    public function createFactory(string $modelName)
    {
        $options = [
            "--model" => $modelName,
        ];
        $this->call('factory', $options);
    }

    /**
     * @param string $transformerName
     * @param string $modelName
     */
    public function createTransformer(string $transformerName, string $modelName)
    {
        $options = [
            "name" => $transformerName,
            "--model" => $modelName,
        ];
        $this->call('transformer', $options);
    }

    /**
     * @param string $listenerName
     * @param string $eventName
     * @param bool $queued
     */
    public function createListener(string $listenerName, string $eventName, bool $queued = false)
    {
        $options = [
            "name" => $listenerName,
            "--event" => $eventName,
            "--queued" => $queued
        ];
        $this->call('listener', $options);
    }

    /**
     * @param string $jobName
     * @param bool $sync
     */
    public function createJob(string $jobName, bool $sync = false)
    {
        $options = [
            "name" => $jobName,
            "--sync" => $sync
        ];
        $this->call('job', $options);
    }

    /**
     * @param string $jobName
     * @param string|null $commandName
     */
    public function createCommand(string $name, ?string $commandName = null)
    {
        $options = [
            "name" => $name,
            "--command" => $commandName
        ];
        $this->call('command', $options);
    }

    /**
     * @param string $modelName
     * @param bool $mongo
     * @param bool $migration
     */
    public function createModel(string $modelName, ?bool $mongo = false, ?bool $migration = true)
    {
        $options = [
            "name" => $modelName,
            "--mongo" => $mongo,
            "--migration" => $migration
        ];
        $this->call('model', $options);
    }


}