use of org.wso2.carbon.apimgt.api.model.APIRevision in project carbon-apimgt by wso2.
the class AbstractAPIManager method getAllDocumentation.
public List<Documentation> getAllDocumentation(Identifier id) throws APIManagementException {
List<Documentation> documentationList = new ArrayList<Documentation>();
String docArtifactKeyType = StringUtils.EMPTY;
docArtifactKeyType = APIConstants.DOCUMENTATION_KEY;
String apiOrAPIProductDocPath;
APIRevision apiRevision = apiMgtDAO.checkAPIUUIDIsARevisionUUID(id.getUUID());
if (apiRevision != null && apiRevision.getApiUUID() != null) {
apiOrAPIProductDocPath = APIUtil.getAPIOrAPIProductRevisionDocPath(apiRevision.getApiUUID(), apiRevision.getId());
} else {
apiOrAPIProductDocPath = APIUtil.getAPIOrAPIProductDocPath(id);
}
String pathToContent = apiOrAPIProductDocPath + APIConstants.INLINE_DOCUMENT_CONTENT_DIR;
String pathToDocFile = apiOrAPIProductDocPath + APIConstants.DOCUMENT_FILE_DIR;
try {
if (registry.resourceExists(apiOrAPIProductDocPath)) {
Resource resource = registry.get(apiOrAPIProductDocPath);
if (resource instanceof org.wso2.carbon.registry.core.Collection) {
List<String> docPaths = getDocPaths((org.wso2.carbon.registry.core.Collection) resource, apiOrAPIProductDocPath);
for (String docPath : docPaths) {
if (!(docPath.equalsIgnoreCase(pathToContent) || docPath.equalsIgnoreCase(pathToDocFile))) {
Resource docResource = registry.get(docPath);
GenericArtifactManager artifactManager = getAPIGenericArtifactManager(registry, docArtifactKeyType);
GenericArtifact docArtifact = artifactManager.getGenericArtifact(docResource.getUUID());
Documentation doc = APIUtil.getDocumentation(docArtifact);
Date contentLastModifiedDate;
Date docLastModifiedDate = docResource.getLastModified();
if (Documentation.DocumentSourceType.INLINE.equals(doc.getSourceType()) || Documentation.DocumentSourceType.MARKDOWN.equals(doc.getSourceType())) {
String contentPath = StringUtils.EMPTY;
if (id instanceof APIIdentifier) {
contentPath = APIUtil.getAPIDocContentPath((APIIdentifier) id, doc.getName());
} else if (id instanceof APIProductIdentifier) {
contentPath = APIUtil.getProductDocContentPath((APIProductIdentifier) id, doc.getName());
}
contentLastModifiedDate = registry.get(contentPath).getLastModified();
doc.setLastUpdated((contentLastModifiedDate.after(docLastModifiedDate) ? contentLastModifiedDate : docLastModifiedDate));
} else {
doc.setLastUpdated(docLastModifiedDate);
}
documentationList.add(doc);
}
}
}
}
} catch (RegistryException e) {
String msg = "Failed to get documentations for api/product " + id.getName();
throw new APIManagementException(msg, e);
}
return documentationList;
}
use of org.wso2.carbon.apimgt.api.model.APIRevision in project carbon-apimgt by wso2.
the class GraphQLSchemaDefinition method getGraphqlSchemaDefinition.
/**
* Returns the graphQL content in registry specified by the wsdl name
*
* @param apiId Api Identifier
* @return graphQL content matching name if exist else null
*/
public String getGraphqlSchemaDefinition(APIIdentifier apiId, Registry registry) throws APIManagementException {
String apiName = apiId.getApiName();
String apiVersion = apiId.getVersion();
String apiProviderName = apiId.getProviderName();
APIRevision apiRevision = ApiMgtDAO.getInstance().checkAPIUUIDIsARevisionUUID(apiId.getUUID());
String resourcePath;
if (apiRevision != null && apiRevision.getApiUUID() != null) {
resourcePath = APIUtil.getRevisionPath(apiRevision.getApiUUID(), apiRevision.getId());
} else {
resourcePath = APIUtil.getGraphqlDefinitionFilePath(apiName, apiVersion, apiProviderName);
}
String schemaDoc = null;
String schemaName = apiId.getProviderName() + APIConstants.GRAPHQL_SCHEMA_PROVIDER_SEPERATOR + apiId.getApiName() + apiId.getVersion() + APIConstants.GRAPHQL_SCHEMA_FILE_EXTENSION;
String schemaResourePath = resourcePath + schemaName;
try {
if (registry.resourceExists(schemaResourePath)) {
Resource schemaResource = registry.get(schemaResourePath);
schemaDoc = IOUtils.toString(schemaResource.getContentStream(), RegistryConstants.DEFAULT_CHARSET_ENCODING);
}
} catch (RegistryException e) {
String msg = "Error while getting schema file from the registry " + schemaResourePath;
log.error(msg, e);
throw new APIManagementException(msg, e);
} catch (IOException e) {
String error = "Error occurred while getting the content of schema: " + schemaName;
log.error(error);
throw new APIManagementException(error, e);
}
return schemaDoc;
}
use of org.wso2.carbon.apimgt.api.model.APIRevision in project carbon-apimgt by wso2.
the class ApiMgtDAO method getRevisionByRevisionUUID.
private APIRevision getRevisionByRevisionUUID(Connection connection, String revisionUUID) throws SQLException {
try (PreparedStatement statement = connection.prepareStatement(SQLConstants.APIRevisionSqlConstants.GET_REVISION_BY_REVISION_UUID)) {
statement.setString(1, revisionUUID);
try (ResultSet rs = statement.executeQuery()) {
while (rs.next()) {
APIRevision apiRevision = new APIRevision();
apiRevision.setId(rs.getInt("ID"));
apiRevision.setApiUUID(rs.getString("API_UUID"));
apiRevision.setRevisionUUID(rs.getString("REVISION_UUID"));
apiRevision.setDescription(rs.getString("DESCRIPTION"));
apiRevision.setCreatedTime(rs.getString("CREATED_TIME"));
apiRevision.setCreatedBy(rs.getString("CREATED_BY"));
return apiRevision;
}
}
}
return null;
}
use of org.wso2.carbon.apimgt.api.model.APIRevision 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.APIRevision in project carbon-apimgt by wso2.
the class ApiMgtDAO method getComments.
/**
**************************************
* Returns all the Comments on an API
*
* @param apiTypeWrapper API type Wrapper
* @param parentCommentID Parent Comment ID
* @return Comment Array
* @throws APIManagementException
*/
public CommentList getComments(ApiTypeWrapper apiTypeWrapper, String parentCommentID, Integer limit, Integer offset) throws APIManagementException {
CommentList commentList = null;
try (Connection connection = APIMgtDBUtil.getConnection()) {
int id = -1;
String uuid;
Identifier identifier;
String currentApiUuid;
if (apiTypeWrapper.isAPIProduct()) {
identifier = apiTypeWrapper.getApiProduct().getId();
uuid = apiTypeWrapper.getApiProduct().getUuid();
APIRevision apiRevision = checkAPIUUIDIsARevisionUUID(uuid);
if (apiRevision != null && apiRevision.getApiUUID() != null) {
currentApiUuid = apiRevision.getApiUUID();
} else {
currentApiUuid = uuid;
}
} else {
identifier = apiTypeWrapper.getApi().getId();
uuid = apiTypeWrapper.getApi().getUuid();
APIRevision apiRevision = checkAPIUUIDIsARevisionUUID(uuid);
if (apiRevision != null && apiRevision.getApiUUID() != null) {
currentApiUuid = apiRevision.getApiUUID();
} else {
currentApiUuid = uuid;
}
}
id = getAPIID(currentApiUuid, connection);
if (id == -1) {
String msg = "Could not load API record for: " + identifier.getName();
throw new APIManagementException(msg);
}
commentList = getComments(currentApiUuid, parentCommentID, limit, offset, connection);
} catch (SQLException e) {
handleException("Failed to retrieve comments for " + apiTypeWrapper.getName(), e);
}
return commentList;
}
Aggregations