663 lines
26 KiB
PHP
663 lines
26 KiB
PHP
<?php
|
||
declare(strict_types = 1);
|
||
|
||
namespace hg\apidoc\parseApi;
|
||
|
||
use Doctrine\Common\Annotations\AnnotationReader;
|
||
use hg\apidoc\Utils;
|
||
use ReflectionClass;
|
||
use Symfony\Component\ClassLoader\ClassMapGenerator;
|
||
use think\annotation\route\Resource;
|
||
use think\annotation\Route;
|
||
use hg\apidoc\annotation\Group;
|
||
use hg\apidoc\annotation\Sort;
|
||
use hg\apidoc\annotation\Param;
|
||
use hg\apidoc\annotation\Title;
|
||
use hg\apidoc\annotation\Desc;
|
||
use hg\apidoc\annotation\Author;
|
||
use hg\apidoc\annotation\Tag;
|
||
use hg\apidoc\annotation\Header;
|
||
use hg\apidoc\annotation\Returned;
|
||
use hg\apidoc\annotation\ParamType;
|
||
use hg\apidoc\annotation\Url;
|
||
use hg\apidoc\annotation\Method;
|
||
use think\annotation\route\Group as RouteGroup;
|
||
use think\facade\App;
|
||
use think\facade\Config;
|
||
|
||
class ParseAnnotation
|
||
{
|
||
|
||
protected $config = [];
|
||
|
||
protected $reader;
|
||
|
||
//tags，当前应用/版本所有的tag
|
||
protected $tags = array();
|
||
|
||
//groups,当前应用/版本的分组name
|
||
protected $groups = array();
|
||
|
||
protected $controller_layer = "";
|
||
|
||
public function __construct()
|
||
{
|
||
$this->reader = new AnnotationReader();
|
||
$this->config = Config::get('apidoc')?Config::get('apidoc'):Config::get('apidoc.');
|
||
$this->controller_layer = Config::get('route.controller_layer',"controller");
|
||
}
|
||
|
||
/**
|
||
* 生成api接口数据
|
||
* @param string $appKey
|
||
* @return array
|
||
*/
|
||
public function renderApiData(string $appKey): array
|
||
{
|
||
$config = $this->config;
|
||
$currentApps = (new Utils())->getCurrentApps($appKey);
|
||
$currentApp = $currentApps[count($currentApps) - 1];
|
||
|
||
if (!empty($config['controllers']) && count($config['controllers']) > 0) {
|
||
// 配置的控制器列表
|
||
$controllers = $this->getConfigControllers($currentApp['path']);
|
||
} else {
|
||
// 默认读取所有的
|
||
$controllers = $this->getDirControllers($currentApp['path']);
|
||
}
|
||
$apiData = [];
|
||
if (!empty($controllers) && count($controllers) > 0) {
|
||
foreach ($controllers as $class) {
|
||
$classData = $this->parseController($class);
|
||
if ($classData !== false) {
|
||
$apiData[] = $classData;
|
||
}
|
||
}
|
||
}
|
||
$json = array(
|
||
"data" => $apiData,
|
||
"tags" => $this->tags,
|
||
"groups" => $this->groups
|
||
);
|
||
return $json;
|
||
}
|
||
|
||
/**
|
||
* 获取生成文档的控制器列表
|
||
* @param string $path
|
||
* @return array
|
||
*/
|
||
protected function getConfigControllers(string $path): array
|
||
{
|
||
$config = $this->config;
|
||
$controllers = [];
|
||
|
||
$configControllers = $config['controllers'];
|
||
if (!empty($configControllers) && count($configControllers) > 0) {
|
||
foreach ($configControllers as $item) {
|
||
if ( strpos($item, $path) !== false && class_exists($item)) {
|
||
$controllers[] = $item;
|
||
}
|
||
}
|
||
}
|
||
return $controllers;
|
||
}
|
||
|
||
/**
|
||
* 获取目录下的控制器列表
|
||
* @param string $path
|
||
* @return array
|
||
*/
|
||
protected function getDirControllers(string $path): array
|
||
{
|
||
if ($path) {
|
||
if (strpos(App::getRootPath(), '/') !== false) {
|
||
$pathStr = str_replace("\\", "/", $path);
|
||
} else {
|
||
$pathStr = $path;
|
||
}
|
||
$dir = App::getRootPath() . $pathStr;
|
||
} else {
|
||
$dir = App::getRootPath() . $this->controller_layer;
|
||
}
|
||
$controllers = [];
|
||
if (is_dir($dir)) {
|
||
$controllers = $this->scanDir($dir, $path);
|
||
}
|
||
return $controllers;
|
||
}
|
||
|
||
/**
|
||
* 处理指定目录下的控制器
|
||
* @param string $dir
|
||
* @param string $appPath
|
||
* @return array
|
||
*/
|
||
protected function scanDir(string $dir, string $appPath): array
|
||
{
|
||
$list = [];
|
||
foreach (ClassMapGenerator::createMap($dir) as $class => $path) {
|
||
if (
|
||
!isset($this->config['filter_controllers']) ||
|
||
(isset($this->config['filter_controllers']) && !in_array($class, $this->config['filter_controllers'])) &&
|
||
$this->config['definitions'] != $class
|
||
) {
|
||
if (strpos($class, '\\') === false) {
|
||
$list[] = $appPath . "\\" . $class;
|
||
} else {
|
||
$list[] = $class;
|
||
}
|
||
}
|
||
}
|
||
return $list;
|
||
}
|
||
|
||
protected function parseController($class)
|
||
{
|
||
$config = $this->config;
|
||
$data = [];
|
||
$refClass = new ReflectionClass($class);
|
||
$classTextAnnotations = $this->parseTextAnnotation($refClass);
|
||
if (in_array("NotParse", $classTextAnnotations)) {
|
||
return false;
|
||
}
|
||
$title = $this->reader->getClassAnnotation($refClass, Title::class);
|
||
$group = $this->reader->getClassAnnotation($refClass, Group::class);
|
||
$sort = $this->reader->getClassAnnotation($refClass, Sort::class);
|
||
|
||
$routeGroup = $this->reader->getClassAnnotation($refClass, RouteGroup::class);
|
||
$controllersNameArr = explode("\\", $class);
|
||
$controllersName = $controllersNameArr[count($controllersNameArr) - 1];
|
||
$data['controller'] = $controllersName;
|
||
$data['group'] = !empty($group->value) ? $group->value : null;
|
||
$data['sort'] = !empty($sort->value) ? $sort->value : null;
|
||
if (!empty($data['group']) && !in_array($data['group'], $this->groups)) {
|
||
$this->groups[] = $data['group'];
|
||
}
|
||
$data['title'] = !empty($title) && !empty($title->value) ? $title->value : "";
|
||
|
||
if (empty($title)) {
|
||
if (!empty($classTextAnnotations) && count($classTextAnnotations) > 0) {
|
||
$data['title'] = $classTextAnnotations[0];
|
||
} else {
|
||
$data['title'] = $controllersName;
|
||
}
|
||
}
|
||
$methodList = [];
|
||
$filter_method = !empty($config['filter_method']) ? $config['filter_method'] : [];
|
||
$data['menu_key'] = $data['controller'] . "_" . mt_rand(10000, 99999);
|
||
|
||
foreach ($refClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $refMethod) {
|
||
if (!empty($refMethod->name) && !in_array($refMethod->name, $filter_method)) {
|
||
$methodItem = $this->parseAnnotation($refMethod, true,"controller");
|
||
if (!count((array)$methodItem)) {
|
||
continue;
|
||
}
|
||
$textAnnotations = $this->parseTextAnnotation($refMethod);
|
||
// 标注不解析的方法
|
||
if (in_array("NotParse", $textAnnotations)) {
|
||
continue;
|
||
}
|
||
// 无标题，且有文本注释
|
||
if (empty($methodItem['title']) && !empty($textAnnotations) && count($textAnnotations) > 0) {
|
||
$methodItem['title'] = $textAnnotations[0];
|
||
}
|
||
// 添加统一headers请求头参数
|
||
if (!empty($config['headers']) && !in_array("NotHeaders", $textAnnotations)) {
|
||
if (!empty($methodItem['header'])) {
|
||
$methodItem['header'] = Utils::arrayMergeAndUnique("name", $config['headers'], $methodItem['header']);
|
||
} else {
|
||
$methodItem['header'] = $config['headers'];
|
||
}
|
||
}
|
||
// 添加统一params请求参数
|
||
if (!empty($config['parameters']) && !in_array("NotParameters", $textAnnotations)) {
|
||
if (!empty($methodItem['param'])) {
|
||
$methodItem['param'] = Utils::arrayMergeAndUnique("name", $config['parameters'], $methodItem['param']);
|
||
} else {
|
||
$methodItem['param'] = $config['parameters'];
|
||
}
|
||
}
|
||
// 添加responses统一响应体
|
||
if (
|
||
!empty($config['responses']) &&
|
||
!is_string($config['responses']) &&
|
||
!in_array("NotResponses", $textAnnotations)
|
||
) {
|
||
// 显示在响应体中
|
||
$returned = [];
|
||
$hasMian = false;
|
||
if (isset($config['responses']['data']) && !$config['responses']['show_responses']) {
|
||
$responsesData = [];
|
||
} else if (isset($config['responses']['data']) && $config['responses']['show_responses'] === true) {
|
||
$responsesData = $config['responses']['data'];
|
||
} else {
|
||
$responsesData = $config['responses'];
|
||
}
|
||
// 合并统一响应体及响应参数相同的字段
|
||
$returnData = [];
|
||
$resKeys = [];
|
||
foreach ($responsesData as $resItem) {
|
||
$resKeys[]=$resItem['name'];
|
||
}
|
||
foreach ($methodItem['return'] as $returnItem){
|
||
if (!(in_array($returnItem['name'],$resKeys) && $returnItem['source']==='controller' && !empty($returnItem['replaceGlobal']))){
|
||
$returnData[]=$returnItem;
|
||
}
|
||
}
|
||
|
||
foreach ($responsesData as $resItem) {
|
||
$resData = $resItem;
|
||
$globalFind = Utils::getArrayFind($methodItem['return'],function ($item)use ($resItem){
|
||
if ($item['name'] == $resItem['name'] && $item['source']==='controller' && !empty($item['replaceGlobal'])){
|
||
return true;
|
||
}
|
||
return false;
|
||
});
|
||
if (!empty($globalFind)){
|
||
$resData = array_merge($resItem,$globalFind);
|
||
}else if (!empty($resData['main']) && $resData['main'] === true) {
|
||
$resData['params'] = $returnData;
|
||
|
||
$resData['resKeys']=$resKeys;
|
||
$hasMian = true;
|
||
}
|
||
$resData['find'] =$globalFind;
|
||
$returned[] = $resData;
|
||
}
|
||
if (!$hasMian) {
|
||
$returned = Utils::arrayMergeAndUnique("name", $returned, $methodItem['return']);
|
||
}
|
||
$methodItem['return'] = $returned;
|
||
}
|
||
// 默认method
|
||
if (empty($methodItem['method'])) {
|
||
$methodItem['method'] = !empty($config['default_method']) ? $config['default_method'] : 'GET';
|
||
}
|
||
// 默认default_author
|
||
if (empty($methodItem['author']) && !empty($config['default_author']) && !in_array("NotDefaultAuthor", $textAnnotations)) {
|
||
$methodItem['author'] = $config['default_author'];
|
||
}
|
||
|
||
// Tags
|
||
if (!empty($methodItem['tag'])) {
|
||
if (strpos($methodItem['tag'], ' ') !== false) {
|
||
$tagArr = explode(" ", $methodItem['tag']);
|
||
foreach ($tagArr as $tag) {
|
||
if (!in_array($tag, $this->tags)) {
|
||
$this->tags[] = $tag;
|
||
}
|
||
}
|
||
} else if (!in_array($methodItem['tag'], $this->tags)) {
|
||
$this->tags[] = $methodItem['tag'];
|
||
}
|
||
}
|
||
|
||
// 无url,自动生成
|
||
if (empty($methodItem['url'])) {
|
||
$methodItem['url'] = $this->autoCreateUrl($refMethod);
|
||
} else if (!empty($routeGroup->value)) {
|
||
// 路由分组，url加上分组
|
||
$methodItem['url'] = '/' . $routeGroup->value . '/' . $methodItem['url'];
|
||
}
|
||
if (!empty($methodItem['url']) && substr($methodItem['url'], 0, 1) != "/") {
|
||
$methodItem['url'] = "/" . $methodItem['url'];
|
||
}
|
||
$methodItem['name'] = $refMethod->name;
|
||
$methodItem['menu_key'] = $methodItem['method'] . "_" . $refMethod->name . "_" . mt_rand(10000, 99999);
|
||
|
||
$methodList[] = $methodItem;
|
||
|
||
}
|
||
|
||
}
|
||
$data['children'] = $methodList;
|
||
return $data;
|
||
}
|
||
|
||
/**
|
||
* 自动生成url
|
||
* @param $method
|
||
* @return string
|
||
*/
|
||
protected function autoCreateUrl($method): string
|
||
{
|
||
if (Config::get("controller_auto_search") || !empty($this->config['controller_auto_search'])){
|
||
$pathArr = explode("\\", $method->class );
|
||
}else{
|
||
$searchString = $this->controller_layer . '\\';
|
||
$substr = substr(strstr($method->class, $searchString), strlen($searchString));
|
||
$pathArr = explode("\\", str_replace($substr, str_replace('\\', '.', $substr), $method->class));
|
||
}
|
||
// 控制器地址
|
||
$filterPathNames = array(App::getNamespace(), $this->controller_layer);
|
||
$classPathArr = [];
|
||
foreach ($pathArr as $item) {
|
||
if (!in_array($item, $filterPathNames)) {
|
||
if (!empty($this->config['auto_url_rule'])){
|
||
switch ($this->config['auto_url_rule']) {
|
||
case 'lcfirst':
|
||
$classPathArr[] = lcfirst($item);
|
||
break;
|
||
case 'ucfirst':
|
||
$classPathArr[] = ucfirst($item);
|
||
break;
|
||
default:
|
||
$classPathArr[] = $item;
|
||
}
|
||
}else{
|
||
$classPathArr[] = $item;
|
||
}
|
||
}
|
||
}
|
||
$classPath = implode('/', $classPathArr);
|
||
return '/' . $classPath . '/' . $method->name;
|
||
}
|
||
|
||
/**
|
||
* ref引用
|
||
* @param $refPath
|
||
* @param bool $enableRefService
|
||
* @return false|string[]
|
||
*/
|
||
protected function renderRef(string $refPath, bool $enableRefService = true): array
|
||
{
|
||
$res = ['type' => 'model'];
|
||
// 通用定义引入
|
||
if (strpos($refPath, '\\') === false) {
|
||
$config = $this->config;
|
||
$refPath = $config['definitions'] . '\\' . $refPath;
|
||
$data = $this->renderService($refPath);
|
||
$res['type'] = "service";
|
||
$res['data'] = $data;
|
||
return $res;
|
||
}
|
||
// 模型引入
|
||
$modelData = (new ParseModel($this->reader))->renderModel($refPath);
|
||
if ($modelData !== false) {
|
||
$res['data'] = $modelData;
|
||
return $res;
|
||
}
|
||
if ($enableRefService === false) {
|
||
return false;
|
||
}
|
||
$data = $this->renderService($refPath);
|
||
$res['type'] = "service";
|
||
$res['data'] = $data;
|
||
return $res;
|
||
}
|
||
|
||
/**
|
||
* 解析注释引用
|
||
* @param $refPath
|
||
* @return array
|
||
* @throws \ReflectionException
|
||
*/
|
||
protected function renderService(string $refPath)
|
||
{
|
||
$pathArr = explode("\\", $refPath);
|
||
$methodName = $pathArr[count($pathArr) - 1];
|
||
unset($pathArr[count($pathArr) - 1]);
|
||
$classPath = implode("\\", $pathArr);
|
||
$classReflect = new \ReflectionClass($classPath);
|
||
$methodName = trim($methodName);
|
||
$refMethod = $classReflect->getMethod($methodName);
|
||
$res = $this->parseAnnotation($refMethod, true);
|
||
return $res;
|
||
}
|
||
|
||
/**
|
||
* 处理Param/Returned的字段名name、params子级参数
|
||
* @param $values
|
||
* @return array
|
||
*/
|
||
protected function handleParamValue($values, string $field = 'param'): array
|
||
{
|
||
$name = "";
|
||
$params = [];
|
||
if (!empty($values) && is_array($values) && count($values) > 0) {
|
||
foreach ($values as $item) {
|
||
if (is_string($item)) {
|
||
$name = $item;
|
||
} else if (is_object($item)) {
|
||
if (!empty($item->ref)) {
|
||
$refRes = $this->renderRef($item->ref, true);
|
||
$params = $this->handleRefData($params, $refRes, $item, $field);
|
||
} else {
|
||
$param = [
|
||
"name" => "",
|
||
"type" => $item->type,
|
||
"desc" => $item->desc,
|
||
"default" => $item->default,
|
||
"require" => $item->require,
|
||
"childrenType"=> $item->childrenType
|
||
];
|
||
$children = $this->handleParamValue($item->value);
|
||
$param['name'] = $children['name'];
|
||
if (count($children['params']) > 0) {
|
||
$param['params'] = $children['params'];
|
||
}
|
||
$params[] = $param;
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
$name = $values;
|
||
}
|
||
return ['name' => $name, 'params' => $params];
|
||
}
|
||
|
||
/**
|
||
* 解析方法注释
|
||
* @param $refMethod
|
||
* @param bool $enableRefService 是否终止service的引入
|
||
* @param string $source 注解来源
|
||
* @return array
|
||
*/
|
||
protected function parseAnnotation($refMethod, bool $enableRefService = true,$source=""): array
|
||
{
|
||
$data = [];
|
||
if ($annotations = $this->reader->getMethodAnnotations($refMethod)) {
|
||
$headers = [];
|
||
$params = [];
|
||
$returns = [];
|
||
|
||
foreach ($annotations as $annotation) {
|
||
switch (true) {
|
||
case $annotation instanceof Param:
|
||
$params = $this->handleParamAndReturned($params,$annotation,'param',$enableRefService);
|
||
break;
|
||
case $annotation instanceof Returned:
|
||
|
||
$returns = $this->handleParamAndReturned($returns,$annotation,'return',$enableRefService,$source);
|
||
break;
|
||
case $annotation instanceof Header:
|
||
if (!empty($annotation->ref)) {
|
||
$refRes = $this->renderRef($annotation->ref, $enableRefService);
|
||
$headers = $this->handleRefData($headers, $refRes, $annotation, 'header');
|
||
} else {
|
||
$param = [
|
||
"name" => $annotation->value,
|
||
"desc" => $annotation->desc,
|
||
"require" => $annotation->require,
|
||
"type" => $annotation->type,
|
||
"default" => $annotation->default,
|
||
];
|
||
$headers[] = $param;
|
||
}
|
||
break;
|
||
case $annotation instanceof Route:
|
||
if (empty($data['method'])) {
|
||
$data['method'] = $annotation->method;
|
||
}
|
||
if (empty($data['url'])) {
|
||
$data['url'] = $annotation->value;
|
||
}
|
||
break;
|
||
case $annotation instanceof Author:
|
||
$data['author'] = $annotation->value;
|
||
break;
|
||
|
||
case $annotation instanceof Title:
|
||
$data['title'] = $annotation->value;
|
||
break;
|
||
case $annotation instanceof Desc:
|
||
$data['desc'] = $annotation->value;
|
||
break;
|
||
case $annotation instanceof ParamType:
|
||
$data['paramType'] = $annotation->value;
|
||
break;
|
||
case $annotation instanceof Url:
|
||
$data['url'] = $annotation->value;
|
||
break;
|
||
case $annotation instanceof Method:
|
||
$data['method'] = $annotation->value;
|
||
break;
|
||
case $annotation instanceof Tag:
|
||
$data['tag'] = $annotation->value;
|
||
break;
|
||
}
|
||
}
|
||
if ($headers && count($headers) > 0) {
|
||
$data['header'] = $headers;
|
||
}
|
||
$data['param'] = $params;
|
||
$data['return'] = $returns;
|
||
}
|
||
return $data;
|
||
}
|
||
|
||
|
||
/**
|
||
* 处理请求参数与返回参数
|
||
* @param $params
|
||
* @param $annotation
|
||
* @param string $type
|
||
* @param false $enableRefService
|
||
* @param string $source 注解来源
|
||
* @return array
|
||
*/
|
||
protected function handleParamAndReturned($params,$annotation,$type="param",$enableRefService=false,$source=""){
|
||
if (!empty($annotation->ref)) {
|
||
$refRes = $this->renderRef($annotation->ref, $enableRefService);
|
||
$params = $this->handleRefData($params, $refRes, $annotation, $type,$source);
|
||
} else {
|
||
$param = [
|
||
"name" => "",
|
||
"type" => $annotation->type,
|
||
"desc" => $annotation->desc,
|
||
"default" => $annotation->default,
|
||
"require" => $annotation->require,
|
||
"childrenType" => $annotation->childrenType,
|
||
"source" => $source,
|
||
"replaceGlobal" =>!empty($annotation->replaceGlobal)?$annotation->replaceGlobal:""
|
||
];
|
||
$children = $this->handleParamValue($annotation->value, $type);
|
||
$param['name'] = $children['name'];
|
||
if (count($children['params']) > 0) {
|
||
$param['params'] = $children['params'];
|
||
if ($annotation->type === 'tree' && !empty($annotation->childrenField)) {
|
||
// 类型为tree的
|
||
$param['params'][] = [
|
||
'params' => $children['params'],
|
||
'name' => $annotation->childrenField,
|
||
'type' => 'array',
|
||
'desc' => $annotation->childrenDesc,
|
||
];
|
||
}
|
||
}
|
||
// 合并同级已有的字段
|
||
$params = Utils::arrayMergeAndUnique("name", $params, [$param]);
|
||
}
|
||
return $params;
|
||
}
|
||
|
||
/**
|
||
* 解析非注解文本注释
|
||
* @param $refMethod
|
||
* @return array|false
|
||
*/
|
||
protected function parseTextAnnotation($refMethod): array
|
||
{
|
||
$annotation = $refMethod->getDocComment();
|
||
if (empty($annotation)) {
|
||
return [];
|
||
}
|
||
if (preg_match('#^/\*\*(.*)\*/#s', $annotation, $comment) === false)
|
||
return [];
|
||
$comment = trim($comment [1]);
|
||
if (preg_match_all('#^\s*\*(.*)#m', $comment, $lines) === false)
|
||
return [];
|
||
$data = [];
|
||
foreach ($lines[1] as $line) {
|
||
$line = trim($line);
|
||
if (!empty ($line) && strpos($line, '@') !== 0) {
|
||
$data[] = $line;
|
||
}
|
||
}
|
||
return $data;
|
||
}
|
||
|
||
|
||
/**
|
||
* 处理param、returned 参数
|
||
* @param $params
|
||
* @param $refRes
|
||
* @param $annotation
|
||
* @param string|null $source 注解来源
|
||
* @return array
|
||
*/
|
||
protected function handleRefData($params, $refRes, $annotation, string $field,$source=""): array
|
||
{
|
||
if ($refRes['type'] === "model" && count($refRes['data']) > 0) {
|
||
// 模型引入
|
||
$data = $refRes['data'];
|
||
} else if ($refRes['type'] === "service" && !empty($refRes['data']) && !empty($refRes['data'][$field])) {
|
||
// service引入
|
||
$data = $refRes['data'][$field];
|
||
} else {
|
||
return $params;
|
||
}
|
||
// 过滤field
|
||
if (!empty($annotation->field)) {
|
||
$data = (new Utils())->filterParamsField($data, $annotation->field, 'field');
|
||
}
|
||
// 过滤withoutField
|
||
if (!empty($annotation->withoutField)) {
|
||
$data = (new Utils())->filterParamsField($data, $annotation->withoutField, 'withoutField');
|
||
}
|
||
|
||
if (!empty($annotation->value)) {
|
||
$item = [
|
||
'name' => $annotation->value,
|
||
'desc' => $annotation->desc,
|
||
'type' => $annotation->type,
|
||
'require' => $annotation->require,
|
||
'default' => $annotation->default,
|
||
'params' => $data,
|
||
'source'=>$source,
|
||
"replaceGlobal" =>!empty($annotation->replaceGlobal)?$annotation->replaceGlobal:""
|
||
];
|
||
$children = $this->handleParamValue($annotation->value, 'param');
|
||
$item['name'] = $children['name'];
|
||
if (count($children['params']) > 0) {
|
||
$item['params'] = Utils::arrayMergeAndUnique("name",$data,$children['params']);
|
||
if ($annotation->type === 'tree' && !empty($annotation->childrenField)) {
|
||
// 类型为tree的
|
||
$item['params'][] = [
|
||
'params' => $item['params'],
|
||
'name' => $annotation->childrenField,
|
||
'type' => 'array',
|
||
'desc' => $annotation->childrenDesc,
|
||
];
|
||
}
|
||
}
|
||
$params[] = $item;
|
||
|
||
|
||
} else {
|
||
$params = array_merge($params, $data);
|
||
}
|
||
return $params;
|
||
}
|
||
} |