Examples with URLMapping org.wso2.carbon.apimgt.api.model.subscription.URLMapping used on opensource projects

Example 11 with URLMapping

use of org.wso2.carbon.apimgt.api.model.subscription.URLMapping in project carbon-apimgt by wso2.

the class SubscriptionValidationDataUtil method fromAPIToAPIListDTO.

public static APIListDTO fromAPIToAPIListDTO(API model) {
    APIListDTO apiListdto = new APIListDTO();
    if (model != null) {
        APIDTO apidto = new APIDTO();
        apidto.setUuid(model.getApiUUID());
        apidto.setApiId(model.getApiId());
        apidto.setVersion(model.getVersion());
        apidto.setContext(model.getContext());
        apidto.setPolicy(model.getPolicy());
        apidto.setProvider(model.getProvider());
        apidto.setApiType(model.getApiType());
        apidto.setName(model.getName());
        apidto.setStatus(model.getStatus());
        apidto.setIsDefaultVersion(model.isDefaultVersion());
        Map<String, URLMapping> urlMappings = model.getAllResources();
        List<URLMappingDTO> urlMappingsDTO = new ArrayList<>();
        for (URLMapping urlMapping : urlMappings.values()) {
            URLMappingDTO urlMappingDTO = new URLMappingDTO();
            urlMappingDTO.setAuthScheme(urlMapping.getAuthScheme());
            urlMappingDTO.setHttpMethod(urlMapping.getHttpMethod());
            urlMappingDTO.setThrottlingPolicy(urlMapping.getThrottlingPolicy());
            urlMappingDTO.setUrlPattern(urlMapping.getUrlPattern());
            urlMappingDTO.setScopes(urlMapping.getScopes());
            urlMappingsDTO.add(urlMappingDTO);
        }
        apidto.setUrlMappings(urlMappingsDTO);
        apiListdto.setCount(1);
        apiListdto.getList().add(apidto);
    } else {
        apiListdto.setCount(0);
    }
    return apiListdto;
}

Example 12 with URLMapping

use of org.wso2.carbon.apimgt.api.model.subscription.URLMapping in project carbon-apimgt by wso2.

the class ApiMgtDAO method addAPIRevision.

/**
 * Adds an API revision record to the database
 *
 * @param apiRevision content of the revision
 * @throws APIManagementException if an error occurs when adding a new API revision
 */
public void addAPIRevision(APIRevision apiRevision) throws APIManagementException {
    try (Connection connection = APIMgtDBUtil.getConnection()) {
        try {
            connection.setAutoCommit(false);
            // Adding to AM_REVISION table
            PreparedStatement statement = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.ADD_API_REVISION);
            statement.setInt(1, apiRevision.getId());
            statement.setString(2, apiRevision.getApiUUID());
            statement.setString(3, apiRevision.getRevisionUUID());
            statement.setString(4, apiRevision.getDescription());
            statement.setString(5, apiRevision.getCreatedBy());
            statement.setTimestamp(6, new Timestamp(System.currentTimeMillis()));
            statement.executeUpdate();
            // Retrieve API ID
            APIIdentifier apiIdentifier = APIUtil.getAPIIdentifierFromUUID(apiRevision.getApiUUID());
            int apiId = getAPIID(apiRevision.getApiUUID(), connection);
            int tenantId = APIUtil.getTenantId(APIUtil.replaceEmailDomainBack(apiIdentifier.getProviderName()));
            String tenantDomain = APIUtil.getTenantDomainFromTenantId(tenantId);
            // Adding to AM_API_URL_MAPPING table
            PreparedStatement getURLMappingsStatement = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.GET_URL_MAPPINGS_WITH_SCOPE_AND_PRODUCT_ID);
            getURLMappingsStatement.setInt(1, apiId);
            List<URITemplate> urlMappingList = new ArrayList<>();
            try (ResultSet rs = getURLMappingsStatement.executeQuery()) {
                while (rs.next()) {
                    String script = null;
                    URITemplate uriTemplate = new URITemplate();
                    uriTemplate.setHTTPVerb(rs.getString(1));
                    uriTemplate.setAuthType(rs.getString(2));
                    uriTemplate.setUriTemplate(rs.getString(3));
                    uriTemplate.setThrottlingTier(rs.getString(4));
                    InputStream mediationScriptBlob = rs.getBinaryStream(5);
                    if (mediationScriptBlob != null) {
                        script = APIMgtDBUtil.getStringFromInputStream(mediationScriptBlob);
                    }
                    uriTemplate.setMediationScript(script);
                    if (!StringUtils.isEmpty(rs.getString(6))) {
                        Scope scope = new Scope();
                        scope.setKey(rs.getString(6));
                        uriTemplate.setScope(scope);
                    }
                    if (rs.getInt(7) != 0) {
                        // Adding product id to uri template id just to store value
                        uriTemplate.setId(rs.getInt(7));
                    }
                    urlMappingList.add(uriTemplate);
                }
            }
            Map<String, URITemplate> uriTemplateMap = new HashMap<>();
            for (URITemplate urlMapping : urlMappingList) {
                if (urlMapping.getScope() != null) {
                    URITemplate urlMappingNew = urlMapping;
                    URITemplate urlMappingExisting = uriTemplateMap.get(urlMapping.getUriTemplate() + urlMapping.getHTTPVerb());
                    if (urlMappingExisting != null && urlMappingExisting.getScopes() != null) {
                        if (!urlMappingExisting.getScopes().contains(urlMapping.getScope())) {
                            urlMappingExisting.setScopes(urlMapping.getScope());
                            uriTemplateMap.put(urlMappingExisting.getUriTemplate() + urlMappingExisting.getHTTPVerb(), urlMappingExisting);
                        }
                    } else {
                        urlMappingNew.setScopes(urlMapping.getScope());
                        uriTemplateMap.put(urlMappingNew.getUriTemplate() + urlMappingNew.getHTTPVerb(), urlMappingNew);
                    }
                } else if (urlMapping.getId() != 0) {
                    URITemplate urlMappingExisting = uriTemplateMap.get(urlMapping.getUriTemplate() + urlMapping.getHTTPVerb());
                    if (urlMappingExisting == null) {
                        uriTemplateMap.put(urlMapping.getUriTemplate() + urlMapping.getHTTPVerb(), urlMapping);
                    }
                } else {
                    uriTemplateMap.put(urlMapping.getUriTemplate() + urlMapping.getHTTPVerb(), urlMapping);
                }
            }
            setOperationPoliciesToURITemplatesMap(apiRevision.getApiUUID(), uriTemplateMap);
            PreparedStatement insertURLMappingsStatement = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.INSERT_URL_MAPPINGS);
            for (URITemplate urlMapping : uriTemplateMap.values()) {
                insertURLMappingsStatement.setInt(1, apiId);
                insertURLMappingsStatement.setString(2, urlMapping.getHTTPVerb());
                insertURLMappingsStatement.setString(3, urlMapping.getAuthType());
                insertURLMappingsStatement.setString(4, urlMapping.getUriTemplate());
                insertURLMappingsStatement.setString(5, urlMapping.getThrottlingTier());
                insertURLMappingsStatement.setString(6, apiRevision.getRevisionUUID());
                insertURLMappingsStatement.addBatch();
            }
            insertURLMappingsStatement.executeBatch();
            // Add to AM_API_RESOURCE_SCOPE_MAPPING table and to AM_API_PRODUCT_MAPPING
            PreparedStatement getRevisionedURLMappingsStatement = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.GET_REVISIONED_URL_MAPPINGS_ID);
            PreparedStatement insertScopeResourceMappingStatement = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.INSERT_SCOPE_RESOURCE_MAPPING);
            PreparedStatement insertProductResourceMappingStatement = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.INSERT_PRODUCT_RESOURCE_MAPPING);
            PreparedStatement insertOperationPolicyMappingStatement = connection.prepareStatement(SQLConstants.OperationPolicyConstants.ADD_API_OPERATION_POLICY_MAPPING);
            Map<String, String> clonedPolicyMap = new HashMap<>();
            for (URITemplate urlMapping : uriTemplateMap.values()) {
                getRevisionedURLMappingsStatement.setInt(1, apiId);
                getRevisionedURLMappingsStatement.setString(2, apiRevision.getRevisionUUID());
                getRevisionedURLMappingsStatement.setString(3, urlMapping.getHTTPVerb());
                getRevisionedURLMappingsStatement.setString(4, urlMapping.getAuthType());
                getRevisionedURLMappingsStatement.setString(5, urlMapping.getUriTemplate());
                getRevisionedURLMappingsStatement.setString(6, urlMapping.getThrottlingTier());
                try (ResultSet rs = getRevisionedURLMappingsStatement.executeQuery()) {
                    while (rs.next()) {
                        if (urlMapping.getScopes() != null) {
                            for (Scope scope : urlMapping.getScopes()) {
                                insertScopeResourceMappingStatement.setString(1, scope.getKey());
                                insertScopeResourceMappingStatement.setInt(2, rs.getInt(1));
                                insertScopeResourceMappingStatement.setInt(3, tenantId);
                                insertScopeResourceMappingStatement.addBatch();
                            }
                        }
                        if (urlMapping.getId() != 0) {
                            insertProductResourceMappingStatement.setInt(1, urlMapping.getId());
                            insertProductResourceMappingStatement.setInt(2, rs.getInt(1));
                            insertProductResourceMappingStatement.addBatch();
                        }
                        if (urlMapping.getOperationPolicies().size() > 0) {
                            for (OperationPolicy policy : urlMapping.getOperationPolicies()) {
                                if (!clonedPolicyMap.keySet().contains(policy.getPolicyId())) {
                                    // Since we are creating a new revision, if the policy is not found in the policy map,
                                    // we have to clone the policy.
                                    String clonedPolicyId = revisionOperationPolicy(connection, policy.getPolicyId(), apiRevision.getApiUUID(), apiRevision.getRevisionUUID(), tenantDomain);
                                    // policy ID is stored in a map as same policy can be applied to multiple operations
                                    // and we only need to create the policy once.
                                    clonedPolicyMap.put(policy.getPolicyId(), clonedPolicyId);
                                }
                                Gson gson = new Gson();
                                String paramJSON = gson.toJson(policy.getParameters());
                                insertOperationPolicyMappingStatement.setInt(1, rs.getInt(1));
                                insertOperationPolicyMappingStatement.setString(2, clonedPolicyMap.get(policy.getPolicyId()));
                                insertOperationPolicyMappingStatement.setString(3, policy.getDirection());
                                insertOperationPolicyMappingStatement.setString(4, paramJSON);
                                insertOperationPolicyMappingStatement.setInt(5, policy.getOrder());
                                insertOperationPolicyMappingStatement.addBatch();
                            }
                        }
                    }
                }
            }
            insertScopeResourceMappingStatement.executeBatch();
            insertProductResourceMappingStatement.executeBatch();
            insertOperationPolicyMappingStatement.executeBatch();
            // Adding to AM_API_CLIENT_CERTIFICATE
            PreparedStatement getClientCertificatesStatement = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.GET_CLIENT_CERTIFICATES);
            getClientCertificatesStatement.setInt(1, apiId);
            List<ClientCertificateDTO> clientCertificateDTOS = new ArrayList<>();
            try (ResultSet rs = getClientCertificatesStatement.executeQuery()) {
                while (rs.next()) {
                    ClientCertificateDTO clientCertificateDTO = new ClientCertificateDTO();
                    clientCertificateDTO.setAlias(rs.getString(1));
                    clientCertificateDTO.setCertificate(APIMgtDBUtil.getStringFromInputStream(rs.getBinaryStream(2)));
                    clientCertificateDTO.setTierName(rs.getString(3));
                    clientCertificateDTOS.add(clientCertificateDTO);
                }
            }
            PreparedStatement insertClientCertificateStatement = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.INSERT_CLIENT_CERTIFICATES);
            for (ClientCertificateDTO clientCertificateDTO : clientCertificateDTOS) {
                insertClientCertificateStatement.setInt(1, tenantId);
                insertClientCertificateStatement.setString(2, clientCertificateDTO.getAlias());
                insertClientCertificateStatement.setInt(3, apiId);
                insertClientCertificateStatement.setBinaryStream(4, getInputStream(clientCertificateDTO.getCertificate()));
                insertClientCertificateStatement.setBoolean(5, false);
                insertClientCertificateStatement.setString(6, clientCertificateDTO.getTierName());
                insertClientCertificateStatement.setString(7, apiRevision.getRevisionUUID());
                insertClientCertificateStatement.addBatch();
            }
            insertClientCertificateStatement.executeBatch();
            // Adding to AM_GRAPHQL_COMPLEXITY table
            PreparedStatement getGraphQLComplexityStatement = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.GET_GRAPHQL_COMPLEXITY);
            List<CustomComplexityDetails> customComplexityDetailsList = new ArrayList<>();
            getGraphQLComplexityStatement.setInt(1, apiId);
            try (ResultSet rs1 = getGraphQLComplexityStatement.executeQuery()) {
                while (rs1.next()) {
                    CustomComplexityDetails customComplexityDetails = new CustomComplexityDetails();
                    customComplexityDetails.setType(rs1.getString("TYPE"));
                    customComplexityDetails.setField(rs1.getString("FIELD"));
                    customComplexityDetails.setComplexityValue(rs1.getInt("COMPLEXITY_VALUE"));
                    customComplexityDetailsList.add(customComplexityDetails);
                }
            }
            PreparedStatement insertGraphQLComplexityStatement = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.INSERT_GRAPHQL_COMPLEXITY);
            for (CustomComplexityDetails customComplexityDetails : customComplexityDetailsList) {
                insertGraphQLComplexityStatement.setString(1, UUID.randomUUID().toString());
                insertGraphQLComplexityStatement.setInt(2, apiId);
                insertGraphQLComplexityStatement.setString(3, customComplexityDetails.getType());
                insertGraphQLComplexityStatement.setString(4, customComplexityDetails.getField());
                insertGraphQLComplexityStatement.setInt(5, customComplexityDetails.getComplexityValue());
                insertGraphQLComplexityStatement.setString(6, apiRevision.getRevisionUUID());
                insertGraphQLComplexityStatement.addBatch();
            }
            insertGraphQLComplexityStatement.executeBatch();
            updateLatestRevisionNumber(connection, apiRevision.getApiUUID(), apiRevision.getId());
            addAPIRevisionMetaData(connection, apiRevision.getApiUUID(), apiRevision.getRevisionUUID());
            connection.commit();
        } catch (SQLException e) {
            connection.rollback();
            handleException("Failed to add API Revision entry of API UUID " + apiRevision.getApiUUID(), e);
        }
    } catch (SQLException e) {
        handleException("Failed to add API Revision entry of API UUID " + apiRevision.getApiUUID(), e);
    }
}

Example 13 with URLMapping

use of org.wso2.carbon.apimgt.api.model.subscription.URLMapping in project carbon-apimgt by wso2.

the class ApiMgtDAO method restoreAPIProductRevision.

/**
 * Restore API Product revision database records as the Current API Product of an API Product
 *
 * @param apiRevision content of the revision
 * @throws APIManagementException if an error occurs when restoring an API revision
 */
public void restoreAPIProductRevision(APIRevision apiRevision) throws APIManagementException {
    try (Connection connection = APIMgtDBUtil.getConnection()) {
        try {
            connection.setAutoCommit(false);
            // Retrieve API ID
            APIProductIdentifier apiProductIdentifier = APIUtil.getAPIProductIdentifierFromUUID(apiRevision.getApiUUID());
            int apiId = getAPIID(apiRevision.getApiUUID(), connection);
            int tenantId = APIUtil.getTenantId(APIUtil.replaceEmailDomainBack(apiProductIdentifier.getProviderName()));
            String tenantDomain = APIUtil.getTenantDomainFromTenantId(tenantId);
            // Remove Current API Product entries from AM_API_URL_MAPPING table
            PreparedStatement removeURLMappingsFromCurrentAPIProduct = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.REMOVE_CURRENT_API_PRODUCT_ENTRIES_IN_AM_API_URL_MAPPING);
            removeURLMappingsFromCurrentAPIProduct.setString(1, Integer.toString(apiId));
            removeURLMappingsFromCurrentAPIProduct.executeUpdate();
            // Copy Revision resources
            PreparedStatement getURLMappingsFromRevisionedAPIProduct = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.GET_API_PRODUCT_REVISION_URL_MAPPINGS_BY_REVISION_UUID);
            getURLMappingsFromRevisionedAPIProduct.setString(1, apiRevision.getRevisionUUID());
            Map<String, URITemplate> urlMappingList = new HashMap<>();
            try (ResultSet rs = getURLMappingsFromRevisionedAPIProduct.executeQuery()) {
                String key, httpMethod, urlPattern;
                while (rs.next()) {
                    String script = null;
                    URITemplate uriTemplate = new URITemplate();
                    httpMethod = rs.getString("HTTP_METHOD");
                    urlPattern = rs.getString("URL_PATTERN");
                    uriTemplate.setHTTPVerb(httpMethod);
                    uriTemplate.setAuthType(rs.getString("AUTH_SCHEME"));
                    uriTemplate.setUriTemplate(rs.getString("URL_PATTERN"));
                    uriTemplate.setThrottlingTier(rs.getString("THROTTLING_TIER"));
                    InputStream mediationScriptBlob = rs.getBinaryStream("MEDIATION_SCRIPT");
                    if (mediationScriptBlob != null) {
                        script = APIMgtDBUtil.getStringFromInputStream(mediationScriptBlob);
                    }
                    uriTemplate.setMediationScript(script);
                    if (rs.getInt("API_ID") != 0) {
                        // Adding product id to uri template id just to store value
                        uriTemplate.setId(rs.getInt("API_ID"));
                    }
                    key = urlPattern + httpMethod;
                    urlMappingList.put(key, uriTemplate);
                }
            }
            // Populate Scope Mappings
            PreparedStatement getScopeMappingsFromRevisionedAPIProduct = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.GET_API_PRODUCT_REVISION_SCOPE_MAPPINGS_BY_REVISION_UUID);
            getScopeMappingsFromRevisionedAPIProduct.setString(1, apiRevision.getRevisionUUID());
            try (ResultSet rs = getScopeMappingsFromRevisionedAPIProduct.executeQuery()) {
                while (rs.next()) {
                    String key = rs.getString("URL_PATTERN") + rs.getString("HTTP_METHOD");
                    if (urlMappingList.containsKey(key)) {
                        URITemplate uriTemplate = urlMappingList.get(key);
                        Scope scope = new Scope();
                        scope.setKey(rs.getString("SCOPE_NAME"));
                        uriTemplate.setScope(scope);
                        uriTemplate.setScopes(scope);
                    }
                }
            }
            setAPIProductOperationPoliciesToURITemplatesMap(apiRevision.getRevisionUUID(), urlMappingList);
            PreparedStatement insertURLMappingsStatement = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.INSERT_URL_MAPPINGS);
            for (URITemplate urlMapping : urlMappingList.values()) {
                insertURLMappingsStatement.setInt(1, urlMapping.getId());
                insertURLMappingsStatement.setString(2, urlMapping.getHTTPVerb());
                insertURLMappingsStatement.setString(3, urlMapping.getAuthType());
                insertURLMappingsStatement.setString(4, urlMapping.getUriTemplate());
                insertURLMappingsStatement.setString(5, urlMapping.getThrottlingTier());
                insertURLMappingsStatement.setString(6, Integer.toString(apiId));
                insertURLMappingsStatement.addBatch();
            }
            insertURLMappingsStatement.executeBatch();
            // Insert Scope Mappings and operation policy mappings
            PreparedStatement getRevisionedURLMappingsStatement = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.GET_REVISIONED_URL_MAPPINGS_ID);
            PreparedStatement addResourceScopeMapping = connection.prepareStatement(SQLConstants.ADD_API_RESOURCE_SCOPE_MAPPING);
            PreparedStatement addOperationPolicyStatement = connection.prepareStatement(SQLConstants.OperationPolicyConstants.ADD_API_OPERATION_POLICY_MAPPING);
            Map<String, String> clonedPoliciesMap = new HashMap<>();
            Set<String> usedClonedPolicies = new HashSet<String>();
            for (URITemplate urlMapping : urlMappingList.values()) {
                getRevisionedURLMappingsStatement.setInt(1, urlMapping.getId());
                getRevisionedURLMappingsStatement.setString(2, Integer.toString(apiId));
                getRevisionedURLMappingsStatement.setString(3, urlMapping.getHTTPVerb());
                getRevisionedURLMappingsStatement.setString(4, urlMapping.getAuthType());
                getRevisionedURLMappingsStatement.setString(5, urlMapping.getUriTemplate());
                getRevisionedURLMappingsStatement.setString(6, urlMapping.getThrottlingTier());
                try (ResultSet rs = getRevisionedURLMappingsStatement.executeQuery()) {
                    if (rs.next()) {
                        int newURLMappingId = rs.getInt("URL_MAPPING_ID");
                        if (urlMapping.getScopes() != null && urlMapping.getScopes().size() > 0) {
                            for (Scope scope : urlMapping.getScopes()) {
                                addResourceScopeMapping.setString(1, scope.getKey());
                                addResourceScopeMapping.setInt(2, newURLMappingId);
                                addResourceScopeMapping.setInt(3, tenantId);
                                addResourceScopeMapping.addBatch();
                            }
                        }
                        if (urlMapping.getOperationPolicies().size() > 0) {
                            for (OperationPolicy policy : urlMapping.getOperationPolicies()) {
                                if (!clonedPoliciesMap.keySet().contains(policy.getPolicyName())) {
                                    String policyId = restoreOperationPolicyRevision(connection, apiRevision.getApiUUID(), policy.getPolicyId(), apiRevision.getId(), tenantDomain);
                                    clonedPoliciesMap.put(policy.getPolicyName(), policyId);
                                    usedClonedPolicies.add(policyId);
                                }
                                Gson gson = new Gson();
                                String paramJSON = gson.toJson(policy.getParameters());
                                addOperationPolicyStatement.setInt(1, rs.getInt(1));
                                addOperationPolicyStatement.setString(2, clonedPoliciesMap.get(policy.getPolicyName()));
                                addOperationPolicyStatement.setString(3, policy.getDirection());
                                addOperationPolicyStatement.setString(4, paramJSON);
                                addOperationPolicyStatement.setInt(5, policy.getOrder());
                                addOperationPolicyStatement.executeUpdate();
                            }
                        }
                    }
                }
            }
            addResourceScopeMapping.executeBatch();
            cleanUnusedClonedOperationPolicies(connection, usedClonedPolicies, apiRevision.getApiUUID());
            // Get URL_MAPPING_IDs from table and add records to product mapping table
            PreparedStatement getURLMappingOfAPIProduct = connection.prepareStatement(SQLConstants.GET_URL_MAPPING_IDS_OF_API_PRODUCT_SQL);
            PreparedStatement insertProductResourceMappingStatement = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.INSERT_PRODUCT_REVISION_RESOURCE_MAPPING);
            getURLMappingOfAPIProduct.setString(1, Integer.toString(apiId));
            try (ResultSet rs = getURLMappingOfAPIProduct.executeQuery()) {
                while (rs.next()) {
                    insertProductResourceMappingStatement.setInt(1, apiId);
                    insertProductResourceMappingStatement.setInt(2, rs.getInt("URL_MAPPING_ID"));
                    insertProductResourceMappingStatement.setString(3, "Current API");
                    insertProductResourceMappingStatement.addBatch();
                }
                insertProductResourceMappingStatement.executeBatch();
            }
            // Restoring AM_API_CLIENT_CERTIFICATE table entries
            PreparedStatement removeClientCertificatesStatement = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.REMOVE_CURRENT_API_ENTRIES_IN_AM_API_CLIENT_CERTIFICATE_BY_API_ID);
            removeClientCertificatesStatement.setInt(1, apiId);
            removeClientCertificatesStatement.executeUpdate();
            PreparedStatement getClientCertificatesStatement = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.GET_CLIENT_CERTIFICATES_BY_REVISION_UUID);
            getClientCertificatesStatement.setInt(1, apiId);
            getClientCertificatesStatement.setString(2, apiRevision.getRevisionUUID());
            List<ClientCertificateDTO> clientCertificateDTOS = new ArrayList<>();
            try (ResultSet rs = getClientCertificatesStatement.executeQuery()) {
                while (rs.next()) {
                    ClientCertificateDTO clientCertificateDTO = new ClientCertificateDTO();
                    clientCertificateDTO.setAlias(rs.getString(1));
                    clientCertificateDTO.setCertificate(APIMgtDBUtil.getStringFromInputStream(rs.getBinaryStream(2)));
                    clientCertificateDTO.setTierName(rs.getString(3));
                    clientCertificateDTOS.add(clientCertificateDTO);
                }
            }
            PreparedStatement insertClientCertificateStatement = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.INSERT_CLIENT_CERTIFICATES_AS_CURRENT_API);
            for (ClientCertificateDTO clientCertificateDTO : clientCertificateDTOS) {
                insertClientCertificateStatement.setInt(1, tenantId);
                insertClientCertificateStatement.setString(2, clientCertificateDTO.getAlias());
                insertClientCertificateStatement.setInt(3, apiId);
                insertClientCertificateStatement.setBinaryStream(4, getInputStream(clientCertificateDTO.getCertificate()));
                insertClientCertificateStatement.setBoolean(5, false);
                insertClientCertificateStatement.setString(6, clientCertificateDTO.getTierName());
                insertClientCertificateStatement.setString(7, "Current API");
                insertClientCertificateStatement.addBatch();
            }
            insertClientCertificateStatement.executeBatch();
            // Restoring AM_GRAPHQL_COMPLEXITY table
            PreparedStatement removeGraphQLComplexityStatement = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.REMOVE_CURRENT_API_ENTRIES_IN_AM_GRAPHQL_COMPLEXITY_BY_API_ID);
            removeGraphQLComplexityStatement.setInt(1, apiId);
            removeGraphQLComplexityStatement.executeUpdate();
            PreparedStatement getGraphQLComplexityStatement = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.GET_GRAPHQL_COMPLEXITY_BY_REVISION_UUID);
            List<CustomComplexityDetails> customComplexityDetailsList = new ArrayList<>();
            getGraphQLComplexityStatement.setInt(1, apiId);
            getGraphQLComplexityStatement.setString(2, apiRevision.getRevisionUUID());
            try (ResultSet rs1 = getGraphQLComplexityStatement.executeQuery()) {
                while (rs1.next()) {
                    CustomComplexityDetails customComplexityDetails = new CustomComplexityDetails();
                    customComplexityDetails.setType(rs1.getString("TYPE"));
                    customComplexityDetails.setField(rs1.getString("FIELD"));
                    customComplexityDetails.setComplexityValue(rs1.getInt("COMPLEXITY_VALUE"));
                    customComplexityDetailsList.add(customComplexityDetails);
                }
            }
            PreparedStatement insertGraphQLComplexityStatement = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.INSERT_GRAPHQL_COMPLEXITY_AS_CURRENT_API);
            for (CustomComplexityDetails customComplexityDetails : customComplexityDetailsList) {
                insertGraphQLComplexityStatement.setString(1, UUID.randomUUID().toString());
                insertGraphQLComplexityStatement.setInt(2, apiId);
                insertGraphQLComplexityStatement.setString(3, customComplexityDetails.getType());
                insertGraphQLComplexityStatement.setString(4, customComplexityDetails.getField());
                insertGraphQLComplexityStatement.setInt(5, customComplexityDetails.getComplexityValue());
                insertGraphQLComplexityStatement.addBatch();
            }
            insertGraphQLComplexityStatement.executeBatch();
            connection.commit();
        } catch (SQLException e) {
            connection.rollback();
            handleException("Failed to restore API Revision entry of API UUID " + apiRevision.getApiUUID(), e);
        }
    } catch (SQLException e) {
        handleException("Failed to restore API Revision entry of API UUID " + apiRevision.getApiUUID(), e);
    }
}

Example 14 with URLMapping

use of org.wso2.carbon.apimgt.api.model.subscription.URLMapping in project carbon-apimgt by wso2.

the class APIKeyValidationService method getTemplates.

private ArrayList<URITemplate> getTemplates(String context, String version) throws APIManagementException {
    String tenantDomain = MultitenantUtils.getTenantDomainFromRequestURL(context);
    if (tenantDomain == null) {
        tenantDomain = MultitenantConstants.SUPER_TENANT_DOMAIN_NAME;
    }
    ArrayList<URITemplate> templates = new ArrayList<URITemplate>();
    SubscriptionDataStore store = SubscriptionDataHolder.getInstance().getTenantSubscriptionStore(tenantDomain);
    if (store == null) {
        return templates;
    }
    API api = store.getApiByContextAndVersion(context, version);
    if (api == null) {
        log.debug("SubscriptionDataStore didn't contains API metadata reading from rest api context: " + context + " And version " + version);
        api = new SubscriptionDataLoaderImpl().getApi(context, version);
        if (api != null) {
            store.addOrUpdateAPI(api);
            if (log.isDebugEnabled()) {
                log.debug("Update SubscriptionDataStore api for " + api.getCacheKey());
            }
        }
    }
    if (api == null || api.getApiId() == 0) {
        return templates;
    }
    List<URLMapping> mapping = api.getResources();
    if (mapping == null || mapping.isEmpty()) {
        return templates;
    }
    int apiTenantId = APIUtil.getTenantId(APIUtil.replaceEmailDomainBack(api.getApiProvider()));
    if (log.isDebugEnabled()) {
        log.debug("Tenant domain: " + tenantDomain + " tenantId: " + apiTenantId);
    }
    ApiPolicy apiPolicy;
    URITemplate template;
    for (URLMapping urlMapping : mapping) {
        template = new URITemplate();
        template.setHTTPVerb(urlMapping.getHttpMethod());
        template.setAuthType(urlMapping.getAuthScheme());
        template.setUriTemplate(urlMapping.getUrlPattern());
        template.setThrottlingTier(urlMapping.getThrottlingPolicy());
        if (store.isApiPoliciesInitialized()) {
            log.debug("SubscriptionDataStore Initialized. Reading API Policies from SubscriptionDataStore");
            apiPolicy = store.getApiPolicyByName(urlMapping.getThrottlingPolicy(), apiTenantId);
            if (apiPolicy == null) {
                // could be null for situations where invoke before map is updated
                log.debug("API Policies not found in the SubscriptionDataStore. Retrieving from the Rest API");
                apiPolicy = new SubscriptionDataLoaderImpl().getAPIPolicy(urlMapping.getThrottlingPolicy(), tenantDomain);
                if (apiPolicy != null) {
                    if (apiPolicy.getName() != null) {
                        store.addOrUpdateApiPolicy(apiPolicy);
                        if (log.isDebugEnabled()) {
                            log.debug("Update SubscriptionDataStore API Policy for " + apiPolicy.getCacheKey());
                        }
                    } else {
                        throw new APIManagementException("Exception while loading api policy for " + urlMapping.getThrottlingPolicy() + " for domain " + tenantDomain);
                    }
                }
            }
        } else {
            log.debug("SubscriptionDataStore not Initialized. Reading API Policies from Rest API");
            apiPolicy = new SubscriptionDataLoaderImpl().getAPIPolicy(urlMapping.getThrottlingPolicy(), tenantDomain);
            if (apiPolicy != null) {
                if (apiPolicy.getName() != null) {
                    store.addOrUpdateApiPolicy(apiPolicy);
                    if (log.isDebugEnabled()) {
                        log.debug("Update SubscriptionDataStore API Policy for " + apiPolicy.getCacheKey());
                    }
                } else {
                    throw new APIManagementException("Exception while loading api policy for " + urlMapping.getThrottlingPolicy() + " for domain " + tenantDomain);
                }
            }
        }
        List<String> tiers = new ArrayList<String>();
        tiers.add(urlMapping.getThrottlingPolicy() + ">" + apiPolicy.isContentAware());
        template.setThrottlingTiers(tiers);
        template.setApplicableLevel(apiPolicy.getApplicableLevel());
        List<APIPolicyConditionGroup> conditions = apiPolicy.getConditionGroups();
        List<ConditionGroupDTO> conditionGroupsList = new ArrayList<ConditionGroupDTO>();
        for (APIPolicyConditionGroup cond : conditions) {
            Set<Condition> condSet = cond.getCondition();
            if (condSet.isEmpty()) {
                continue;
            }
            List<ConditionDTO> conditionDtoList = new ArrayList<ConditionDTO>();
            for (Condition condition : condSet) {
                ConditionDTO item = new ConditionDTO();
                item.setConditionName(condition.getName());
                item.setConditionType(condition.getConditionType());
                item.setConditionValue(condition.getValue());
                item.isInverted(condition.isInverted());
                conditionDtoList.add(item);
            }
            ConditionGroupDTO group = new ConditionGroupDTO();
            group.setConditionGroupId("_condition_" + cond.getConditionGroupId());
            group.setConditions(conditionDtoList.toArray(new ConditionDTO[] {}));
            conditionGroupsList.add(group);
        }
        ConditionGroupDTO defaultGroup = new ConditionGroupDTO();
        defaultGroup.setConditionGroupId(APIConstants.THROTTLE_POLICY_DEFAULT);
        conditionGroupsList.add(defaultGroup);
        template.getThrottlingConditions().add(APIConstants.THROTTLE_POLICY_DEFAULT);
        template.setConditionGroups(conditionGroupsList.toArray(new ConditionGroupDTO[] {}));
        templates.add(template);
    }
    return templates;
}

Example 15 with URLMapping

use of org.wso2.carbon.apimgt.api.model.subscription.URLMapping in project carbon-apimgt by wso2.

the class HandshakeProcessor method setResourcesMapToContext.

/**
 * Set the resource map with VerbInfoDTOs to the context using URL mappings from the InboundMessageContext.
 *
 * @param inboundMessageContext InboundMessageContext
 */
private void setResourcesMapToContext(InboundMessageContext inboundMessageContext) {
    List<URLMapping> urlMappings = inboundMessageContext.getElectedAPI().getResources();
    Map<String, ResourceInfoDTO> resourcesMap = inboundMessageContext.getResourcesMap();
    ResourceInfoDTO resourceInfoDTO;
    VerbInfoDTO verbInfoDTO;
    for (URLMapping urlMapping : urlMappings) {
        resourceInfoDTO = resourcesMap.get(urlMapping.getUrlPattern());
        if (resourceInfoDTO == null) {
            resourceInfoDTO = new ResourceInfoDTO();
            resourceInfoDTO.setUrlPattern(urlMapping.getUrlPattern());
            resourceInfoDTO.setHttpVerbs(new LinkedHashSet<>());
            resourcesMap.put(urlMapping.getUrlPattern(), resourceInfoDTO);
        }
        verbInfoDTO = new VerbInfoDTO();
        verbInfoDTO.setHttpVerb(urlMapping.getHttpMethod());
        verbInfoDTO.setAuthType(urlMapping.getAuthScheme());
        verbInfoDTO.setThrottling(urlMapping.getThrottlingPolicy());
        resourceInfoDTO.getHttpVerbs().add(verbInfoDTO);
    }
}