if ( StringUtils.isBlank(subtypeModel.getName()) || subtypeModel.getName().equals(model.getName())) { subtypeModel.setName(_typeNameResolver.nameForType(_mapper.constructType(subtypeType), TypeNameResolver.Options.SKIP_API_MODEL)); .title(subtypeModel.getTitle()) .name(subtypeModel.getName()) .deprecated(subtypeModel.getDeprecated()) .additionalProperties(subtypeModel.getAdditionalProperties()) .description(subtypeModel.getDescription()) .discriminator(subtypeModel.getDiscriminator()) .example(subtypeModel.getExample()) .exclusiveMaximum(subtypeModel.getExclusiveMaximum()) .exclusiveMinimum(subtypeModel.getExclusiveMinimum()) .externalDocs(subtypeModel.getExternalDocs()) .format(subtypeModel.getFormat()) .maximum(subtypeModel.getMaximum()) .maxItems(subtypeModel.getMaxItems()) .maxLength(subtypeModel.getMaxLength()) .maxProperties(subtypeModel.getMaxProperties()) .minimum(subtypeModel.getMinimum()) .minItems(subtypeModel.getMinItems()) .minLength(subtypeModel.getMinLength()) .minProperties(subtypeModel.getMinProperties()) .multipleOf(subtypeModel.getMultipleOf()) .not(subtypeModel.getNot()) .nullable(subtypeModel.getNullable()) .pattern(subtypeModel.getPattern()) .properties(subtypeModel.getProperties())
public static Schema resolveSchemaFromType(Class<?> schemaImplementation, Components components, JsonView jsonViewAnnotation) { Schema schemaObject = new Schema(); if (schemaImplementation.getName().startsWith("java.lang")) { schemaObject.setType(schemaImplementation.getSimpleName().toLowerCase()); } else { ResolvedSchema resolvedSchema = ModelConverters.getInstance().readAllAsResolvedSchema(new AnnotatedType().type(schemaImplementation).jsonViewAnnotation(jsonViewAnnotation)); Map<String, Schema> schemaMap; if (resolvedSchema != null) { schemaMap = resolvedSchema.referencedSchemas; schemaMap.forEach((key, referencedSchema) -> { if (components != null) { components.addSchemas(key, referencedSchema); } }); schemaObject.set$ref(COMPONENTS_REF + resolvedSchema.schema.getName()); } } if (StringUtils.isBlank(schemaObject.get$ref()) && StringUtils.isBlank(schemaObject.getType())) { // default to string schemaObject.setType("string"); } return schemaObject; }
@Test(description = "it should not create an xml object for $ref") public void shouldNotCreateXmlObjectForRef() throws IOException { final Schema model = new Schema().$ref("Monster"); model.setDescription("oops"); model.setExternalDocs(new ExternalDocumentation() .description("external docs") .url("http://swagger.io")); assertEquals(Json.mapper().writeValueAsString(model), "{\"$ref\":\"#/components/schemas/Monster\"}"); }
protected void addRequiredItem(Schema model, String propName) { if (model == null || propName == null || StringUtils.isBlank(propName)) { return; } if (model.getRequired() == null || model.getRequired().isEmpty()) { model.addRequiredItem(propName); } if (model.getRequired().stream().noneMatch(s -> propName.equals(s))) { model.addRequiredItem(propName); } }
private static Schema process(Schema id, String propertyName, AnnotatedType type, ModelConverterContext context) { Schema model = context.resolve(removeJsonIdentityAnnotations(type)); Schema mi = model; mi.addProperties(propertyName, id); return new Schema().$ref(StringUtils.isNotEmpty(mi.get$ref()) ? mi.get$ref() : mi.getName()); } private static AnnotatedType removeJsonIdentityAnnotations(AnnotatedType type) {
schemaObject = new ComposedSchema(); } else { schemaObject = new Schema(); schemaObject.setDescription(schema.description()); schemaObject.set$ref(schema.ref()); schemaObject.setType(schema.type()); schemaObject.setDefault(schema.defaultValue()); schemaObject.setExample(Json.mapper().readTree(schema.example())); } catch (IOException e) { schemaObject.setExample(schema.example()); schemaObject.setFormat(schema.format()); schemaObject.setPattern(schema.pattern()); schemaObject.setReadOnly(schema.readOnly()); schemaObject.setDeprecated(schema.deprecated()); schemaObject.setExclusiveMaximum(schema.exclusiveMaximum()); schemaObject.setExclusiveMinimum(schema.exclusiveMinimum()); schemaObject.setMaxProperties(schema.maxProperties());
StringUtils.isNotEmpty(resolvedSchemaAnnotation.ref())) { if (resolvedArrayAnnotation == null) { return new Schema().$ref(resolvedSchemaAnnotation.ref()).name(name); } else { ArraySchema schema = new ArraySchema(); resolveArraySchema(annotatedType, schema, resolvedArrayAnnotation); return schema.items(new Schema().$ref(resolvedSchemaAnnotation.ref()).name(name)); } else { innerSchema = context.resolve(aType); if (innerSchema != null && "object".equals(innerSchema.getType()) && StringUtils.isNotBlank(innerSchema.getName())) { if (context.getDefinedModels().containsKey(innerSchema.getName())) { innerSchema = new Schema().$ref(constructRef(innerSchema.getName())); } else if (innerSchema != null && innerSchema.get$ref() != null) { innerSchema = new Schema().$ref(StringUtils.isNotEmpty(innerSchema.get$ref()) ? innerSchema.get$ref() : innerSchema.getName()); } else { Schema implSchema = context.resolve(aType); if (implSchema != null && aType.isResolveAsRef() && "object".equals(implSchema.getType()) && StringUtils.isNotBlank(implSchema.getName())) { if (context.getDefinedModels().containsKey(implSchema.getName())) { implSchema = new Schema().$ref(constructRef(implSchema.getName())); } else if (implSchema != null && implSchema.get$ref() != null) { implSchema = new Schema().$ref(StringUtils.isNotEmpty(implSchema.get$ref()) ? implSchema.get$ref() : implSchema.getName()); return new Schema();
public AnyProperty(Schema prop) { if (prop != null) { setName(prop.getName()); setDescription(prop.getDescription()); setExample(prop.getExample()); setFormat(prop.getFormat()); setReadOnly(prop.getReadOnly()); setRequired(prop.getRequired()); setTitle(prop.getTitle()); setExtensions(prop.getExtensions()); setXml(prop.getXml()); setExternalDocs(prop.getExternalDocs()); setProperties(prop.getProperties()); set$ref(prop.get$ref()); } } }
public Schema modelFromProperty(ObjectSchema object, String path) { String description = object.getDescription(); String example = null; Object obj = object.getExample(); if (obj != null) { example = obj.toString(); } String name = object.getName(); XML xml = object.getXml(); Map<String, Schema> properties = object.getProperties(); Schema model = new Schema();//TODO Verify this! model.setDescription(description); model.setExample(example); model.setName(name); model.setXml(xml); model.setType(object.getType()); if (properties != null) { flattenProperties(properties, path); model.setProperties(properties); } return model; }
final Schema model = converter.resolve(type, context, chain); if (model != null) { final Map<String, Schema> properties = model.getProperties(); final Map<String, Schema> updatedProperties = new LinkedHashMap<String, Schema>(); if (properties != null) { String convertedKey = toSnakeCase(key); Schema prop = properties.get(key); if (prop.get$ref() != null) { Pair<String, String> refName = extractSimpleName(prop.get$ref()); if (!StringUtils.isBlank(refName.getRight())) { // skip if didn't resolve simple name prop.set$ref(constructRef(toSnakeCase(refName.getLeft()), refName.getRight())); model.getProperties().clear(); model.setProperties(updatedProperties); if (model.getName() != null) { String prevName = model.getName(); model.setName(toSnakeCase(model.getName())); context.defineModel(model.getName(), model, type, prevName);
public void preprocessOpenAPI(OpenAPI openAPI) { Info info = openAPI.getInfo(); info.setDescription(toHtml(info.getDescription())); info.setTitle(toHtml(info.getTitle())); Map<String, Schema> models = openAPI.getComponents().getSchemas(); for (Schema model : models.values()) { model.setDescription(toHtml(model.getDescription())); model.setTitle(toHtml(model.getTitle())); } }
protected <T> void updateLocalRefs(String file, Schema schema) { if(schema.get$ref() != null) { String updatedLocation = merge(file, schema.get$ref()); schema.set$ref(updatedLocation); } else if(schema.getProperties() != null) { Map<String,Schema> properties = schema.getProperties(); for(Schema property : properties.values()) { updateLocalRefs(file, property); } } }
@Test public void testJodaDateTime() { final Map<String, Schema> models = ModelConverters.getInstance().read(ModelWithJodaDateTime.class); assertEquals(models.size(), 1); // don't create a Joda DateTime object final Schema model = models.get("ModelWithJodaDateTime"); final Schema dateTimeProperty = (Schema) model.getProperties().get("createdAt"); assertTrue(dateTimeProperty instanceof DateTimeSchema); assertTrue(model.getRequired().contains("createdAt")); assertEquals(dateTimeProperty.getDescription(), "creation timestamp"); final Schema nameProperty = (Schema) model.getProperties().get("name"); assertTrue(nameProperty instanceof StringSchema); assertEquals(nameProperty.getDescription(), "name of the model"); }
public Schema modelFromProperty(ObjectSchema object, String path) { String description = object.getDescription(); String example = null; Object obj = object.getExample(); if (obj != null) { example = obj.toString(); } XML xml = object.getXml(); Map<String, Schema> properties = object.getProperties(); Schema model = new Schema(); model.setDescription(description); model.setExample(example); model.setName(object.getName()); model.setXml(xml); model.setRequired(object.getRequired()); if (properties != null) { flattenProperties(properties, path); model.setProperties(properties); } return model; }
@Test public void extractProperties() { final Map<String, Schema> models = ModelConverters.getInstance().readAll(Family.class); assertEquals(models.size(), 3); final Schema person = models.get("Person"); final Schema employer = (Schema) person.getProperties().get("employer"); assertTrue(employer instanceof ArraySchema); final ArraySchema employerProperty = (ArraySchema) employer; final Schema items = employerProperty.getItems(); assertEquals(items.get$ref(), "#/components/schemas/Employer"); final Schema awards = (Schema) person.getProperties().get("awards"); assertTrue(awards instanceof ArraySchema); assertTrue(((ArraySchema) awards).getItems() instanceof StringSchema); }
@Test public void testMap() throws Exception { final ModelResolver modelResolver = new ModelResolver(mapper()); final ModelConverterContextImpl context = new ModelConverterContextImpl(modelResolver); final Schema model = context .resolve(new AnnotatedType(MapBean.class)); final Map<String, Schema> props = model.getProperties(); assertEquals(1, props.size()); final Schema prop = props.get("stuff"); assertNotNull(prop); assertEquals(prop.getType(), "object"); final Schema items = (Schema)prop.getAdditionalProperties(); assertNotNull(items); assertEquals(items.getType(), "string"); assertEquals(items.getFormat(), "date-time"); }
@Test(description = "it should ignore a hidden field") public void testHiddenField() { final Map<String, Schema> models = ModelConverters.getInstance().read(ModelWithHiddenFields.class); final Schema model = models.get("ModelWithHiddenFields"); assertNotNull(model); assertEquals(model.getProperties().size(), 2); final Schema idValue = (Schema) model.getProperties().get("id"); assertTrue(idValue instanceof IntegerSchema); assertTrue(model.getRequired().contains("id")); final Schema nameValue = (Schema) model.getProperties().get("name"); assertTrue(nameValue instanceof StringSchema); }
private void handleUnwrapped(List<Schema> props, Schema innerModel, String prefix, String suffix) { if (StringUtils.isBlank(suffix) && StringUtils.isBlank(prefix)) { if (innerModel.getProperties() != null) { props.addAll(innerModel.getProperties().values()); } } else { if (prefix == null) { prefix = ""; } if (suffix == null) { suffix = ""; } if (innerModel.getProperties() != null) { for (Schema prop : (Collection<Schema>) innerModel.getProperties().values()) { try { Schema clonedProp = Json.mapper().readValue(Json.pretty(prop), Schema.class); clonedProp.setName(prefix + prop.getName() + suffix); props.add(clonedProp); } catch (IOException e) { LOGGER.error("Exception cloning property", e); return; } } } } }