255 lines
12 KiB
JavaScript
255 lines
12 KiB
JavaScript
import {message} from 'ant-design-vue';
|
|
// 无需特殊处理的参数类型
|
|
let notNeedHandleTypeArr = ['file', 'string', 'integer', 'long', 'double', 'object', 'number', 'boolean', 'ref'];
|
|
/**
|
|
* 参数解析
|
|
* @author 暮光：城中城
|
|
* @since 2017年5月7日
|
|
*/
|
|
export default {
|
|
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 subType = undefined;
|
|
let children = undefined;
|
|
let additional = undefined;
|
|
if (type === 'array') {
|
|
// 解析parameter.items.$ref 或 parameter.items.originalRef {$ref: "#/definitions/Model", originalRef: "Model"}
|
|
// 解析parameter.items.type {type: 'file'}
|
|
if (parameter.items && parameter.items.originalRef) {
|
|
children = this.getParamDefinitions(parameter.items.originalRef, definitionsDataMap, indexKey, {}, 0);
|
|
} else if (parameter.schema) {
|
|
if (parameter.schema.items && parameter.schema.items.originalRef) {
|
|
children = this.getParamDefinitions(parameter.schema.items.originalRef, definitionsDataMap, indexKey, {}, 0);
|
|
} else if (parameter.schema.type) {
|
|
subType = parameter.schema.type;
|
|
}
|
|
} else if (parameter.items && parameter.items.type) {
|
|
subType = parameter.items.type;
|
|
} else {
|
|
this.logMessage('001', type, parameter);
|
|
}
|
|
} else if (!type) {
|
|
if (parameter.schema) {
|
|
if (parameter.schema.originalRef) {
|
|
// 解析parameter.schema {originalRef: "Model", $ref: "#/definitions/Model"}
|
|
type = parameter.schema.originalRef;
|
|
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 (parameter.schema.items.originalRef) {
|
|
children = this.getParamDefinitions(parameter.schema.items.originalRef, definitionsDataMap, indexKey, {}, 0);
|
|
} else if (parameter.schema.items.type) {
|
|
subType = parameter.schema.items.type;
|
|
} else {
|
|
this.log('0014', type, parameter);
|
|
}
|
|
} else {
|
|
this.log('0011', type, parameter);
|
|
}
|
|
} else {
|
|
this.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 {
|
|
this.logMessage('0012', type, parameter);
|
|
}
|
|
} else {
|
|
this.logMessage('002', type, parameter);
|
|
}
|
|
} else {
|
|
if (notNeedHandleTypeArr.indexOf(type) >= 0) {
|
|
// 无需特殊处理的类型
|
|
} else {
|
|
this.logMessage('003', type, parameter);
|
|
}
|
|
}
|
|
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,
|
|
collectionFormat: parameter.collectionFormat,// 枚举多选时=multi
|
|
description: description,
|
|
additional: additional,
|
|
children: children,
|
|
});
|
|
indexKey++;
|
|
}
|
|
return requestParamList;
|
|
},
|
|
getResponseParamList(responses, definitionsDataMap) {
|
|
let responsesList = [];
|
|
let indexKey = 1;
|
|
Object.keys(responses).forEach(code => {
|
|
let codeResponses = responses[code];
|
|
let type = undefined;
|
|
let children = undefined;
|
|
if (codeResponses.schema && codeResponses.schema.originalRef) {
|
|
type = codeResponses.schema.originalRef;
|
|
children = this.getParamDefinitions(codeResponses.schema.originalRef, definitionsDataMap, indexKey, {}, 0);
|
|
}
|
|
responsesList.push({
|
|
code: code,
|
|
type: type,
|
|
key: indexKey,
|
|
desc: codeResponses.description,
|
|
schemas: children,
|
|
});
|
|
indexKey++;
|
|
});
|
|
return responsesList;
|
|
},
|
|
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') {
|
|
let currentLevelTypes = {};
|
|
Object.keys(properties).forEach(key => {
|
|
let parameter = properties[key];
|
|
let type = parameter.type;
|
|
let format = parameter.format;
|
|
let description = parameter.description || '';
|
|
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 {originalRef: "Model", $ref: "#/definitions/Model"}
|
|
if (parameter.items && parameter.items.originalRef) {
|
|
subType = parameter.items.originalRef;
|
|
children = this.getParamDefinitions(parameter.items.originalRef, definitionsDataMap, keySub, parentRef, deep + 1);
|
|
} else if (parameter.items && parameter.items.type) {
|
|
subType = parameter.items.type;
|
|
} else {
|
|
this.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 {
|
|
this.log('0041', type, parameter);
|
|
}
|
|
} else if (!type) {
|
|
if (parameter.originalRef) {
|
|
type = parameter.originalRef;
|
|
children = this.getParamDefinitions(parameter.originalRef, definitionsDataMap, keySub, parentRef, deep + 1);
|
|
} else {
|
|
this.logMessage('005', type, parameter);
|
|
}
|
|
} else {
|
|
if (notNeedHandleTypeArr.indexOf(type) >= 0) {
|
|
// 无需特殊处理的类型
|
|
} else {
|
|
this.logMessage('006', type, parameter);
|
|
}
|
|
}
|
|
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,
|
|
children: children,
|
|
});
|
|
indexSub++;
|
|
currentLevelTypes[type] = 1;
|
|
});
|
|
}
|
|
return paramList.length > 0 ? paramList : undefined;
|
|
},
|
|
getAdditionalProperties(additionalProperties, additional, definitionsDataMap, keySub, parentRef, deep) {
|
|
if (additionalProperties.originalRef) {
|
|
additional.type = additionalProperties.originalRef;
|
|
additional.children = this.getParamDefinitions(additionalProperties.originalRef, 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 (additionalProperties.items && additionalProperties.items.originalRef) {
|
|
let children = this.getParamDefinitions(additionalProperties.items.originalRef, definitionsDataMap, keySub, parentRef, deep + 1);
|
|
additional.additional = {
|
|
type: additionalProperties.items.originalRef,
|
|
children: children
|
|
};
|
|
return children;
|
|
} else {
|
|
this.logMessage('007', '', additionalProperties);
|
|
}
|
|
} else {
|
|
additional.type = additionalProperties.type;
|
|
if (notNeedHandleTypeArr.indexOf(additional.type) >= 0) {
|
|
// 无需特殊处理的类型
|
|
} else {
|
|
this.logMessage('008', '', additionalProperties);
|
|
}
|
|
}
|
|
return undefined;
|
|
},
|
|
log(code, type, parameter) {
|
|
console.log(code + '-遇到未处理的类型，请联系开发人员修改：' + type, parameter);
|
|
},
|
|
logMessage(code, type, parameter) {
|
|
console.log(code + '-遇到未处理的类型，请联系开发人员修改：' + type, parameter);
|
|
message.error(code + '-遇到未处理的类型，请联系开发人员修改：' + type);
|
|
}
|
|
}
|
|
|