App\Modules\Core\Console\Commands\GenerateDoc

Complexity

Total Complexity

37

Size/Duplication

Total Lines	254
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	handle()	0	38	5
A	getRoutes()	0	14	2
A	getHeaders()	0	14	3
A	processDocBlock()	0	14	3
B	getPostData()	0	25	7
A	getErrors()	0	18	3
A	getMethodBody()	0	12	1
A	getModels()	0	16	5
B	getResponseObject()	0	8	7

<?php

namespace App\Modules\Core\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Support\Arr;

class GenerateDoc extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'doc:generate';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Generate api documentation';

    /**
     * Init new object.
     *
     * @return  void

Adding a @return annotation to constructors is generally not recommended as a constructor does not have a meaningful return value.

     */
    public function __construct()
    {
        parent::__construct();
    }

    /**
     * Execute the console command.
     *
     * @return mixed
     */
    public function handle()
    {
        $docData           = [];
        $docData['models'] = [];
        $routes            = $this->getRoutes();
        foreach ($routes as $route) {
            if ($route) {
                $actoinArray = explode('@', $route['action']);
                if (Arr::get($actoinArray, 1, false)) {
                    $controller       = $actoinArray[0];
                    $method           = $actoinArray[1];
                    $route['name']    = $method !== 'index' ? $method : 'list';
                    
                    $reflectionClass  = new \ReflectionClass($controller);
                    $reflectionMethod = $reflectionClass->getMethod($method);
                    $classProperties  = $reflectionClass->getDefaultProperties();
                    $skipLoginCheck   = Arr::get($classProperties, 'skipLoginCheck', false);
                    $validationRules  = Arr::get($classProperties, 'validationRules', false);

                    dd($classProperties);
                    $this->processDocBlock($route, $reflectionMethod);
                    $this->getHeaders($route, $method, $skipLoginCheck);
                    $this->getPostData($route, $reflectionMethod, $validationRules);

                    $route['response'] = $this->getResponseObject($classProperties['model'], $route['name'], $route['returnDocBlock']);

                    preg_match('/api\/([^#]+)\//iU', $route['uri'], $module);
                    $docData['modules'][$module[1]][substr($route['prefix'], strlen('/api/'.$module[1].'/') - 1)][] = $route;

                    $this->getModels($classProperties['model'], $docData);
                }
            }
        }
        
        $docData['errors']  = $this->getErrors();
        $docData['reports'] = \Core::reports()->all();
        \File::put(app_path('Modules/Core/Resources/api.json'), json_encode($docData));
    }

    /**
     * Get list of all registered routes.
     *
     * @return collection
     */
    protected function getRoutes()
    {
        return collect(\Route::getRoutes())->map(function ($route) {
            if (strpos($route->uri(), 'api/') !== false) {
                return [
                    'method' => $route->methods()[0],
                    'uri'    => $route->uri(),
                    'action' => $route->getActionName(),
                    'prefix' => $route->getPrefix()
                ];
            }
            return false;
        })->all();
    }

    /**
     * Generate headers for the given route.
     *
     * @param  array  &$route
     * @param  string $method
     * @param  array  $skipLoginCheck
     * @return void
     */
    protected function getHeaders(&$route, $method, $skipLoginCheck)
    {
        $route['headers'] = [
        'Accept'       => 'application/json',
        'Content-Type' => 'application/json',
        'locale'       => 'The language of the returned data: ar, en or all.',
        'time-zone'    => 'Your locale time zone',
        ];


        if (! $skipLoginCheck || ! in_array($method, $skipLoginCheck)) {

The expression $skipLoginCheck of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            $route['headers']['Authorization'] = 'Bearer {token}';
        }
    }

    /**
     * Generate description and params for the given route
     * based on the docblock.
     *
     * @param  array  &$route
     * @param  \ReflectionMethod $reflectionMethod
     * @return void
     */
    protected function processDocBlock(&$route, $reflectionMethod)
    {
        $factory                 = \phpDocumentor\Reflection\DocBlockFactory::createInstance();
        $docblock                = $factory->create($reflectionMethod->getDocComment());
        $route['description']    = trim(preg_replace('/\s+/', ' ', $docblock->getSummary()));
        $params                  = $docblock->getTagsByName('param');
        $route['returnDocBlock'] = $docblock->getTagsByName('return')[0]->getType()->getFqsen()->getName();
        foreach ($params as $param) {
            $name = $param->getVariableName();
            if ($name !== 'request') {
                $route['parametars'][$param->getVariableName()] = $param->getDescription()->render();
            }
        }
    }

    /**
     * Generate post body for the given route.
     *
     * @param  array  &$route
     * @param  \ReflectionMethod $reflectionMethod
     * @param  array  $validationRules
     * @return void
     */
    protected function getPostData(&$route, $reflectionMethod, $validationRules)
    {
        if ($route['method'] == 'POST') {
            $body = $this->getMethodBody($reflectionMethod);

            preg_match('/\$this->validate\(\$request,([^#]+)\);/iU', $body, $match);
            if (count($match)) {
                if ($match[1] == '$this->validationRules') {
                    $route['body'] = $validationRules;
                } else {
                    $route['body'] = eval('return '.str_replace(',\'.$request->get(\'id\')', ',{id}\'', $match[1]).';');
                }

                foreach ($route['body'] as &$rule) {
                    if (strpos($rule, 'unique')) {
                        $rule = substr($rule, 0, strpos($rule, 'unique') + 6);
                    } elseif (strpos($rule, 'exists')) {
                        $rule = substr($rule, 0, strpos($rule, 'exists') - 1);
                    }
                }
            } else {
                $route['body'] = 'conditions';
            }
        }
    }

    /**
     * Generate application errors.
     *
     * @return array
     */
    protected function getErrors()
    {
        $errors          = [];
        $reflectionClass = new \ReflectionClass('App\Modules\Core\Utl\ErrorHandler');
        foreach ($reflectionClass->getMethods() as $method) {
            $methodName       = $method->name;
            $reflectionMethod = $reflectionClass->getMethod($methodName);
            $body             = $this->getMethodBody($reflectionMethod);

            preg_match('/\$error=\[\'status\'=>([^#]+)\,/iU', $body, $match);

            if (count($match)) {
                $errors[$match[1]][] = $methodName;
            }
        }

        return $errors;
    }

    /**
     * Get the given method body code.
     *
     * @param  object $reflectionMethod
     * @return string
     */
    protected function getMethodBody($reflectionMethod)
    {
        $filename   = $reflectionMethod->getFileName();
        $start_line = $reflectionMethod->getStartLine() - 1;
        $end_line   = $reflectionMethod->getEndLine();
        $length     = $end_line - $start_line;
        $source     = file($filename);
        $body       = implode("", array_slice($source, $start_line, $length));
        $body       = trim(preg_replace('/\s+/', '', $body));

        return $body;
    }

    /**
     * Get example object of all availble models.
     *
     * @param  string $modelName
     * @param  array  $docData
     * @return string
     */
    protected function getModels($modelName, &$docData)
    {
        if ($modelName && ! Arr::has($docData['models'], $modelName)) {
            $modelClass = call_user_func_array("\Core::{$modelName}", [])->modelClass;
            $model      = factory($modelClass)->make();
            $modelArr   = $model->toArray();

            if ($model->trans && ! $model->trans->count()) {
                $modelArr['trans'] = [
                    'en' => factory($modelClass.'Translation')->make()->toArray()
                ];
            }

            $docData['models'][$modelName] = json_encode($modelArr, JSON_PRETTY_PRINT);
        }
    }

    /**
     * Get the route response object type.
     *
     * @param  string $modelName
     * @param  string $method
     * @param  string $returnDocBlock
     * @return array
     */
    protected function getResponseObject($modelName, $method, $returnDocBlock)
    {
        $config    = \CoreConfig::getConfig();
        $relations = Arr::has($config['relations'], $modelName) ? Arr::has($config['relations'][$modelName], $method) ? $config['relations'][$modelName] : false : false;
        $modelName = call_user_func_array("\Core::{$returnDocBlock}", []) ? $returnDocBlock : $modelName;

        return $relations ? [$modelName => $relations && $relations[$method] ? $relations[$method] : []] : false;
    }
}