Examples with OAS2Parser org.wso2.carbon.apimgt.impl.definitions.OAS2Parser used on opensource projects

Example 1 with OAS2Parser

use of org.wso2.carbon.apimgt.impl.definitions.OAS2Parser in project carbon-apimgt by wso2.

the class PublisherCommonUtils method addAPIWithGeneratedSwaggerDefinition.

/**
 * Add API with the generated swagger from the DTO.
 *
 * @param apiDto     API DTO of the API
 * @param oasVersion Open API Definition version
 * @param username   Username
 * @param organization  Organization Identifier
 * @return Created API object
 * @throws APIManagementException Error while creating the API
 * @throws CryptoException        Error while encrypting
 */
public static API addAPIWithGeneratedSwaggerDefinition(APIDTO apiDto, String oasVersion, String username, String organization) throws APIManagementException, CryptoException {
    if (APIUtil.isOnPremResolver()) {
        String name = apiDto.getName();
        // replace all white spaces in the API Name
        apiDto.setName(name.replaceAll("\\s+", ""));
    }
    if (APIDTO.TypeEnum.ASYNC.equals(apiDto.getType())) {
        throw new APIManagementException("ASYNC API type does not support API creation from scratch", ExceptionCodes.API_CREATION_NOT_SUPPORTED_FOR_ASYNC_TYPE_APIS);
    }
    boolean isWSAPI = APIDTO.TypeEnum.WS.equals(apiDto.getType());
    boolean isAsyncAPI = isWSAPI || APIDTO.TypeEnum.WEBSUB.equals(apiDto.getType()) || APIDTO.TypeEnum.SSE.equals(apiDto.getType()) || APIDTO.TypeEnum.ASYNC.equals(apiDto.getType());
    username = StringUtils.isEmpty(username) ? RestApiCommonUtil.getLoggedInUsername() : username;
    APIProvider apiProvider = RestApiCommonUtil.getProvider(username);
    // validate web socket api endpoint configurations
    if (isWSAPI && !PublisherCommonUtils.isValidWSAPI(apiDto)) {
        throw new APIManagementException("Endpoint URLs should be valid web socket URLs", ExceptionCodes.INVALID_ENDPOINT_URL);
    }
    // validate sandbox and production endpoints
    if (!PublisherCommonUtils.validateEndpoints(apiDto)) {
        throw new APIManagementException("Invalid/Malformed endpoint URL(s) detected", ExceptionCodes.INVALID_ENDPOINT_URL);
    }
    Map endpointConfig = (Map) apiDto.getEndpointConfig();
    CryptoUtil cryptoUtil = CryptoUtil.getDefaultCryptoUtil();
    // OAuth 2.0 backend protection: API Key and API Secret encryption
    encryptEndpointSecurityOAuthCredentials(endpointConfig, cryptoUtil, StringUtils.EMPTY, StringUtils.EMPTY, apiDto);
    // AWS Lambda: secret key encryption while creating the API
    if (apiDto.getEndpointConfig() != null) {
        if (endpointConfig.containsKey(APIConstants.AMZN_SECRET_KEY)) {
            String secretKey = (String) endpointConfig.get(APIConstants.AMZN_SECRET_KEY);
            if (!StringUtils.isEmpty(secretKey)) {
                String encryptedSecretKey = cryptoUtil.encryptAndBase64Encode(secretKey.getBytes());
                endpointConfig.put(APIConstants.AMZN_SECRET_KEY, encryptedSecretKey);
                apiDto.setEndpointConfig(endpointConfig);
            }
        }
    }
    /* if (isWSAPI) {
            ArrayList<String> websocketTransports = new ArrayList<>();
            websocketTransports.add(APIConstants.WS_PROTOCOL);
            websocketTransports.add(APIConstants.WSS_PROTOCOL);
            apiDto.setTransport(websocketTransports);
        }*/
    API apiToAdd = prepareToCreateAPIByDTO(apiDto, apiProvider, username, organization);
    validateScopes(apiToAdd);
    // validate API categories
    List<APICategory> apiCategories = apiToAdd.getApiCategories();
    List<APICategory> apiCategoriesList = new ArrayList<>();
    for (APICategory category : apiCategories) {
        category.setOrganization(organization);
        apiCategoriesList.add(category);
    }
    apiToAdd.setApiCategories(apiCategoriesList);
    if (apiCategoriesList.size() > 0) {
        if (!APIUtil.validateAPICategories(apiCategoriesList, organization)) {
            throw new APIManagementException("Invalid API Category name(s) defined", ExceptionCodes.from(ExceptionCodes.API_CATEGORY_INVALID));
        }
    }
    if (!isAsyncAPI) {
        APIDefinition oasParser;
        if (RestApiConstants.OAS_VERSION_2.equalsIgnoreCase(oasVersion)) {
            oasParser = new OAS2Parser();
        } else {
            oasParser = new OAS3Parser();
        }
        SwaggerData swaggerData = new SwaggerData(apiToAdd);
        String apiDefinition = oasParser.generateAPIDefinition(swaggerData);
        apiToAdd.setSwaggerDefinition(apiDefinition);
    } else {
        AsyncApiParser asyncApiParser = new AsyncApiParser();
        String asyncApiDefinition = asyncApiParser.generateAsyncAPIDefinition(apiToAdd);
        apiToAdd.setAsyncApiDefinition(asyncApiDefinition);
    }
    apiToAdd.setOrganization(organization);
    if (isAsyncAPI) {
        AsyncApiParser asyncApiParser = new AsyncApiParser();
        String apiDefinition = asyncApiParser.generateAsyncAPIDefinition(apiToAdd);
        apiToAdd.setAsyncApiDefinition(apiDefinition);
    }
    // adding the api
    apiProvider.addAPI(apiToAdd);
    return apiToAdd;
}

Example 2 with OAS2Parser

use of org.wso2.carbon.apimgt.impl.definitions.OAS2Parser in project carbon-apimgt by wso2.

the class OASParserUtilTest method testGetOASParser.

@Test
public void testGetOASParser() throws Exception {
    String oas3 = IOUtils.toString(getClass().getClassLoader().getResourceAsStream("definitions" + File.separator + "petstore_v3.yaml"), "UTF-8");
    APIDefinition definition = OASParserUtil.getOASParser(oas3);
    Assert.assertNotNull(definition);
    Assert.assertTrue(definition instanceof OAS3Parser);
    String oas2 = IOUtils.toString(getClass().getClassLoader().getResourceAsStream("definitions" + File.separator + "petstore_v2.yaml"), "UTF-8");
    definition = OASParserUtil.getOASParser(oas2);
    Assert.assertNotNull(definition);
    Assert.assertTrue(definition instanceof OAS2Parser);
    String oasError = IOUtils.toString(getClass().getClassLoader().getResourceAsStream("definitions" + File.separator + "petstore_error.json"), "UTF-8");
    try {
        definition = OASParserUtil.getOASParser(oasError);
        Assert.fail("Exception expected");
    } catch (APIManagementException e) {
        Assert.assertTrue(e.getCause() instanceof IOException);
    }
    String oasInvalid = IOUtils.toString(getClass().getClassLoader().getResourceAsStream("definitions" + File.separator + "petstore_invalid.yaml"), "UTF-8");
    try {
        definition = OASParserUtil.getOASParser(oasInvalid);
        Assert.fail("Exception expected");
    } catch (APIManagementException e) {
        Assert.assertTrue(e.getMessage().contains("Invalid OAS definition provided."));
    }
}

Example 3 with OAS2Parser

use of org.wso2.carbon.apimgt.impl.definitions.OAS2Parser in project carbon-apimgt by wso2.

the class OASParserUtil method extractRelevantSourceData.

private static void extractRelevantSourceData(Map<API, List<APIProductResource>> apiToProductResourceMapping, SwaggerUpdateContext context) throws APIManagementException {
    // Extract Paths that exist in the destination swagger from the source swagger
    for (Map.Entry<API, List<APIProductResource>> mappingEntry : apiToProductResourceMapping.entrySet()) {
        String sourceSwagger = mappingEntry.getKey().getSwaggerDefinition();
        SwaggerVersion sourceSwaggerVersion = getSwaggerVersion(sourceSwagger);
        if (sourceSwaggerVersion == SwaggerVersion.OPEN_API) {
            OpenAPI srcOpenAPI = ((OAS3Parser) oas3Parser).getOpenAPI(sourceSwagger);
            Set<Components> aggregatedComponents = context.getAggregatedComponents();
            Components components = srcOpenAPI.getComponents();
            if (components != null) {
                aggregatedComponents.add(components);
            }
            Set<Scope> allScopes = oas3Parser.getScopes(sourceSwagger);
            Paths srcPaths = srcOpenAPI.getPaths();
            List<APIProductResource> apiProductResources = mappingEntry.getValue();
            for (APIProductResource apiProductResource : apiProductResources) {
                URITemplate uriTemplate = apiProductResource.getUriTemplate();
                PathItem srcPathItem = srcPaths.get(uriTemplate.getUriTemplate());
                readPathsAndScopes(srcPathItem, uriTemplate, allScopes, context);
            }
        } else if (sourceSwaggerVersion == SwaggerVersion.SWAGGER) {
            Swagger srcSwagger = ((OAS2Parser) oas2Parser).getSwagger(sourceSwagger);
            Set<Components> aggregatedComponents = context.getAggregatedComponents();
            Components components = swaggerConverter.readContents(sourceSwagger, null, null).getOpenAPI().getComponents();
            if (components != null) {
                aggregatedComponents.add(components);
            }
            Set<Scope> allScopes = oas2Parser.getScopes(sourceSwagger);
            Map<String, Path> srcPaths = srcSwagger.getPaths();
            List<APIProductResource> apiProductResources = mappingEntry.getValue();
            for (APIProductResource apiProductResource : apiProductResources) {
                URITemplate uriTemplate = apiProductResource.getUriTemplate();
                Path srcPath = srcPaths.get(uriTemplate.getUriTemplate());
                readPathsAndScopes(swaggerConverter.convert(srcPath), uriTemplate, allScopes, context);
            }
        }
    }
}

Example 4 with OAS2Parser

use of org.wso2.carbon.apimgt.impl.definitions.OAS2Parser in project carbon-apimgt by wso2.

the class ApisApiServiceImpl method importSOAPAPI.

/**
 * Import an API from WSDL as a SOAP API
 *
 * @param fileInputStream file data as input stream
 * @param fileDetail file details
 * @param url URL of the WSDL
 * @param apiToAdd API object to be added to the system (which is not added yet)
 * @param organization Organization
 * @param service service
 * @return API added api
 */
private API importSOAPAPI(InputStream fileInputStream, Attachment fileDetail, String url, API apiToAdd, String organization, ServiceEntry service) {
    try {
        APIProvider apiProvider = RestApiCommonUtil.getLoggedInUserProvider();
        // adding the api
        apiProvider.addAPI(apiToAdd);
        if (StringUtils.isNotBlank(url)) {
            apiToAdd.setWsdlUrl(url);
            apiProvider.addWSDLResource(apiToAdd.getUuid(), null, url, organization);
        } else if (fileDetail != null && fileInputStream != null) {
            PublisherCommonUtils.addWsdl(fileDetail.getContentType().toString(), fileInputStream, apiToAdd, apiProvider, organization);
        } else if (service != null && fileInputStream == null) {
            RestApiUtil.handleBadRequest("Error while importing WSDL to create a SOAP API", log);
        } else if (service != null) {
            PublisherCommonUtils.addWsdl(RestApiConstants.APPLICATION_OCTET_STREAM, fileInputStream, apiToAdd, apiProvider, organization);
        }
        // add the generated swagger definition to SOAP
        APIDefinition oasParser = new OAS2Parser();
        SwaggerData swaggerData = new SwaggerData(apiToAdd);
        String apiDefinition = generateSOAPAPIDefinition(oasParser.generateAPIDefinition(swaggerData));
        apiProvider.saveSwaggerDefinition(apiToAdd, apiDefinition, organization);
        APIIdentifier createdApiId = apiToAdd.getId();
        // Retrieve the newly added API to send in the response payload
        API createdApi = apiProvider.getAPIbyUUID(apiToAdd.getUuid(), organization);
        return createdApi;
    } catch (APIManagementException e) {
        RestApiUtil.handleInternalServerError("Error while importing WSDL to create a SOAP API", e, log);
    }
    return null;
}