Apache Chemistry and CMIS

In this post, I will explain how you can use apache chemistry API’s to query the enterprise content management systems. Apache Chemistry project provides client libraries for you to easily implement integration with any of the content management products that support or implement CMIS standard. As you might be aware that there are multiple standards such as JCR and CMIS  for interacting with the content repositories. Although with JCR 2 support for SQL-92 is now available,  I really prefer the conciseness and wider adoption of the  CMIS standard, and the fact that Apache chemistry API’s really make it easy to interact with the content repository. 

I am sharing an example that you can readily test without any special environment setup.  Alfresco, is one of the vendors that provides a ECM product, which supports the CMIS standard. Alfresco, offers a public repository for you to play with.  I will cover this example on a piecemeal basis.

1. Connecting to the repository: 

   SessionFactory sessionFactory = SessionFactoryImpl.newInstance();
           Map<String,String> parameter = new HashMap<String,String>();
           parameter.put(SessionParameter.USER, "admin");
           //the binding type to use
           parameter.put(SessionParameter.BINDING_TYPE, BindingType.ATOMPUB.value());
           parameter.put(SessionParameter.PASSWORD, "admin");
           //the endpoint
           parameter.put(SessionParameter.ATOMPUB_URL, "http://cmis.alfresco.com/s/cmis");
           parameter.put(SessionParameter.BINDING_TYPE, BindingType.ATOMPUB.value());
           //fetch the list of repositories
           List<Repository> repositories = sessionFactory.getRepositories(parameter);
           //establish a session with the first ?
           Session session = repositories.get(0).createSession();

   
   
   

   To connect to the repository, you require a few basic parameters such as the username, password, endpoint url (In this case the REST AtomPub service) and a binding type to specify which type of endpoint is it (WEBSERVICES, ATOMPUB, BROWSER, LOCAL, CUSTOM ) are the valid binding types. After we have this information , we still need a repository id to connect to. In this case, I am using the first repository from a list of repositories to establish the session. Now, let’s create a query statement to search for the documents.

   
   
   
   
   



2. Querying the repository: 

   //query builder for convenience
   QueryStatement qs=session.createQueryStatement("SELECT D.*, O.* FROM cmis:document AS D JOIN cm:ownable AS O ON D.cmis:objectId = O.cmis:objectId " +
           " where " +
           " D.cmis:name in (?)" +
           " and " +
           " D.cmis:creationDate > TIMESTAMP ? " +
           " order by cmis:creationDate desc");
   //array for the in argument
   String documentNames[]= new String[]{"Project Objectives.ppt","Project Overview.ppt"};
   qs.setString(1, documentNames);
   Calendar now = Calendar.getInstance();
   //subtract 5 year for viewing documents for last 5 year
   now.add(Calendar.YEAR, -5);
   qs.setDateTime(2, now);
   //get the first 50 records only.
   ItemIterable<QueryResult> results = session.query(qs.toQueryString(), false).getPage(50);

   
   
   

   Here I have used createQueryStatement  method to build a query just for convenience, you could also directly specify a query string(not recommended). The query is essentially a join between objects. This sample code shows, how to specify the date (Line 14) and an array (Line 10) for the in clause as parameters.  Line 16 assigns the searched values to an Iterable interface, where each QueryResult is a record containing the selected columns.

   
   



3. Iterating the results:
   
   

   for(QueryResult record: results) {
       Object documentName=record.getPropertyByQueryName("D.cmis:name").getFirstValue();
       logger.info("D.cmis:name " + ": " + documentName);
   
       Object documentReference=record.getPropertyByQueryName("D.cmis:objectId").getFirstValue();
       logger.info("--------------------------------------");
       logger.info("Content URL: http://cmis.alfresco.com/service/cmis/content?conn=default&id="+documentReference);
   }

   
   As explained above, we get a Iterable result-set to iterate over the individual records. To fetch the first value from the record (as there might be multiple valued attributes), I am using the getFirstValue method of the PropertyData interface.  Note Line 7 as it contains the actual URL of the resource, which is just a base URL to which the object id of the matched document is appended.



4. Closing the connection ? As per the chemistry javadoc, there is no need to close a session, as it is purely a client side concept, which makes sense as we are not holding a connection here.

Viewing the results: To view the actual documents just use the URL’s generated by the log statement in the browser.

Building the code: Add the following dependency to maven for building the sample.

    <dependency>
         <groupId>org.apache.chemistry.opencmis</groupId>
         <artifactId>chemistry-opencmis-client-impl</artifactId>
         <version>0.12.0</version>
     </dependency>

Wrapping up: I have just covered one example of the CMIS Query API  and Apache chemistry to query for the documents. Kindly refer to the documentation links provided in reference section for other usages.  Below, is the gist that contains the entire sample code.

References:

CMIS_Query_Language Java Examples for Apache Chemistry

Read More

Retrofit custom JSON deserializer

Retrofit uses Google’s gson libraries to deserialize JSON representation to Java object representation. Although, this deserialization process works for most of the cases, sometimes you would have to override the deserialization process to parse a part of the response or because you don’t have any clear object representation of the JSON data.

In this post, I will share an example of a custom deserializer to parse the response from Wiktionary’s word definition API. First, let us take a look at the request and response.

The request URL is mentioned below:-

http://en.wiktionary.org/w/api.php?format=json&action=query&titles=sublime&prop=extracts&redirects&continue

The response is mentioned below, It has been shortened for brevity.

{"batchcomplete":"","query":{"pages":{"200363":{"pageid":200363,"ns":0,"title":"sublime","extract":"<p></p>\n<h2><span id=\"English\">English</span></h2>\n<h3><span id=\"Pronunciation\">Pronunciation</span></h3>\n<ul><li>\n</li>\n<li>Rhymes: <span lang=\"\">-a\u026am</span></li>\n</ul><h3><span id=\"Etymology_1\">Etymology 1</span></h3>\n<p>From <span>Middle English</span> <i class=\"Latn mention\" .......for brevity }}}}  

As, you can see the data we would be interested in is extract and probably the pageid. Now, as there is no straightforward object representation of this entire response in Java, so we would implement our own custom deserializer to parse this JSON response.

The code for the deserializer  is mentioned below.

public class DictionaryResponseDeserializer implements JsonDeserializer<WicktionarySearchResponse> {

    @Override
    public WicktionarySearchResponse deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        Gson gson=new Gson();
        JsonElement value = null;
        value = json.getAsJsonObject().get("query").getAsJsonObject().get("pages");
        WicktionarySearchResponse response = new WicktionarySearchResponse();
        if(value!=null) {
            Iterable<Map.Entry<String, JsonElement>> entries = value.getAsJsonObject().entrySet();
            Query query = new Query();
ArrayList<ResultPage> resultPages = new ArrayList<ResultPage>();
            for (Map.Entry<String, JsonElement> entry : entries) {
                resultPages.add(new Gson().fromJson(entry.getValue(), ResultPage.class));

            }
            query.setPages(resultPages);
            response.setQuery(query);
        }


        return response;
    }
}

Pay special attention to the highlighted lines. On the first highlighted line, we are assigning the JsonElement with the value of the object that contains all the pages from the JSON response, as we are interested in only that data.  Next, we iterate the assigned value and as we are interested in the actual values and not the keys (as the key pageid is already present in the individual pageid objects), so we just use entry.getValue to obtain that and then transform it to a Java POJO instance using the GSON object instance.

Below, I have mentioned the service interface and an util class to invoke the word search API.

public interface DictionaryService {

    @GET("/w/api.php")
    public void getMeaningOfWord(@QueryMap Map<String, String> map, Callback<WicktionarySearchResponse> response);

    @GET("/w/api.php")
    public WicktionarySearchResponse getMeaningOfWord(@QueryMap Map<String, String> map);
}

/**
 * Created by Ramandeep on 07-01-2015.
 */
public class DictionaryUtil {
    private static final String tag="DictionaryUtil";
    private static Gson gson= initGson();

    private static Gson initGson() {
    if(gson==null){
        gson= new GsonBuilder().registerTypeAdapter(WicktionarySearchResponse.class,new DictionaryResponseDeserializer()).create();
    }
    return gson;
    }

    public static WicktionarySearchResponse searchDefinition(String word){
        WicktionarySearchResponse searchResponse=null;
        RestAdapter restAdapter = new RestAdapter.Builder()
                .setEndpoint("http://wiktionary.org").setConverter(new GsonConverter(gson))
                .build();
        DictionaryService serviceImpl=    restAdapter.create(DictionaryService.class);
        Map queryMap=new HashMap();
        queryMap.put("action","query");
        queryMap.put("prop","extracts");
        queryMap.put("redirects",null);
        queryMap.put("format","json");
        queryMap.put("continue",null);
        queryMap.put("titles",word);
         try {
             searchResponse=  serviceImpl.getMeaningOfWord(queryMap);
         }catch (Exception e){
             if(e==null&&e.getMessage()!=null) {
                 Log.e(tag, e.getMessage());
             }
         }
        return searchResponse;

    }




}

 

 

Below, I have mentioned the POJO classes. In order of hierarchy.

public class WicktionarySearchResponse {

private Query query=null;

    public Query getQuery() {
        return query;
    }

    public void setQuery(Query query) {
        this.query = query;
    }
}

public class Query {


    public List<ResultPage> getPages() {
        return pages;
    }

    public void setPages(List<ResultPage> pages) {
        this.pages = pages;
    }

    private List<ResultPage> pages=null;


}

public class ResultPage {
    private long pageId;
    private String title;
    private int index;
    private String extract;

    public ResultPage() {
    }

    public long getPageId() {
        return pageId;
    }

    public void setPageId(long pageId) {
        this.pageId = pageId;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }

    public String getExtract() {
        return extract;
    }

    public void setExtract(String extract) {
        this.extract = extract;
    }
}

Read More