Java ArrayProperty类代码示例

import io.swagger.models.properties.ArrayProperty; //导入依赖的package包/类
private Object mapCollection(TupleEntity entity, ArrayProperty schema,
    ValueContext valueContext) {
  Property itemSchema = schema.getItems();

  if (itemSchema == null) {
    throw new EntityMapperRuntimeException("Array schemas must have an 'items' property.");
  }

  if (!(itemSchema instanceof ObjectProperty)) {
    throw new EntityMapperRuntimeException(
        "Only array items of type 'object' are supported for now.");
  }

  TupleQueryResult result = entity.getResult();

  ImmutableList.Builder<Map<String, Object>> collectionBuilder = new ImmutableList.Builder<>();
  Map<String, Property> itemProperties = ((ObjectProperty) itemSchema).getProperties();

  while (result.hasNext()) {
    collectionBuilder.add(mapBindingSet(result.next(), itemProperties, valueContext));
  }

  return collectionBuilder.build();
}
 

import io.swagger.models.properties.ArrayProperty; //导入依赖的package包/类
private static void initConverters() {
  // inner converters
  for (Class<? extends Property> propertyCls : PROPERTY_MAP.keySet()) {
    addInnerConverter(propertyCls);
  }

  converterMap.put(RefProperty.class, new RefPropertyConverter());
  converterMap.put(ArrayProperty.class, new ArrayPropertyConverter());
  converterMap.put(MapProperty.class, new MapPropertyConverter());
  converterMap.put(StringProperty.class, new StringPropertyConverter());
  converterMap.put(ObjectProperty.class, new ObjectPropertyConverter());

  converterMap.put(ModelImpl.class, new ModelImplConverter());
  converterMap.put(RefModel.class, new RefModelConverter());
  converterMap.put(ArrayModel.class, new ArrayModelConverter());

  converterMap.put(BodyParameter.class, new BodyParameterConverter());

  AbstractSerializableParameterConverter converter = new AbstractSerializableParameterConverter();
  converterMap.put(QueryParameter.class, converter);
  converterMap.put(PathParameter.class, converter);
  converterMap.put(HeaderParameter.class, converter);
  converterMap.put(FormParameter.class, converter);
  converterMap.put(CookieParameter.class, converter);
}
 

import io.swagger.models.properties.ArrayProperty; //导入依赖的package包/类
@Override
public JavaType convert(ClassLoader classLoader, String packageName, Swagger swagger, Object def) {
  AbstractSerializableParameter<?> param = (AbstractSerializableParameter<?>) def;

  switch (param.getType()) {
    case ArrayProperty.TYPE:
      return ArrayPropertyConverter.findJavaType(classLoader,
          packageName,
          swagger,
          param.getItems(),
          param.isUniqueItems());
    case StringProperty.TYPE:
      return StringPropertyConverter.findJavaType(classLoader,
          packageName,
          swagger,
          param.getType(),
          param.getFormat(),
          param.getEnum());
    default:
      return ConverterMgr.findJavaType(param.getType(), param.getFormat());
  }
}
 

import io.swagger.models.properties.ArrayProperty; //导入依赖的package包/类
@Override
public Object map(@NonNull TupleEntity entity, @NonNull MediaType mediaType) {
  Property schema = entity.getSchemaMap().get(mediaType);

  ValueContext valueContext = ValueContext.builder().build();

  if (schema == null) {
    throw new EntityMapperRuntimeException(
        String.format("No schema found for media type '%s'.", mediaType.toString()));
  }

  if (schema instanceof ResponseProperty) {
    schema = ((ResponseProperty) schema).getSchema();
  }
  if (schema instanceof ObjectProperty) {
    return mapObject(entity, (ObjectProperty) schema, valueContext);
  }
  if (schema instanceof ArrayProperty) {
    return mapCollection(entity, (ArrayProperty) schema, valueContext);
  }

  return ImmutableMap.of();
}
 

import io.swagger.models.properties.ArrayProperty; //导入依赖的package包/类
@Override
public Object mapGraphValue(@NonNull ArrayProperty property,
    @NonNull GraphEntityContext graphEntityContext, @NonNull ValueContext valueContext,
    @NonNull SchemaMapperAdapter schemaMapperAdapter) {
  ImmutableList.Builder<Object> builder = ImmutableList.builder();

  if (hasSubjectFilterVendorExtension(property)) {
    Set<Resource> subjects = getSubjects(property, graphEntityContext);

    subjects.forEach(subject -> {
      ValueContext subjectContext = valueContext.toBuilder().value(subject).build();

      builder.add(schemaMapperAdapter.mapGraphValue(property.getItems(), graphEntityContext,
          subjectContext, schemaMapperAdapter));
    });
  } else if (valueContext.getValue() != null) {
    if (property.getVendorExtensions().containsKey(OpenApiSpecificationExtensions.LDPATH)) {
      queryAndValidate(property, graphEntityContext, valueContext, schemaMapperAdapter, builder);
    } else {
      throw new SchemaMapperRuntimeException(String.format(
          "ArrayProperty must have a '%s' attribute", OpenApiSpecificationExtensions.LDPATH));
    }
  }

  return builder.build();
}
 

import io.swagger.models.properties.ArrayProperty; //导入依赖的package包/类
private void queryAndValidate(ArrayProperty property, GraphEntityContext graphEntityContext,
    ValueContext valueContext, SchemaMapperAdapter schemaMapperAdapter,
    ImmutableList.Builder<Object> builder) {
  LdPathExecutor ldPathExecutor = graphEntityContext.getLdPathExecutor();
  Collection<Value> queryResult = ldPathExecutor.ldPathQuery(valueContext.getValue(),
      (String) property.getVendorExtensions().get(OpenApiSpecificationExtensions.LDPATH));

  validateMinItems(property, queryResult);
  validateMaxItems(property, queryResult);

  queryResult.forEach(valueNext -> {
    ValueContext newValueContext = valueContext.toBuilder().value(valueNext).build();
    Optional innerPropertySolved =
        Optional.fromNullable(schemaMapperAdapter.mapGraphValue(property.getItems(),
            graphEntityContext, newValueContext, schemaMapperAdapter));
    builder.add(innerPropertySolved);

  });

}
 

import io.swagger.models.properties.ArrayProperty; //导入依赖的package包/类
@Test
public void map_MapsToMapperResult_ForRequiredPropertyWithPresentBinding() {
  // Assert
  StringProperty nameProperty = new StringProperty().required(true);
  TupleEntity entity = new TupleEntity(
      ImmutableMap.of(MediaType.APPLICATION_JSON_TYPE, new ArrayProperty().items(
          new ObjectProperty().required(true).properties(ImmutableMap.of("name", nameProperty)))),
      result);
  when(result.hasNext()).thenReturn(true, false);
  when(result.next()).thenReturn(
      new ListBindingSet(ImmutableList.of("name"), ImmutableList.of(DBEERPEDIA.BROUWTOREN_NAME)));
  when(schemaMapper.mapTupleValue(any(StringProperty.class),
      any(ValueContext.class))).thenReturn(DBEERPEDIA.BROUWTOREN_NAME.stringValue());

  // Act
  Object mappedEntity = tupleEntityMapper.map(entity, MediaType.APPLICATION_JSON_TYPE);

  // Assert
  assertThat(mappedEntity, instanceOf(ImmutableList.class));
  assertThat((ImmutableList<Object>) mappedEntity, hasSize(1));
  assertThat((ImmutableList<Object>) mappedEntity,
      contains(ImmutableMap.of("name", DBEERPEDIA.BROUWTOREN_NAME.stringValue())));
}
 

import io.swagger.models.properties.ArrayProperty; //导入依赖的package包/类
@Test
public void map_MapsToAbsentOptionalValue_ForOptionalPropertyWithAbsentBinding() {
  // Arrange
  TupleEntity entity = new TupleEntity(ImmutableMap.of(MediaType.APPLICATION_JSON_TYPE,
      new ArrayProperty().items(new ObjectProperty().properties(
          ImmutableMap.of("name", new StringProperty().required(false))))),
      result);
  when(result.hasNext()).thenReturn(true, false);
  when(result.next()).thenReturn(new ListBindingSet(ImmutableList.of(), ImmutableList.of()));

  // Act
  Object mappedEntity = tupleEntityMapper.map(entity, MediaType.APPLICATION_JSON_TYPE);

  // Assert
  assertThat(mappedEntity, instanceOf(ImmutableList.class));
  assertThat((ImmutableList<Object>) mappedEntity, hasSize(1));
  assertThat((ImmutableList<Object>) mappedEntity,
      contains(ImmutableMap.of("name", Optional.absent())));
}
 

import io.swagger.models.properties.ArrayProperty; //导入依赖的package包/类
@Test
public void map_ThrowException_ForRequiredPropertyWithAbsentBinding() {
  // Assert
  final TupleEntity entity = new TupleEntity(ImmutableMap.of(MediaType.APPLICATION_JSON_TYPE,
      new ArrayProperty().items(new ObjectProperty().properties(
          ImmutableMap.of("name", new StringProperty().required(true))))),
      result);
  when(result.hasNext()).thenReturn(true, false);
  when(result.next()).thenReturn(new ListBindingSet(ImmutableList.of(), ImmutableList.of()));

  // Assert
  thrown.expect(EntityMapperRuntimeException.class);
  thrown.expectMessage("Property 'name' is required.");

  // Act
  tupleEntityMapper.map(entity, MediaType.APPLICATION_JSON_TYPE);
}
 

import io.swagger.models.properties.ArrayProperty; //导入依赖的package包/类
@Test
public void mapGraphValue_ExcludesArrayProperty_WhenVendorExtIsSetAndArrayIsEmpty() {
  // Arrange
  ArrayProperty childProperty = new ArrayProperty(new StringProperty());

  childProperty.setVendorExtension(OpenApiSpecificationExtensions.LDPATH,
      DBEERPEDIA.NAME.stringValue());

  property.setProperties(ImmutableMap.of(DBEERPEDIA.NAME.stringValue(), childProperty));
  property.setVendorExtension(
      OpenApiSpecificationExtensions.EXCLUDE_PROPERTIES_WHEN_EMPTY_OR_NULL, true);

  when(ldPathExecutorMock.ldPathQuery(DBEERPEDIA.BROUWTOREN,
      DBEERPEDIA.NAME.stringValue())).thenReturn(ImmutableSet.of());

  // Act
  Map result = (ImmutableMap) schemaMapperAdapter.mapGraphValue(property, contextMock,
      ValueContext.builder().value(DBEERPEDIA.BROUWTOREN).build(), schemaMapperAdapter);

  // Assert
  assertThat(result.isEmpty(), is(true));
}
 

import io.swagger.models.properties.ArrayProperty; //导入依赖的package包/类
@Test
public void mapGraphValue_IncludesArrayProperty_WhenVendorExtIsSetAndArrayIsNotEmpty() {
  // Arrange
  ArrayProperty childProperty = new ArrayProperty(new StringProperty());

  childProperty.setVendorExtension(OpenApiSpecificationExtensions.LDPATH,
      DBEERPEDIA.NAME.stringValue());

  property.setProperties(ImmutableMap.of(DBEERPEDIA.NAME.stringValue(), childProperty));
  property.setVendorExtension(
      OpenApiSpecificationExtensions.EXCLUDE_PROPERTIES_WHEN_EMPTY_OR_NULL, true);

  when(ldPathExecutorMock.ldPathQuery(DBEERPEDIA.BROUWTOREN,
      DBEERPEDIA.NAME.stringValue())).thenReturn(ImmutableSet.of(DBEERPEDIA.BROUWTOREN_NAME));

  // Act
  Map result = (ImmutableMap) schemaMapperAdapter.mapGraphValue(property, contextMock,
      ValueContext.builder().value(DBEERPEDIA.BROUWTOREN).build(), schemaMapperAdapter);

  // Assert
  assertThat(result, is(ImmutableMap.of(DBEERPEDIA.NAME.stringValue(),
      Optional.of(ImmutableList.of(Optional.of(DBEERPEDIA.BROUWTOREN_NAME.stringValue()))))));
}
 

import io.swagger.models.properties.ArrayProperty; //导入依赖的package包/类
private Property evaluateSchema(Swagger swagger, Property schema) {
  Property newSchemaModel = null;
  if (schema instanceof RefProperty) {
    // Only response type defined in @ApiOperation:
    // e.g. response = JavaBean.class
    newSchemaModel = wrapWithResultContainerModel(swagger, (RefProperty) schema, SwaggerRefPropertyFactory.PropertyContainerType.NONE);
  } else if (schema instanceof ArrayProperty) {
    // Both response type and container "list" defined in @ApiOperation:
    // e.g. response = JavaBean.class, responseContainer = list
    Property itemsProperty = ArrayProperty.class.cast(schema).getItems();
    if (itemsProperty instanceof RefProperty) {
      newSchemaModel = wrapWithResultContainerModel(swagger, (RefProperty) itemsProperty, SwaggerRefPropertyFactory.PropertyContainerType.LIST);
    }
  }

  return newSchemaModel != null ? newSchemaModel : schema;
}
 

import io.swagger.models.properties.ArrayProperty; //导入依赖的package包/类
@Test
public void testTransformOperationForObjectList() {
  Operation operation = createOperation(createArrayProperty());
  Swagger swagger = createSwagger(operation);

  transformation.beforeHook(swagger);
  transformation.transformOperation(swagger, operation);

  // Test that the schema points to the injected ResultContainer model definition.
  RefProperty resultContainerRefProperty = (RefProperty) swagger.getPath("/test").getGet().getResponses().get("200").getSchema();
  assertEquals("ResultContainer-TestObject-list", resultContainerRefProperty.getSimpleRef());

  // Test that the injected ResultContainer model definition exists.
  Model refModelDefinition = swagger.getDefinitions().get("ResultContainer-TestObject-list");
  assertNotNull(refModelDefinition);

  // Test that the 'data' property points to the correct model definition.
  ArrayProperty dataArrayProperty = (ArrayProperty) refModelDefinition.getProperties().get("data");
  assertEquals("TestObject", ((RefProperty) dataArrayProperty.getItems()).getSimpleRef());
}
 

import io.swagger.models.properties.ArrayProperty; //导入依赖的package包/类
private void getSchemaFromModel(Model model) {
    HashMap<String, Property> references = getAllSchemaReferencesFromModel(model);

    references.forEach((modelKey, property) -> {
        String simpleRef = null;
        Boolean isArray = false;
        if (property instanceof RefProperty) {
            simpleRef = ((RefProperty) property).getSimpleRef();
        } else {
            Property items = ((ArrayProperty) property).getItems();
            if (items instanceof RefProperty) {
                simpleRef = ((RefProperty) items).getSimpleRef();
            } else {
                return;
            }
        }
        if (simpleRef != null) {
            getDefinationsFromSchemaReference(simpleRef, modelKey);
        }

    });
}
 

import io.swagger.models.properties.ArrayProperty; //导入依赖的package包/类
@Test
public void extractProperties() {
    final Map<String, Model> models = ModelConverters.getInstance().readAll(Family.class);
    assertEquals(models.size(), 3);

    final Model person = models.get("Person");
    final Property employer = person.getProperties().get("employer");

    assertTrue(employer instanceof ArrayProperty);
    final ArrayProperty employerProperty = (ArrayProperty) employer;

    final Property items = employerProperty.getItems();
    assertTrue(items instanceof RefProperty);
    assertEquals(((RefProperty) items).getSimpleRef(), "Employer");

    final Property awards = person.getProperties().get("awards");
    assertTrue(awards instanceof ArrayProperty);
    assertTrue(((ArrayProperty) awards).getItems() instanceof StringProperty);
}