MDS Java Code Example

package test.com.mris.mds.rs.services.client.example;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Authenticator;
import java.net.CookieHandler;
import java.net.CookieManager;
import java.net.CookiePolicy;
import java.net.HttpURLConnection;
import java.net.PasswordAuthentication;
import java.net.URL;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.zip.GZIPInputStream;

/**
 * This class handles MDS client requests.
 */
public class MDSClientHandler
{
   // The user credentials
   private String userId;
   private String password;
   
   // The user agent
   private String userAgent;
   
   // The endpoint
   private String endpoint;
   
   // Use gzip
   private boolean requestGZip = false;
   
   // Debug mode
   private boolean debug = false;
   
   // The logger for this class
   Logger logger = Logger.getLogger(this.getClass().getCanonicalName());
   
   /**
    * The Constructor of this class.
    
    @param userId the user id
    @param password the password
    @param userAgent the user agent
    @param endpoint the endpoint
    
    */
   public MDSClientHandler(String userId, String password, String userAgent, String endpoint)
   {
      this.userId = userId;
      this.password = password;
      this.userAgent = userAgent;
      this.endpoint = endpoint;
      
      if (endpoint.endsWith("/"== false)
      {
         // Ensure that the endpoint has a trailing "/"
         endpoint += "/";
      }
      
      /**
       * Setup the Cookie Policy
       */
      CookieManager cookieManager = new CookieManager();
      cookieManager.setCookiePolicy(CookiePolicy.ACCEPT_ALL);
      CookieHandler.setDefault(cookieManager);
      
      /**
       * Set the default authentication so that Digest authentication can be supported.
       */
      Authenticator.setDefault(new MDSAuthenticator());
   }

   /**
    * This method performs a logout request via the Logout service.
    *
    */
   public void logout()
   {
      processRequest(getResourceUrl("Logout"));
   }
   
   /**
    * This method performs a request for the UserSessionInfo service 
    *
    @return the UserSessionInfo response
    
    @since 1.0
    */
   public String getUserSessionInfo()
   {
      return processRequest(getResourceUrl("UserSessionInfo"));
   }
   
   /**
    * This method is used to indicate if GZip encoding is to be requested.  
    *
    @param value if true, gzip will be requested
    */
   public void requestGZip(boolean value)
   {
      this.requestGZip = value;
   }
   
   /**
    * This method is used to indicate the debugging mode.  
    *
    @param value if true, debugging will be turned on
    */
   public void setDebuggingOn(boolean value)
   {
      this.debug = value;
   }
   
   /**
    * This method executes a resource query. 
    *
    @param resourcePath the resource path
    @param query the MDS query value
    @param count Optional, if true, indicates that only the record count is to be returned
    @param limit Optional, specifies the Limit.
    
    @return the MDS response
    
    @since 1.0
    */
   public String executeRequest(String resourcePath, String query, Boolean count, Integer limit)
   {
      String url = getResourceUrl(resourcePath);
      url += "/?Query=" + query;
      if (count != null && count == Boolean.TRUE)
      {
         url += "&Count=1";
      }
      if (limit != null)
      {
         url += "&Limit=" + limit;
      }
      return processRequest(url);
   }
   
   /**
    * This method executes a resource request. 
    *
    @param resourcePath the resource path
    @param resourceKeys a comma delimited list of resource keys
    @param selectFields Optional, specifies the comma delimited list of Select fields
    
    @return the MDS response
    
    @since 1.0
    */
   public String executeRequest(String resourcePath, String[] resourceKeys, String selectFields)
   {
      String url = getResourceUrl(resourcePath);
      if (resourceKeys != null)
      {
         String resourceKeyList = null;
         for (String resourceKey : resourceKeys)
         {
            if (resourceKeyList == null)
            {
               resourceKeyList = resourceKey;
            }
            else
            {
               resourceKeyList += "," + resourceKey;
            }
         }
         url += "/" + resourceKeyList;
      }
      if (selectFields != null)
      {
         url += "?Select=" + selectFields;
      }
      
      return processRequest(url);
   }
   
   /**
    * This method processes the MDS request 
    
    @param url the request url
    
    @return the MDS response
    */
   private String processRequest(String url)
   {      
      HttpURLConnection conn = null;
      try
      {
         conn = createRequest(url);
         
         if (debug)
         {
            logger.info("Authentication Succeeded");
            
            String headerInfo = "The following headers were received in the response:\n";
            Map<String,List<String>> headers = conn.getHeaderFields();
            for (String headerName : headers.keySet())
            {
               List<String> headerValueList = headers.get(headerName);
               for (String headerValue : headerValueList)
               {
                  headerInfo += "\t" + headerName + ": " + headerValue + "\n";                  
               }
            }
            logger.info(headerInfo);
         }
      }
      catch(IOException e)
      {
         logger.log(Level.SEVERE, "Failed to create connection.", e);
         return null;
      }
      try
      {
         String contentEncoding = conn.getContentEncoding();
         StringBuffer content = new StringBuffer();         
         InputStream is = (InputStreamconn.getInputStream();
         if (contentEncoding != null && contentEncoding.equals("gzip"))
         {
            is = new GZIPInputStream(is);
         }
         
         if (debuglogger.info("Response stream received.");         
         
         BufferedReader in = new BufferedReader(new InputStreamReader(is));
         String line;
         while ((line = in.readLine()) != null)
         {
            content.append(line + "\n");
            if (debuglogger.info(line);
         }
         in.close();
         return content.toString();
      }
      catch (IOException e)
      {
         logger.log(Level.SEVERE, "Request failed.", e);
         return null;
      }
   }
   
   /**
    * This method creates an <code>HttpURLConnection</code> for the specified URL. 
    *
    @param url the request URL
    
    @return the HttpURLConnection
    
    @throws IOException if there was an error with the connection
    */
   private HttpURLConnection createRequest(String url)
   throws IOException
   {
      HttpURLConnection conn = null;
      
      URL _url = new URL(url);
      conn = (HttpURLConnection)_url.openConnection();
      conn.setRequestMethod("GET");      
      conn.setRequestProperty("User-Agent", userAgent);
      if (this.requestGZip)
      {
         conn.setRequestProperty("Accept-Encoding""gzip");
      }
      
      conn.connect();
      return conn;
   }
   
   /**
    * This method gets the fully qualified URL for the specified resource path 
    *
    @param resourcePath the resource path
    
    @return the request URL
    */
   private String getResourceUrl(String resourcePath)
   {
      if (resourcePath.startsWith("/"))
      {
         resourcePath = resourcePath.substring(1, resourcePath.length() 1);
      }
      return endpoint + resourcePath;
   }
   
   /**
    * This class is the Authenticator to be used for Digest Authentication.
    */
   private class MDSAuthenticator extends Authenticator 
   {
      public PasswordAuthentication getPasswordAuthentication() 
      {
         return (new PasswordAuthentication(userId, password.toCharArray()));
      }
   }
}