ResolvedParameter extractParametersResult = new ResolvedParameter(); if (parameter != null && (StringUtils.isNotBlank(parameter.getIn()) || StringUtils.isNotBlank(parameter.get$ref()))) { parameters.add(parameter); } else if (includeRequestBody) {
/** * Retrieves the default value of a parameter * * @return the default value of the parameter */ public Optional<Object> getDefaultValue() { Validate.notNull(parameter, "parameter must not be null!"); if (parameter.get$ref() == null) { return Optional.ofNullable(parameter.getSchema()).map(Schema::getDefault); } return Optional.empty(); } }
if(existingParameters.get$ref() != null) { if (parameter.get$ref() != null) { RefFormat format = computeRefFormat(parameter.get$ref()); if (isAnExternalRefFormat(format)) { parameter.set$ref(processRefToExternalParameter(parameter.get$ref(), format)); } else { processRefToExternalParameter(file + parameter.get$ref(), RefFormat.RELATIVE);
if(existingParameters.get$ref() != null) { if (parameter.get$ref() != null) { RefFormat format = computeRefFormat(parameter.get$ref()); if (isAnExternalRefFormat(format)) { parameter.set$ref(processRefToExternalParameter(parameter.get$ref(), format)); } else { processRefToExternalParameter(file + parameter.get$ref(), RefFormat.RELATIVE);
public ParameterAdapter(Swagger2MarkupConverter.Context context, PathOperation operation, Parameter parameter, DocumentResolver definitionDocumentResolver) { Validate.notNull(parameter, "parameter must not be null"); this.parameter = parameter; if (parameter.get$ref() != null) { Optional.ofNullable(context.getCache() .loadRef(parameter.get$ref(), computeRefFormat(parameter.get$ref()), Object.class)) .filter(o -> o instanceof RequestBody) .map(o -> ((RequestBody) o)) .ifPresent(body -> { parameter.setIn("Body"); parameter.setName("body"); parameter.setDescription(body.getDescription()); }); } type = getType(definitionDocumentResolver); config = context.getConfig(); if (config.isInlineSchemaEnabled()) { if (config.isFlatBodyEnabled()) { if (!(type instanceof ObjectType)) { type = InlineSchemaUtils.createInlineType(type, parameter.getName(), operation.getId() + " " + parameter.getName(), inlineDefinitions); } } else { type = InlineSchemaUtils.createInlineType(type, parameter.getName(), operation.getId() + " " + parameter.getName(), inlineDefinitions); } } }
/** * Retrieves the type of a parameter, or otherwise null * * @param definitionDocumentResolver the definition document resolver * @return the type of the parameter, or otherwise null */ private Type getType(DocumentResolver definitionDocumentResolver) { Validate.notNull(parameter, "parameter must not be null!"); Type type; if (parameter.get$ref() != null) { String refName = RefUtils.computeSimpleRef(parameter.get$ref()); type = new RefType(definitionDocumentResolver.apply(refName), new ObjectType(refName, null)); } else { Schema serializableParameter = parameter.getSchema(); @SuppressWarnings("unchecked") List<String> enums = serializableParameter.getEnum(); if (CollectionUtils.isNotEmpty(enums)) { type = new EnumType(serializableParameter.getName(), enums); } else { type = new BasicType(serializableParameter.getType(), serializableParameter.getName(), serializableParameter.getFormat()); } if (serializableParameter.getType().equals("array")) { String collectionFormat = serializableParameter.getFormat(); type = new ArrayType(serializableParameter.getName(), new PropertyAdapter(serializableParameter).getType(definitionDocumentResolver), collectionFormat); } } return type; }
public Optional<ChangedParameters> diff( List<Parameter> left, List<Parameter> right, DiffContext context) { ChangedParameters changedParameters = new ChangedParameters(left, right != null ? new ArrayList<>(right) : null, context); if (null == left) left = new ArrayList<>(); if (null == right) right = new ArrayList<>(); for (Parameter leftPara : left) { leftPara = refPointer.resolveRef(leftComponents, leftPara, leftPara.get$ref()); Optional<Parameter> rightParam = contains(rightComponents, right, leftPara); if (!rightParam.isPresent()) { changedParameters.getMissing().add(leftPara); } else { Parameter rightPara = rightParam.get(); right.remove(rightPara); openApiDiff .getParameterDiff() .diff(leftPara, rightPara, context) .ifPresent(changedParameters.getChanged()::add); } } changedParameters.getIncreased().addAll(right); return isChanged(changedParameters); } }
@Override public BallerinaParameter buildContext(Parameter parameter, OpenAPI openAPI) throws BallerinaOpenApiException { this.name = parameter.getName(); this.in = parameter.getIn(); this.description = parameter.getDescription(); this.required = parameter.getRequired(); this.deprecated = parameter.getDeprecated(); this.allowEmptyValue = parameter.getAllowEmptyValue(); this.ref = parameter.get$ref(); this.style = parameter.getStyle(); this.explode = parameter.getExplode(); this.allowReserved = parameter.getAllowReserved(); this.examples = parameter.getExamples(); this.example = parameter.getExample(); this.content = parameter.getContent(); this.extensions = parameter.getExtensions(); this.schema = new BallerinaSchema().buildContext(parameter.getSchema(), openAPI); return this; }
/** * If a Parameter contains a reference to an other Parameter with '$ref', returns the referenced Parameter if it is found or the actual Parameter in the other cases. * * @param openAPI specification being checked * @param parameter potentially containing a '$ref' * @return parameter without '$ref' */ public static Parameter getReferencedParameter(OpenAPI openAPI, Parameter parameter) { if (parameter != null && StringUtils.isNotEmpty(parameter.get$ref())) { String name = getSimpleRef(parameter.get$ref()); Parameter referencedParameter = getParameter(openAPI, name); if (referencedParameter != null) { return referencedParameter; } } return parameter; }
public Parameter resolveParameter(Parameter parameter){ String $ref = parameter.get$ref(); RefFormat refFormat = computeRefFormat($ref); if (!isAnExternalRefFormat(refFormat)){ if (parameters != null && !parameters.isEmpty()) { String referenceKey = computeDefinitionName($ref); return parameters.getOrDefault(referenceKey, parameter); } } return parameter; }
public Parameter resolveParameter(Parameter parameter){ String $ref = parameter.get$ref(); RefFormat refFormat = computeRefFormat($ref); if (!isAnExternalRefFormat(refFormat)){ if (parameters != null && !parameters.isEmpty()) { String referenceKey = computeDefinitionName($ref); return parameters.getOrDefault(referenceKey, parameter); } } return parameter; }
public static Optional<Parameter> contains( Components components, List<Parameter> parameters, Parameter parameter) { return parameters .stream() .filter(param -> same(refPointer.resolveRef(components, param, param.get$ref()), parameter)) .findFirst(); }
public Parameter resolveParameter(Parameter parameter){ String $ref = parameter.get$ref(); RefFormat refFormat = computeRefFormat($ref); if (!isAnExternalRefFormat(refFormat)){ if (parameters != null && !parameters.isEmpty()) { String referenceKey = computeDefinitionName($ref); return parameters.getOrDefault(referenceKey, parameter); } } return parameter; }