/src/edu/ucsb/nceas/metacat/client/MetacatClient.java - Annotate - Metacat - Ecoinformatics Redmine

metacat/src/edu/ucsb/nceas/metacat/client/MetacatClient.java @ 3285

-            jones
+/**
  *  '$RCSfile$'
  *  Copyright: 2000 Regents of the University of California and the
  *              National Center for Ecological Analysis and Synthesis
+ *
  *   '$Author$'
  *     '$Date$'
  * '$Revision$'
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 package edu.ucsb.nceas.metacat.client;
-            barteau
+import com.oreilly.servlet.multipart.FilePart;
 import com.oreilly.servlet.multipart.MultipartParser;
 import com.oreilly.servlet.multipart.ParamPart;
 import com.oreilly.servlet.multipart.Part;
 import edu.ucsb.nceas.metacat.MetaCatUtil;
 import java.io.BufferedInputStream;
-            tao
+import java.io.BufferedReader;
-            jones
+import java.io.InputStream;
-            jones
+import java.io.InputStreamReader;
-            jones
+import java.io.PushbackReader;
-            jones
+import java.io.StringReader;
-            jones
+import java.io.IOException;
-            jones
+import java.io.StringWriter;
-            jones
+import java.io.Reader;
 import java.net.URL;
-            barteau
+import java.util.HashMap;
 import java.util.Iterator;
-            jones
+import java.util.Properties;
-            berkley
+import java.util.Vector;
-            barteau
+import javax.xml.xpath.XPath;
 import javax.xml.xpath.XPathFactory;
 import org.w3c.dom.Document;
 import org.w3c.dom.DocumentType;
 import org.w3c.dom.Element;
             jones
-            jones
+import org.w3c.dom.Node;
-            berkley
+import org.w3c.dom.NodeList;
             jones
-            jones
+import edu.ucsb.nceas.utilities.HttpMessage;
-            jones
+import edu.ucsb.nceas.utilities.IOUtil;
-            jones
+import edu.ucsb.nceas.utilities.XMLUtilities;
-            sgarg
+import java.io.File;
-            barteau
+import javax.xml.xpath.XPathConstants;
 import javax.xml.xpath.XPathExpressionException;
             jones
             jones
-            jones
+/**
-            sgarg
+ *  This interface provides methods for initializing and logging in to a
  *  Metacat server, and then querying, reading, transforming, inserting,
-            jones
+ *  updating and deleting documents from that server.
  */
-            barteau
+public class MetacatClient implements Metacat {
-            jones
+    /** The URL string for the metacat server */
     private String metacatUrl;
             barteau
-            jones
+    /** The session identifier for the session */
     private String sessionId;
             barteau
     public static final String              FGDC_SYSTEM_ID = "http://www.fgdc.gov/metadata/fgdc-std-001-1998.dtd";
     private static XPath                    xpath = XPathFactory.newInstance().newXPath();
     private Document                        loginResponse = null, metadataDoc = null;
     private String                          user = null;
-            jones
+    /**
-            barteau
+     * The Login cookie name.
      */
     public final static String                    LOGIN_COOOKIE = "cookie";
     /**
-            jones
+     * Constructor to create a new instance. Protected because instances
      * should only be created by the factory MetacatFactory.
      */
-            barteau
+    protected MetacatClient() {
-            jones
+        this.metacatUrl = null;
         this.sessionId = null;
             jones
             barteau
-            jones
+    /**
      *  Method used to log in to a metacat server. Implementations will need
      *  to cache a cookie value to make the session persistent.  Each time a
      *  call is made to one of the other methods (e.g., read), the cookie will
      *  need to be passed back to the metacat server along with the request.
+     *
      *  @param username   the username of the user, like an LDAP DN
      *  @param password   the password for that user for authentication
-            jones
+     *  @return the response string from metacat in XML format
-            jones
+     *  @throws MetacatAuthException when the username/password could
      *                    not be authenticated
      */
-            sgarg
+    public String login(String username, String password)
-            barteau
+    throws MetacatAuthException, MetacatInaccessibleException {
-            jones
+        Properties prop = new Properties();
         prop.put("action", "login");
         prop.put("qformat", "xml");
         prop.put("username", username);
         prop.put("password", password);
             barteau
-            jones
+        String response = null;
         try {
-            sgarg
+            response = sendDataForString(prop, null, null, 0);
-            jones
+        } catch (Exception e) {
             throw new MetacatInaccessibleException(e.getMessage());
+        }
             barteau
-            jones
+        if (response.indexOf("<login>") == -1) {
-            jones
+            setSessionId("");
-            jones
+            throw new MetacatAuthException(response);
-            jones
+        } else {
-            jones
+            int start = response.indexOf("<sessionId>") + 11;
-            jones
+            int end = response.indexOf("</sessionId>");
             if ((start != -1) && (end != -1)) {
-            jones
+                setSessionId(response.substring(start,end));
             jones
             jones
-            jones
+        return response;
             jones
             sgarg
     /**
      *  Method used to log in to a metacat server. Implementations will need
      *  to cache a cookie value to make the session persistent.  Each time a
      *  call is made to one of the other methods (e.g., read), the cookie will
      *  need to be passed back to the metacat server along with the request.
+     *
      *  @param username   the username of the user, like an LDAP DN
      *  @param password   the password for that user for authentication
      *  @return the response string from metacat in XML format
      *  @throws MetacatAuthException when the username/password could
      *                    not be authenticated
      */
-            barteau
+    public String getloggedinuserinfo() throws MetacatInaccessibleException {
-            sgarg
+        Properties prop = new Properties();
         prop.put("action", "getloggedinuserinfo");
         prop.put("qformat", "xml");
             barteau
-            sgarg
+        String response = null;
         try {
             response = sendDataForString(prop, null, null, 0);
         } catch (Exception e) {
             throw new MetacatInaccessibleException(e.getMessage());
+        }
             barteau
-            sgarg
+        return response;
+    }
             barteau
-            jones
+    /**
-            jones
+     *  Method used to log out a metacat server. The Metacat server will end
      *  the session when this call is invoked.
             tao
-            jones
+     *  @return the response string from metacat in XML format
-            tao
+     *  @throws MetacatInaccessibleException when the metacat server can not be
      *                                    reached or does not respond
      */
-            barteau
+    public String logout() throws MetacatInaccessibleException, MetacatException {
-            tao
+        Properties prop = new Properties();
         prop.put("action", "logout");
-            sgarg
+        prop.put("qformat", "xml");
             barteau
-            tao
+        String response = null;
         try {
-            sgarg
+            response = sendDataForString(prop, null, null, 0);
-            tao
+        } catch (Exception e) {
             throw new MetacatInaccessibleException(e.getMessage());
+        }
             barteau
-            tao
+        if (response.indexOf("<logout>") == -1) {
             throw new MetacatException(response);
+        }
-            jones
+        setSessionId("");
-            jones
+        return response;
             tao
             barteau
-            tao
+    /**
-            jones
+     * Read an XML document from the metacat server session, accessed by docid,
      * and returned as a Reader.
+     *
      * @param docid the identifier of the document to be read
      * @return a Reader for accessing the document
-            sgarg
+     * @throws InsufficientKarmaException when the user has insufficent rights
-            jones
+     *                                    for the operation
-            jones
+     * @throws MetacatInaccessibleException when the metacat server can not be
      *                                    reached or does not respond
      * @throws MetacatException when the metacat server generates another error
-            jones
+     */
-            jones
+    public Reader read(String docid) throws InsufficientKarmaException,
-            barteau
+            MetacatInaccessibleException, MetacatException, DocumentNotFoundException {
-            jones
+        PushbackReader pbr = null;
             barteau
-            jones
+        Properties prop = new Properties();
         prop.put("action", "read");
         prop.put("qformat", "xml");
         prop.put("docid", docid);
         InputStream response = null;
         try {
-            sgarg
+            response = sendData(prop, null, null, 0);
-            jones
+        } catch (Exception e) {
             throw new MetacatInaccessibleException(e.getMessage());
+        }
         pbr = new PushbackReader(new InputStreamReader(response), 512);
         try {
             char[] characters = new char[512];
             int len = pbr.read(characters, 0, 512);
             StringWriter sw = new StringWriter();
             sw.write(characters, 0, len);
             String message = sw.toString();
             sw.close();
             pbr.unread(characters, 0, len);
             if (message.indexOf("<error>") != -1) {
                 if (message.indexOf("does not have permission") != -1) {
                     throw new InsufficientKarmaException(message);
-            berkley
+                } else if(message.indexOf("does not exist") != -1) {
                     throw new DocumentNotFoundException(message);
-            jones
+                } else {
                     throw new MetacatException(message);
+                }
+            }
         } catch (IOException ioe) {
             throw new MetacatException(
-            sgarg
+                    "MetacatClient: Error converting Reader to String."
-            jones
+                    + ioe.getMessage());
+        }
         return pbr;
             jones
             barteau
-            jones
+    /**
-            barteau
+     * Read inline data from the metacat server session, accessed by
      * inlinedataid and returned as a Reader.
+     *
      * @param inlinedataid the identifier of the data to be read
      * @return a Reader for accessing the document
      * @throws InsufficientKarmaException when the user has insufficent rights
      *                                    for the operation
      * @throws MetacatInaccessibleException when the metacat server can not be
      *                                    reached or does not respond
      * @throws MetacatException when the metacat server generates another error
      */
     public Reader readInlineData(String inlinedataid)
     throws InsufficientKarmaException,
             MetacatInaccessibleException, MetacatException {
         PushbackReader pbr = null;
         Properties prop = new Properties();
         prop.put("action", "readinlinedata");
         prop.put("inlinedataid", inlinedataid);
         InputStream response = null;
         try {
             response = sendData(prop, null, null, 0);
         } catch (Exception e) {
             throw new MetacatInaccessibleException(e.getMessage());
+        }
         pbr = new PushbackReader(new InputStreamReader(response), 512);
         try {
             char[] characters = new char[512];
             int len = pbr.read(characters, 0, 512);
             StringWriter sw = new StringWriter();
             sw.write(characters, 0, len);
             String message = sw.toString();
             sw.close();
             pbr.unread(characters, 0, len);
             if (message.indexOf("<error>") != -1) {
                 if (message.indexOf("does not have permission") != -1) {
                     throw new InsufficientKarmaException(message);
                 } else {
                     throw new MetacatException(message);
+                }
+            }
         } catch (IOException ioe) {
             throw new MetacatException(
                     "MetacatClient: Error converting Reader to String."
                     + ioe.getMessage());
+        }
         return pbr;
+    }
-            sgarg
+    /**
-            sgarg
+     * Query the metacat document store with the given metacat-compatible
-            jones
+     * query document, and return the result set as a Reader.
+     *
      * @param xmlQuery a Reader for accessing the XML version of the query
      * @return a Reader for accessing the result set
      */
-            tao
+    public Reader query(Reader xmlQuery) throws MetacatInaccessibleException,
-            barteau
+            IOException {
-            tao
+        Reader reader = null;
         String query = null;
-            jones
+        try {
-            barteau
+            query = IOUtil.getAsString(xmlQuery, true);
-            jones
+        } catch (IOException ioE) {
-            barteau
+            throw ioE;
             tao
             barteau
-            tao
+        //set up properties
         Properties prop = new Properties();
         prop.put("action", "squery");
         prop.put("qformat", "xml");
         prop.put("query", query);
             barteau
-            tao
+        InputStream response = null;
         try {
-            sgarg
+            response = sendData(prop, null, null, 0);
-            tao
+        } catch (Exception e) {
             throw new MetacatInaccessibleException(e.getMessage());
+        }
         reader = new InputStreamReader(response);
         return reader;
             jones
             barteau
-            jones
+    /**
      * Insert an XML document into the repository.
+     *
      * @param docid the docid to insert the document
      * @param xmlDocument a Reader for accessing the XML document to be inserted
-            sgarg
+     * @param schema a Reader for accessing the DTD or XML Schema for
-            jones
+     *               the document
-            jones
+     * @return the metacat response message
-            sgarg
+     * @throws InsufficientKarmaException when the user has insufficent rights
-            jones
+     *                                    for the operation
-            jones
+     * @throws MetacatInaccessibleException when the metacat server can not be
      *                                    reached or does not respond
      * @throws MetacatException when the metacat server generates another error
      * @throws IOException when there is an error reading the xml document
-            jones
+     */
-            jones
+    public String insert(String docid, Reader xmlDocument, Reader schema)
-            barteau
+    throws InsufficientKarmaException, MetacatException, IOException,
             MetacatInaccessibleException {
-            jones
+        Reader reader = null;
         String doctext = null;
         String schematext = null;
         try {
-            barteau
+            doctext = IOUtil.getAsString(xmlDocument, true);
             if (schema != null) {
                 schematext = IOUtil.getAsString(schema, true);
+            }
-            jones
+        } catch (IOException ioE) {
-            barteau
+            throw ioE;
             jones
             barteau
-            jones
+        //set up properties
         Properties prop = new Properties();
         prop.put("action", "insert");
         prop.put("docid", docid);
         prop.put("doctext", doctext);
         if (schematext != null) {
             prop.put("dtdtext", schematext);
+        }
             barteau
-            jones
+        String response = null;
         try {
-            sgarg
+            response = sendDataForString(prop, null, null, 0);
-            jones
+        } catch (Exception e) {
             throw new MetacatInaccessibleException(e.getMessage());
+        }
             barteau
-            jones
+        // Check for an error condition
         if (response.indexOf("<error>") != -1) {
             if (response.indexOf("does not have permission") != -1) {
                 throw new InsufficientKarmaException(response);
             } else {
                 throw new MetacatException(response);
+            }
+        }
             barteau
-            jones
+        return response;
             jones
             barteau
-            jones
+    /**
      * Update an XML document in the repository.
+     *
      * @param docid the docid to update
      * @param xmlDocument a Reader for accessing the XML text to be updated
-            sgarg
+     * @param schema a Reader for accessing the DTD or XML Schema for
-            jones
+     *               the document
-            jones
+     * @return the metacat response message
-            sgarg
+     * @throws InsufficientKarmaException when the user has insufficent rights
-            jones
+     *                                    for the operation
-            jones
+     * @throws MetacatInaccessibleException when the metacat server can not be
      *                                    reached or does not respond
      * @throws MetacatException when the metacat server generates another error
      * @throws IOException when there is an error reading the xml document
-            jones
+     */
-            jones
+    public String update(String docid, Reader xmlDocument, Reader schema)
-            barteau
+    throws InsufficientKarmaException, MetacatException, IOException,
             MetacatInaccessibleException {
-            jones
+        Reader reader = null;
         String doctext = null;
         String schematext = null;
         try {
-            barteau
+            doctext = IOUtil.getAsString(xmlDocument, true);
             if (schema != null) {
                 schematext = IOUtil.getAsString(schema, true);
+            }
-            jones
+        } catch (IOException ioE) {
-            barteau
+            throw ioE;
             jones
             barteau
-            jones
+        //set up properties
         Properties prop = new Properties();
         prop.put("action", "update");
         prop.put("docid", docid);
         prop.put("doctext", doctext);
         if (schematext != null) {
             prop.put("dtdtext", schematext);
+        }
             barteau
-            jones
+        String response = null;
         try {
-            sgarg
+            response = sendDataForString(prop, null, null, 0);
-            jones
+        } catch (Exception e) {
             throw new MetacatInaccessibleException(e.getMessage());
+        }
             barteau
-            jones
+        // Check for an error condition
         if (response.indexOf("<error>") != -1) {
             if (response.indexOf("does not have permission") != -1) {
                 throw new InsufficientKarmaException(response);
             } else {
                 throw new MetacatException(response);
+            }
+        }
             barteau
-            jones
+        return response;
             jones
             barteau
-            jones
+    /**
-            barteau
+     * Upload a data document into the repository.
+     *
      * @param docid the docid to insert the document
      * @param document a Reader for accessing the document to be uploaded
      * @return the metacat response message
      * @throws InsufficientKarmaException when the user has insufficent rights
      *                                    for the operation
      * @throws MetacatInaccessibleException when the metacat server can not be
      *                                    reached or does not respond
      * @throws MetacatException when the metacat server generates another error
      * @throws IOException when there is an error reading the xml document
      */
     public String upload(String docid, File file)
     throws InsufficientKarmaException, MetacatException, IOException,
             MetacatInaccessibleException {
         URL url = new URL(metacatUrl.trim());
         HttpMessage msg = new HttpMessage(url);
         //set up properties
         Properties arg = new Properties();
         arg.put("action", "upload");
         arg.put("docid", docid);
         Properties filenames = new Properties();
         String filename = file.getAbsolutePath();
         filenames.put("datafile", filename);
         String response = null;
         try {
-            sgarg
+            response = sendDataForString(arg, filenames, null, 0);
-            barteau
+        } catch (Exception e) {
-            sgarg
+            throw new MetacatInaccessibleException(e.getMessage());
             barteau
         // Check for an error condition
         if (response.indexOf("<error>") != -1) {
-            sgarg
+            if (response.indexOf("does not have permission") != -1) {
-            barteau
+                throw new InsufficientKarmaException(response);
-            sgarg
+            } else {
-            barteau
+                throw new MetacatException(response);
             sgarg
             barteau
         return response;
+    }
     /**
      * Upload a data document into the repository.
+     *
      * @param docid the docid to insert the document
      * @param document a Reader for accessing the document to be uploaded
      * @return the metacat response message
      * @throws InsufficientKarmaException when the user has insufficent rights
      *                                    for the operation
      * @throws MetacatInaccessibleException when the metacat server can not be
      *                                    reached or does not respond
      * @throws MetacatException when the metacat server generates another error
      * @throws IOException when there is an error reading the xml document
      */
     public String upload(String docid, String filename, InputStream fileData,
             int size)
             throws InsufficientKarmaException, MetacatException, IOException,
             MetacatInaccessibleException {
         URL url = new URL(metacatUrl.trim());
         HttpMessage msg = new HttpMessage(url);
         //set up properties
         Properties arg = new Properties();
         arg.put("action", "upload");
         arg.put("docid", docid);
         Properties filenames = new Properties();
         filenames.put("datafile", filename);
         String response = null;
         try {
-            sgarg
+            response = sendDataForString(arg, filenames, fileData, size);
-            barteau
+        } catch (Exception e) {
-            sgarg
+            throw new MetacatInaccessibleException(e.getMessage());
             barteau
         // Check for an error condition
         if (response.indexOf("<error>") != -1) {
-            sgarg
+            if (response.indexOf("does not have permission") != -1) {
-            barteau
+                throw new InsufficientKarmaException(response);
-            sgarg
+            } else {
-            barteau
+                throw new MetacatException(response);
             sgarg
             barteau
         return response;
+    }
-            sgarg
+    /**
-            jones
+     * Delete an XML document in the repository.
+     *
      * @param docid the docid to delete
-            jones
+     * @return the metacat response message
-            sgarg
+     * @throws InsufficientKarmaException when the user has insufficent rights
-            jones
+     *                                    for the operation
-            jones
+     * @throws MetacatInaccessibleException when the metacat server can not be
      *                                    reached or does not respond
      * @throws MetacatException when the metacat server generates another error
-            jones
+     */
-            jones
+    public String delete(String docid)
-            barteau
+    throws InsufficientKarmaException, MetacatException,
             MetacatInaccessibleException {
-            jones
+        //set up properties
         Properties prop = new Properties();
         prop.put("action", "delete");
         prop.put("docid", docid);
             barteau
-            jones
+        String response = null;
         try {
-            sgarg
+            response = sendDataForString(prop, null, null, 0);
-            jones
+        } catch (Exception e) {
             throw new MetacatInaccessibleException(e.getMessage());
+        }
             barteau
-            jones
+        // Check for an error condition
         if (response.indexOf("<error>") != -1) {
             if (response.indexOf("does not have permission") != -1) {
                 throw new InsufficientKarmaException(response);
             } else {
                 throw new MetacatException(response);
+            }
+        }
-            harris
+        return response;
+    }
             barteau
-            harris
+    /**
      * set the access on an XML document in the repository.
+     *
-            harris
+     * @param _docid the docid of the document for which the access should be applied.
             harris
      * @param _principal the document's principal
+     *
      * @param _permission the access permission to be applied to the docid
      *  {e.g. read,write,all}
+     *
      * @param _permType the permission type to be applied to the document
      *  {e.g. allow or deny}
+     *
      * @param _permOrder the order that the document's permissions should be
      *  processed {e.g. denyFirst or allowFirst}
+     *
+     *
      * @return the metacat response message
+     *
      * @throws InsufficientKarmaException when the user has insufficent rights
      *                                    for the operation
      * @throws MetacatInaccessibleException when the metacat server can not be
      *                                    reached or does not respond
      * @throws MetacatException when the metacat server generates another error
      */
     public String setAccess(String _docid, String _principal, String
-            barteau
+            _permission, String _permType,
             String _permOrder )
             throws InsufficientKarmaException, MetacatException,
             MetacatInaccessibleException {
-            harris
+        //set up properties
         Properties prop = new Properties();
         prop.put("action", "setaccess");
         prop.put("docid", _docid);
         prop.put("principal", _principal);
         prop.put("permission", _permission);
         prop.put("permType", _permType);
         prop.put("permOrder", _permOrder);
             barteau
-            harris
+        String response = null;
         try {
             response = sendDataForString(prop, null, null, 0);
         } catch (Exception e) {
             throw new MetacatInaccessibleException(e.getMessage());
+        }
             barteau
-            harris
+        // Check for an error condition
         if (response.indexOf("<error>") != -1) {
             if (response.indexOf("does not have permission") != -1) {
                 throw new InsufficientKarmaException(response);
             } else {
                 throw new MetacatException(response);
+            }
+        }
-            jones
+        return response;
             jones
             barteau
-            jones
+    /**
      * When the MetacatFactory creates an instance it needs to set the
      * MetacatUrl to which connections should be made.
+     *
      * @param metacatUrl the URL for the metacat server
      */
-            barteau
+    public void setMetacatUrl(String metacatUrl) {
-            jones
+        this.metacatUrl = metacatUrl;
             jones
             barteau
-            jones
+    /**
      * Get the session identifier for this session.  This is only valid if
      * the login methods has been called successfully for this Metacat object
      * beforehand.
+     *
      * @returns the sessionId as a String, or null if the session is invalid
      */
-            barteau
+    public String getSessionId() {
-            jones
+        return this.sessionId;
+    }
             barteau
-            jones
+    /**
-            sgarg
+     * Set the session identifier for this session.  This identifier was
      * previously established with a call to login.  To continue to use the
-            jones
+     * same session, set the session id before making a call to one of the
      * metacat access methods (e.g., read, query, insert, etc.).
+     *
      * @param String the sessionId from a previously established session
      */
-            barteau
+    public void setSessionId(String sessionId) {
-            jones
+        this.sessionId = sessionId;
+    }
             tao
     /**
-            barteau
+     * The method will return the latest revision in metacat server
-            jones
+     * for a given document id. If some error happens, this method will throw
-            barteau
+     * an exception.
-            tao
+     * @param docId String  the given docid you want to use. the docid it self
      *                      can have or haven't revision number
      * @throws MetacatException
      */
-            barteau
+    public int getNewestDocRevision(String docId) throws MetacatException {
         int rev = 0;
         //set up properties
         Properties prop = new Properties();
         prop.put("action", "getrevisionanddoctype");
         prop.put("docid", docId);
         String response = null;
         try {
             response = sendDataForString(prop, null, null, 0);
             //parseRevisionResponse will return null if there is an
             //error that it can't handle
             String revStr = parserRevisionResponse(response);
             Integer revObj = new Integer(revStr);
             rev = revObj.intValue();
             // Check for an error condition
             if (response.indexOf("<error>") != -1 && revStr == null) {
                 throw new MetacatException(response);
+            }
         } catch (Exception e) {
             throw new MetacatException(e.getMessage());
+        }
         return rev;
+    }
-            jones
+    /**
      * Return the highest document id for a given scope.  This is used by
      * clients to make it easier to determine the next free identifier in a
-            barteau
+     * sequence for a given scope.
-            jones
+     * @param scope String  the scope to use for looking up the latest id
      * @throws MetacatException when an error occurs
      */
     public String getLastDocid(String scope) throws MetacatException {
         String lastIdentifier = "";
         //set up properties
         Properties prop = new Properties();
         prop.put("action", "getlastdocid");
         prop.put("scope", scope);
             barteau
-            jones
+        String response = null;
         try {
-            tao
+            response = sendDataForString(prop, null, null, 0);
             // Check for an error condition
-            jones
+            if (response.indexOf("<error>") != -1) {
-            barteau
+                throw new MetacatException(response);
-            jones
+            } else {
                 Reader responseReader = new StringReader(response);
-            barteau
+                Node root =
                         XMLUtilities.getXMLReaderAsDOMTreeRootNode(responseReader);
                 Node docidNode =
                         XMLUtilities.getNodeWithXPath(root, "/lastDocid/docid");
-            jones
+                lastIdentifier = docidNode.getFirstChild().getNodeValue();
             jones
         } catch (Exception e) {
-            tao
+            throw new MetacatException(e.getMessage());
+        }
-            jones
+        return lastIdentifier;
+    }
             berkley
     /**
      * return a list of all docids that match a given scope.  if scope is null
      * return all docids registered in the system
      * @param scope String  the scope to use to limit the docid query
      * @throws MetacatException when an error occurs
      */
     public Vector getAllDocids(String scope) throws MetacatException {
         Vector resultVec = new Vector();
         //set up properties
         Properties prop = new Properties();
         prop.put("action", "getalldocids");
-            barteau
+        if(scope != null) {
             prop.put("scope", scope);
             berkley
             barteau
-            berkley
+        String response = null;
         try {
             response = sendDataForString(prop, null, null, 0);
             // Check for an error condition
             if (response.indexOf("<error>") != -1) {
-            barteau
+                throw new MetacatException(response);
-            berkley
+            } else {
                 Reader responseReader = new StringReader(response);
-            barteau
+                Node root =
                         XMLUtilities.getXMLReaderAsDOMTreeRootNode(responseReader);
-            berkley
+                NodeList nlist = root.getChildNodes();
-            barteau
+                for(int i=0; i<nlist.getLength(); i++) {
                     Node n = nlist.item(i);
                     if(n.getNodeName().equals("docid")) {
                         //add the content to the return vector
                         String nodeVal = n.getFirstChild().getNodeValue();
                         resultVec.addElement(nodeVal);
+                    }
             berkley
+            }
         } catch (Exception e) {
             throw new MetacatException(e.getMessage());
+        }
         return resultVec;
+    }
             berkley
     /**
      * return true of the given docid is registered, false if not
      * @param scope String  the scope to use to limit the docid query
      * @throws MetacatException when an error occurs
      */
     public boolean isRegistered(String docid) throws MetacatException {
         Vector resultVec = new Vector();
         //set up properties
         Properties prop = new Properties();
         prop.put("action", "isregistered");
-            barteau
+        if(docid == null) {
             throw new MetacatException("<error>Cannot check if a null docid " +
                     "is registered.</error>");
             berkley
         prop.put("docid", docid);
             barteau
-            berkley
+        String response = null;
         try {
             response = sendDataForString(prop, null, null, 0);
             // Check for an error condition
             if (response.indexOf("<error>") != -1) {
-            barteau
+                throw new MetacatException(response);
-            berkley
+            } else {
                 Reader responseReader = new StringReader(response);
                 StringBuffer sb = new StringBuffer();
                 char[] c = new char[1024];
                 int numread = responseReader.read(c, 0, 1024);
-            barteau
+                while(numread != -1) {
                     sb.append(new String(c, 0, numread));
                     numread = responseReader.read(c, 0, 1024);
             berkley
                 String responseStr = sb.toString();
-            barteau
+                if(responseStr.indexOf("true") != -1) {
                     return true;
             berkley
                 return false;
+            }
         } catch (Exception e) {
             throw new MetacatException(e.getMessage());
+        }
+    }
             barteau
-            jones
+    /************************************************************************
      * PRIVATE METHODS
      ************************************************************************/
             barteau
-            jones
+    /**
      * Send a request to metacat.
+     *
      * @param prop the properties to be URL encoded and sent
-            sgarg
+     * @param filename  the properties to be sent to Metacat
      *                  in case of upload, otherwise null
      * @param fileData  the inputStream for the file data to be sent to Metacat
      *                  in case of upload, otherwise null
      * @param size      the size of the data being sent to Metacat
      *                  in case of upload, otherwise 0
-            jones
+     */
-            sgarg
+    synchronized private InputStream sendDataOnce(Properties args,
-            barteau
+            Properties filename,
             InputStream fileData,
             int size)
             throws Exception {
-            jones
+        InputStream returnStream = null;
         URL url = new URL(metacatUrl);
         HttpMessage msg = new HttpMessage(url);
-            jones
+        msg.setCookie("JSESSIONID="+this.sessionId);
-            sgarg
+        if (filename == null){
             returnStream = msg.sendPostData(args);
         } else if (fileData == null){
             returnStream = msg.sendPostData(args, filename);
         } else if (size > 0) {
             returnStream = msg.sendPostData(args, filename, fileData, size);
-            sgarg
+        } else {
-            sgarg
+            throw new MetacatException("Invalid size specified for " +
-            barteau
+                    "the input stream being passed");
             sgarg
-            jones
+        return returnStream;
+    }
             barteau
-            jones
+    /**
      * Send a request to Metacat
+     *
-            sgarg
+     * @param args  the properties to be sent to Metacat
      * @param filename  the properties to be sent to Metacat
      *                  in case of upload, otherwise null
      * @param fileData  the inputStream for the file data to be sent to Metacat
      *                  in case of upload, otherwise null
      * @param size      the size of the data being sent to Metacat
      *                  in case of upload, otherwise 0
-            jones
+     * @return      InputStream as returned by Metacat
      */
-            sgarg
+    synchronized private InputStream sendData(Properties args,
-            barteau
+            Properties filename,
             InputStream fileData,
             int size)
             throws Exception {
-            jones
+        InputStream returnStream = null;
         /*
             Note:  The reason that there are three try statements all executing
             the same code is that there is a problem with the initial connection
-            sgarg
+            using the HTTPClient protocol handler.  These try statements make
             sure that a connection is made because it gives each connection a
-            jones
+nd and 3rd chance to work before throwing an error.
             THIS IS A TOTAL HACK.  THIS NEEDS TO BE LOOKED INTO AFTER THE BETA1
             RELEASE OF MORPHO!!!  cwb (7/24/01)
-            barteau
+         */
-            jones
+        try {
-            barteau
+            return sendDataOnce(args, filename, fileData, size);
-            jones
+        } catch (Exception e) {
             try {
-            sgarg
+                return sendDataOnce(args, filename, fileData, size);
-            jones
+            } catch (Exception e2) {
                 try {
-            sgarg
+                    return sendDataOnce(args, filename, fileData, size);
-            jones
+                } catch (Exception e3) {
                     System.err.println(
-            berkley
+                            "Failed to send data to metacat 3 times: " + e3.getMessage());
                     System.err.println("metacaturl: " + metacatUrl);
-            jones
+                    throw e3;
+                }
+            }
+        }
+    }
             barteau
-            jones
+    /**
      * Send a request to Metacat
+     *
-            sgarg
+     * @param args      the properties to be sent to Metacat
      * @param filename  the properties to be sent to Metacat
      *                  in case of upload, otherwise null
      * @param fileData  the inputStream for the file data to be sent to Metacat
      *                  in case of upload, otherwise null
      * @param size      the size of the data being sent to Metacat
      *                  in case of upload, otherwise 0
      * @return          a string as returned by Metacat
-            jones
+     */
-            sgarg
+    synchronized private String sendDataForString(Properties args,
-            barteau
+            Properties filename,
             InputStream fileData,
             int size)
             throws Exception {
-            jones
+        String response = null;
             barteau
-            jones
+        try {
             InputStreamReader returnStream =
-            sgarg
+                    new InputStreamReader(sendData(args, filename,
-            barteau
+                    fileData, size));
-            jones
+            StringWriter sw = new StringWriter();
             int len;
             char[] characters = new char[512];
             while ((len = returnStream.read(characters, 0, 512)) != -1) {
                 sw.write(characters, 0, len);
+            }
             returnStream.close();
             response = sw.toString();
             sw.close();
         } catch (Exception e) {
             throw e;
+        }
         return response;
+    }
             tao
     /*
      * "getversionanddoctype" action will return a string from metacat server.
      * The string format is "revision;doctype"(This is bad idea, we should use xml)
      * This method will get revision string from the response string
      */
-            barteau
+    private String parserRevisionResponse(String response) throws Exception {
         String revision = null;
         if (response != null) {
             if(response.indexOf("<error>") != -1) {
                 if(response.indexOf("There is not record") != -1) {
                     return "0";
                 } else {
                     return null;
+                }
             } else {
                 int firstSemiCol = response.indexOf(";");
                 revision = response.substring(0, firstSemiCol);
+            }
             berkley
-            barteau
+        return revision;
+    }
     /**
      * JSP API: This is a convenience method to reduce the amount of code in a Metacat Client
      * JSP.  It handles creating/reusing an instance of a MetacatClient.
      * @param request Since this is intended to be used by a JSP, it is passed the
      * available "request" variable (the HttpServletRequest).
      * @throws edu.ucsb.nceas.metacat.client.MetacatInaccessibleException Received by MetacatFactory.
      * @return MetacatClient instance.
      */
     public static MetacatClient getMetacatClient(javax.servlet.http.HttpServletRequest request) throws MetacatInaccessibleException {
         MetacatClient                       result;
         String                              metacatPath = "http://%1$s%2$s/metacat";
         String                              host, context;
         javax.servlet.http.HttpSession      session;
         session = request.getSession();
         result = (MetacatClient) session.getAttribute("MetacatClient");
         if (result == null) {
             host = request.getHeader("host");
             context = request.getContextPath();
             metacatPath = String.format(metacatPath, host, context);
             result = (MetacatClient) MetacatFactory.createMetacatConnection(metacatPath);
             session.setAttribute("MetacatClient", result);
+        }
         return(result);
+    }
     /**
      * JSP API: When the user logs in, the server will send back a string containing XML.  Calling
      * this method with the string will allow other methods to work, such as isLoggIn()
      * and getLoginResponseElement().
      * @param xmlString XML in String format.
      * @throws java.io.IOException Input/Output exception.
      */
     public void setLoginResponse(String xmlString) throws IOException {
         if (xmlString != null) {
             loginResponse = XMLUtilities.getXMLReaderAsDOMDocument(new StringReader(xmlString));
+        }
+    }
     private void setMetadataDoc(InputStream ioStream) throws IOException {
         BufferedReader                          buffy;
         if (ioStream != null) {
             buffy = new BufferedReader(new InputStreamReader(ioStream));
             metadataDoc = XMLUtilities.getXMLReaderAsDOMDocument(buffy);
+        }
+    }
     /**
      * JSP API: A convenient and efficient method to retrieve info from the "login response".
      * @param elementName String of the elementName.
      * NOTE: setLoginResponse() must have been called first,
      * otherwise it will always return null.
      * @throws javax.xml.xpath.XPathExpressionException XPath error.
      * @return String containing the text content of the element, or null.
      */
     public String getLoginResponseElement(String elementName) throws XPathExpressionException {
         String                      result = null;
         if (loginResponse != null) {
             result = (String) xpath.evaluate(elementName, loginResponse.getDocumentElement(), XPathConstants.STRING);
             if (result != null)
                 result = result.trim();
+        }
         return(result);
+    }
     /**
      * JSP API: Easy way to get info from an uploaded metadata XML file.
      * Note:  doMetadataUpload() must have been called first.
      * @param elementName String containing the elemement name
      * @throws javax.xml.xpath.XPathExpressionException Thrown by XPath
      * @return String text content of the named element
      */
     public String getMetadataDocElement(String elementName) throws XPathExpressionException {
         String                      result = null;
         if (metadataDoc != null) {
             result = (String) xpath.evaluate(elementName, metadataDoc.getDocumentElement(), XPathConstants.STRING);
             result = result.trim();
+        }
         return(result);
+    }
     /**
      * JSP API: A convenience method to be used by JSP or any other client code that requires
      * the user to be logged in.  NOTE: setUser() must have been called first,
      * otherwise it will always return false.
      * @return boolean  true if user has logged in for this session, false otherwise.
      */
     public boolean isLoggedIn() {
         return(user != null);
+    }
     /**
      * JSP API: After calling "login(ldapUserName, pwd)", call this with the username
      * and servers response message.  You can than use isLoggedIn() to determine if
      * the user is logged in, getLoginResponseElement(), etc.  The user name will also
      * used by calls to doMetadataUpload() for Document Id creation (scope).
      * @param userName User name
      * @param serverResponse XML login response sent from Metacat.
      */
     public void setUser(String userName, String serverResponse) {
         if (serverResponse != null && serverResponse.contains("login"))
             user = userName;
-            berkley
+        else
-            barteau
+            user = null;
+    }
     /**
      * JSP API:  Handles metadata file and data file uploads for inserting new
      * Metacat data packages.  Note: if content type is not "multipart/form-data",
      * nothing will happen; thus, it's safe to be (unintentionally) called by other
      * types of form submissions.
      * @param request HTTP request.
      * @return A 1-line status message for the user.
      */
     public String doMetadataUpload(javax.servlet.http.HttpServletRequest request) {
         String                      result = "", contentType, formatType;
         String                      lastDocId, nextDocId, metaDocId;
         StringBuilder               fileName = new StringBuilder();
         Reader                      reader;
         int                         sizeLimit;
         MultipartParser             multipartParser;
         InputStream                 inputStream;
         Node                        newBranch, metaRootNode;
         HashMap                     dataDocIDs;
         //*** Only process request if a file upload.
         contentType = request.getContentType();
         if (isLoggedIn() && contentType != null && contentType.contains("multipart/form-data")) {
             try {
                 //*** Init the MultipartParser.
                 sizeLimit = (new Integer(MetaCatUtil.getOption("datafilesizelimit"))).intValue();
                 multipartParser = new MultipartParser(request, sizeLimit * 1024 * 1024);
                 //*** Get the First file, which should be the metadata file.
                 inputStream = getNextInputStream(multipartParser, fileName);
                 if (fileName.toString().toLowerCase().endsWith(".xml")) {
                     setMetadataDoc(inputStream);
                     //*** Get the Metadata File's DOC ID.
                     lastDocId = getLastDocid(user);
                     metaDocId = lastDocId = nextDocId(lastDocId);
                     if (isFGDC()) {
                         //*** Loop thru all of the data files, get fileName and inputStream.
                         dataDocIDs = new HashMap();
                         fileName = new StringBuilder();
                         while ((inputStream = getNextInputStream(multipartParser, fileName)) != null) {
                             //*** Get the data file's DOC ID.
                             nextDocId = nextDocId(lastDocId);
                             //*** Set the file format (just using file extension for now).
                             formatType = fileName.substring(fileName.lastIndexOf(".")+1).toUpperCase();
                             dataDocIDs.put(nextDocId, formatType);
                             //*** Upload the data file to metacat.
                             upload(nextDocId, fileName.toString(), inputStream, sizeLimit);
                             lastDocId = nextDocId;
                             fileName = new StringBuilder();
+                        }
                         //*** Store the User Name and Doc Id in the FGDC document.
                         newBranch = getFGDCdisinfo(getLoginResponseElement("name"), metaDocId, dataDocIDs);
                         System.out.println("MetacatClient.doMetadataUpload: " + XMLUtilities.getDOMTreeAsString(newBranch));
                         metaRootNode = addDistInfoToFGDC(newBranch);
                         //*** Upload the metadata file to metacat.
                         reader = XMLUtilities.getDOMTreeAsReader(metadataDoc.getDocumentElement(), false);
                         insert(metaDocId, reader, null);
                         result = "MetaCat Package Inserted:  Metadata Doc ID #" + metaDocId;
                         reader.close();
                     } else {
                         System.out.println("MetacatClient.doUpload: not an FGDC file = " + fileName);
                         result = fileName + " is not an FGDC file.  Files not uploaded.";
                         //TODO add other types of metadata grammars here...
+                    }
                 } else {
                     result = "The first file must be an XML Metadata file.  Files not uploaded.";
+                }
                 if (inputStream != null)
                     inputStream.close();
             } catch (MetacatException ex)  {
                 result = ex.getMessage();
                 System.out.println("MetacatClient.doUpload: MetacatException = " + result);
             } catch (IOException ex)  {
                 System.out.println("MetacatClient.doUpload: " + ex);
             } catch (Exception ex) {
                 System.out.println("MetacatClient.doUpload: " + ex);
             } catch (Error err) {
                 System.out.println("MetacatClient.doUpload: ERR - " + err.getCause());
                 result = "ERR: " + err.getMessage();
+            }
             berkley
-            barteau
+        return(result);
             tao
             barteau
     private InputStream getNextInputStream(MultipartParser multipartParser, StringBuilder fileName) throws IOException {
         InputStream                     result = null;
         Part                            part;
         String                          parmName = null, value = null, fnam;
         while ((part = multipartParser.readNextPart()) != null) {
             if (part.isParam()) {
                 parmName = part.getName();
                 value = ((ParamPart) part).getStringValue();
                 System.out.println("MetacatClient.doUpload: parmName = " + parmName + "  value = " + value);
             } else if (part.isFile()) {
                 fnam = ((FilePart) part).getFileName();
                 if (fnam != null && !fnam.equals("")) {
                     //*** File name is passed back via StringBuilder fileName param.
                     fileName.append(fnam);
                     result = ((FilePart) part).getInputStream();
                     System.out.println("MetacatClient.doUpload: fileName = " + fileName + "  inputStream = " + result.toString());
                     break;
+                }
+            }
+        }
         return(result);
+    }
     private String nextDocId(String lastDocId) {
         String                      result = null, tokens[];
         int                         vers;
         String                      template = user.toLowerCase() + ".%1$d.%2$d";
         if(lastDocId != null && lastDocId.contains(".")) {
             lastDocId = lastDocId.replace('.','~'); //*** This is necessary for the split to work.
             tokens = lastDocId.split("~");
             if(tokens.length > 1 && !tokens[1].equals("")) {
                 try {
                     vers = Integer.parseInt(tokens[1]);
                     result = String.format(template, 1 + vers, 1);
                 } catch (NumberFormatException ex) {
                     //*** In case the lastDocId has something other than a number.
                     result = String.format(template, 1, 1);
+                }
             } else {
                 //*** In case the lastDocId ends with a '.'
                 result = String.format(template, 1, 1);
+            }
         } else {
             //*** In case there isn't any doc Id's with the user name.
             result = String.format(template, 1, 1);
+        }
         return(result);
+    }
     private boolean isFGDC() {
         boolean                     result = false;
         DocumentType                docType;
         String                      sysId, title = null;
         final String                FGDC_TEST_EXPRESSION = "/metadata/idinfo/citation/citeinfo/title";
         //*** First, try the rigid proper way of determining it.
         if (metadataDoc != null) {
             docType = metadataDoc.getDoctype();
             if (docType != null) {
                 sysId = docType.getSystemId();
                 if (sysId != null)
                     result = sysId.contains(FGDC_SYSTEM_ID);
+            }
+        }
         //*** It might not have a doc type line, so try another method.
         if (!result) {
             try {
                 title = getMetadataDocElement(FGDC_TEST_EXPRESSION);
             } catch (XPathExpressionException ex) {
                 ex.printStackTrace();
+            }
             result = (title != null && !title.equals(""));
+        }
         return(result);
+    }
     private Node getFGDCdisinfo(String contactName, String resourceDescription, HashMap dataDocIDs) throws IOException {
         Node                        result = null, node, digformBranch, formname, stdorder;
         Document                    doc;
         Iterator                    iterIt;
         String                      key, value;
         //*** This is a valid/minimal FGDC "distinfo" branch.
         final String XML = "<distinfo>"
                 + "    <distrib>"
                 + "        <cntinfo>"
                 + "            <cntperp>"
                 + "                <cntper></cntper>"
                 + "            </cntperp>"
                 + "            <cntaddr>"
                 + "                <addrtype></addrtype>"
                 + "                <address></address>"
                 + "                <city></city>"
                 + "                <state></state>"
                 + "                <postal></postal>"
                 + "                <country></country>"
                 + "            </cntaddr>"
                 + "            <cntvoice></cntvoice>"
                 + "        </cntinfo>"
                 + "    </distrib>"
                 + "    <resdesc></resdesc>"
                 + "    <distliab></distliab>"
                 + "    <stdorder>"
                 + "        <digform>"
                 + "            <digtinfo>"
                 + "                <formname></formname>"
                 + "            </digtinfo>"
                 + "            <digtopt>"
                 + "                <onlinopt>"
                 + "                    <computer>"
                 + "                        <networka>"
                 + "                            <networkr></networkr>"
                 + "                        </networka>"
                 + "                    </computer>"
                 + "                </onlinopt>"
                 + "            </digtopt>"
                 + "        </digform>"
                 + "        <fees></fees>"
                 + "    </stdorder>"
                 + "</distinfo>";
         doc = XMLUtilities.getXMLReaderAsDOMDocument(new StringReader(XML));
         result = doc.getDocumentElement();
         try {
             //*** Set the Contact Person.
             node = (Node) xpath.evaluate("/distinfo/distrib/cntinfo/cntperp/cntper", result, XPathConstants.NODE);
             node.setTextContent(contactName);
             //*** Set the metadata Doc Id.
             node = (Node) xpath.evaluate("/distinfo/resdesc", result, XPathConstants.NODE);
             node.setTextContent(resourceDescription);
             //*** Loop thru the files, setting their format and Doc Id.
             stdorder = (Node) xpath.evaluate("/distinfo/stdorder", result, XPathConstants.NODE);
             digformBranch = (Node) xpath.evaluate("/distinfo/stdorder/digform", result, XPathConstants.NODE);
             iterIt = dataDocIDs.keySet().iterator();
             while(iterIt.hasNext()) {
                 //*** Save the data file Doc ID (required).
                 key = (String) iterIt.next();
                 node = (Node) xpath.evaluate("digtopt/onlinopt/computer/networka/networkr", digformBranch, XPathConstants.NODE);
                 node.setTextContent(key);
                 //*** Save the data file format (optional).
                 formname = (Node) xpath.evaluate("digtinfo/formname", digformBranch, XPathConstants.NODE);
                 if ((value = (String) dataDocIDs.get(key)) != null && !value.equals("")) {
                     formname.setTextContent(value);
                 } else {
                     //*** We did a deep clone of the branch, so clear prior contents.
                     formname.setTextContent("");
+                }
                 //*** Clone branch for next file.
                 if (iterIt.hasNext()) {
                     digformBranch = digformBranch.cloneNode(true);
                     stdorder.appendChild(digformBranch);
+                }
+            }
         } catch (XPathExpressionException ex) {
             ex.printStackTrace();
+        }
         return(result);
+    }
     private Node addDistInfoToFGDC(Node newBranch) {
         Node                        result = null, node;
         if (newBranch != null) {
             result = metadataDoc.getDocumentElement();
             try {
                 //*** Get a reference to the FGDC required "metainfo" node (only 1 allowed).
                 node = (Node) xpath.evaluate("/metadata/metainfo", result, XPathConstants.NODE);
                 if (node != null) {
                     newBranch = metadataDoc.importNode(newBranch, true);
                     //*** Add the new "distinfo" before it.
                     result.insertBefore(newBranch, node);
+                }
             } catch (XPathExpressionException ex) {
                 ex.printStackTrace();
+            }
+        }
         return(result);
+    }
             jones

Project

General

Profile

Metacat