352 lines
15 KiB
JavaScript
352 lines
15 KiB
JavaScript
import logUtil from '../utils/logUtil.js';
|
||
// 无需特殊处理的参数类型
|
||
let notNeedHandleTypeArr = ['file', 'string', 'integer', 'long', 'double', 'object', 'number', 'boolean', 'ref'];
|
||
|
||
/**
|
||
* openApi格式的参数解析参数解析
|
||
* @author 暮光：城中城
|
||
* @since 2017年5月7日
|
||
*/
|
||
export default {
|
||
/**
|
||
* 解析请求的参数
|
||
* @param parameters swagger.parameters
|
||
* @param definitionsDataMap 解析的path里对应的数据map，{url + "." + method: swagger.paths.post}
|
||
* @returns [] 参数列表：[{
|
||
* type: '',
|
||
* key: '',
|
||
* in: '',
|
||
* name: '',
|
||
* subType: '',
|
||
* required: '否',
|
||
* format: '',
|
||
* enum: '',
|
||
* example: '',
|
||
* collectionFormat: 'multi',
|
||
* description: '',
|
||
* additional: '',
|
||
* children: [],
|
||
* }]
|
||
*/
|
||
getRequestParamList(parameters, definitionsDataMap) {
|
||
if (!parameters) {
|
||
return [];
|
||
}
|
||
let indexKey = 1;
|
||
let requestParamList = [];
|
||
for (let i = 0; i < parameters.length; i++) {
|
||
let parameter = parameters[i];
|
||
let description = parameter.description || '';
|
||
let type = parameter.type;
|
||
let format = parameter.format;
|
||
let example = parameter['x-example'];
|
||
let subType = undefined;
|
||
let children = undefined;
|
||
let additional = undefined;
|
||
if (type === 'array') {
|
||
// 解析parameter.items.$ref 或 parameter.items.$ref {$ref: "#/definitions/Model"}
|
||
// 解析parameter.items.type {type: 'file'}
|
||
if (this.isSchemaRef(parameter.items)) {
|
||
subType = this.getSchemaRef(parameter.items);
|
||
children = this.getParamDefinitions(subType, definitionsDataMap, indexKey, {}, 0);
|
||
} else if (parameter.schema) {
|
||
if (this.isSchemaRef(parameter.schema.items)) {
|
||
subType = this.getSchemaRef(parameter.schema.items);
|
||
children = this.getParamDefinitions(subType, definitionsDataMap, indexKey, {}, 0);
|
||
} else if (parameter.schema.type) {
|
||
subType = parameter.schema.type;
|
||
}
|
||
} else if (parameter.items && parameter.items.type) {
|
||
subType = parameter.items.type;
|
||
} else {
|
||
logUtil.logMessage('001', type, parameter);
|
||
}
|
||
} else if (!type) {
|
||
if (parameter.schema) {
|
||
if (this.isSchemaRef(parameter.schema)) {
|
||
// 解析parameter.schema {$ref: "#/definitions/Model"}
|
||
type = this.getSchemaRef(parameter.schema);
|
||
children = this.getParamDefinitions(type, definitionsDataMap, indexKey, {}, 0);
|
||
} else if (parameter.schema.type) {
|
||
type = parameter.schema.type;
|
||
if (parameter.schema.additionalProperties) {
|
||
additional = {};
|
||
children = this.getAdditionalProperties(parameter.schema.additionalProperties, additional, definitionsDataMap, indexKey, {}, 0);
|
||
format = additional.type;
|
||
} else if (parameter.schema.items) {
|
||
if (this.isSchemaRef(parameter.schema.items)) {
|
||
subType = this.getSchemaRef(parameter.schema.items);
|
||
children = this.getParamDefinitions(subType, definitionsDataMap, indexKey, {}, 0);
|
||
} else if (parameter.schema.items.type) {
|
||
subType = parameter.schema.items.type;
|
||
} else {
|
||
logUtil.log('0014', type, parameter);
|
||
}
|
||
} else {
|
||
logUtil.log('0011', type, parameter);
|
||
}
|
||
} else {
|
||
logUtil.logMessage('0013', type, parameter);
|
||
}
|
||
} else if (parameter.items && parameter.items.type) {
|
||
// 解析parameter.items {type: "object", $ref: "#/definitions/Model"}
|
||
type = parameter.items.type;
|
||
if (parameter.items.additionalProperties) {
|
||
additional = {};
|
||
children = this.getAdditionalProperties(parameter.items.additionalProperties, additional, definitionsDataMap, indexKey, {}, 0);
|
||
format = additional.type;
|
||
} else {
|
||
logUtil.logMessage('0012', type, parameter);
|
||
}
|
||
} else {
|
||
logUtil.logMessage('002', type, parameter);
|
||
}
|
||
} else {
|
||
if (notNeedHandleTypeArr.indexOf(type) >= 0) {
|
||
// 无需特殊处理的类型
|
||
} else {
|
||
logUtil.logMessage('003', type, parameter);
|
||
}
|
||
}
|
||
if (example) {
|
||
description = description ? (description + '，') : '';
|
||
description += '例：' + example;
|
||
}
|
||
if (parameter.enum && parameter.enum.length > 0) {
|
||
description = description || '枚举类型';
|
||
description += '，可选值：' + parameter.enum.join('、');
|
||
}
|
||
requestParamList.push({
|
||
type: type,
|
||
key: indexKey,
|
||
in: parameter.in,
|
||
name: parameter.name,
|
||
subType: subType,
|
||
required: parameter.required ? '是' : '否',
|
||
format: format,
|
||
enum: parameter.enum,
|
||
example: example,
|
||
collectionFormat: parameter.collectionFormat,// 枚举多选时=multi
|
||
description: description,
|
||
additional: additional,
|
||
children: children,
|
||
});
|
||
indexKey++;
|
||
}
|
||
return requestParamList;
|
||
},
|
||
/**
|
||
* 解析请求返回的结果集
|
||
* @param responses swagger.parameters
|
||
* @param definitionsDataMap 解析的path里对应的数据map，{url + "." + method: swagger.paths.post}
|
||
* @returns [] 参数列表：[{
|
||
* code: '',
|
||
* type: '',
|
||
* key: '',
|
||
* desc: '',
|
||
* schemas: [],
|
||
* }]
|
||
*/
|
||
getResponseParamList(responses, definitionsDataMap) {
|
||
let responsesList = [];
|
||
let indexKey = 1;
|
||
Object.keys(responses).forEach(code => {
|
||
let codeResponses = responses[code];
|
||
let type = undefined;
|
||
let children = undefined;
|
||
if (this.isSchemaRef(codeResponses.schema)) {
|
||
type = this.getSchemaRef(codeResponses.schema);
|
||
children = this.getParamDefinitions(type, definitionsDataMap, indexKey, {}, 0);
|
||
}
|
||
responsesList.push({
|
||
code: code,
|
||
type: type,
|
||
key: indexKey,
|
||
desc: codeResponses.description,
|
||
schemas: children,
|
||
});
|
||
indexKey++;
|
||
});
|
||
return responsesList;
|
||
},
|
||
/**
|
||
* 判断是否包含$ref属性
|
||
* @param schema
|
||
* @returns {boolean}
|
||
*/
|
||
isSchemaRef(schema) {
|
||
return !!(schema && schema['$ref']);
|
||
},
|
||
/**
|
||
* 获取对象的$ref属性
|
||
* @param schema
|
||
* @returns {string}
|
||
*/
|
||
getSchemaRef(schema) {
|
||
if (schema['$ref'] && schema['$ref'].indexOf('#/definitions/') === 0) return schema['$ref'].replace('#/definitions/', '');
|
||
logUtil.logMessage('9467', '', schema);
|
||
return '';
|
||
},
|
||
/**
|
||
* 获取swagger.definitions里的对象信息
|
||
* @param ref 对象名
|
||
* @param definitionsDataMap 解析的path里对应的数据map，{url + "." + method: swagger.paths.post}
|
||
* @param indexKey 层级key
|
||
* @param parentRef 父级已用过的ref，防止无限递归
|
||
* @param deep 层级深度，大于10层则不再解析，防止层级太深或无线递归
|
||
* @returns {undefined|
|
||
* {
|
||
* type: '',
|
||
* name: '',
|
||
* key: '',
|
||
* subType: '',
|
||
* format: '',
|
||
* description: '',
|
||
* enum: '',
|
||
* additional: '',
|
||
* example: '',
|
||
* children: [],
|
||
* }
|
||
* }
|
||
*/
|
||
getParamDefinitions(ref, definitionsDataMap, indexKey, parentRef, deep) {
|
||
let definition = definitionsDataMap[ref];
|
||
// 层级大于5层 或者 没有类型定义
|
||
if (deep >= 10 || !definition) {
|
||
return undefined;
|
||
}
|
||
// 允许重复递归一次
|
||
parentRef[ref] = (parentRef[ref] || 0) + 1;
|
||
if (parentRef[ref] > 2) {
|
||
return undefined;
|
||
}
|
||
let paramList = [];
|
||
let type = definition.type;
|
||
let properties = definition.properties;
|
||
let indexSub = 1;
|
||
if (type === 'object' && properties) {
|
||
let currentLevelTypes = {};
|
||
Object.keys(properties).forEach(key => {
|
||
let parameter = properties[key];
|
||
let type = parameter.type;
|
||
let format = parameter.format;
|
||
let description = parameter.description || '';
|
||
let example = parameter['example'] || parameter['x-example'];
|
||
let subType = undefined;
|
||
let additional = undefined;
|
||
let enums = undefined;
|
||
let keySub = indexKey + '_' + indexSub;
|
||
let children = undefined;
|
||
// 把当前层级用过的类型清除，防止多个同类型在一层，后面的不能解析
|
||
Object.keys(currentLevelTypes).forEach(currentLevelType => {
|
||
parentRef[currentLevelType] = undefined;
|
||
});
|
||
if (type === 'array') {
|
||
// 解析parameter.items {$ref: "#/definitions/Model"}
|
||
if (this.isSchemaRef(parameter.items)) {
|
||
subType = this.getSchemaRef(parameter.items);
|
||
children = this.getParamDefinitions(subType, definitionsDataMap, keySub, parentRef, deep + 1);
|
||
} else if (parameter.items && parameter.items.type) {
|
||
subType = parameter.items.type;
|
||
} else {
|
||
logUtil.logMessage('004', type, parameter);
|
||
}
|
||
} else if (type === 'object') {
|
||
if (parameter.additionalProperties) {
|
||
additional = {};
|
||
children = this.getAdditionalProperties(parameter.additionalProperties, additional, definitionsDataMap, keySub, parentRef, deep + 1);
|
||
format = additional.type;
|
||
} else {
|
||
logUtil.log('0041', type, parameter);
|
||
}
|
||
} else if (!type) {
|
||
if (this.isSchemaRef(parameter)) {
|
||
type = this.getSchemaRef(parameter);
|
||
children = this.getParamDefinitions(type, definitionsDataMap, keySub, parentRef, deep + 1);
|
||
} else {
|
||
logUtil.logMessage('005', type, parameter);
|
||
}
|
||
} else {
|
||
if (notNeedHandleTypeArr.indexOf(type) >= 0) {
|
||
// 无需特殊处理的类型
|
||
} else {
|
||
logUtil.logMessage('006', type, parameter);
|
||
}
|
||
}
|
||
if (example) {
|
||
description = description ? (description + '，') : '';
|
||
description += '例：' + example;
|
||
}
|
||
if (parameter.items && parameter.items.enum && parameter.items.enum.length > 0) {
|
||
enums = parameter.items.enum;
|
||
description = description || '枚举类型';
|
||
description += '，可选值：' + parameter.items.enum.join('、');
|
||
}
|
||
paramList.push({
|
||
type: type,
|
||
name: key,
|
||
key: keySub,
|
||
subType: subType,
|
||
format: format,
|
||
description: description,
|
||
enum: enums,
|
||
additional: additional,
|
||
example: example,
|
||
children: children,
|
||
});
|
||
indexSub++;
|
||
currentLevelTypes[type] = 1;
|
||
});
|
||
}
|
||
return paramList.length > 0 ? paramList : undefined;
|
||
},
|
||
/**
|
||
* parameter.schema.additionalProperties 类型的参数值处理
|
||
* @param additionalProperties
|
||
* @param additional
|
||
* @param definitionsDataMap
|
||
* @param keySub
|
||
* @param parentRef
|
||
* @param deep
|
||
* @returns {
|
||
* undefined
|
||
* |{type: "", name: "", key: "", subType: "", format: "", description: "", enum: "", additional: "", example: "", children: *[]}
|
||
* |{}
|
||
* |{children: (undefined|{type: "", name: "", key: "", subType: "", format: "", description: "", enum: "", additional: "", example: "", children: *[]}), type: string}
|
||
* }
|
||
*/
|
||
getAdditionalProperties(additionalProperties, additional, definitionsDataMap, keySub, parentRef, deep) {
|
||
if (this.isSchemaRef(additionalProperties)) {
|
||
additional.type = this.getSchemaRef(additionalProperties);
|
||
additional.children = this.getParamDefinitions(additional.type, definitionsDataMap, keySub, parentRef, deep + 1);
|
||
return additional.additional;
|
||
} else if (additionalProperties.additionalProperties) {
|
||
additional.type = additionalProperties.type;
|
||
additional.additional = {};
|
||
return this.getAdditionalProperties(additionalProperties.additionalProperties, additional.additional, definitionsDataMap, keySub, parentRef, deep + 1);
|
||
} else if (additionalProperties.type === 'array') {
|
||
additional.type = additionalProperties.type;
|
||
if (this.isSchemaRef(additionalProperties.items)) {
|
||
let subType = this.getSchemaRef(additionalProperties.items);
|
||
let children = this.getParamDefinitions(subType, definitionsDataMap, keySub, parentRef, deep + 1);
|
||
additional.additional = {
|
||
type: subType,
|
||
children: children
|
||
};
|
||
return children;
|
||
} else {
|
||
logUtil.logMessage('007', '', additionalProperties);
|
||
}
|
||
} else {
|
||
additional.type = additionalProperties.type;
|
||
if (notNeedHandleTypeArr.indexOf(additional.type) >= 0) {
|
||
// 无需特殊处理的类型
|
||
} else {
|
||
logUtil.logMessage('008', '', additionalProperties);
|
||
}
|
||
}
|
||
return undefined;
|
||
},
|
||
}
|
||
|