Examples with DocumentContent org.wso2.carbon.apimgt.core.models.DocumentContent used on opensource projects

Example 11 with DocumentContent

use of org.wso2.carbon.apimgt.core.models.DocumentContent in project carbon-apimgt by wso2.

the class APIImportExportTestCase method testGetMultipleApiDetailsWithNonFatalErrors.

@Test(description = "Test getAPIDetails - multiple APIs with non-critical error in retrieving information of one API")
void testGetMultipleApiDetailsWithNonFatalErrors() throws APIManagementException {
    printTestMethodName();
    apiPublisher = Mockito.mock(APIPublisher.class);
    String api4Id = UUID.randomUUID().toString();
    Endpoint api4SandBoxEndpointId = new Endpoint.Builder().id(UUID.randomUUID().toString()).applicableLevel(APIMgtConstants.API_SPECIFIC_ENDPOINT).name("abcd").build();
    Endpoint api4ProdEndpointId = new Endpoint.Builder().id(UUID.randomUUID().toString()).applicableLevel(APIMgtConstants.API_SPECIFIC_ENDPOINT).name("cdef").build();
    API api4 = createApi("provider4", api4Id, "testapi4", "1.0.0", "Test API 4 - version 1.0.0", createEndpointTypeToIdMap(api4SandBoxEndpointId, api4ProdEndpointId)).build();
    String api4Doc1Id = UUID.randomUUID().toString();
    DocumentInfo api4Doc1Info = createAPIDoc(api4Doc1Id, "api1doc1", "", "API 4 DOC 1", DocumentInfo.DocType.HOWTO, "other type", DocumentInfo.SourceType.INLINE, "", DocumentInfo.Visibility.PRIVATE);
    String api4Doc2Id = UUID.randomUUID().toString();
    DocumentInfo api4Doc2Info = createAPIDoc(api4Doc2Id, "api1doc2.pdf", "api1doc2.pdf", "API 4 DOC 2", DocumentInfo.DocType.PUBLIC_FORUM, "other type", DocumentInfo.SourceType.FILE, "", DocumentInfo.Visibility.API_LEVEL);
    String api4Doc3Id = UUID.randomUUID().toString();
    DocumentInfo api4Doc3Info = createAPIDoc(api4Doc3Id, "api1doc3", "", "API 4 DOC 3", DocumentInfo.DocType.OTHER, "other type", DocumentInfo.SourceType.OTHER, "", DocumentInfo.Visibility.API_LEVEL);
    List<DocumentInfo> api1DocumentInfo = new ArrayList<>();
    api1DocumentInfo.add(api4Doc1Info);
    api1DocumentInfo.add(api4Doc2Info);
    api1DocumentInfo.add(api4Doc3Info);
    // contents for documents
    DocumentContent api4Doc1Content = createDocContent(api4Doc1Info, "Sample inline content for API1 DOC 1", null);
    DocumentContent api4Doc2Content = createDocContent(api4Doc2Info, "", api1Doc2Stream);
    DocumentContent api4Doc3Content = createDocContent(api4Doc3Info, "", null);
    Mockito.when(apiPublisher.getAPIbyUUID(api4Id)).thenReturn(api4);
    Mockito.when(apiPublisher.getApiSwaggerDefinition(api4Id)).thenReturn(api1Definition);
    Mockito.when(apiPublisher.getApiGatewayConfig(api4Id)).thenReturn(api1GatewayConfig);
    Mockito.when(apiPublisher.getAllDocumentation(api4Id, 0, Integer.MAX_VALUE)).thenReturn(api1DocumentInfo);
    Mockito.when(apiPublisher.getDocumentationContent(api4Doc1Id)).thenReturn(api4Doc1Content);
    Mockito.when(apiPublisher.getDocumentationContent(api4Doc2Id)).thenReturn(api4Doc2Content);
    Mockito.when(apiPublisher.getDocumentationContent(api4Doc3Id)).thenReturn(api4Doc3Content);
    Mockito.when(apiPublisher.getThumbnailImage(api4Id)).thenReturn(null);
    String api5Id = UUID.randomUUID().toString();
    Endpoint api5SandBoxEndpointId = new Endpoint.Builder().id(UUID.randomUUID().toString()).applicableLevel(APIMgtConstants.API_SPECIFIC_ENDPOINT).name("abcd").build();
    Endpoint api5ProdEndpointId = new Endpoint.Builder().id(UUID.randomUUID().toString()).applicableLevel(APIMgtConstants.API_SPECIFIC_ENDPOINT).name("cdef").build();
    API api5 = createApi("provider5", api5Id, "testapi4", "1.0.0", "Test API 5 - version 1.0.0", createEndpointTypeToIdMap(api5SandBoxEndpointId, api5ProdEndpointId)).build();
    String api5Doc1Id = UUID.randomUUID().toString();
    DocumentInfo api5Doc1Info = createAPIDoc(api5Doc1Id, "api1doc1", "", "API 5 DOC 1", DocumentInfo.DocType.HOWTO, "other type", DocumentInfo.SourceType.INLINE, "", DocumentInfo.Visibility.PRIVATE);
    String api5Doc3Id = UUID.randomUUID().toString();
    DocumentInfo api5Doc3Info = createAPIDoc(api5Doc3Id, "api1doc3", "", "API 5 DOC 3", DocumentInfo.DocType.OTHER, "other type", DocumentInfo.SourceType.OTHER, "", DocumentInfo.Visibility.API_LEVEL);
    List<DocumentInfo> api5DocumentInfo = new ArrayList<>();
    api5DocumentInfo.add(api5Doc1Info);
    api5DocumentInfo.add(api5Doc3Info);
    // contents for documents
    DocumentContent api5Doc1Content = createDocContent(api5Doc1Info, "Sample inline content for API1 DOC 1", null);
    DocumentContent api5Doc3Content = createDocContent(api5Doc3Info, "", null);
    Mockito.when(apiPublisher.getAPIbyUUID(api5Id)).thenReturn(api5);
    Mockito.when(apiPublisher.getApiSwaggerDefinition(api5Id)).thenReturn(api1Definition);
    Mockito.when(apiPublisher.getApiGatewayConfig(api5Id)).thenReturn(api1GatewayConfig);
    Mockito.when(apiPublisher.getAllDocumentation(api5Id, 0, Integer.MAX_VALUE)).thenReturn(api5DocumentInfo);
    Mockito.when(apiPublisher.getDocumentationContent(api5Doc1Id)).thenReturn(api5Doc1Content);
    Mockito.when(apiPublisher.getDocumentationContent(api5Doc3Id)).thenReturn(api5Doc3Content);
    Mockito.when(apiPublisher.getThumbnailImage(api5Id)).thenReturn(getClass().getClassLoader().getResourceAsStream("api1_thumbnail.png"));
    Mockito.when(apiPublisher.getAllDocumentation(api4Id, 0, Integer.MAX_VALUE)).thenThrow(APIManagementException.class);
    List<API> apis = new ArrayList<>();
    apis.add(api4);
    apis.add(api5);
    Mockito.when(apiPublisher.searchAPIs(Integer.MAX_VALUE, 0, "*")).thenReturn(apis);
    ApiImportExportManager importExportManager = new ApiImportExportManager(apiPublisher);
    Set<APIDetails> apiDetailsSet = importExportManager.getAPIDetails(Integer.MAX_VALUE, 0, "*");
    Assert.assertEquals(apiDetailsSet.size() == 2, true, "Error getting API details");
}

Example 12 with DocumentContent

use of org.wso2.carbon.apimgt.core.models.DocumentContent in project carbon-apimgt by wso2.

the class FileBasedApiImportExportManager method exportDocumentationToFileSystem.

/**
 * Writes the given List of {@link DocumentInfo} objects to the file system
 *
 * @param documentInfo   list of {@link DocumentInfo} objects
 * @param apiDetails     {@link APIDetails} instance, to which the documents are related to
 * @param exportLocation file system location to which documents will be written
 */
private void exportDocumentationToFileSystem(Set<DocumentInfo> documentInfo, APIDetails apiDetails, String exportLocation) {
    if (documentInfo == null || documentInfo.isEmpty()) {
        log.debug("No documentation found for API with api: " + apiDetails.getApi().getName() + ", " + "version: " + apiDetails.getApi().getVersion());
        return;
    }
    // create Documents root directory
    String documentsBaseDirectory = exportLocation + File.separator + DOCUMENTS_ROOT_DIRECTORY;
    try {
        APIFileUtils.createDirectory(documentsBaseDirectory);
        Gson gson = new GsonBuilder().setPrettyPrinting().create();
        for (DocumentInfo aDocumentInfo : documentInfo) {
            // create the root directory for each document
            String apiExportDir = documentsBaseDirectory + File.separator + aDocumentInfo.getId();
            APIFileUtils.createDirectory(apiExportDir);
            // for each document, write a DocumentInfo to a separate json file
            String apiDocMetaFileLocation = apiExportDir + File.separator + DOCUMENTATION_DEFINITION_FILE;
            APIFileUtils.createFile(apiDocMetaFileLocation);
            APIFileUtils.writeToFile(apiDocMetaFileLocation, gson.toJson(aDocumentInfo));
            // if the document's SourceType is FILE, retrieve and write the content to a file
            DocumentContent content;
            if (aDocumentInfo.getSourceType().equals(DocumentInfo.SourceType.FILE)) {
                content = apiDetails.getDocumentContent(aDocumentInfo.getId());
                if (content != null) {
                    APIFileUtils.createFile(apiExportDir + File.separator + content.getDocumentInfo().getFileName());
                    APIFileUtils.writeStreamToFile(apiExportDir + File.separator + content.getDocumentInfo().getFileName(), content.getFileContent());
                    // modify the document metadata to contain the file name
                    DocumentInfo modifiedDocInfo = new DocumentInfo.Builder(aDocumentInfo).fileName(content.getDocumentInfo().getFileName()).build();
                    APIFileUtils.writeToFile(apiDocMetaFileLocation, gson.toJson(modifiedDocInfo));
                }
            } else if (aDocumentInfo.getSourceType().equals(DocumentInfo.SourceType.INLINE)) {
                content = apiDetails.getDocumentContent(aDocumentInfo.getId());
                if (content != null) {
                    APIFileUtils.createFile(apiExportDir + File.separator + content.getDocumentInfo().getName());
                    APIFileUtils.writeToFile(apiExportDir + File.separator + content.getDocumentInfo().getName(), content.getInlineContent());
                    // modify the document metadata to contain the inline content name
                    DocumentInfo modifiedDocInfo = new DocumentInfo.Builder(aDocumentInfo).name(content.getDocumentInfo().getName()).build();
                    APIFileUtils.writeToFile(apiDocMetaFileLocation, gson.toJson(modifiedDocInfo));
                }
            }
        }
    } catch (APIMgtDAOException e) {
        log.error("Error in exporting documents to file system for api: " + apiDetails.getApi().getName() + ", version: " + apiDetails.getApi().getVersion());
        // cleanup
        try {
            APIFileUtils.deleteDirectory(path);
        } catch (APIMgtDAOException ignore) {
            log.warn("Unable to remove directory " + path);
        }
    }
    if (log.isDebugEnabled()) {
        log.debug("Successfully exported documentation for api: " + apiDetails.getApi().getName() + ", version: " + apiDetails.getApi().getVersion());
    }
}

Example 13 with DocumentContent

use of org.wso2.carbon.apimgt.core.models.DocumentContent in project carbon-apimgt by wso2.

the class ApiImportExportManager method updateAPIDetails.

/**
 * Updates the API details
 *
 * @param apiDetails {@link APIDetails} instance
 * @throws APIManagementException if an error occurs while updating API details
 */
void updateAPIDetails(APIDetails apiDetails) throws APIManagementException {
    // update everything
    String swaggerDefinition = apiDetails.getSwaggerDefinition();
    String gatewayConfig = apiDetails.getGatewayConfiguration();
    Map<String, Endpoint> endpointTypeToIdMap = new HashMap<>();
    // endpoints
    for (Endpoint endpoint : apiDetails.getEndpoints()) {
        try {
            apiPublisher.updateEndpoint(endpoint);
            endpointTypeToIdMap.put(endpoint.getType(), endpoint);
        } catch (APIManagementException e) {
            // skip updating this API, log and continue
            log.error("Error while updating the endpoint with id: " + endpoint.getId() + ", type: " + endpoint.getType() + " for API: " + apiDetails.getApi().getName() + ", version: " + apiDetails.getApi().getVersion());
        }
    }
    API.APIBuilder apiBuilder = new API.APIBuilder(apiDetails.getApi());
    apiPublisher.updateAPI(apiBuilder.apiDefinition(swaggerDefinition).gatewayConfig(gatewayConfig).endpoint(endpointTypeToIdMap));
    // docs
    try {
        Set<DocumentInfo> documentInfo = apiDetails.getAllDocumentInformation();
        for (DocumentInfo aDocInfo : documentInfo) {
            apiPublisher.updateDocumentation(aDocInfo.getId(), aDocInfo);
        }
        Collection<DocumentContent> docContents = apiDetails.getDocumentContents();
        for (DocumentContent docContent : docContents) {
            // update documentation
            if (docContent.getDocumentInfo().getSourceType().equals(DocumentInfo.SourceType.FILE)) {
                apiPublisher.uploadDocumentationFile(docContent.getDocumentInfo().getId(), docContent.getFileContent(), URLConnection.guessContentTypeFromStream(docContent.getFileContent()));
            } else if (docContent.getDocumentInfo().getSourceType().equals(DocumentInfo.SourceType.INLINE)) {
                apiPublisher.addDocumentationContent(docContent.getDocumentInfo().getId(), docContent.getInlineContent());
            }
        }
    } catch (APIManagementException e) {
        // no need to throw, log and continue
        log.error("Error while adding Document details for API: " + apiDetails.getApi().getName() + ", version: " + apiDetails.getApi().getVersion(), e);
    } catch (IOException e) {
        // no need to throw, log and continue
        log.error("Error while retrieving content type of the File documentation of API : " + apiDetails.getApi().getName() + ", version: " + apiDetails.getApi().getVersion(), e);
    }
    // update thumbnail
    try {
        apiPublisher.saveThumbnailImage(apiDetails.getApi().getId(), apiDetails.getThumbnailStream(), "thumbnail");
    } catch (APIManagementException e) {
        // no need to throw, log and continue
        log.error("Error while updating thumbnail for API: " + apiDetails.getApi().getName() + ", version: " + apiDetails.getApi().getVersion(), e);
    }
}

Example 14 with DocumentContent

use of org.wso2.carbon.apimgt.core.models.DocumentContent in project carbon-apimgt by wso2.

the class ApiImportExportManager method getAPIDetails.

/**
 * Retrieves all API details of the APIs for the given search query. API details consist of:
 *      1. API {@link org.wso2.carbon.apimgt.core.models.API}
 *      2. Document Info {@link org.wso2.carbon.apimgt.core.models.DocumentInfo}
 *      3. Document Content {@link org.wso2.carbon.apimgt.core.models.DocumentContent}
 *      4. Swagger Definition
 *      5. Gateway Definition
 *      6. Thumbnail content
 *
 * @param limit number of max results
 * @param offset starting location when returning a limited set of results
 * @param query searchQuery
 * @return {@link APIDetails} instance
 * @throws APIManagementException if an error occurs while retrieving API details
 */
public Set<APIDetails> getAPIDetails(Integer limit, Integer offset, String query) throws APIManagementException {
    Set<APIDetails> apiDetailSet = new HashSet<>();
    // search for APIs
    List<API> apis = apiPublisher.searchAPIs(limit, offset, query);
    if (apis == null || apis.isEmpty()) {
        // no APIs found, return
        return apiDetailSet;
    }
    // iterate and collect all information
    for (API api : apis) {
        api = apiPublisher.getAPIbyUUID(api.getId());
        // get endpoints at API Level
        Map<String, Endpoint> endpoints = api.getEndpoint();
        if (endpoints.isEmpty()) {
            log.error("No Endpoints found for api: " + api.getName() + ", version: " + api.getVersion());
        // skip this API
        // continue;
        }
        Set<Endpoint> endpointSet = new HashSet<>();
        for (Map.Entry<String, Endpoint> endpointEntry : endpoints.entrySet()) {
            if (APIMgtConstants.GLOBAL_ENDPOINT.equals(endpointEntry.getValue().getApplicableLevel())) {
                Endpoint endpoint = new Endpoint.Builder(apiPublisher.getEndpoint(endpointEntry.getValue().getId())).id("").build();
                endpoints.replace(endpointEntry.getKey(), endpoint);
                endpointSet.add(endpoint);
            }
        }
        // get Endpoints at Resource Level
        Map<String, UriTemplate> uriTemplateMap = api.getUriTemplates();
        uriTemplateMap.forEach((k, v) -> {
            UriTemplate.UriTemplateBuilder uriTemplateBuilder = new UriTemplate.UriTemplateBuilder(v);
            Map<String, Endpoint> resourceEndpoints = uriTemplateBuilder.getEndpoint();
            resourceEndpoints.forEach((type, value) -> {
                Endpoint endpoint = null;
                if (APIMgtConstants.GLOBAL_ENDPOINT.equals(value.getApplicableLevel())) {
                    try {
                        endpoint = new Endpoint.Builder(apiPublisher.getEndpoint(value.getId())).id("").build();
                        endpointSet.add(endpoint);
                    } catch (APIManagementException e) {
                        log.error("Error in getting endpoints for Resource: " + v.getTemplateId(), e);
                    }
                } else {
                    endpoint = new Endpoint.Builder(value).id("").build();
                }
                resourceEndpoints.replace(type, endpoint);
            });
            uriTemplateMap.replace(k, uriTemplateBuilder.endpoint(resourceEndpoints).build());
        });
        api = new API.APIBuilder(api).endpoint(endpoints).uriTemplates(uriTemplateMap).build();
        // get swagger definition
        String swaggerDefinition;
        try {
            swaggerDefinition = apiPublisher.getApiSwaggerDefinition(api.getId());
        } catch (APIManagementException e) {
            log.error("Error in getting Swagger configuration for api: " + api.getName() + ", version: " + api.getVersion(), e);
            // skip this API
            continue;
        }
        // get gateway configuration
        String gatewayConfig;
        try {
            gatewayConfig = apiPublisher.getApiGatewayConfig(api.getId());
        } catch (APIManagementException e) {
            log.error("Error in getting gateway configuration for api: " + api.getName() + ", version: " + api.getVersion(), e);
            // skip this API
            continue;
        }
        // get doc information
        List<DocumentInfo> documentInfo = null;
        try {
            documentInfo = apiPublisher.getAllDocumentation(api.getId(), 0, Integer.MAX_VALUE);
        } catch (APIManagementException e) {
            log.error("Error in getting documentation content for api: " + api.getName() + ", version: " + api.getVersion(), e);
        // no need to skip the API as docs don't affect API functionality
        }
        Set<DocumentContent> documentContents = new HashSet<>();
        if (documentInfo != null && !documentInfo.isEmpty()) {
            // iterate and collect document content
            for (DocumentInfo aDocumentInfo : documentInfo) {
                try {
                    documentContents.add(apiPublisher.getDocumentationContent(aDocumentInfo.getId()));
                } catch (APIManagementException e) {
                    log.error("Error in getting documentation content for api: " + api.getName() + ", version: " + api.getVersion() + ", doc id: " + aDocumentInfo.getId(), e);
                // no need to skip the API as docs don't affect API functionality
                }
            }
        }
        // get thumbnail
        InputStream thumbnailStream = null;
        try {
            thumbnailStream = apiPublisher.getThumbnailImage(api.getId());
        } catch (APIManagementException e) {
            log.error("Error in getting thumbnail for api: " + api.getName() + ", version: " + api.getVersion(), e);
        // no need to skip the API as thumbnail don't affect API functionality
        }
        // search operation returns a summary of APIs, need to get all details of APIs
        APIDetails apiDetails = new APIDetails(api, swaggerDefinition);
        apiDetails.setGatewayConfiguration(gatewayConfig);
        apiDetails.setEndpoints(endpointSet);
        if (documentInfo != null && !documentInfo.isEmpty()) {
            apiDetails.addDocumentInformation(documentInfo);
        }
        if (!documentContents.isEmpty()) {
            apiDetails.addDocumentContents(documentContents);
        }
        if (thumbnailStream != null) {
            apiDetails.setThumbnailStream(thumbnailStream);
        }
        apiDetailSet.add(apiDetails);
    }
    return apiDetailSet;
}

Example 15 with DocumentContent

use of org.wso2.carbon.apimgt.core.models.DocumentContent in project carbon-apimgt by wso2.

the class ApisApiServiceImplTestCase method testApisApiIdDocumentsDocumentIdContentGetFile.

@Test
public void testApisApiIdDocumentsDocumentIdContentGetFile() throws Exception {
    String fileName = "mytext.txt";
    printTestMethodName();
    ApisApiServiceImpl apisApiService = new ApisApiServiceImpl();
    APIPublisher apiPublisher = Mockito.mock(APIPublisherImpl.class);
    PowerMockito.mockStatic(RestAPIPublisherUtil.class);
    PowerMockito.when(RestAPIPublisherUtil.getApiPublisher(USER)).thenReturn(apiPublisher);
    String api1Id = UUID.randomUUID().toString();
    String documentId = UUID.randomUUID().toString();
    DocumentInfo documentInfo = SampleTestObjectCreator.createDefaultDocumentationInfo().sourceType(DocumentInfo.SourceType.FILE).fileName(fileName).build();
    DocumentContent documentContent = DocumentContent.newDocumentContent().documentInfo(documentInfo).build();
    Mockito.doReturn(documentContent).doThrow(new IllegalArgumentException()).when(apiPublisher).getDocumentationContent(documentId);
    Response response = apisApiService.apisApiIdDocumentsDocumentIdContentGet(api1Id, documentId, null, null, getRequest());
    assertEquals(response.getStatus(), 200);
    assertTrue(response.getStringHeaders().get("Content-Disposition").toString().contains(fileName));
}