DocumentorService - Code Metrics - Inspection of "Recursive dto class detection" - psfs/core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 1b381e...137834 )

by Fran

created 2017-10-15 23:30 UTC

DocumentorService D

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	659
Duplicated Lines	3.34 %

Coupling/Cohesion

Components	2
Dependencies	10

Test Coverage

Coverage

Importance

Changes

Metric	Value
dl	22
loc	659
ccs	0
cts	293
cp	0
rs	4.6279
c	0
b	0
f	0
wmc	99
lcom	2
cbo	10

21 Methods

Rating	Name	Duplication	Size	Complexity
B	getModules()	0	22	6
B	extractApiEndpoints()	0	21	5
B	extractApiInfo()	0	21	7
A	extractRoute()	0	7	1
A	extractApi()	0	7	1
A	checkDeprecated()	0	4	1
A	extractVisibility()	0	10	2
B	extractDescription()	4	15	5
A	extractVarType()	0	11	3
A	extractPayload()	4	20	4
A	extractDtoProperties()	0	10	2
D	extractReturn()	4	30	9
D	extractModelFields()	0	34	9
B	extractMethodInfo()	0	33	6
B	swaggerResponses()	0	45	6
C	swaggerFormatter()	10	71	13
A	extractDtoName()	0	10	2
B	setQueryParams()	0	30	3
B	setRequestHeaders()	0	27	3
B	setRequestParams()	0	24	6
B	checkDtoAttributes()	0	28	5

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like DocumentorService often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use DocumentorService, and based on these observations, apply Extract Interface, too.

<?php

namespace PSFS\services;

use Propel\Runtime\Map\ColumnMap;
use PSFS\base\config\Config;
use PSFS\base\Logger;
use PSFS\base\Request;
use PSFS\base\Router;
use PSFS\base\Service;
use PSFS\base\types\helpers\DocumentorHelper;
use PSFS\base\types\helpers\GeneratorHelper;
use PSFS\base\types\helpers\I18nHelper;
use PSFS\base\types\helpers\InjectorHelper;
use PSFS\base\types\helpers\RouterHelper;
use Symfony\Component\Finder\Finder;

/**
 * Class DocumentorService
 * @package PSFS\services
 */
class DocumentorService extends Service
{
    public static $nativeMethods = [
        'modelList', // Api list
        'get', // Api get
        'post', // Api post
        'put', // Api put
        'delete', // Api delete
    ];

    const DTO_INTERFACE = '\\PSFS\\base\\dto\\Dto';
    const MODEL_INTERFACE = '\\Propel\\Runtime\\ActiveRecord\\ActiveRecordInterface';

    private $classes = [];


    /**
     * @Injectable
     * @var \PSFS\base\Router route
     */
    protected $route;


    /**
     * Method that extract all modules
     * @param string $requestModule
     * @return array
     */
    public function getModules($requestModule)
    {
        $modules = [];
        $domains = $this->route->getDomains();
        if (count($domains)) {
            foreach ($domains as $module => $info) {
                try {
                    $module = preg_replace('/(@|\/)/', '', $module);
                    if (!preg_match('/^ROOT/i', $module) && $module == $requestModule) {
                        $modules = [
                            'name' => $module,
                            'path' => realpath($info['template'] . DIRECTORY_SEPARATOR . '..'),
                        ];
                    }
                } catch (\Exception $e) {
                    $modules[] = $e->getMessage();
                }
            }
        }

        return $modules;
    }

    /**
     * Method that extract all endpoints for each module
     *
     * @param array $module
     *
     * @return array
     */
    public function extractApiEndpoints(array $module)
    {
        $module_path = $module['path'] . DIRECTORY_SEPARATOR . 'Api';
        $module_name = $module['name'];
        $endpoints = [];
        if (file_exists($module_path)) {
            $finder = new Finder();
            $finder->files()->in($module_path)->depth(0)->name('*.php');
            if (count($finder)) {
                /** @var \SplFileInfo $file */
                foreach ($finder as $file) {
                    $namespace = "\\{$module_name}\\Api\\" . str_replace('.php', '', $file->getFilename());
                    $info = $this->extractApiInfo($namespace, $module_name);
                    if (!empty($info)) {
                        $endpoints[$namespace] = $info;
                    }
                }
            }
        }
        return $endpoints;
    }

    /**
     * Method that extract all the endpoit information by reflection
     *
     * @param string $namespace
     * @param string $module
     * @return array
     */
    public function extractApiInfo($namespace, $module)
    {
        $info = [];
        if (Router::exists($namespace) && !I18nHelper::checkI18Class($namespace)) {
            $reflection = new \ReflectionClass($namespace);
            $visible = InjectorHelper::checkIsVisible($reflection->getDocComment());
            if($visible) {
                foreach ($reflection->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
                    try {
                        $mInfo = $this->extractMethodInfo($namespace, $method, $reflection, $module);
                        if (NULL !== $mInfo) {
                            $info[] = $mInfo;
                        }
                    } catch (\Exception $e) {
                        Logger::getInstance()->errorLog($e->getMessage());
                    }
                }
            }
        }
        return $info;
    }

    /**
     * Extract route from doc comments
     *
     * @param string $comments
     *
     * @return string
     */
    protected function extractRoute($comments = '')
    {
        $route = '';
        preg_match('/@route\ (.*)\n/i', $comments, $route);

        return $route[1];
    }

    /**
     * Extract api from doc comments
     *
     * @param string $comments
     *
     * @return string
     */
    protected function extractApi($comments = '')
    {
        $api = '';
        preg_match('/@api\ (.*)\n/i', $comments, $api);

        return $api[1];
    }

    /**
     * Extract api from doc comments
     *
     * @param string $comments
     *
     * @return boolean
     */
    protected function checkDeprecated($comments = '')
    {
        return false != preg_match('/@deprecated\n/i', $comments);
    }

    /**
     * Extract visibility from doc comments
     *
     * @param string $comments
     *
     * @return boolean
     */
    protected function extractVisibility($comments = '')
    {
        $visible = TRUE;
        preg_match('/@visible\ (true|false)\n/i', $comments, $visibility);
        if (count($visibility)) {
            $visible = !('false' == $visibility[1]);
        }

        return $visible;
    }

    /**
     * Method that extract the description for the endpoint
     *
     * @param string $comments
     *
     * @return string
     */
    protected function extractDescription($comments = '')
    {
        $description = '';
        $docs = explode("\n", $comments);
        if (count($docs)) {
            foreach ($docs as &$doc) {
                if (!preg_match('/(\*\*|\@)/i', $doc) && preg_match('/\*\ /i', $doc)) {
                    $doc = explode('* ', $doc);
                    $description = $doc[1];
                }
            }
        }

        return $description;
    }

    /**
     * Method that extract the type of a variable
     *
     * @param string $comments
     *
     * @return string
     */
    public static function extractVarType($comments = '')
    {
        $type = 'string';
        preg_match('/@var\ (.*) (.*)\n/i', $comments, $varType);
        if (count($varType)) {
            $aux = trim($varType[1]);
            $type = str_replace(' ', '', strlen($aux) > 0 ? $varType[1] : $varType[2]);
        }

        return $type;
    }

    /**
     * Method that extract the payload for the endpoint
     *
     * @param string $model
     * @param string $comments
     *
     * @return array

     */
    protected function extractPayload($model, $comments = '')
    {
        $payload = [];
        preg_match('/@payload\ (.*)\n/i', $comments, $doc);
        $isArray = false;
        if (count($doc)) {
            $namespace = str_replace('{__API__}', $model, $doc[1]);
            if (false !== strpos($namespace, '[') && false !== strpos($namespace, ']')) {
                $namespace = str_replace(']', '', str_replace('[', '', $namespace));
                $isArray = true;
            }
            $payload = $this->extractModelFields($namespace);
            $reflector = new \ReflectionClass($namespace);
            $namespace = $reflector->getShortName();
        } else {
            $namespace = $model;
        }

        return [$namespace, $payload, $isArray];
    }

    /**
     * Extract all the properties from Dto class
     *
     * @param string $class
     *
     * @return array
     */
    protected function extractDtoProperties($class)
    {
        $properties = [];
        $reflector = new \ReflectionClass($class);
        if ($reflector->isSubclassOf(self::DTO_INTERFACE)) {
            $properties = array_merge($properties, InjectorHelper::extractVariables($reflector));
        }

        return $properties;
    }

    /**
     * Extract return class for api endpoint
     *
     * @param string $model
     * @param string $comments
     *
     * @return string

     */
    protected function extractReturn($model, $comments = '')
    {
        $modelDto = [];
        preg_match('/\@return\ (.*)\((.*)\)\n/i', $comments, $returnTypes);
        if (count($returnTypes)) {
            // Extract principal DTO information
            if (array_key_exists(1, $returnTypes)) {
                $modelDto = $this->extractDtoProperties($returnTypes[1]);
            }
            if (array_key_exists(2, $returnTypes)) {
                $subDtos = preg_split('/,?\ /', str_replace('{__API__}', $model, $returnTypes[2]));
                if (count($subDtos)) {
                    foreach ($subDtos as $subDto) {
                        list($field, $dtoName) = explode('=', $subDto);
                        $isArray = false;
                        if (false !== strpos($dtoName, '[') && false !== strpos($dtoName, ']')) {
                            $dtoName = str_replace(']', '', str_replace('[', '', $dtoName));
                            $isArray = true;
                        }
                        $dto = $this->extractModelFields($dtoName);
                        $modelDto[$field] = ($isArray) ? [$dto] : $dto;
                        $modelDto['objects'][$dtoName] = $dto;
                        $modelDto = $this->checkDtoAttributes($dto, $modelDto, $dtoName);
                    }
                }
            }
        }

        return $modelDto;
    }

    /**
     * Extract all fields from a ActiveResource model
     *
     * @param string $namespace
     *
     * @return mixed
     */
    protected function extractModelFields($namespace)
    {
        $payload = [];
        try {
            $reflector = new \ReflectionClass($namespace);
            // Checks if reflector is a subclass of propel ActiveRecords
            if (NULL !== $reflector && $reflector->isSubclassOf(self::MODEL_INTERFACE)) {
                $tableMap = $namespace::TABLE_MAP;
                $tableMap = $tableMap::getTableMap();
                /** @var ColumnMap $field */
                foreach ($tableMap->getColumns() as $field) {
                    list($type, $format) = DocumentorHelper::translateSwaggerFormats($field->getType());
                    $info = [
                        "type" => $type,
                        "required" => $field->isNotNull(),
                        'format' => $format,
                    ];
                    if(count($field->getValueSet())) {
                        $info['enum'] = array_values($field->getValueSet());
                    }
                    if(null !== $field->getDefaultValue()) {
                        $info['default'] = $field->getDefaultValue();
                    }
                    $payload[$field->getPhpName()] = $info;
                }
            } elseif (null !== $reflector && $reflector->isSubclassOf(self::DTO_INTERFACE)) {
                $payload = $this->extractDtoProperties($namespace);
            }
        } catch (\Exception $e) {
            Logger::getInstance()->errorLog($e->getMessage());
        }

        return $payload;
    }

    /**
     * Method that extract all the needed info for each method in each API
     *
     * @param string $namespace
     * @param \ReflectionMethod $method
     * @param \ReflectionClass $reflection
     * @param string $module
     *
     * @return array
     */
    protected function extractMethodInfo($namespace, \ReflectionMethod $method, \ReflectionClass $reflection, $module)
    {
        $methodInfo = NULL;
        $docComments = $method->getDocComment();
        if (FALSE !== $docComments && preg_match('/\@route\ /i', $docComments)) {
            $api = self::extractApi($reflection->getDocComment());
            list($route, $info) = RouterHelper::extractRouteInfo($method, $api, $module);
            $route = explode('#|#', $route);
            $modelNamespace = str_replace('Api', 'Models', $namespace);
            if ($info['visible'] && !self::checkDeprecated($docComments)) {
                try {
                    $return = $this->extractReturn($modelNamespace, $docComments);
                    $url = array_pop($route);
                    $methodInfo = [
                        'url' => str_replace("/" . $module . "/api", '', $url),
                        'method' => $info['http'],
                        'description' => $info['label'],
                        'return' => $return,
                        'objects' => $return['objects'],
                        'class' => $reflection->getShortName(),
                    ];
                    unset($methodInfo['return']['objects']);
                    $this->setRequestParams($method, $methodInfo, $modelNamespace, $docComments);
                    $this->setQueryParams($method, $methodInfo);
                    $this->setRequestHeaders($reflection, $methodInfo);
                } catch (\Exception $e) {
                    Logger::getInstance()->errorLog($e->getMessage());
                }
            }
        }

        return $methodInfo;
    }

    /**
     * @return array
     */
    private static function swaggerResponses()
    {
        $codes = [200, 400, 404, 500];
        $responses = [];
        foreach ($codes as $code) {
            switch ($code) {
                default:
                case 200:
                    $message = _('Successful response');
                    break;
                case 400:
                    $message = _('Client error in request');
                    break;
                case 404:
                    $message = _('Service not found');
                    break;
                case 500:
                    $message = _('Server error');
                    break;
            }
            $responses[$code] = [
                'description' => $message,
                'schema' => [
                    'type' => 'object',
                    'properties' => [
                        'success' => [
                            'type' => 'boolean'
                        ],
                        'data' => [
                            'type' => 'boolean',
                        ],
                        'total' => [
                            'type' => 'integer',
                            'format' => 'int32',
                        ],
                        'pages' => [
                            'type' => 'integer',
                            'format' => 'int32',
                        ]
                    ]
                ]
            ];
        }
        return $responses;
    }

    /**
     * Method that export
     * @param array $module
     *
     * @return array

     */
    public static function swaggerFormatter(array $module)
    {
        $formatted = [
            "swagger" => "2.0",
            "host" => preg_replace('/^(http|https)\:\/\/(.*)\/$/i', '$2', Router::getInstance()->getRoute('', true)),
            "basePath" => '/' . $module['name'] . '/api',
            "schemes" => [Request::getInstance()->getServer('HTTPS') == 'on' ? "https" : "http"],
            "info" => [
                "title" => _('Documentación API módulo ') . $module['name'],
                "version" => Config::getParam('api.version', '1.0.0'),
                "contact" => [
                    "name" => Config::getParam("author", "Fran López"),
                    "email" => Config::getParam("author.email", "[email protected]"),
                ]
            ]
        ];
        $dtos = $paths = [];
        $endpoints = DocumentorService::getInstance()->extractApiEndpoints($module);
        foreach ($endpoints as $model) {
            foreach ($model as $endpoint) {
                if (!preg_match('/^\/(admin|api)\//i', $endpoint['url']) && strlen($endpoint['url'])) {
                    $url = preg_replace('/\/' . $module['name'] . '\/api/i', '', $endpoint['url']);
                    $description = $endpoint['description'];
                    $method = strtolower($endpoint['method']);
                    $paths[$url][$method] = [
                        'summary' => $description,
                        'produces' => ['application/json'],
                        'consumes' => ['application/json'],
                        'responses' => self::swaggerResponses(),
                        'parameters' => [],
                    ];
                    if (array_key_exists('parameters', $endpoint)) {
                        foreach ($endpoint['parameters'] as $parameter => $type) {
                            list($type, $format) = DocumentorHelper::translateSwaggerFormats($type);
                            $paths[$url][$method]['parameters'][] = [
                                'in' => 'path',
                                'required' => true,
                                'name' => $parameter,
                                'type' => $type,
                                'format' => $format,
                            ];
                        }
                    }
                    if (array_key_exists('query', $endpoint)) {
                        foreach ($endpoint['query'] as $query) {
                            $paths[$url][$method]['parameters'][] = $query;
                        }
                    }
                    if (array_key_exists('headers', $endpoint)) {
                        foreach ($endpoint['headers'] as $query) {
                            $paths[$url][$method]['parameters'][] = $query;
                        }
                    }
                    $isReturn = true;
                    foreach ($endpoint['objects'] as $name => $object) {
                        DocumentorHelper::parseObjects($paths, $dtos, $name, $endpoint, $object, $url, $method, $isReturn);

                        $isReturn = false;
                    }
                }
            }
        }
        ksort($dtos);
        uasort($paths, function($path1, $path2) {
            $key1 = array_keys($path1)[0];
            $key2 = array_keys($path2)[0];
            return strcmp($path1[$key1]['tags'][0], $path2[$key2]['tags'][0]);
        });
        $formatted['definitions'] = $dtos;
        $formatted['paths'] = $paths;
        return $formatted;
    }

    /**
     * Method that extract the Dto class for the api documentation
     * @param string $dto
     * @param boolean $isArray
     *
     * @return string
     */
    protected function extractDtoName($dto, $isArray = false)
    {
        $dto = explode('\\', $dto);
        $modelDto = array_pop($dto) . "Dto";
        if ($isArray) {
            $modelDto .= "List";
        }

        return $modelDto;
    }

    /**
     * @param \ReflectionMethod $method
     * @param $methodInfo
     */
    protected function setQueryParams(\ReflectionMethod $method, &$methodInfo)
    {
        if (in_array($methodInfo['method'], ['GET']) && in_array($method->getShortName(), self::$nativeMethods)) {
            $methodInfo['query'] = [];
            $methodInfo['query'][] = [
                "name" => "__limit",
                "in" => "query",
                "description" => _("Límite de registros a devolver, -1 para devolver todos los registros"),
                "required" => false,
                "type" => "integer",
            ];
            $methodInfo['query'][] = [
                "name" => "__page",
                "in" => "query",
                "description" => _("Página a devolver"),
                "required" => false,
                "type" => "integer",
            ];
            $methodInfo['query'][] = [
                "name" => "__fields",
                "in" => "query",
                "description" => _("Campos a devolver"),
                "required" => false,
                "type" => "array",
                "items" => [
                    "type" => "string",
                ]
            ];
        }
    }
    /**
     * @param \ReflectionClass $reflection
     * @param $methodInfo
     */
    protected function setRequestHeaders(\ReflectionClass $reflection, &$methodInfo)
    {

        $methodInfo['headers'] = [];
        foreach($reflection->getProperties() as $property) {
            $doc = $property->getDocComment();
            preg_match('/@header\ (.*)\n/i', $doc, $headers);
            if(count($headers)) {
                $header = [
                    "name" => $headers[1],
                    "in" => "header",
                    "required" => true,
                ];

                // Extract var type
                $header['type'] = $this->extractVarType($doc);

                // Extract description
                $header['description'] = InjectorHelper::getLabel($doc);

                // Extract default value
                $header['default'] = InjectorHelper::getDefaultValue($doc);

                $methodInfo['headers'][] = $header;
            }
        }
    }

    /**
     * @param \ReflectionMethod $method
     * @param array $methodInfo
     * @param string $modelNamespace
     * @param string $docComments
     */
    protected function setRequestParams(\ReflectionMethod $method, &$methodInfo, $modelNamespace, $docComments)
    {
        if (in_array($methodInfo['method'], ['POST', 'PUT'])) {
            list($payloadNamespace, $payloadDto, $isArray) = $this->extractPayload($modelNamespace, $docComments);
            if (count($payloadDto)) {
                $methodInfo['payload'] = [
                    'type' => $payloadNamespace,
                    'properties' => $payloadDto,
                    'is_array' => $isArray,
                ];
            }
        }
        if ($method->getNumberOfParameters() > 0) {
            $methodInfo['parameters'] = [];
            foreach ($method->getParameters() as $parameter) {
                $parameterName = $parameter->getName();
                $types = [];
                preg_match_all('/\@param\ (.*)\ \$' . $parameterName . '$/im', $docComments, $types);
                if (count($types) > 1) {
                    $methodInfo['parameters'][$parameterName] = $types[1][0];
                }
            }
        }
    }

    /**
     * @param $dto
     * @param $modelDto
     * @param $dtoName
     * @return array
     */
    protected function checkDtoAttributes($dto, $modelDto, $dtoName)
    {
        foreach ($dto as $param => &$info) {
            if (array_key_exists('class', $info)) {
                if ($info['is_array']) {
                    $modelDto['objects'][$dtoName][$param] = [
                        'type' => 'array',
                        'items' => [
                            '$ref' => '#/definitions/' . $info['shortName'],
                        ]
                    ];
                } else {
                    $modelDto['objects'][$dtoName][$param] = [
                        'type' => 'object',
                        '$ref' => '#/definitions/' . $info['shortName'],
                    ];
                }
                $modelDto['objects'][$info['class']] = $info['variables'];
                $paramDto = $this->checkDtoAttributes($info['variables'], $info['variables'], $info['class']);
                if(array_key_exists('objects', $paramDto)) {
                    $modelDto['objects'] = array_merge($modelDto['objects'], $paramDto['objects']);
                }
            } else {
                $modelDto['objects'][$dtoName][$param] = $info;
            }
        }
        return $modelDto;
    }
}


1		<?php
2
3		namespace PSFS\services;
4
5		use Propel\Runtime\Map\ColumnMap;
6		use PSFS\base\config\Config;
7		use PSFS\base\Logger;
8		use PSFS\base\Request;
9		use PSFS\base\Router;
10		use PSFS\base\Service;
11		use PSFS\base\types\helpers\DocumentorHelper;
12		use PSFS\base\types\helpers\GeneratorHelper;
13		use PSFS\base\types\helpers\I18nHelper;
14		use PSFS\base\types\helpers\InjectorHelper;
15		use PSFS\base\types\helpers\RouterHelper;
16		use Symfony\Component\Finder\Finder;
17
18		/**
19		* Class DocumentorService
20		* @package PSFS\services
21		*/
22		class DocumentorService extends Service
23		{
24		public static $nativeMethods = [
25		'modelList', // Api list
26		'get', // Api get
27		'post', // Api post
28		'put', // Api put
29		'delete', // Api delete
30		];
31
32		const DTO_INTERFACE = '\\PSFS\\base\\dto\\Dto';
33		const MODEL_INTERFACE = '\\Propel\\Runtime\\ActiveRecord\\ActiveRecordInterface';
34
35		private $classes = [];
		0 ignored issues – show Unused Code introduced 2017-09-16 06:27 UTC by Report Bug Copy Issue Report The property `$classes` is not used and could be removed. This check marks private properties in classes that are never used. Those properties can be removed. Loading history...
36
37		/**
38		* @Injectable
39		* @var \PSFS\base\Router route
40		*/
41		protected $route;
42
43
44		/**
45		* Method that extract all modules
46		* @param string $requestModule
47		* @return array
48		*/
49		public function getModules($requestModule)
50		{
51		$modules = [];
52		$domains = $this->route->getDomains();
53		if (count($domains)) {
54		foreach ($domains as $module => $info) {
55		try {
56		$module = preg_replace('/(@\|\/)/', '', $module);
57		if (!preg_match('/^ROOT/i', $module) && $module == $requestModule) {
58		$modules = [
59		'name' => $module,
60		'path' => realpath($info['template'] . DIRECTORY_SEPARATOR . '..'),
61		];
62		}
63		} catch (\Exception $e) {
64		$modules[] = $e->getMessage();
65		}
66		}
67		}
68
69		return $modules;
70		}
71
72		/**
73		* Method that extract all endpoints for each module
74		*
75		* @param array $module
76		*
77		* @return array
78		*/
79		public function extractApiEndpoints(array $module)
80		{
81		$module_path = $module['path'] . DIRECTORY_SEPARATOR . 'Api';
82		$module_name = $module['name'];
83		$endpoints = [];
84		if (file_exists($module_path)) {
85		$finder = new Finder();
86		$finder->files()->in($module_path)->depth(0)->name('*.php');
87		if (count($finder)) {
88		/** @var \SplFileInfo $file */
89		foreach ($finder as $file) {
90		$namespace = "\\{$module_name}\\Api\\" . str_replace('.php', '', $file->getFilename());
91		$info = $this->extractApiInfo($namespace, $module_name);
92		if (!empty($info)) {
93		$endpoints[$namespace] = $info;
94		}
95		}
96		}
97		}
98		return $endpoints;
99		}
100
101		/**
102		* Method that extract all the endpoit information by reflection
103		*
104		* @param string $namespace
105		* @param string $module
106		* @return array
107		*/
108		public function extractApiInfo($namespace, $module)
109		{
110		$info = [];
111		if (Router::exists($namespace) && !I18nHelper::checkI18Class($namespace)) {
112		$reflection = new \ReflectionClass($namespace);
113		$visible = InjectorHelper::checkIsVisible($reflection->getDocComment());
114		if($visible) {
115		foreach ($reflection->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
116		try {
117		$mInfo = $this->extractMethodInfo($namespace, $method, $reflection, $module);
118		if (NULL !== $mInfo) {
119		$info[] = $mInfo;
120		}
121		} catch (\Exception $e) {
122		Logger::getInstance()->errorLog($e->getMessage());
123		}
124		}
125		}
126		}
127		return $info;
128		}
129
130		/**
131		* Extract route from doc comments
132		*
133		* @param string $comments
134		*
135		* @return string
136		*/
137		protected function extractRoute($comments = '')
138		{
139		$route = '';
140		preg_match('/@route\ (.*)\n/i', $comments, $route);
141
142		return $route[1];
143		}
144
145		/**
146		* Extract api from doc comments
147		*
148		* @param string $comments
149		*
150		* @return string
151		*/
152		protected function extractApi($comments = '')
153		{
154		$api = '';
155		preg_match('/@api\ (.*)\n/i', $comments, $api);
156
157		return $api[1];
158		}
159
160		/**
161		* Extract api from doc comments
162		*
163		* @param string $comments
164		*
165		* @return boolean
166		*/
167		protected function checkDeprecated($comments = '')
168		{
169		return false != preg_match('/@deprecated\n/i', $comments);
170		}
171
172		/**
173		* Extract visibility from doc comments
174		*
175		* @param string $comments
176		*
177		* @return boolean
178		*/
179		protected function extractVisibility($comments = '')
180		{
181		$visible = TRUE;
182		preg_match('/@visible\ (true\|false)\n/i', $comments, $visibility);
183		if (count($visibility)) {
184		$visible = !('false' == $visibility[1]);
185		}
186
187		return $visible;
188		}
189
190		/**
191		* Method that extract the description for the endpoint
192		*
193		* @param string $comments
194		*
195		* @return string
196		*/
197		protected function extractDescription($comments = '')
198		{
199		$description = '';
200		$docs = explode("\n", $comments);
201		if (count($docs)) {
202		foreach ($docs as &$doc) {
203	View Code Duplication	if (!preg_match('/(\\\|\@)/i', $doc) && preg_match('/\*\ /i', $doc)) {
204		$doc = explode('* ', $doc);
205		$description = $doc[1];
206		}
207		}
208		}
209
210		return $description;
211		}
212
213		/**
214		* Method that extract the type of a variable
215		*
216		* @param string $comments
217		*
218		* @return string
219		*/
220		public static function extractVarType($comments = '')
221		{
222		$type = 'string';
223		preg_match('/@var\ (.) (.)\n/i', $comments, $varType);
224		if (count($varType)) {
225		$aux = trim($varType[1]);
226		$type = str_replace(' ', '', strlen($aux) > 0 ? $varType[1] : $varType[2]);
227		}
228
229		return $type;
230		}
231
232		/**
233		* Method that extract the payload for the endpoint
234		*
235		* @param string $model
236		* @param string $comments
237		*
238		* @return array
		0 ignored issues – show Documentation introduced 2017-10-11 23:16 UTC by Report Bug Copy Issue Report Consider making the return type a bit more specific; maybe use `array<string\|array\|boolean>`. This check looks for the generic type `array` as a return type and suggests a more specific type. This type is inferred from the actual code. Loading history...
239		*/
240		protected function extractPayload($model, $comments = '')
241		{
242		$payload = [];
243		preg_match('/@payload\ (.*)\n/i', $comments, $doc);
244		$isArray = false;
245		if (count($doc)) {
246		$namespace = str_replace('{__API__}', $model, $doc[1]);
247	View Code Duplication	if (false !== strpos($namespace, '[') && false !== strpos($namespace, ']')) {
248		$namespace = str_replace(']', '', str_replace('[', '', $namespace));
249		$isArray = true;
250		}
251		$payload = $this->extractModelFields($namespace);
252		$reflector = new \ReflectionClass($namespace);
253		$namespace = $reflector->getShortName();
254		} else {
255		$namespace = $model;
256		}
257
258		return [$namespace, $payload, $isArray];
259		}
260
261		/**
262		* Extract all the properties from Dto class
263		*
264		* @param string $class
265		*
266		* @return array
267		*/
268		protected function extractDtoProperties($class)
269		{
270		$properties = [];
271		$reflector = new \ReflectionClass($class);
272		if ($reflector->isSubclassOf(self::DTO_INTERFACE)) {
273		$properties = array_merge($properties, InjectorHelper::extractVariables($reflector));
274		}
275
276		return $properties;
277		}
278
279		/**
280		* Extract return class for api endpoint
281		*
282		* @param string $model
283		* @param string $comments
284		*
285		* @return string
		0 ignored issues – show Documentation introduced 2016-05-08 18:01 UTC by Report Bug Copy Issue Report Should the return type not be `array`? Also, consider making the array more specific, something like `array<String>`, or `String[]`. This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. If the return type contains the type array, this check recommends the use of a more specific type like `String[]` or `array<String>`. Loading history...
286		*/
287		protected function extractReturn($model, $comments = '')
288		{
289		$modelDto = [];
290		preg_match('/\@return\ (.)\((.)\)\n/i', $comments, $returnTypes);
291		if (count($returnTypes)) {
292		// Extract principal DTO information
293		if (array_key_exists(1, $returnTypes)) {
294		$modelDto = $this->extractDtoProperties($returnTypes[1]);
295		}
296		if (array_key_exists(2, $returnTypes)) {
297		$subDtos = preg_split('/,?\ /', str_replace('{__API__}', $model, $returnTypes[2]));
298		if (count($subDtos)) {
299		foreach ($subDtos as $subDto) {
300		list($field, $dtoName) = explode('=', $subDto);
301		$isArray = false;
302	View Code Duplication	if (false !== strpos($dtoName, '[') && false !== strpos($dtoName, ']')) {
303		$dtoName = str_replace(']', '', str_replace('[', '', $dtoName));
304		$isArray = true;
305		}
306		$dto = $this->extractModelFields($dtoName);
307		$modelDto[$field] = ($isArray) ? [$dto] : $dto;
308		$modelDto['objects'][$dtoName] = $dto;
309		$modelDto = $this->checkDtoAttributes($dto, $modelDto, $dtoName);
310		}
311		}
312		}
313		}
314
315		return $modelDto;
316		}
317
318		/**
319		* Extract all fields from a ActiveResource model
320		*
321		* @param string $namespace
322		*
323		* @return mixed
324		*/
325		protected function extractModelFields($namespace)
326		{
327		$payload = [];
328		try {
329		$reflector = new \ReflectionClass($namespace);
330		// Checks if reflector is a subclass of propel ActiveRecords
331		if (NULL !== $reflector && $reflector->isSubclassOf(self::MODEL_INTERFACE)) {
332		$tableMap = $namespace::TABLE_MAP;
333		$tableMap = $tableMap::getTableMap();
334		/** @var ColumnMap $field */
335		foreach ($tableMap->getColumns() as $field) {
336		list($type, $format) = DocumentorHelper::translateSwaggerFormats($field->getType());
337		$info = [
338		"type" => $type,
339		"required" => $field->isNotNull(),
340		'format' => $format,
341		];
342		if(count($field->getValueSet())) {
343		$info['enum'] = array_values($field->getValueSet());
344		}
345		if(null !== $field->getDefaultValue()) {
346		$info['default'] = $field->getDefaultValue();
347		}
348		$payload[$field->getPhpName()] = $info;
349		}
350		} elseif (null !== $reflector && $reflector->isSubclassOf(self::DTO_INTERFACE)) {
351		$payload = $this->extractDtoProperties($namespace);
352		}
353		} catch (\Exception $e) {
354		Logger::getInstance()->errorLog($e->getMessage());
355		}
356
357		return $payload;
358		}
359
360		/**
361		* Method that extract all the needed info for each method in each API
362		*
363		* @param string $namespace
364		* @param \ReflectionMethod $method
365		* @param \ReflectionClass $reflection
366		* @param string $module
367		*
368		* @return array
369		*/
370		protected function extractMethodInfo($namespace, \ReflectionMethod $method, \ReflectionClass $reflection, $module)
371		{
372		$methodInfo = NULL;
373		$docComments = $method->getDocComment();
374		if (FALSE !== $docComments && preg_match('/\@route\ /i', $docComments)) {
375		$api = self::extractApi($reflection->getDocComment());
376		list($route, $info) = RouterHelper::extractRouteInfo($method, $api, $module);
377		$route = explode('#\|#', $route);
378		$modelNamespace = str_replace('Api', 'Models', $namespace);
379		if ($info['visible'] && !self::checkDeprecated($docComments)) {
380		try {
381		$return = $this->extractReturn($modelNamespace, $docComments);
382		$url = array_pop($route);
383		$methodInfo = [
384		'url' => str_replace("/" . $module . "/api", '', $url),
385		'method' => $info['http'],
386		'description' => $info['label'],
387		'return' => $return,
388		'objects' => $return['objects'],
389		'class' => $reflection->getShortName(),
390		];
391		unset($methodInfo['return']['objects']);
392		$this->setRequestParams($method, $methodInfo, $modelNamespace, $docComments);
393		$this->setQueryParams($method, $methodInfo);
394		$this->setRequestHeaders($reflection, $methodInfo);
395		} catch (\Exception $e) {
396		Logger::getInstance()->errorLog($e->getMessage());
397		}
398		}
399		}
400
401		return $methodInfo;
402		}
403
404		/**
405		* @return array
406		*/
407		private static function swaggerResponses()
408		{
409		$codes = [200, 400, 404, 500];
410		$responses = [];
411		foreach ($codes as $code) {
412		switch ($code) {
413		default:
414		case 200:
415		$message = _('Successful response');
416		break;
417		case 400:
418		$message = _('Client error in request');
419		break;
420		case 404:
421		$message = _('Service not found');
422		break;
423		case 500:
424		$message = _('Server error');
425		break;
426		}
427		$responses[$code] = [
428		'description' => $message,
429		'schema' => [
430		'type' => 'object',
431		'properties' => [
432		'success' => [
433		'type' => 'boolean'
434		],
435		'data' => [
436		'type' => 'boolean',
437		],
438		'total' => [
439		'type' => 'integer',
440		'format' => 'int32',
441		],
442		'pages' => [
443		'type' => 'integer',
444		'format' => 'int32',
445		]
446		]
447		]
448		];
449		}
450		return $responses;
451		}
452
453		/**
454		* Method that export
455		* @param array $module
456		*
457		* @return array
		0 ignored issues – show Documentation introduced 2017-03-18 16:47 UTC by Report Bug Copy Issue Report Consider making the return type a bit more specific; maybe use `array<string,string\|array>`. This check looks for the generic type `array` as a return type and suggests a more specific type. This type is inferred from the actual code. Loading history...
458		*/
459		public static function swaggerFormatter(array $module)
460		{
461		$formatted = [
462		"swagger" => "2.0",
463		"host" => preg_replace('/^(http\|https)\:\/\/(.*)\/$/i', '$2', Router::getInstance()->getRoute('', true)),
464		"basePath" => '/' . $module['name'] . '/api',
465		"schemes" => [Request::getInstance()->getServer('HTTPS') == 'on' ? "https" : "http"],
466		"info" => [
467		"title" => _('Documentación API módulo ') . $module['name'],
468		"version" => Config::getParam('api.version', '1.0.0'),
469		"contact" => [
470		"name" => Config::getParam("author", "Fran López"),
471		"email" => Config::getParam("author.email", "[email protected]"),
472		]
473		]
474		];
475		$dtos = $paths = [];
476		$endpoints = DocumentorService::getInstance()->extractApiEndpoints($module);
477		foreach ($endpoints as $model) {
478		foreach ($model as $endpoint) {
479		if (!preg_match('/^\/(admin\|api)\//i', $endpoint['url']) && strlen($endpoint['url'])) {
480		$url = preg_replace('/\/' . $module['name'] . '\/api/i', '', $endpoint['url']);
481		$description = $endpoint['description'];
482		$method = strtolower($endpoint['method']);
483		$paths[$url][$method] = [
484		'summary' => $description,
485		'produces' => ['application/json'],
486		'consumes' => ['application/json'],
487		'responses' => self::swaggerResponses(),
488		'parameters' => [],
489		];
490		if (array_key_exists('parameters', $endpoint)) {
491		foreach ($endpoint['parameters'] as $parameter => $type) {
492		list($type, $format) = DocumentorHelper::translateSwaggerFormats($type);
493		$paths[$url][$method]['parameters'][] = [
494		'in' => 'path',
495		'required' => true,
496		'name' => $parameter,
497		'type' => $type,
498		'format' => $format,
499		];
500		}
501		}
502	View Code Duplication	if (array_key_exists('query', $endpoint)) {
503		foreach ($endpoint['query'] as $query) {
504		$paths[$url][$method]['parameters'][] = $query;
505		}
506		}
507	View Code Duplication	if (array_key_exists('headers', $endpoint)) {
508		foreach ($endpoint['headers'] as $query) {
509		$paths[$url][$method]['parameters'][] = $query;
510		}
511		}
512		$isReturn = true;
513		foreach ($endpoint['objects'] as $name => $object) {
514		DocumentorHelper::parseObjects($paths, $dtos, $name, $endpoint, $object, $url, $method, $isReturn);
		0 ignored issues – show Coding Style introduced 2017-10-15 23:33 UTC by Report Bug Copy Issue Report This line exceeds maximum limit of 120 characters; contains 123 characters Overly long lines are hard to read on any screen. Most code styles therefor impose a maximum limit on the number of characters in a line. Loading history...
515		$isReturn = false;
516		}
517		}
518		}
519		}
520		ksort($dtos);
521		uasort($paths, function($path1, $path2) {
522		$key1 = array_keys($path1)[0];
523		$key2 = array_keys($path2)[0];
524		return strcmp($path1[$key1]['tags'][0], $path2[$key2]['tags'][0]);
525		});
526		$formatted['definitions'] = $dtos;
527		$formatted['paths'] = $paths;
528		return $formatted;
529		}
530
531		/**
532		* Method that extract the Dto class for the api documentation
533		* @param string $dto
534		* @param boolean $isArray
535		*
536		* @return string
537		*/
538		protected function extractDtoName($dto, $isArray = false)
539		{
540		$dto = explode('\\', $dto);
541		$modelDto = array_pop($dto) . "Dto";
542		if ($isArray) {
543		$modelDto .= "List";
544		}
545
546		return $modelDto;
547		}
548
549		/**
550		* @param \ReflectionMethod $method
551		* @param $methodInfo
552		*/
553		protected function setQueryParams(\ReflectionMethod $method, &$methodInfo)
554		{
555		if (in_array($methodInfo['method'], ['GET']) && in_array($method->getShortName(), self::$nativeMethods)) {
556		$methodInfo['query'] = [];
557		$methodInfo['query'][] = [
558		"name" => "__limit",
559		"in" => "query",
560		"description" => _("Límite de registros a devolver, -1 para devolver todos los registros"),
561		"required" => false,
562		"type" => "integer",
563		];
564		$methodInfo['query'][] = [
565		"name" => "__page",
566		"in" => "query",
567		"description" => _("Página a devolver"),
568		"required" => false,
569		"type" => "integer",
570		];
571		$methodInfo['query'][] = [
572		"name" => "__fields",
573		"in" => "query",
574		"description" => _("Campos a devolver"),
575		"required" => false,
576		"type" => "array",
577		"items" => [
578		"type" => "string",
579		]
580		];
581		}
582		}
583		/**
584		* @param \ReflectionClass $reflection
585		* @param $methodInfo
586		*/
587		protected function setRequestHeaders(\ReflectionClass $reflection, &$methodInfo)
588		{
589
590		$methodInfo['headers'] = [];
591		foreach($reflection->getProperties() as $property) {
592		$doc = $property->getDocComment();
593		preg_match('/@header\ (.*)\n/i', $doc, $headers);
594		if(count($headers)) {
595		$header = [
596		"name" => $headers[1],
597		"in" => "header",
598		"required" => true,
599		];
600
601		// Extract var type
602		$header['type'] = $this->extractVarType($doc);
603
604		// Extract description
605		$header['description'] = InjectorHelper::getLabel($doc);
606
607		// Extract default value
608		$header['default'] = InjectorHelper::getDefaultValue($doc);
609
610		$methodInfo['headers'][] = $header;
611		}
612		}
613		}
614
615		/**
616		* @param \ReflectionMethod $method
617		* @param array $methodInfo
618		* @param string $modelNamespace
619		* @param string $docComments
620		*/
621		protected function setRequestParams(\ReflectionMethod $method, &$methodInfo, $modelNamespace, $docComments)
622		{
623		if (in_array($methodInfo['method'], ['POST', 'PUT'])) {
624		list($payloadNamespace, $payloadDto, $isArray) = $this->extractPayload($modelNamespace, $docComments);
625		if (count($payloadDto)) {
626		$methodInfo['payload'] = [
627		'type' => $payloadNamespace,
628		'properties' => $payloadDto,
629		'is_array' => $isArray,
630		];
631		}
632		}
633		if ($method->getNumberOfParameters() > 0) {
634		$methodInfo['parameters'] = [];
635		foreach ($method->getParameters() as $parameter) {
636		$parameterName = $parameter->getName();
637		$types = [];
638		preg_match_all('/\@param\ (.*)\ \$' . $parameterName . '$/im', $docComments, $types);
639		if (count($types) > 1) {
640		$methodInfo['parameters'][$parameterName] = $types[1][0];
641		}
642		}
643		}
644		}
645
646		/**
647		* @param $dto
648		* @param $modelDto
649		* @param $dtoName
650		* @return array
651		*/
652		protected function checkDtoAttributes($dto, $modelDto, $dtoName)
653		{
654		foreach ($dto as $param => &$info) {
655		if (array_key_exists('class', $info)) {
656		if ($info['is_array']) {
657		$modelDto['objects'][$dtoName][$param] = [
658		'type' => 'array',
659		'items' => [
660		'$ref' => '#/definitions/' . $info['shortName'],
661		]
662		];
663		} else {
664		$modelDto['objects'][$dtoName][$param] = [
665		'type' => 'object',
666		'$ref' => '#/definitions/' . $info['shortName'],
667		];
668		}
669		$modelDto['objects'][$info['class']] = $info['variables'];
670		$paramDto = $this->checkDtoAttributes($info['variables'], $info['variables'], $info['class']);
671		if(array_key_exists('objects', $paramDto)) {
672		$modelDto['objects'] = array_merge($modelDto['objects'], $paramDto['objects']);
673		}
674		} else {
675		$modelDto['objects'][$dtoName][$param] = $info;
676		}
677		}
678		return $modelDto;
679		}
680		}
681

psfs / core