Examples with io.swagger.v3.oas.models.security io.swagger.v3.oas.models.security used on opensource projects

Example 1 with io.swagger.v3.oas.models.security

use of io.swagger.v3.oas.models.security in project flink by apache.

the class OpenApiSpecGenerator method createDocumentationFile.

@VisibleForTesting
static void createDocumentationFile(DocumentingRestEndpoint restEndpoint, RestAPIVersion apiVersion, Path outputFile) throws IOException {
    final OpenAPI openApi = new OpenAPI();
    // eagerly initialize some data-structures to simplify operations later on
    openApi.setPaths(new io.swagger.v3.oas.models.Paths());
    openApi.setComponents(new Components());
    setInfo(openApi, apiVersion);
    List<MessageHeaders> specs = restEndpoint.getSpecs().stream().filter(spec -> spec.getSupportedAPIVersions().contains(apiVersion)).filter(OpenApiSpecGenerator::shouldBeDocumented).collect(Collectors.toList());
    specs.forEach(spec -> add(spec, openApi));
    final List<Schema> asyncOperationSchemas = collectAsyncOperationResultVariants(specs);
    // this adds the schema for every JSON object
    openApi.components(new Components().schemas(new HashMap<>(modelConverterContext.getDefinedModels())));
    injectAsyncOperationResultSchema(openApi, asyncOperationSchemas);
    overrideIdSchemas(openApi);
    overrideSerializeThrowableSchema(openApi);
    Files.deleteIfExists(outputFile);
    Files.write(outputFile, Yaml.pretty(openApi).getBytes(StandardCharsets.UTF_8));
}

Example 2 with io.swagger.v3.oas.models.security

use of io.swagger.v3.oas.models.security in project swagger-core by swagger-api.

the class ParameterProcessor method applyAnnotations.

public static Parameter applyAnnotations(Parameter parameter, Type type, List<Annotation> annotations, Components components, String[] classTypes, String[] methodTypes, JsonView jsonViewAnnotation) {
    final AnnotationsHelper helper = new AnnotationsHelper(annotations, type);
    if (helper.isContext()) {
        return null;
    }
    if (parameter == null) {
        // consider it to be body param
        parameter = new Parameter();
    }
    // first handle schema
    List<Annotation> reworkedAnnotations = new ArrayList<>(annotations);
    Annotation paramSchemaOrArrayAnnotation = getParamSchemaAnnotation(annotations);
    if (paramSchemaOrArrayAnnotation != null) {
        reworkedAnnotations.add(paramSchemaOrArrayAnnotation);
    }
    AnnotatedType annotatedType = new AnnotatedType().type(type).resolveAsRef(true).skipOverride(true).jsonViewAnnotation(jsonViewAnnotation).ctxAnnotations(reworkedAnnotations.toArray(new Annotation[reworkedAnnotations.size()]));
    ResolvedSchema resolvedSchema = ModelConverters.getInstance().resolveAsResolvedSchema(annotatedType);
    if (resolvedSchema.schema != null) {
        parameter.setSchema(resolvedSchema.schema);
    }
    resolvedSchema.referencedSchemas.forEach(components::addSchemas);
    // handle first FormParam as it affects Explode resolving
    for (Annotation annotation : annotations) {
        if (annotation.annotationType().getName().equals("javax.ws.rs.FormParam")) {
            try {
                String name = (String) annotation.annotationType().getMethod("value").invoke(annotation);
                if (StringUtils.isNotBlank(name)) {
                    parameter.setName(name);
                }
            } catch (Exception e) {
            }
            // set temporarily to "form" to inform caller that we need to further process along other form parameters
            parameter.setIn("form");
        } else if (annotation.annotationType().getName().endsWith("FormDataParam")) {
            try {
                String name = (String) annotation.annotationType().getMethod("value").invoke(annotation);
                if (StringUtils.isNotBlank(name)) {
                    parameter.setName(name);
                }
            } catch (Exception e) {
            }
            // set temporarily to "form" to inform caller that we need to further process along other form parameters
            parameter.setIn("form");
        }
    }
    for (Annotation annotation : annotations) {
        if (annotation instanceof io.swagger.v3.oas.annotations.Parameter) {
            io.swagger.v3.oas.annotations.Parameter p = (io.swagger.v3.oas.annotations.Parameter) annotation;
            if (p.hidden()) {
                return null;
            }
            if (StringUtils.isNotBlank(p.ref())) {
                parameter = new Parameter().$ref(p.ref());
                return parameter;
            }
            if (StringUtils.isNotBlank(p.description())) {
                parameter.setDescription(p.description());
            }
            if (StringUtils.isNotBlank(p.name())) {
                parameter.setName(p.name());
            }
            if (StringUtils.isNotBlank(p.in().toString())) {
                parameter.setIn(p.in().toString());
            }
            if (StringUtils.isNotBlank(p.example())) {
                try {
                    parameter.setExample(Json.mapper().readTree(p.example()));
                } catch (IOException e) {
                    parameter.setExample(p.example());
                }
            }
            if (p.deprecated()) {
                parameter.setDeprecated(p.deprecated());
            }
            if (p.required()) {
                parameter.setRequired(p.required());
            }
            if (p.allowEmptyValue()) {
                parameter.setAllowEmptyValue(p.allowEmptyValue());
            }
            if (p.allowReserved()) {
                parameter.setAllowReserved(p.allowReserved());
            }
            Map<String, Example> exampleMap = new LinkedHashMap<>();
            if (p.examples().length == 1 && StringUtils.isBlank(p.examples()[0].name())) {
                Optional<Example> exampleOptional = AnnotationsUtils.getExample(p.examples()[0], true);
                if (exampleOptional.isPresent()) {
                    parameter.setExample(exampleOptional.get());
                }
            } else {
                for (ExampleObject exampleObject : p.examples()) {
                    AnnotationsUtils.getExample(exampleObject).ifPresent(example -> exampleMap.put(exampleObject.name(), example));
                }
            }
            if (exampleMap.size() > 0) {
                parameter.setExamples(exampleMap);
            }
            if (p.extensions().length > 0) {
                Map<String, Object> extensionMap = AnnotationsUtils.getExtensions(p.extensions());
                if (extensionMap != null && !extensionMap.isEmpty()) {
                    extensionMap.forEach(parameter::addExtension);
                }
            }
            Optional<Content> content = AnnotationsUtils.getContent(p.content(), classTypes, methodTypes, parameter.getSchema(), null, jsonViewAnnotation);
            if (content.isPresent()) {
                parameter.setContent(content.get());
                parameter.setSchema(null);
            }
            setParameterStyle(parameter, p);
            setParameterExplode(parameter, p);
        } else if (annotation.annotationType().getName().equals("javax.ws.rs.PathParam")) {
            try {
                String name = (String) annotation.annotationType().getMethod("value").invoke(annotation);
                if (StringUtils.isNotBlank(name)) {
                    parameter.setName(name);
                }
            } catch (Exception e) {
            }
        } else if (annotation.annotationType().getName().equals("javax.validation.constraints.Size")) {
            try {
                if (parameter.getSchema() == null) {
                    parameter.setSchema(new ArraySchema());
                }
                if (parameter.getSchema() instanceof ArraySchema) {
                    ArraySchema as = (ArraySchema) parameter.getSchema();
                    Integer min = (Integer) annotation.annotationType().getMethod("min").invoke(annotation);
                    if (min != null) {
                        as.setMinItems(min);
                    }
                    Integer max = (Integer) annotation.annotationType().getMethod("max").invoke(annotation);
                    if (max != null) {
                        as.setMaxItems(max);
                    }
                }
            } catch (Exception e) {
                LOGGER.error("failed on " + annotation.annotationType().getName(), e);
            }
        } else if (ModelResolver.NOT_NULL_ANNOTATIONS.contains(annotation.annotationType().getSimpleName())) {
            parameter.setRequired(true);
        }
    }
    final String defaultValue = helper.getDefaultValue();
    Schema paramSchema = parameter.getSchema();
    if (paramSchema == null) {
        if (parameter.getContent() != null && !parameter.getContent().values().isEmpty()) {
            paramSchema = parameter.getContent().values().iterator().next().getSchema();
        }
    }
    if (paramSchema != null) {
        if (paramSchema instanceof ArraySchema) {
            ArraySchema as = (ArraySchema) paramSchema;
            if (defaultValue != null) {
                as.getItems().setDefault(defaultValue);
            }
        } else {
            if (defaultValue != null) {
                paramSchema.setDefault(defaultValue);
            }
        }
    }
    return parameter;
}

Example 3 with io.swagger.v3.oas.models.security

use of io.swagger.v3.oas.models.security in project swagger-core by swagger-api.

the class EnumPropertyTest method testEnumRefPropertyWithFQNTypeNameResolver.

@Test(description = "it should read a model with an enum property as a reference with fqn TypeNameResolver")
public void testEnumRefPropertyWithFQNTypeNameResolver() {
    TypeNameResolver.std.setUseFqn(true);
    Schema schema = context.resolve(new AnnotatedType(ModelWithEnumRefProperty.class));
    final Map<String, Schema> models = context.getDefinedModels();
    final String yaml = "io.swagger.v3.core.oas.models.ModelWithEnumRefProperty:\n" + "  type: object\n" + "  properties:\n" + "    a:\n" + "      $ref: '#/components/schemas/io.swagger.v3.core.oas.models.TestEnum'\n" + "    b:\n" + "      $ref: '#/components/schemas/io.swagger.v3.core.oas.models.TestEnum'\n" + "    c:\n" + "      $ref: '#/components/schemas/io.swagger.v3.core.oas.models.TestSecondEnum'\n" + "    d:\n" + "      type: string\n" + "      enum:\n" + "      - A_PRIVATE\n" + "      - A_PUBLIC\n" + "      - A_SYSTEM\n" + "      - A_INVITE_ONLY\n" + "io.swagger.v3.core.oas.models.TestEnum:\n" + "  type: string\n" + "  enum:\n" + "  - PRIVATE\n" + "  - PUBLIC\n" + "  - SYSTEM\n" + "  - INVITE_ONLY\n" + "io.swagger.v3.core.oas.models.TestSecondEnum:\n" + "  type: string\n" + "  enum:\n" + "  - A_PRIVATE\n" + "  - A_PUBLIC\n" + "  - A_SYSTEM\n" + "  - A_INVITE_ONLY\n";
    TypeNameResolver.std.setUseFqn(false);
    SerializationMatchers.assertEqualsToYaml(models, yaml);
}

Example 4 with io.swagger.v3.oas.models.security

use of io.swagger.v3.oas.models.security in project swagger-core by swagger-api.

the class AnnotationsUtils method getSchemaFromAnnotation.

public static Optional<Schema> getSchemaFromAnnotation(io.swagger.v3.oas.annotations.media.Schema schema, Components components, JsonView jsonViewAnnotation) {
    if (schema == null || !hasSchemaAnnotation(schema)) {
        return Optional.empty();
    }
    Schema schemaObject = null;
    if (schema.oneOf().length > 0 || schema.allOf().length > 0 || schema.anyOf().length > 0) {
        schemaObject = new ComposedSchema();
    } else {
        schemaObject = new Schema();
    }
    if (StringUtils.isNotBlank(schema.description())) {
        schemaObject.setDescription(schema.description());
    }
    if (StringUtils.isNotBlank(schema.ref())) {
        schemaObject.set$ref(schema.ref());
    }
    if (StringUtils.isNotBlank(schema.type())) {
        schemaObject.setType(schema.type());
    }
    if (StringUtils.isNotBlank(schema.defaultValue())) {
        schemaObject.setDefault(schema.defaultValue());
    }
    if (StringUtils.isNotBlank(schema.example())) {
        try {
            schemaObject.setExample(Json.mapper().readTree(schema.example()));
        } catch (IOException e) {
            schemaObject.setExample(schema.example());
        }
    }
    if (StringUtils.isNotBlank(schema.format())) {
        schemaObject.setFormat(schema.format());
    }
    if (StringUtils.isNotBlank(schema.pattern())) {
        schemaObject.setPattern(schema.pattern());
    }
    if (schema.readOnly()) {
        schemaObject.setReadOnly(schema.readOnly());
    }
    if (schema.deprecated()) {
        schemaObject.setDeprecated(schema.deprecated());
    }
    if (schema.exclusiveMaximum()) {
        schemaObject.setExclusiveMaximum(schema.exclusiveMaximum());
    }
    if (schema.exclusiveMinimum()) {
        schemaObject.setExclusiveMinimum(schema.exclusiveMinimum());
    }
    if (schema.maxProperties() > 0) {
        schemaObject.setMaxProperties(schema.maxProperties());
    }
    if (schema.maxLength() != Integer.MAX_VALUE && schema.maxLength() > 0) {
        schemaObject.setMaxLength(schema.maxLength());
    }
    if (schema.minProperties() > 0) {
        schemaObject.setMinProperties(schema.minProperties());
    }
    if (schema.minLength() > 0) {
        schemaObject.setMinLength(schema.minLength());
    }
    if (schema.multipleOf() != 0) {
        schemaObject.setMultipleOf(BigDecimal.valueOf(schema.multipleOf()));
    }
    if (NumberUtils.isCreatable(schema.maximum())) {
        String filteredMaximum = schema.maximum().replace(Constants.COMMA, StringUtils.EMPTY);
        schemaObject.setMaximum(new BigDecimal(filteredMaximum));
    }
    if (NumberUtils.isCreatable(schema.minimum())) {
        String filteredMinimum = schema.minimum().replace(Constants.COMMA, StringUtils.EMPTY);
        schemaObject.setMinimum(new BigDecimal(filteredMinimum));
    }
    if (schema.nullable()) {
        schemaObject.setNullable(schema.nullable());
    }
    if (StringUtils.isNotBlank(schema.title())) {
        schemaObject.setTitle(schema.title());
    }
    if (schema.writeOnly()) {
        schemaObject.setWriteOnly(schema.writeOnly());
    }
    // process after readOnly and writeOnly
    if (schema.accessMode().equals(io.swagger.v3.oas.annotations.media.Schema.AccessMode.READ_ONLY)) {
        schemaObject.setReadOnly(true);
        schemaObject.setWriteOnly(null);
    } else if (schema.accessMode().equals(io.swagger.v3.oas.annotations.media.Schema.AccessMode.WRITE_ONLY)) {
        schemaObject.setReadOnly(false);
        schemaObject.setWriteOnly(null);
    } else if (schema.accessMode().equals(io.swagger.v3.oas.annotations.media.Schema.AccessMode.READ_WRITE)) {
        schemaObject.setReadOnly(null);
        schemaObject.setWriteOnly(null);
    }
    if (schema.requiredProperties().length > 0) {
        schemaObject.setRequired(Arrays.asList(schema.requiredProperties()));
    }
    if (schema.allowableValues().length > 0) {
        schemaObject.setEnum(Arrays.asList(schema.allowableValues()));
    }
    if (schema.extensions().length > 0) {
        Map<String, Object> extensions = AnnotationsUtils.getExtensions(schema.extensions());
        if (extensions != null) {
            extensions.forEach(schemaObject::addExtension);
        }
    }
    getExternalDocumentation(schema.externalDocs()).ifPresent(schemaObject::setExternalDocs);
    if (!schema.not().equals(Void.class)) {
        Class<?> schemaImplementation = schema.not();
        Schema notSchemaObject = resolveSchemaFromType(schemaImplementation, components, jsonViewAnnotation);
        schemaObject.setNot(notSchemaObject);
    }
    if (schema.oneOf().length > 0) {
        Class<?>[] schemaImplementations = schema.oneOf();
        for (Class<?> schemaImplementation : schemaImplementations) {
            Schema oneOfSchemaObject = resolveSchemaFromType(schemaImplementation, components, jsonViewAnnotation);
            ((ComposedSchema) schemaObject).addOneOfItem(oneOfSchemaObject);
        }
    }
    if (schema.anyOf().length > 0) {
        Class<?>[] schemaImplementations = schema.anyOf();
        for (Class<?> schemaImplementation : schemaImplementations) {
            Schema anyOfSchemaObject = resolveSchemaFromType(schemaImplementation, components, jsonViewAnnotation);
            ((ComposedSchema) schemaObject).addAnyOfItem(anyOfSchemaObject);
        }
    }
    if (schema.allOf().length > 0) {
        Class<?>[] schemaImplementations = schema.allOf();
        for (Class<?> schemaImplementation : schemaImplementations) {
            Schema allOfSchemaObject = resolveSchemaFromType(schemaImplementation, components, jsonViewAnnotation);
            ((ComposedSchema) schemaObject).addAllOfItem(allOfSchemaObject);
        }
    }
    if (schema.additionalProperties().equals(io.swagger.v3.oas.annotations.media.Schema.AdditionalPropertiesValue.TRUE)) {
        schemaObject.additionalProperties(true);
    } else if (schema.additionalProperties().equals(io.swagger.v3.oas.annotations.media.Schema.AdditionalPropertiesValue.FALSE)) {
        schemaObject.additionalProperties(false);
    }
    return Optional.of(schemaObject);
}

Example 5 with io.swagger.v3.oas.models.security

use of io.swagger.v3.oas.models.security in project swagger-core by swagger-api.

the class CustomResolverTest method testCustomConverter.

@Test(description = "it should ignore properties with type Bar")
public void testCustomConverter() {
    // add the custom converter
    final ModelConverters converters = new ModelConverters();
    converters.addConverter(new CustomConverter(Json.mapper()));
    Map<String, Schema> models = converters.readAll(Foo.class);
    Schema model = models.get("io.swagger.v3.core.converting.override.CustomResolverTest$Foo");
    assertNotNull(model);
    assertEquals(model.getProperties().size(), 2);
    final Schema barProperty = (Schema) model.getProperties().get("bar");
    assertEquals(barProperty.get$ref(), "#/components/schemas/io.swagger.v3.core.converting.override.CustomResolverTest$Bar");
    final Schema titleProperty = (Schema) model.getProperties().get("title");
    assertNotNull(titleProperty);
    model = models.get("io.swagger.v3.core.converting.override.CustomResolverTest$Bar");
    assertNotNull(model);
}