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

Example 66 with Info

use of io.swagger.v3.oas.models.info.Info in project snow-owl by b2ihealthcare.

the class BaseApiConfig method docs.

/**
 * Expose this as @Bean annotated component in the implementation configuration class.
 * @return a configured docket for this API module
 */
protected final GroupedOpenApi docs(final String apiBaseUrl, final String apiGroup, final String apiVersion, final String apiTitle, final String apiTermsOfServiceUrl, final String apiContact, final String apiLicense, final String apiLicenseUrl, final String apiDescription) {
    return GroupedOpenApi.builder().group(apiGroup).pathsToMatch(apiBaseUrl.endsWith("/") ? apiBaseUrl + "**" : apiBaseUrl + "/**").packagesToScan(getApiBasePackages()).addOpenApiCustomiser(api -> {
        Info apiInfo = api.getInfo();
        apiInfo.setTitle(apiTitle);
        apiInfo.setDescription(apiDescription);
        apiInfo.setVersion(apiVersion);
        apiInfo.setTermsOfService(apiTermsOfServiceUrl);
        Contact contact = new Contact();
        contact.setName("B2i Healthcare");
        contact.setEmail(apiContact);
        contact.setUrl(apiLicenseUrl);
        apiInfo.setContact(contact);
        License license = new License();
        license.setName(apiLicense);
        license.setUrl(apiLicenseUrl);
        apiInfo.setLicense(license);
        // configure global security
        api.getComponents().addSecuritySchemes("basic", new SecurityScheme().type(SecurityScheme.Type.HTTP).scheme("basic")).addSecuritySchemes("bearer", new SecurityScheme().type(SecurityScheme.Type.APIKEY).scheme("bearer").in(In.HEADER).bearerFormat("JWT"));
        // disable servers prop
        api.setServers(List.of());
    }).addOperationCustomizer((operation, method) -> {
        return operation.addSecurityItem(new SecurityRequirement().addList("basic").addList("bearer"));
    }).build();
// .useDefaultResponseMessages(false)
// .alternateTypeRules(getAlternateTypeRules(resolver));
}

Example 67 with Info

use of io.swagger.v3.oas.models.info.Info in project carbon-apimgt by wso2.

the class GraphQLSchemaDefinition method buildSchemaWithAdditionalInfo.

/**
 * build schema with additional info
 *
 * @param api                   api object
 * @param graphqlComplexityInfo
 * @return schemaDefinition
 */
public String buildSchemaWithAdditionalInfo(API api, GraphqlComplexityInfo graphqlComplexityInfo) {
    Swagger swagger = null;
    Map<String, String> scopeRoleMap = new HashMap<>();
    Map<String, String> operationScopeMap = new HashMap<>();
    Map<String, String> operationAuthSchemeMap = new HashMap<>();
    Map<String, String> operationThrottlingMap = new HashMap<>();
    String operationScopeType;
    StringBuilder schemaDefinitionBuilder = new StringBuilder(api.getGraphQLSchema());
    schemaDefinitionBuilder.append("\n");
    StringBuilder operationScopeMappingBuilder = new StringBuilder();
    StringBuilder scopeRoleMappingBuilder = new StringBuilder();
    StringBuilder operationAuthSchemeMappingBuilder = new StringBuilder();
    StringBuilder operationThrottlingMappingBuilder = new StringBuilder();
    StringBuilder policyBuilder = new StringBuilder();
    String swaggerDef = api.getSwaggerDefinition();
    OpenAPI openAPI = null;
    LinkedHashMap<String, Object> scopeBindings = null;
    if (swaggerDef != null) {
        OpenAPIParser parser = new OpenAPIParser();
        openAPI = parser.readContents(swaggerDef, null, null).getOpenAPI();
    }
    Map<String, Object> extensions = null;
    if (openAPI != null) {
        extensions = openAPI.getComponents().getSecuritySchemes().get(APIConstants.SWAGGER_APIM_DEFAULT_SECURITY).getFlows().getImplicit().getExtensions();
    }
    if (extensions != null) {
        scopeBindings = (LinkedHashMap<String, Object>) openAPI.getComponents().getSecuritySchemes().get(APIConstants.SWAGGER_APIM_DEFAULT_SECURITY).getFlows().getImplicit().getExtensions().get(APIConstants.SWAGGER_X_SCOPES_BINDINGS);
    }
    if (swaggerDef != null) {
        for (URITemplate template : api.getUriTemplates()) {
            String scopeInURITemplate = template.getScope() != null ? template.getScope().getKey() : null;
            if (scopeInURITemplate != null) {
                operationScopeMap.put(template.getUriTemplate(), scopeInURITemplate);
                if (!scopeRoleMap.containsKey(scopeInURITemplate)) {
                    if (scopeBindings != null) {
                        scopeRoleMap.put(scopeInURITemplate, scopeBindings.get(scopeInURITemplate).toString());
                    }
                }
            }
        }
        for (URITemplate template : api.getUriTemplates()) {
            operationThrottlingMap.put(template.getUriTemplate(), template.getThrottlingTier());
            operationAuthSchemeMap.put(template.getUriTemplate(), template.getAuthType());
        }
        if (operationScopeMap.size() > 0) {
            String base64EncodedURLOperationKey;
            String base64EncodedURLScope;
            for (Map.Entry<String, String> entry : operationScopeMap.entrySet()) {
                base64EncodedURLOperationKey = Base64.getUrlEncoder().withoutPadding().encodeToString(entry.getKey().getBytes(Charset.defaultCharset()));
                base64EncodedURLScope = Base64.getUrlEncoder().withoutPadding().encodeToString(entry.getValue().getBytes(Charset.defaultCharset()));
                operationScopeType = "type " + APIConstants.SCOPE_OPERATION_MAPPING + "_" + base64EncodedURLOperationKey + "{\n" + base64EncodedURLScope + ": String\n}\n";
                operationScopeMappingBuilder.append(operationScopeType);
            }
            schemaDefinitionBuilder.append(operationScopeMappingBuilder.toString());
        }
        if (scopeRoleMap.size() > 0) {
            String[] roleList;
            String scopeType;
            String base64EncodedURLScopeKey;
            String scopeRoleMappingType;
            String base64EncodedURLRole;
            String roleField;
            for (Map.Entry<String, String> entry : scopeRoleMap.entrySet()) {
                List<String> scopeRoles = new ArrayList<>();
                base64EncodedURLScopeKey = Base64.getUrlEncoder().withoutPadding().encodeToString(entry.getKey().getBytes(Charset.defaultCharset()));
                scopeType = "type " + APIConstants.SCOPE_ROLE_MAPPING + "_" + base64EncodedURLScopeKey + "{\n";
                StringBuilder scopeRoleBuilder = new StringBuilder(scopeType);
                roleList = entry.getValue().split(",");
                for (String role : roleList) {
                    if (!role.equals("") && !scopeRoles.contains(role)) {
                        base64EncodedURLRole = Base64.getUrlEncoder().withoutPadding().encodeToString(role.getBytes(Charset.defaultCharset()));
                        roleField = base64EncodedURLRole + ": String\n";
                        scopeRoleBuilder.append(roleField);
                        scopeRoles.add(role);
                    }
                }
                if (scopeRoles.size() > 0 && !StringUtils.isEmpty(scopeRoleBuilder.toString())) {
                    scopeRoleMappingType = scopeRoleBuilder.toString() + "}\n";
                    scopeRoleMappingBuilder.append(scopeRoleMappingType);
                }
            }
            schemaDefinitionBuilder.append(scopeRoleMappingBuilder.toString());
        }
        if (operationThrottlingMap.size() > 0) {
            String operationThrottlingType;
            for (Map.Entry<String, String> entry : operationThrottlingMap.entrySet()) {
                String base64EncodedURLOperationKey = Base64.getUrlEncoder().withoutPadding().encodeToString(entry.getKey().getBytes(Charset.defaultCharset()));
                String base64EncodedURLThrottilingTier = Base64.getUrlEncoder().withoutPadding().encodeToString(entry.getValue().getBytes(Charset.defaultCharset()));
                operationThrottlingType = "type " + APIConstants.OPERATION_THROTTLING_MAPPING + "_" + base64EncodedURLOperationKey + "{\n" + base64EncodedURLThrottilingTier + ": String\n}\n";
                operationThrottlingMappingBuilder.append(operationThrottlingType);
            }
            schemaDefinitionBuilder.append(operationThrottlingMappingBuilder.toString());
        }
        if (operationAuthSchemeMap.size() > 0) {
            String operationAuthSchemeType;
            String isSecurityEnabled;
            for (Map.Entry<String, String> entry : operationAuthSchemeMap.entrySet()) {
                String base64EncodedURLOperationKey = Base64.getUrlEncoder().withoutPadding().encodeToString(entry.getKey().getBytes(Charset.defaultCharset()));
                if (entry.getValue().equalsIgnoreCase(APIConstants.AUTH_NO_AUTHENTICATION)) {
                    isSecurityEnabled = APIConstants.OPERATION_SECURITY_DISABLED;
                } else {
                    isSecurityEnabled = APIConstants.OPERATION_SECURITY_ENABLED;
                }
                operationAuthSchemeType = "type " + APIConstants.OPERATION_AUTH_SCHEME_MAPPING + "_" + base64EncodedURLOperationKey + "{\n" + isSecurityEnabled + ": String\n}\n";
                operationAuthSchemeMappingBuilder.append(operationAuthSchemeType);
            }
            schemaDefinitionBuilder.append(operationAuthSchemeMappingBuilder.toString());
        }
        if (operationAuthSchemeMap.size() > 0) {
            // Constructing the policy definition
            JSONObject jsonPolicyDefinition = policyDefinitionToJson(graphqlComplexityInfo);
            String base64EncodedPolicyDefinition = Base64.getUrlEncoder().withoutPadding().encodeToString(jsonPolicyDefinition.toJSONString().getBytes(Charset.defaultCharset()));
            String policyDefinition = "type " + APIConstants.GRAPHQL_ACCESS_CONTROL_POLICY + " {\n" + base64EncodedPolicyDefinition + ": String\n}\n";
            policyBuilder.append(policyDefinition);
            schemaDefinitionBuilder.append(policyBuilder.toString());
        }
    }
    return schemaDefinitionBuilder.toString();
}

Example 68 with Info

use of io.swagger.v3.oas.models.info.Info in project carbon-apimgt by wso2.

the class OAS3Parser method validateAPIDefinition.

/**
 * This method validates the given OpenAPI definition by content
 *
 * @param apiDefinition     OpenAPI Definition content
 * @param host OpenAPI Definition url
 * @param returnJsonContent whether to return the converted json form of the OpenAPI definition
 * @return APIDefinitionValidationResponse object with validation information
 */
@Override
public APIDefinitionValidationResponse validateAPIDefinition(String apiDefinition, String host, boolean returnJsonContent) throws APIManagementException {
    APIDefinitionValidationResponse validationResponse = new APIDefinitionValidationResponse();
    OpenAPIV3Parser openAPIV3Parser = new OpenAPIV3Parser();
    ParseOptions options = new ParseOptions();
    options.setResolve(true);
    SwaggerParseResult parseAttemptForV3 = openAPIV3Parser.readContents(apiDefinition, null, options);
    if (CollectionUtils.isNotEmpty(parseAttemptForV3.getMessages())) {
        validationResponse.setValid(false);
        for (String message : parseAttemptForV3.getMessages()) {
            OASParserUtil.addErrorToValidationResponse(validationResponse, message);
            if (message.contains(APIConstants.OPENAPI_IS_MISSING_MSG)) {
                ErrorItem errorItem = new ErrorItem();
                errorItem.setErrorCode(ExceptionCodes.INVALID_OAS3_FOUND.getErrorCode());
                errorItem.setMessage(ExceptionCodes.INVALID_OAS3_FOUND.getErrorMessage());
                errorItem.setDescription(ExceptionCodes.INVALID_OAS3_FOUND.getErrorMessage());
                validationResponse.getErrorItems().add(errorItem);
            }
        }
    } else {
        OpenAPI openAPI = parseAttemptForV3.getOpenAPI();
        io.swagger.v3.oas.models.info.Info info = openAPI.getInfo();
        List<String> endpoints;
        String endpointWithHost = "";
        if (openAPI.getServers() == null || openAPI.getServers().isEmpty()) {
            endpoints = null;
        } else {
            endpoints = openAPI.getServers().stream().map(url -> url.getUrl()).collect(Collectors.toList());
            for (String endpoint : endpoints) {
                if (endpoint.startsWith("/")) {
                    if (StringUtils.isEmpty(host)) {
                        endpointWithHost = "http://api.yourdomain.com" + endpoint;
                    } else {
                        endpointWithHost = host + endpoint;
                    }
                    endpoints.set(endpoints.indexOf(endpoint), endpointWithHost);
                }
            }
        }
        String title = null;
        String context = null;
        if (!StringUtils.isBlank(info.getTitle())) {
            title = info.getTitle();
            context = info.getTitle().replaceAll("\\s", "").toLowerCase();
        }
        OASParserUtil.updateValidationResponseAsSuccess(validationResponse, apiDefinition, openAPI.getOpenapi(), title, info.getVersion(), context, info.getDescription(), endpoints);
        validationResponse.setParser(this);
        if (returnJsonContent) {
            if (!apiDefinition.trim().startsWith("{")) {
                // not a json (it is yaml)
                JsonNode jsonNode = DeserializationUtils.readYamlTree(apiDefinition);
                validationResponse.setJsonContent(jsonNode.toString());
            } else {
                validationResponse.setJsonContent(apiDefinition);
            }
        }
    }
    return validationResponse;
}

Example 69 with Info

use of io.swagger.v3.oas.models.info.Info in project carbon-apimgt by wso2.

the class RestApiCommonUtil method generateOpenAPIForAsync.

/**
 * Generate a basic OpenAPI definition with given details.
 *
 * @param name             name of the API.
 * @param version          version of the API.
 * @param context          context of the API.
 * @param callbackEndpoint callback URL of the async API.
 * @return OpenAPI definition as String.
 * @throws JsonProcessingException Error occurred while generating the OpenAPI.
 */
public static String generateOpenAPIForAsync(String name, String version, String context, String callbackEndpoint) throws JsonProcessingException {
    OpenAPI openAPI = new OpenAPI();
    Info info = new Info();
    info.setTitle(name);
    info.setDescription("API Definition of " + name);
    info.setVersion(version);
    openAPI.setInfo(info);
    ArrayList<Server> servers = new ArrayList<>();
    Server server = new Server();
    server.setUrl("/");
    servers.add(server);
    openAPI.setServers(Arrays.asList(server));
    Paths paths = new Paths();
    PathItem pathItem = new PathItem();
    Operation operation = new Operation();
    ApiResponses apiResponses = new ApiResponses();
    ApiResponse apiResponse = new ApiResponse();
    apiResponse.setDescription("Default response");
    apiResponses.addApiResponse("default", apiResponse);
    operation.setResponses(apiResponses);
    pathItem.setPost(operation);
    paths.addPathItem("/*", pathItem);
    openAPI.paths(paths);
    List<String> urls = new ArrayList<>();
    urls.add(callbackEndpoint);
    Map<String, Object> tempMap = new HashMap();
    tempMap.put("type", "http");
    tempMap.put("urls", urls);
    openAPI.addExtension(X_WSO2_PRODUCTION_ENDPOINTS, tempMap);
    openAPI.addExtension(X_WSO2_SANDBOX_ENDPOINTS, tempMap);
    openAPI.addExtension(X_WSO2_AUTH_HEADER, "Authorization");
    openAPI.addExtension(X_WSO2_BASEPATH, context + "/" + version);
    openAPI.addExtension(X_WSO2_DISABLE_SECURITY, true);
    return Json.mapper().writeValueAsString(openAPI);
}

Example 70 with Info

use of io.swagger.v3.oas.models.info.Info in project atlasmap by atlasmap.

the class AtlasService method validateMappingRequest.

/**
 * Validates the mapping file.
 * @param mapping mapping
 * @param mappingDefinitionId mapping definition ID
 * @param uriInfo URI info
 * @return {@link Validations} validation result
 */
@PUT
@Path("/mapping/validate/{mappingDefinitionId}")
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
@Operation(summary = "Validate Mapping", description = "Validate mapping file")
@RequestBody(description = "Mapping file content", content = @Content(schema = @Schema(implementation = AtlasMapping.class)))
@ApiResponses(@ApiResponse(responseCode = "200", content = @Content(schema = @Schema(implementation = Validations.class)), description = "Return a validation result"))
public Response validateMappingRequest(InputStream mapping, @Parameter(description = "Mapping ID") @PathParam("mappingDefinitionId") Integer mappingDefinitionId, @Context UriInfo uriInfo) {
    try {
        AtlasMapping atlasMapping = fromJson(mapping, AtlasMapping.class);
        LOG.debug("Validate mappings: {}", atlasMapping.getName());
        return validateMapping(mappingDefinitionId, atlasMapping, uriInfo);
    } catch (AtlasException | IOException e) {
        throw new WebApplicationException(e.getMessage(), e, Status.INTERNAL_SERVER_ERROR);
    }
}