Optional<ArraySchema> arraySchema = AnnotationsUtils.getArraySchema(arrayAnnotation, components, jsonViewAnnotation); if (arraySchema.isPresent()) { arraySchema.get().setItems(schemaObject); return arraySchema; } else { Optional<ArraySchema> arraySchemaFromAnnotation = AnnotationsUtils.getArraySchema(arrayAnnotation, components, jsonViewAnnotation); if (arraySchemaFromAnnotation.isPresent()) { if (arraySchemaFromAnnotation.get().getItems() != null && StringUtils.isBlank(arraySchemaFromAnnotation.get().getItems().get$ref()) && StringUtils.isBlank(arraySchemaFromAnnotation.get().getItems().getType())) { arraySchemaFromAnnotation.get().getItems().setType("string");
return Optional.empty(); ArraySchema arraySchemaObject = new ArraySchema(); if (arraySchema.uniqueItems()) { arraySchemaObject.setUniqueItems(arraySchema.uniqueItems()); arraySchemaObject.setMaxItems(arraySchema.maxItems()); arraySchemaObject.setMinItems(arraySchema.minItems()); if (extensions != null) { for (String ext : extensions.keySet()) { arraySchemaObject.addExtension(ext, extensions.get(ext)); getSchemaFromAnnotation(arraySchema.schema(), components, jsonViewAnnotation).ifPresent(schema -> { if (StringUtils.isNotBlank(schema.getType()) || StringUtils.isNotBlank(schema.get$ref())) { arraySchemaObject.setItems(schema);
@Test(description = "it should serialize a string array property") public void serializeArrayStringProperty() throws IOException { final Schema p = new ArraySchema().items(new StringSchema()); final String json = "{\"type\":\"array\",\"items\":{\"type\":\"string\"}}"; assertEquals(m.writeValueAsString(p), json); }
@Test(description = "it should serialize an array model") public void serializeArrayModel() throws IOException { final ArraySchema model = new ArraySchema(); model.setItems(new Schema().$ref("Pet")); assertEquals(m.writeValueAsString(model), "{\"type\":\"array\",\"items\":{\"$ref\":\"#/components/schemas/Pet\"}}"); }
@Test public void extractPrimitiveArray() { final Map<String, Schema> models = ModelConverters.getInstance().readAll(ModelWithPrimitiveArray.class); assertEquals(models.size(), 1); final Schema model = models.get("ModelWithPrimitiveArray"); final ArraySchema longArray = (ArraySchema) model.getProperties().get("longArray"); final Schema longArrayItems = longArray.getItems(); assertTrue(longArrayItems instanceof IntegerSchema); final ArraySchema intArray = (ArraySchema) model.getProperties().get("intArray"); assertTrue(intArray.getItems() instanceof IntegerSchema); }
@SuppressWarnings("static-method") public Schema modelFromProperty(ArraySchema object, @SuppressWarnings("unused") String path) { String description = object.getDescription(); String example = null; Object obj = object.getExample(); if (obj != null) { example = obj.toString(); } Schema inner = object.getItems(); if (inner instanceof ObjectSchema) { ArraySchema model = new ArraySchema(); model.setDescription(description); model.setExample(example); model.setItems(object.getItems()); return model; } return null; }
try { if (parameter.getSchema() == null) { parameter.setSchema(new ArraySchema()); Integer min = (Integer) annotation.annotationType().getMethod("min").invoke(annotation); if (min != null) { as.setMinItems(min); as.setMaxItems(max); ArraySchema as = (ArraySchema) paramSchema; if (defaultValue != null) { as.getItems().setDefault(defaultValue);
@SuppressWarnings("static-method") public Schema modelFromProperty(MapSchema object, @SuppressWarnings("unused") String path) { String description = object.getDescription(); String example = null; Object obj = object.getExample(); if (obj != null) { example = obj.toString(); } ArraySchema model = new ArraySchema(); model.setDescription(description); model.setName(object.getName()); model.setExample(example); model.setItems(ModelUtils.getAdditionalProperties(object)); return model; }
@SuppressWarnings("static-method") public Schema modelFromProperty(ArraySchema object, @SuppressWarnings("unused") String path) { String description = object.getDescription(); String example = null; Object obj = object.getExample(); if (obj != null) { example = obj.toString(); } Schema inner = object.getItems(); if (inner instanceof ObjectSchema) { ArraySchema model = new ArraySchema(); model.setDescription(description); model.setExample(example); model.setItems(object.getItems()); model.setName(object.getName()); return model; } return 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)); .skipOverride(true); if (resolvedArrayAnnotation != null) { ArraySchema schema = new ArraySchema(); resolveArraySchema(annotatedType, schema, resolvedArrayAnnotation); Schema innerSchema = null; schema.setItems(innerSchema); return schema; } else { ArraySchema schema = new ArraySchema(); resolveArraySchema(annotatedType, schema, resolvedArrayAnnotation); schema.setItems(model); return schema; new ArraySchema().items(items); if (_isSetType(type.getRawClass())) { arrayModel.setUniqueItems(true); ArraySchema schema = new ArraySchema(); schema.setItems(model); resolveArraySchema(annotatedType, schema, resolvedArrayAnnotation); return schema;
public static Schema changeObjectSchemaToAnySchema(Schema schema) { if (schema instanceof ObjectSchema) { return new AnyProperty(schema); } if (schema instanceof ArraySchema) { ((ArraySchema) schema).items(changeObjectSchemaToAnySchema(((ArraySchema) schema).getItems())); } if (schema instanceof MapSchema) { if (schema.getAdditionalProperties() != null) { schema.setAdditionalProperties(changeObjectSchemaToAnySchema((Schema) schema.getAdditionalProperties())); } } return schema; }
@Test public void testReadOnlyByteArray() { Schema model = new Schema() .addProperties("byteArray", new ArraySchema().items(new BinarySchema()).readOnly(true)); assertEquals(Json.pretty(model), "{" + NEWLINE + " \"properties\" : {" + NEWLINE + " \"byteArray\" : {" + NEWLINE + " \"type\" : \"array\"," + NEWLINE + " \"readOnly\" : true," + NEWLINE + " \"items\" : {" + NEWLINE + " \"type\" : \"string\"," + NEWLINE + " \"format\" : \"binary\"" + NEWLINE + " }" + NEWLINE + " }" + NEWLINE + " }" + NEWLINE + "}"); }
private static Object generateExampleForArrayModel(ArraySchema model, Map<String, Schema> definitions, DocumentResolver definitionDocumentResolver, MarkupDocBuilder markupDocBuilder, Map<String, Integer> refStack) { if (model.getExample() != null) { return model.getExample(); } else if (model.getProperties() != null) { return new Object[]{exampleMapForProperties(model.getProperties(), definitions, definitionDocumentResolver, markupDocBuilder, refStack)}; } else { Schema itemProperty = model.getItems(); return getExample(itemProperty, definitions, definitionDocumentResolver, markupDocBuilder, refStack); } }
@Test public void testSimple() throws Exception { final ModelConverter mr = modelResolver(); ModelConverterContextImpl ctx = new ModelConverterContextImpl(mr); final Schema model = mr.resolve(new AnnotatedType(XmlDecoratedBean.class), ctx, null); final XML xml = model.getXml(); assertNotNull(xml); assertEquals(xml.getName(), "xmlDecoratedBean"); // Cast it to an array property final ArraySchema property = (ArraySchema) model.getProperties().get("elements"); assertNotNull(property); final XML propertyXml = property.getXml(); assertNotNull(propertyXml); assertNull(propertyXml.getName()); assertTrue(propertyXml.getWrapped()); // Get the xml for items for the array property final XML itemsXml = property.getItems().getXml(); assertNotNull(itemsXml); // Check the name of item name assertEquals(itemsXml.getName(), "element"); assertNotNull(model.getProperties().get("elementC")); }
return arraySchema; Annotation newArraySchema = new io.swagger.v3.oas.annotations.media.ArraySchema() {
ArraySchema arraySchema = Json.mapper().convertValue(v2Model, ArraySchema.class); arraySchema.setItems(convert(((ArrayModel) v2Model).getItems()));
} else if (property instanceof ArraySchema) { ArraySchema sp = (ArraySchema) property; sp.setMinItems(size.min()); sp.setMaxItems(size.max());
@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); }
@SuppressWarnings("static-method") public Schema modelFromProperty(ArraySchema object, @SuppressWarnings("unused") String path) { String description = object.getDescription(); String example = null; Object obj = object.getExample(); if (obj != null) { example = obj.toString(); } Schema inner = object.getItems(); if (inner instanceof ObjectSchema) { ArraySchema model = new ArraySchema(); model.setDescription(description); model.setExample(example); model.setItems(object.getItems()); return model; } return null; }
try { if (parameter.getSchema() == null) { parameter.setSchema(new ArraySchema()); Integer min = (Integer) annotation.annotationType().getMethod("min").invoke(annotation); if (min != null) { as.setMinItems(min); as.setMaxItems(max); ArraySchema as = (ArraySchema) paramSchema; if (defaultValue != null) { as.getItems().setDefault(defaultValue);