In this tutorial, we will discuss various ways to retrieve objects via the Core API from the yuuvis® API system using an OkHttp3 Java client.

Check out our graphical overview of the architecture which describes the basic use case flow for retrieving content or metadata.

Table of Contents

Requirements

To work through this tutorial, the following is required:

Set-up yuuvis® API system (see minikube setup, for example)
A user with at least read permissions on a document type in the system (see tutorial for permissions)
Simple Maven project

Maven Configuration

Our Java client will submit its requests to the Core API using OkHttp 3.12 by Square, Inc. Therefore, the following block must be added to the Maven dependencies in the pom.xml of the project:

pom.xml

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>3.12.0</version>
</dependency>

Client Configuration

To interact with the yuuvis® API system via the Core API, we use an OkHttp3 client to send HTTP requests and read their responses.

OkHttp3 Client and Variables

String baseUrl = "http://127.0.0.1"; //baseUrl of gateway: "http://<host>:<port>"
String username = "clouduser";
String userpassword = "secret";
String tenant = "default";
String auth = java.util.Base64.getEncoder().encodeToString((username + ":" + userpassword).getBytes());
  
OkHttpClient.Builder builder = new OkHttpClient.Builder();
OkHttpClient client = builder.build();

For more information on setting up the OkHttp3 client with cookie handling, please refer to this login tutorial.

Retrieving Documents

To be able to access documents, they must exist in the system. A tutorial for importing documents can be found here.

Retrieving Documents via Object ID

The direct access to a document takes place via its object ID via GET request to the endpoint /api/dms/objects/{objectId}. The objectId serves as a unique identifier of a document and can be obtained from the response of the API call of an import (see Tutorial for updating documents: Determining the objectId after import).

Retrieving Metadata of an Object

String objectId = "1234567890"; //example-objectId

Request metadataRequest = new Request.Builder()
        .header("Authorization", "Basic " + auth)
        .header("X-ID-TENANT-NAME", tenant)
        .url(baseUrl+ "/api/dms/objects/" + objectId)
        .get().build();


Response metadataResponse = client.newCall(metadataRequest).execute();
String metadataResponseString = metadataResponse.body().string();

The API call response will contain the current version of the objects' metadata in JSON format.

To retrieve the content of an object, a GET request is sent to the endpoint /api/dms/objects/{objectId}/contents/file.

Retrieving Content of an Object

Request contentRequest = new Request.Builder()
        .header("Authorization", "Basic " + auth)
        .header("X-ID-TENANT-NAME", tenant)
        .url(baseUrl+ "/api/dms/objects/" + objectId + "/contents/file")
        .get().build();

If a specific version of the document is to be requested, the endpoint to be called for the documents' metadata changes to /api/dms/objects/{objectId}/versions/{versionNr} and for the documents' content to /api/dms/objects/{objectId}/versions/{versionNr}/contents/file. More about this topic can be found in the Updating Documents via Core API tutorial under Versioning.

Retrieving Documents via Search Endpoint

The Core API provides a search endpoint (/api/dms/objects/search) that can process search queries written in the proprietary Search Query Language. The search query is sent to the search endpoint in JSON format in the body of a POST request.

Query in JSON Format

{
	"query": {
		"maxItems": 50,
		"statement": "SELECT * FROM system:object WHERE CONTAINS('Europan') AND Name Like 'E%'",
		"skipCount": 0
	}
}

This example query searches for all objects of type enaio:object whose content contains the string "Europan" and whose value of attribute Name begins with the character 'E'.

To create such a query object programmatically, a JSON library is needed to create the query JSON. We'll be using org.json, so the following block must be added to the Maven dependencies in the pom.xml of the Java project:

pom.xml

<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20180813</version>
</dependency>

Now we can implement a method createQueryJSON(String statement, int skipCount, int maxItems) that creates a query object and returns it as a string. We send the string to the search endpoint in the request body of a POST request:

Retrieving Documents via Search Endpoint

public static String createQueryJSON(String statement, int skipCount, int maxItems) {
    JSONObject queryObject = new JSONObject();
    JSONObject queryAttributes = new JSONObject();
    queryAttributes.put("statement", statement);
    queryAttributes.put("skipCount", skipCount);
    queryAttributes.put("maxItems", maxItems);
    queryObject.put("query", queryAttributes);

    return queryObject.toString();
}


String query = createQueryJSON("SELECT * FROM system:object WHERE CONTAINS('Europan') AND Name Like 'E%'", 0, 50);


Request attributeSearchRequest = new Request.Builder()
        .header("Authorization", "Basic " + auth)
        .header("X-ID-TENANT-NAME", tenant)
        .url(baseUrl + "/api/dms/objects/search")
        .post(RequestBody.create(MediaType.parse("application/json; charset=utf-8"), query))
        .build();
Response attributeSearchResponse = client.newCall(attributeSearchRequest).execute();
System.out.println(attributeSearchResponse.body().string());

The expected response is a list of DMS objects with metadata matching the search query, which can also be an empty list.

Summary

This tutorial showed how to use an OkHttpClient to retrieve documents via Core API.

A complete code example can be found in this Git repository.

More Tutorials

Importing Documents

This tutorial shows how documents can be imported into a yuuvis® API system via the Core API. During this tutorial, a short Java application will be developed that implements the HTTP requests for importing documents. We additionally provide a JavaScript version of this tutorial. Keep reading

Updating Documents

This tutorial demonstrates how to update documents in yuuvis® API with the Core API. The following example will result in a short Java application that implements the HTTP requests for updating a document. Keep reading

Deleting Documents

This tutorial explains how documents can be deleted using the Core API with the help of a Java client. This tutorial requires basic knowledge of importing documents using the Core API. Keep reading

Browser not supported