public String getName() { return parameter.getName(); }
public boolean getRequired() { return parameter.getRequired(); }
public Map<String, Object> getVendorExtensions() { return parameter.getVendorExtensions(); }
example = getExamplesFromBodyParameter(parameter); if (example == null) { Model schema = ((BodyParameter) parameter).getSchema(); if (schema instanceof RefModel) { String simpleRef = ((RefModel) schema).getSimpleRef(); if (generateMissingExamples) { Object abstractSerializableParameterExample; abstractSerializableParameterExample = ((AbstractSerializableParameter) parameter).getExample(); if (abstractSerializableParameterExample == null) { abstractSerializableParameterExample = parameter.getVendorExtensions().get("x-example"); Property item = ((AbstractSerializableParameter) parameter).getItems(); if (item != null) { abstractSerializableParameterExample = item.getExample(); example = parameter.getName() +":\"" +((HeaderParameter) parameter).getType()+ "\""; } else if (parameter instanceof PathParameter) { String pathExample = (String) examples.get("path"); pathExample = pathExample.replace('{' + parameter.getName() + '}', encodeExampleForUrl(abstractSerializableParameterExample)); example = pathExample; } else if (parameter instanceof QueryParameter) { if (parameter.getRequired()) String pathExample = path + separator + parameter.getName() + "=" + encodeExampleForUrl(abstractSerializableParameterExample); examples.put("path", pathExample); String simpleRef = ((RefParameter) parameter).getSimpleRef(); example = generateExampleForRefModel(generateMissingExamples, simpleRef, definitions, definitionDocumentResolver, markupDocBuilder, new HashMap<>());
Model model = bodyParameter.getSchema(); type = new BasicType("string", bodyParameter.getName()); AbstractSerializableParameter serializableParameter = (AbstractSerializableParameter) parameter; @SuppressWarnings("unchecked") List<String> enums = serializableParameter.getEnum(); type = new EnumType(serializableParameter.getName(), enums); } else { type = new BasicType(serializableParameter.getType(), serializableParameter.getName(), serializableParameter.getFormat()); if (serializableParameter.getType().equals("array")) { String collectionFormat = serializableParameter.getCollectionFormat(); type = new ArrayType(serializableParameter.getName(), new PropertyAdapter(serializableParameter.getItems()).getType(definitionDocumentResolver), collectionFormat); String refName = ((RefParameter) parameter).getSimpleRef();
if (CollectionUtils.isNotEmpty(parameters)) { for (Parameter parameter : parameters) { if (StringUtils.equals(parameter.getIn(), "body")) { ParameterAdapter parameterAdapter = new ParameterAdapter(context, operation, parameter, definitionDocumentResolver); String description = parameter.getDescription(); if (isNotBlank(description)) { markupDocBuilder.paragraph(markupDescription(config.getSwaggerMarkupLanguage(), markupDocBuilder, description)); typeInfos.italicText(labels.getLabel(NAME_COLUMN)).textLine(COLON + parameter.getName()); typeInfos.italicText(labels.getLabel(FLAGS_COLUMN)).textLine(COLON + (BooleanUtils.isTrue(parameter.getRequired()) ? labels.getLabel(FLAGS_REQUIRED).toLowerCase() : labels.getLabel(FLAGS_OPTIONAL).toLowerCase()));
/** * Generate a default example value for parameter. * * @param parameter parameter * @return a generated example for the parameter */ public static Object generateExample(AbstractSerializableParameter<?> parameter) { switch (parameter.getType()) { case "integer": return 0; case "number": return 0.0; case "boolean": return true; case "string": return ExamplesUtil.generateStringExample(parameter.getFormat(), parameter.getEnum()); default: return parameter.getType(); } }
public String getIn() { return WordUtils.capitalize(parameter.getIn()); }
.stream(); } else { parameter.setName(it.name()); parameter.setRequired(!it.optional()); parameter.setDescription(property.getDescription()); it.description().ifPresent(parameter::setDescription); return Stream.of(parameter);
private SerializableParameter complement(Property property, RouteParameter source, SerializableParameter param) { param.setType(property.getType()); param.setFormat(property.getFormat()); // array param: if (property instanceof ArrayProperty) { param.setItems(((ArrayProperty) property).getItems()); } // enum values: List<String> enums = source.enums(); if (enums.size() > 0) { param.setEnum(enums); } // default value: if (param instanceof AbstractSerializableParameter) { ((AbstractSerializableParameter) param).setDefault(source.defaultValue()); } return param; } }
/** * Retrieves example payloads for body parameter either from examples or from vendor extensions. * @param parameter parameter to get the examples for * @return examples if found otherwise null */ private static Object getExamplesFromBodyParameter(Parameter parameter) { Object examples = ((BodyParameter) parameter).getExamples(); if (examples == null) { examples = parameter.getVendorExtensions().get("x-examples"); } return examples; }
public String getDescription() { return parameter.getDescription(); }
/** * 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 instanceof AbstractSerializableParameter) { AbstractSerializableParameter serializableParameter = (AbstractSerializableParameter) parameter; return Optional.ofNullable(serializableParameter.getDefaultValue()); } return Optional.empty(); }
public Optional<Integer> getMinItems() { if (parameter instanceof SerializableParameter) { Integer minItems = ((SerializableParameter) parameter).getMinItems(); return Optional.ofNullable(minItems); } return Optional.empty(); }
public Optional<Integer> getMaxItems() { if (parameter instanceof SerializableParameter) { Integer maxItems = ((SerializableParameter) parameter).getMaxItems(); return Optional.ofNullable(maxItems); } return Optional.empty(); } }
public String getPattern() { return parameter.getPattern(); }
private List<Parameter> expandParameter(Map<String, Model> models, RouteParameter it, Supplier<SerializableParameter> factory, String typeName, String prefix, boolean optional) { List<Parameter> parameters = new ArrayList<>(); Model model = models.get(typeName); Map<String, Property> properties = model.getProperties(); Optional.ofNullable(properties).ifPresent(props -> props.values().stream() .flatMap(p -> { SerializableParameter result = complement(p, it, factory.get()); String name = prefix + p.getName(); if (p instanceof RefProperty) { return expandParameter(models, it, factory, ((RefProperty) p).getSimpleRef(), name + ".", optional).stream(); } else { result.setName(name); boolean required; if (optional) { required = false; } else { required = p.getRequired(); } String desc = Strings.emptyToNull(p.getDescription()); result.setRequired(required); result.setDescription(desc); return Stream.of(result); } }) .forEach(parameters::add) ); return parameters; }
@JsonIgnore public String getAccess() { return parameter.getAccess(); }
public ParameterAdapter(Swagger2MarkupConverter.Context context, PathOperation operation, Parameter parameter, DocumentResolver definitionDocumentResolver) { Validate.notNull(parameter, "parameter must not be null"); this.parameter = parameter; type = getType(context.getSwagger().getDefinitions(), 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); } } }
/** * Filter parameters to display in parameters section * * @param parameter parameter to filter * @return true if parameter can be displayed */ private boolean filterParameter(Parameter parameter) { return (!config.isFlatBodyEnabled() || !StringUtils.equals(parameter.getIn(), "body")); }