use of org.wso2.carbon.apimgt.api.model.APIIdentifier in project carbon-apimgt by wso2.
the class RegistryPersistenceUtilTestCase method testTenantDomain.
@Test
public void testTenantDomain() {
PowerMockito.mockStatic(ServerConfiguration.class);
ServerConfiguration config = Mockito.mock(ServerConfiguration.class);
PowerMockito.when(ServerConfiguration.getInstance()).thenReturn(config);
PowerMockito.when(config.getFirstProperty(anyString())).thenReturn(null);
String domain = RegistryPersistenceUtil.getTenantDomain(new APIIdentifier("test@" + TENANT_DOMAIN, "test", "1.0"));
domain = RegistryPersistenceUtil.getTenantDomain(new APIIdentifier("test", "test", "1.0"));
}
use of org.wso2.carbon.apimgt.api.model.APIIdentifier in project carbon-apimgt by wso2.
the class RegistryPersistenceUtilTestCase method testcreateAPIArtifactContent.
@Test
public void testcreateAPIArtifactContent() throws APIPersistenceException, APIManagementException, RegistryException {
API api = new API(new APIIdentifier("pubuser", "TestAPI", "1.0"));
Set<Tier> availableTiers = new HashSet<Tier>();
availableTiers.add(new Tier("Unlimited"));
availableTiers.add(new Tier("Gold"));
api.setAvailableTiers(availableTiers);
Set<URITemplate> uriTemplates = new HashSet<URITemplate>();
URITemplate template = new URITemplate();
template.setHTTPVerb("GET");
template.setUriTemplate("/test");
template.setAuthType("None");
uriTemplates.add(template);
api.setUriTemplates(uriTemplates);
List<APICategory> categories = new ArrayList<APICategory>();
APICategory category = new APICategory();
category.setName("testcategory");
categories.add(category);
api.setApiCategories(categories);
List<Label> gatewayLabels = new ArrayList<Label>();
Label label = new Label();
label.setName("TestLabel");
gatewayLabels.add(label);
GenericArtifact genericArtifact = new GenericArtifactImpl(new QName("", "TestAPI", ""), "application/vnd.wso2-api+xml");
genericArtifact.setAttribute("URITemplate", "/test");
GenericArtifact retArtifact = RegistryPersistenceUtil.createAPIArtifactContent(genericArtifact, api);
Assert.assertEquals("API name does not match", api.getId().getApiName(), retArtifact.getAttribute("overview_name"));
Assert.assertEquals("API version does not match", api.getId().getVersion(), retArtifact.getAttribute("overview_version"));
Assert.assertEquals("API provider does not match", api.getId().getProviderName(), retArtifact.getAttribute("overview_provider"));
}
use of org.wso2.carbon.apimgt.api.model.APIIdentifier in project carbon-apimgt by wso2.
the class APIInfoMappingUtil method fromAPIInfoListToDTO.
/**
* Converts a List object of APIIdentifiers into a DTO
*
* @param apiIds a list of APIIdentifier objects
* @return APIInfoListDTO object containing APIInfoDTOs
*/
public static APIInfoListDTO fromAPIInfoListToDTO(List<APIIdentifier> apiIds) throws UnsupportedEncodingException {
APIInfoListDTO apiInfoListDTO = new APIInfoListDTO();
List<APIInfoDTO> apiInfoDTOs = apiInfoListDTO.getList();
if (apiInfoDTOs == null) {
apiInfoDTOs = new ArrayList<>();
apiInfoListDTO.setList(apiInfoDTOs);
}
for (APIIdentifier apiId : apiIds) {
apiInfoDTOs.add(fromAPIInfoToDTO(apiId));
}
apiInfoListDTO.setCount(apiInfoDTOs.size());
return apiInfoListDTO;
}
use of org.wso2.carbon.apimgt.api.model.APIIdentifier in project carbon-apimgt by wso2.
the class ApiMgtDAO method restoreAPIRevision.
/**
* Restore API revision database records as the Current API of an API
*
* @param apiRevision content of the revision
* @throws APIManagementException if an error occurs when restoring an API revision
*/
public void restoreAPIRevision(APIRevision apiRevision) throws APIManagementException {
try (Connection connection = APIMgtDBUtil.getConnection()) {
try {
connection.setAutoCommit(false);
// 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);
// Removing related Current API entries from AM_API_URL_MAPPING table
PreparedStatement removeURLMappingsStatement = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.REMOVE_CURRENT_API_ENTRIES_IN_AM_API_URL_MAPPING_BY_API_ID);
removeURLMappingsStatement.setInt(1, apiId);
removeURLMappingsStatement.executeUpdate();
// Restoring to AM_API_URL_MAPPING table
PreparedStatement getURLMappingsStatement = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.GET_URL_MAPPINGS_WITH_SCOPE_AND_PRODUCT_ID_BY_REVISION_UUID);
getURLMappingsStatement.setInt(1, apiId);
getURLMappingsStatement.setString(2, apiRevision.getRevisionUUID());
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 {
uriTemplateMap.put(urlMapping.getUriTemplate() + urlMapping.getHTTPVerb(), urlMapping);
}
}
setOperationPoliciesToURITemplatesMap(apiRevision.getRevisionUUID(), uriTemplateMap);
PreparedStatement insertURLMappingsStatement = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.INSERT_URL_MAPPINGS_CURRENT_API);
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.addBatch();
}
insertURLMappingsStatement.executeBatch();
// Add to AM_API_RESOURCE_SCOPE_MAPPING table and to AM_API_PRODUCT_MAPPING
PreparedStatement getCurrentAPIURLMappingsStatement = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.GET_CURRENT_API_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);
PreparedStatement deleteOutdatedOperationPolicyStatement = connection.prepareStatement(SQLConstants.OperationPolicyConstants.DELETE_OPERATION_POLICY_BY_POLICY_ID);
Map<String, String> restoredPolicyMap = new HashMap<>();
Set<String> usedClonedPolicies = new HashSet<String>();
for (URITemplate urlMapping : uriTemplateMap.values()) {
if (urlMapping.getScopes() != null) {
getCurrentAPIURLMappingsStatement.setInt(1, apiId);
getCurrentAPIURLMappingsStatement.setString(2, urlMapping.getHTTPVerb());
getCurrentAPIURLMappingsStatement.setString(3, urlMapping.getAuthType());
getCurrentAPIURLMappingsStatement.setString(4, urlMapping.getUriTemplate());
getCurrentAPIURLMappingsStatement.setString(5, urlMapping.getThrottlingTier());
try (ResultSet rs = getCurrentAPIURLMappingsStatement.executeQuery()) {
while (rs.next()) {
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) {
getCurrentAPIURLMappingsStatement.setInt(1, apiId);
getCurrentAPIURLMappingsStatement.setString(2, urlMapping.getHTTPVerb());
getCurrentAPIURLMappingsStatement.setString(3, urlMapping.getAuthType());
getCurrentAPIURLMappingsStatement.setString(4, urlMapping.getUriTemplate());
getCurrentAPIURLMappingsStatement.setString(5, urlMapping.getThrottlingTier());
try (ResultSet rs = getCurrentAPIURLMappingsStatement.executeQuery()) {
while (rs.next()) {
insertProductResourceMappingStatement.setInt(1, urlMapping.getId());
insertProductResourceMappingStatement.setInt(2, rs.getInt(1));
insertProductResourceMappingStatement.addBatch();
}
}
}
if (!urlMapping.getOperationPolicies().isEmpty()) {
getCurrentAPIURLMappingsStatement.setInt(1, apiId);
getCurrentAPIURLMappingsStatement.setString(2, urlMapping.getHTTPVerb());
getCurrentAPIURLMappingsStatement.setString(3, urlMapping.getAuthType());
getCurrentAPIURLMappingsStatement.setString(4, urlMapping.getUriTemplate());
getCurrentAPIURLMappingsStatement.setString(5, urlMapping.getThrottlingTier());
try (ResultSet rs = getCurrentAPIURLMappingsStatement.executeQuery()) {
while (rs.next()) {
for (OperationPolicy policy : urlMapping.getOperationPolicies()) {
if (!restoredPolicyMap.keySet().contains(policy.getPolicyName())) {
String restoredPolicyId = restoreOperationPolicyRevision(connection, apiRevision.getApiUUID(), policy.getPolicyId(), apiRevision.getId(), 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.
restoredPolicyMap.put(policy.getPolicyName(), restoredPolicyId);
usedClonedPolicies.add(restoredPolicyId);
}
Gson gson = new Gson();
String paramJSON = gson.toJson(policy.getParameters());
insertOperationPolicyMappingStatement.setInt(1, rs.getInt(1));
insertOperationPolicyMappingStatement.setString(2, restoredPolicyMap.get(policy.getPolicyName()));
insertOperationPolicyMappingStatement.setString(3, policy.getDirection());
insertOperationPolicyMappingStatement.setString(4, paramJSON);
insertOperationPolicyMappingStatement.setInt(5, policy.getOrder());
insertOperationPolicyMappingStatement.addBatch();
}
}
}
}
}
insertScopeResourceMappingStatement.executeBatch();
insertProductResourceMappingStatement.executeBatch();
insertOperationPolicyMappingStatement.executeBatch();
deleteOutdatedOperationPolicyStatement.executeBatch();
cleanUnusedClonedOperationPolicies(connection, usedClonedPolicies, apiRevision.getApiUUID());
// 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();
restoreAPIRevisionMetaDataToWorkingCopy(connection, apiRevision.getApiUUID(), apiRevision.getRevisionUUID());
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);
}
}
use of org.wso2.carbon.apimgt.api.model.APIIdentifier in project carbon-apimgt by wso2.
the class ApiMgtDAO method makeKeysForwardCompatible.
public void makeKeysForwardCompatible(ApiTypeWrapper apiTypeWrapper, List<API> oldAPIVersions) throws APIManagementException {
// if there are no previous versions, there is no need to copy subscriptions
if (oldAPIVersions == null || oldAPIVersions.isEmpty()) {
return;
}
String getSubscriptionDataQuery = SQLConstants.GET_SUBSCRIPTION_DATA_SQL.replaceAll("_API_VERSION_LIST_", String.join(",", Collections.nCopies(oldAPIVersions.size(), "?")));
APIIdentifier apiIdentifier = apiTypeWrapper.getApi().getId();
try {
// Retrieve all the existing subscription for the old version
try (Connection connection = APIMgtDBUtil.getConnection()) {
connection.setAutoCommit(false);
try (PreparedStatement prepStmt = connection.prepareStatement(getSubscriptionDataQuery)) {
prepStmt.setString(1, APIUtil.replaceEmailDomainBack(apiIdentifier.getProviderName()));
prepStmt.setString(2, apiIdentifier.getApiName());
int index = 3;
for (API oldAPI : oldAPIVersions) {
prepStmt.setString(index++, oldAPI.getId().getVersion());
}
try (ResultSet rs = prepStmt.executeQuery()) {
List<SubscriptionInfo> subscriptionData = new ArrayList<SubscriptionInfo>();
while (rs.next() && !(APIConstants.SubscriptionStatus.ON_HOLD.equals(rs.getString("SUB_STATUS")))) {
int subscriptionId = rs.getInt("SUBSCRIPTION_ID");
String tierId = rs.getString("TIER_ID");
int applicationId = rs.getInt("APPLICATION_ID");
String apiVersion = rs.getString("VERSION");
String subscriptionStatus = rs.getString("SUB_STATUS");
SubscriptionInfo info = new SubscriptionInfo(subscriptionId, tierId, applicationId, apiVersion, subscriptionStatus);
subscriptionData.add(info);
}
// To keep track of already added subscriptions (apps)
List<Integer> addedApplications = new ArrayList<>();
for (int i = oldAPIVersions.size() - 1; i >= 0; i--) {
API oldAPI = oldAPIVersions.get(i);
for (SubscriptionInfo info : subscriptionData) {
try {
if (info.getApiVersion().equals(oldAPI.getId().getVersion()) && !addedApplications.contains(info.getApplicationId())) {
String subscriptionStatus;
if (APIConstants.SubscriptionStatus.BLOCKED.equalsIgnoreCase(info.getSubscriptionStatus())) {
subscriptionStatus = APIConstants.SubscriptionStatus.BLOCKED;
} else if (APIConstants.SubscriptionStatus.UNBLOCKED.equalsIgnoreCase(info.getSubscriptionStatus())) {
subscriptionStatus = APIConstants.SubscriptionStatus.UNBLOCKED;
} else if (APIConstants.SubscriptionStatus.PROD_ONLY_BLOCKED.equalsIgnoreCase(info.getSubscriptionStatus())) {
subscriptionStatus = APIConstants.SubscriptionStatus.PROD_ONLY_BLOCKED;
} else if (APIConstants.SubscriptionStatus.REJECTED.equalsIgnoreCase(info.getSubscriptionStatus())) {
subscriptionStatus = APIConstants.SubscriptionStatus.REJECTED;
} else {
subscriptionStatus = APIConstants.SubscriptionStatus.ON_HOLD;
}
apiTypeWrapper.setTier(info.getTierId());
Application application = getLightweightApplicationById(connection, info.getApplicationId());
int subscriptionId = addSubscription(connection, apiTypeWrapper, application, subscriptionStatus, apiIdentifier.getProviderName());
if (subscriptionId == -1) {
String msg = "Unable to add a new subscription for the API: " + apiIdentifier.getName() + ":v" + apiIdentifier.getVersion();
log.error(msg);
throw new APIManagementException(msg);
}
addedApplications.add(info.getApplicationId());
}
// catching the exception because when copy the api without the option "require
// re-subscription"
// need to go forward rather throwing the exception
} catch (SubscriptionAlreadyExistingException e) {
log.error("Error while adding subscription " + e.getMessage(), e);
} catch (SubscriptionBlockedException e) {
log.info("Subscription is blocked: " + e.getMessage());
}
}
}
}
connection.commit();
} catch (SQLException e) {
connection.rollback();
throw e;
}
}
} catch (SQLException e) {
handleException("Error when executing the SQL queries", e);
}
}
Aggregations