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

metacat/src/edu/ucsb/nceas/metacat/DocumentImpl.java @ 505

-            jones
+/**
  *  '$RCSfile$'
  *    Purpose: A Class that represents an XML document
  *  Copyright: 2000 Regents of the University of California and the
  *             National Center for Ecological Analysis and Synthesis
  *    Authors: Matt Jones
  *    Release: @release@
+ *
  *   '$Author$'
  *     '$Date$'
  * '$Revision$'
  */
 package edu.ucsb.nceas.metacat;
 import java.sql.*;
-            jones
+import java.io.File;
 import java.io.FileReader;
 import java.io.IOException;
-            jones
+import java.io.PrintWriter;
-            jones
+import java.io.Reader;
 import java.io.StringWriter;
 import java.io.Writer;
             jones
-            jones
+import java.util.Iterator;
-            jones
+import java.util.Stack;
-            jones
+import java.util.TreeSet;
             jones
 import org.xml.sax.AttributeList;
 import org.xml.sax.ContentHandler;
 import org.xml.sax.DTDHandler;
 import org.xml.sax.EntityResolver;
 import org.xml.sax.ErrorHandler;
 import org.xml.sax.InputSource;
 import org.xml.sax.XMLReader;
 import org.xml.sax.SAXException;
 import org.xml.sax.SAXParseException;
 import org.xml.sax.helpers.XMLReaderFactory;
-            jones
+/**
  * A class that represents an XML document. It can be created with a simple
-            jones
+ * document identifier from a database connection.  It also will write an
  * XML text document to a database connection using SAX.
-            jones
+ */
 public class DocumentImpl {
-            bojilova
+  static final int ALL = 1;
   static final int WRITE = 2;
   static final int READ = 4;
-            jones
+  private Connection conn = null;
   private String docid = null;
   private String docname = null;
   private String doctype = null;
-            berkley
+  private String doctitle = null;
   private String createdate = null;
   private String updatedate = null;
-            jones
+  private String system_id = null;
   private long rootnodeid;
   private ElementNode rootNode = null;
-            jones
+  private TreeSet nodeRecordList = null;
             jones
   /**
-            jones
+   * Constructor, creates document from database connection, used
    * for reading the document
             jones
    * @param conn the database connection from which to read the document
    * @param docid the identifier of the document to be created
    */
   public DocumentImpl(Connection conn, String docid) throws McdbException
+  {
-            berkley
+    try {
-            jones
+      this.conn = conn;
       this.docid = docid;
       // Look up the document information
       getDocumentInfo(docid);
       // Download all of the document nodes using a single SQL query
-            jones
+      // The sort order of the records is determined by the NodeComparator
       // class, and needs to represent a depth-first traversal for the
       // toXml() method to work properly
       nodeRecordList = getNodeRecordList(rootnodeid);
             jones
     } catch (McdbException ex) {
       throw ex;
     } catch (Throwable t) {
       throw new McdbException("Error reading document " + docid + ".");
+    }
+  }
-            jones
+  /**
-            jones
+   * Construct a new document instance, writing the contents to the database.
    * This method is called from DBSAXHandler because we need to know the
    * root element name for documents without a DOCTYPE before creating it.
             jones
    * @param conn the JDBC Connection to which all information is written
    * @param rootnodeid - sequence id of the root node in the document
    * @param docname - the name of DTD, i.e. the name immediately following
    *        the DOCTYPE keyword ( should be the root element name ) or
    *        the root element name if no DOCTYPE declaration provided
    *        (Oracle's and IBM parsers are not aware if it is not the
    *        root element name)
    * @param doctype - Public ID of the DTD, i.e. the name immediately
    *                  following the PUBLIC keyword in DOCTYPE declaration or
    *                  the docname if no Public ID provided or
    *                  null if no DOCTYPE declaration provided
+   *
    */
   public DocumentImpl(Connection conn, long rootnodeid, String docname,
-            bojilova
+                      String doctype, String docid, String action, String user)
-            bojilova
+                      throws SQLException, Exception
             jones
     this.conn = conn;
     this.rootnodeid = rootnodeid;
     this.docname = docname;
     this.doctype = doctype;
     this.docid = docid;
-            bojilova
+    writeDocumentToDB(action, user);
             jones
             jones
-            jones
+  /**
    * get the document name
    */
   public String getDocname() {
     return docname;
+  }
   /**
    * get the document type (which is the PublicID)
    */
   public String getDoctype() {
     return doctype;
+  }
   /**
    * get the system identifier
    */
   public String getSystemID() {
     return system_id;
+  }
   /**
    * get the root node identifier
    */
   public long getRootNodeID() {
     return rootnodeid;
+  }
             berkley
   /**
    * get the creation date
    */
   public String getCreateDate() {
     return createdate;
+  }
   /**
    * get the update date
    */
   public String getUpdateDate() {
     return updatedate;
+  }
             jones
-            jones
+  /**
    * Get the document identifier (docid)
    */
   public String getDocID() {
     return docid;
+  }
             berkley
   /**
    *get the document title
    */
   public String getDocTitle() {
     return doctitle;
+  }
             jones
             jones
-            jones
+  /**
-            jones
+   * Print a string representation of the XML document
-            jones
+   */
   public String toString()
+  {
-            jones
+    StringWriter docwriter = new StringWriter();
     this.toXml(docwriter);
     String document = docwriter.toString();
     return document;
+  }
   /**
    * Get a text representation of the XML document as a string
    * This older algorithm uses a recursive tree of Objects to represent the
    * nodes of the tree.  Each object is passed the data for the document
    * and searches all of the document data to find its children nodes and
    * recursively build.  Thus, because each node reads the whole document,
    * this algorithm is extremely slow for larger documents, and the time
    * to completion is O(N^N) wrt the number of nodes.  See toXml() for a
    * better algorithm.
    */
   public String readUsingSlowAlgorithm()
+  {
-            jones
+    StringBuffer doc = new StringBuffer();
-            jones
+    // Create the elements from the downloaded data in the TreeSet
     rootNode = new ElementNode(nodeRecordList, rootnodeid);
-            jones
+    // Append the resulting document to the StringBuffer and return it
     doc.append("<?xml version=\"1.0\"?>\n");
     if (docname != null) {
       if ((doctype != null) && (system_id != null)) {
         doc.append("<!DOCTYPE " + docname + " PUBLIC \"" + doctype +
                    "\" \"" + system_id + "\">\n");
       } else {
         doc.append("<!DOCTYPE " + docname + ">\n");
+      }
+    }
     doc.append(rootNode.toString());
     return (doc.toString());
+  }
   /**
-            jones
+   * Print a text representation of the XML document to a Writer
+   *
    * @param pw the Writer to which we print the document
    */
   public void toXml(Writer pw)
+  {
     PrintWriter out = null;
     if (pw instanceof PrintWriter) {
       out = (PrintWriter)pw;
     } else {
       out = new PrintWriter(pw);
+    }
     MetaCatUtil util = new MetaCatUtil();
     Stack openElements = new Stack();
     boolean atRootElement = true;
     boolean previousNodeWasElement = false;
     // Step through all of the node records we were given
     Iterator it = nodeRecordList.iterator();
     while (it.hasNext()) {
       NodeRecord currentNode = (NodeRecord)it.next();
       //util.debugMessage("[Got Node ID: " + currentNode.nodeid +
                           //" (" + currentNode.parentnodeid +
                           //", " + currentNode.nodeindex +
                           //", " + currentNode.nodetype +
                           //", " + currentNode.nodename +
                           //", " + currentNode.nodedata + ")]");
       // Print the end tag for the previous node if needed
       //
       // This is determined by inspecting the parent nodeid for the
       // currentNode.  If it is the same as the nodeid of the last element
       // that was pushed onto the stack, then we are still in that previous
       // parent element, and we do nothing.  However, if it differs, then we
       // have returned to a level above the previous parent, so we go into
       // a loop and pop off nodes and print out their end tags until we get
       // the node on the stack to match the currentNode parentnodeid
       //
       // So, this of course means that we rely on the list of elements
       // having been sorted in a depth first traversal of the nodes, which
       // is handled by the NodeComparator class used by the TreeSet
       if (!atRootElement) {
         NodeRecord currentElement = (NodeRecord)openElements.peek();
         if ( currentNode.parentnodeid != currentElement.nodeid ) {
           while ( currentNode.parentnodeid != currentElement.nodeid ) {
             currentElement = (NodeRecord)openElements.pop();
             util.debugMessage("\n POPPED: " + currentElement.nodename);
-            bojilova
+            if (previousNodeWasElement) {
               out.print(">");
               previousNodeWasElement = false;
+            }
-            jones
+            out.print("</" + currentElement.nodename + ">" );
             currentElement = (NodeRecord)openElements.peek();
+          }
+        }
+      }
       // Handle the DOCUMENT node
       if (currentNode.nodetype.equals("DOCUMENT")) {
         out.println("<?xml version=\"1.0\"?>");
         if (docname != null) {
           if ((doctype != null) && (system_id != null)) {
             out.println("<!DOCTYPE " + docname + " PUBLIC \"" + doctype +
                        "\" \"" + system_id + "\">");
           } else {
             out.println("<!DOCTYPE " + docname + ">");
+          }
+        }
       // Handle the ELEMENT nodes
       } else if (currentNode.nodetype.equals("ELEMENT")) {
         if (atRootElement) {
           atRootElement = false;
         } else {
           if (previousNodeWasElement) {
             out.print(">");
+          }
+        }
         openElements.push(currentNode);
         util.debugMessage("\n PUSHED: " + currentNode.nodename);
         previousNodeWasElement = true;
         out.print("<" + currentNode.nodename);
       // Handle the ATTRIBUTE nodes
       } else if (currentNode.nodetype.equals("ATTRIBUTE")) {
         out.print(" " + currentNode.nodename + "=\""
                  + currentNode.nodedata + "\"");
       } else if (currentNode.nodetype.equals("TEXT")) {
         if (previousNodeWasElement) {
           out.print(">");
+        }
         out.print(currentNode.nodedata);
         previousNodeWasElement = false;
       // Handle the COMMENT nodes
       } else if (currentNode.nodetype.equals("COMMENT")) {
         if (previousNodeWasElement) {
           out.print(">");
+        }
         out.print("<!--" + currentNode.nodedata + "-->");
         previousNodeWasElement = false;
       // Handle the PI nodes
       } else if (currentNode.nodetype.equals("PI")) {
         if (previousNodeWasElement) {
           out.print(">");
+        }
         out.print("<?" + currentNode.nodename + " " +
                         currentNode.nodedata + "?>");
         previousNodeWasElement = false;
       // Handle any other node type (do nothing)
       } else {
         // Any other types of nodes are not handled.
         // Probably should throw an exception here to indicate this
+      }
       out.flush();
+    }
     // Print the final end tag for the root element
     NodeRecord currentElement = (NodeRecord)openElements.pop();
     util.debugMessage("\n POPPED: " + currentElement.nodename);
     out.print("</" + currentElement.nodename + ">" );
     out.flush();
+  }
   /**
-            jones
+   * Look up the document type information from the database
+   *
    * @param docid the id of the document to look up
    */
   private void getDocumentInfo(String docid) throws McdbException
+  {
     PreparedStatement pstmt;
     try {
       pstmt =
-            berkley
+        conn.prepareStatement("SELECT docname, doctype, rootnodeid,doctitle, " +
                               "date_created, date_updated " +
                                "FROM xml_documents " +
-            bojilova
+                               "WHERE docid LIKE ?");
-            jones
+      // Bind the values to the query
       pstmt.setString(1, docid);
       pstmt.execute();
       ResultSet rs = pstmt.getResultSet();
       boolean tableHasRows = rs.next();
       if (tableHasRows) {
         this.docname    = rs.getString(1);
         this.doctype    = rs.getString(2);
         this.rootnodeid = rs.getLong(3);
-            berkley
+        this.doctitle   = rs.getString(4);
         this.createdate = rs.getString(5);
         this.updatedate = rs.getString(6);
             jones
       pstmt.close();
       if (this.doctype != null) {
         pstmt =
           conn.prepareStatement("SELECT system_id " +
                                   "FROM xml_catalog " +
-            bojilova
+                                 "WHERE public_id LIKE ?");
-            jones
+        // Bind the values to the query
         pstmt.setString(1, doctype);
         pstmt.execute();
         rs = pstmt.getResultSet();
         tableHasRows = rs.next();
         if (tableHasRows) {
           this.system_id  = rs.getString(1);
+        }
         pstmt.close();
+      }
     } catch (SQLException e) {
       throw new McdbException("Error accessing database connection.", e);
+    }
     if (this.docname == null) {
       throw new McdbDocNotFoundException("Document not found: " + docid);
+    }
+  }
   /**
    * Look up the node data from the database
+   *
-            jones
+   * @param rootnodeid the id of the root node of the node tree to look up
-            jones
+   */
-            jones
+  private TreeSet getNodeRecordList(long rootnodeid) throws McdbException
             jones
     PreparedStatement pstmt;
     TreeSet nodeRecordList = new TreeSet(new NodeComparator());
     long nodeid = 0;
     long parentnodeid = 0;
     long nodeindex = 0;
     String nodetype = null;
     String nodename = null;
     String nodedata = null;
     try {
       pstmt =
       conn.prepareStatement("SELECT nodeid,parentnodeid,nodeindex, " +
            "nodetype,nodename,"+
            "replace(" +
            "replace(" +
            "replace(nodedata,'&','&amp;') " +
            ",'<','&lt;') " +
            ",'>','&gt;') " +
-            jones
+           "FROM xml_nodes WHERE rootnodeid = ?");
             jones
       // Bind the values to the query
-            jones
+      pstmt.setLong(1, rootnodeid);
             jones
       pstmt.execute();
       ResultSet rs = pstmt.getResultSet();
       boolean tableHasRows = rs.next();
       while (tableHasRows) {
         nodeid = rs.getLong(1);
         parentnodeid = rs.getLong(2);
         nodeindex = rs.getLong(3);
         nodetype = rs.getString(4);
         nodename = rs.getString(5);
         nodedata = rs.getString(6);
         // add the data to the node record list hashtable
         NodeRecord currentRecord = new NodeRecord(nodeid, parentnodeid,
                                    nodeindex, nodetype, nodename, nodedata);
         nodeRecordList.add(currentRecord);
         // Advance to the next node
         tableHasRows = rs.next();
+      }
       pstmt.close();
     } catch (SQLException e) {
       throw new McdbException("Error accessing database connection.", e);
+    }
     if (nodeRecordList != null) {
       return nodeRecordList;
     } else {
       throw new McdbException("Error getting node data: " + docid);
+    }
+  }
-            bojilova
+ /** creates SQL code and inserts new document into DB connection */
   private void writeDocumentToDB(String action, String user)
                throws SQLException, Exception {
     try {
       PreparedStatement pstmt = null;
       if (action.equals("INSERT")) {
         //AccessionNumber ac = new AccessionNumber();
         //this.docid = ac.generate(docid, "INSERT");
         pstmt = conn.prepareStatement(
             "INSERT INTO xml_documents " +
             "(docid, rootnodeid, docname, doctype, " +
             "user_owner, user_updated, date_created, date_updated) " +
             "VALUES (?, ?, ?, ?, ?, ?, sysdate, sysdate)");
         // Bind the values to the query
         pstmt.setString(1, this.docid);
         pstmt.setLong(2, rootnodeid);
         pstmt.setString(3, docname);
         pstmt.setString(4, doctype);
         pstmt.setString(5, user);
         pstmt.setString(6, user);
       } else if (action.equals("UPDATE")) {
         // Save the old document entry in a backup table
         DocumentImpl.archiveDocRevision( conn, docid, user );
         // Delete index for the old version of docid
         // The new index is inserting on the next calls to DBSAXNode
         pstmt = conn.prepareStatement(
                 "DELETE FROM xml_index WHERE docid='" + this.docid + "'");
         pstmt.execute();
         pstmt.close();
         // Update the new document to reflect the new node tree
         pstmt = conn.prepareStatement(
             "UPDATE xml_documents " +
             "SET rootnodeid = ?, docname = ?, doctype = ?, " +
             "user_updated = ?, date_updated = sysdate WHERE docid LIKE ?");
         // Bind the values to the query
         pstmt.setLong(1, rootnodeid);
         pstmt.setString(2, docname);
         pstmt.setString(3, doctype);
         pstmt.setString(4, user);
         pstmt.setString(5, this.docid);
       } else {
         System.err.println("Action not supported: " + action);
+      }
       // Do the insertion
       pstmt.execute();
       pstmt.close();
     } catch (SQLException sqle) {
       throw sqle;
 //    } catch (AccessionNumberException ane) {
 //      MetaCatUtil.debugMessage("Invalid accession number.");
 //      MetaCatUtil.debugMessage(ane.getMessage());
 //      throw ane;
     } catch (Exception e) {
       throw e;
+    }
+  }
-            jones
+  /**
-            bojilova
+   * Get the document title
    */
   public String getTitle() {
     return doctitle;
+  }
   /**
    * Set the document title
+   *
    * @param title the new title for the document
    */
             berkley
-            bojilova
+  public void setTitle( String title ) {
     this.doctitle = title;
     try {
       PreparedStatement pstmt;
       pstmt = conn.prepareStatement(
             "UPDATE xml_documents " +
             " SET doctitle = ? " +
             "WHERE docid = ?");
       // Bind the values to the query
       pstmt.setString(1, doctitle);
       pstmt.setString(2, docid);
       // Do the insertion
       pstmt.execute();
       pstmt.close();
     } catch (SQLException e) {
       System.out.println(e.getMessage());
+    }
+  }
   /**
    * Look up the title of the first child element named "title"
    * and record it as the document title
    */
 /*   NOT NEEDED ANY MORE
   public void setTitleFromChildElement() {
     String title = null;
     long assigned_id=0;
     PreparedStatement pstmt;
     try {
       pstmt = conn.prepareStatement(
               "SELECT nodedata FROM xml_nodes " +
               "WHERE nodetype = 'TEXT' " +
               "AND rootnodeid = ? " +
               "AND parentnodeid IN " +
               "  (SELECT nodeid FROM xml_nodes " +
               "  WHERE nodename = 'title' " +
               "  AND nodetype =  'ELEMENT' " +
               "  AND rootnodeid = ? ) " +
               "ORDER BY nodeid");
 */
       // The above query might be slow, and probably will be because
       // it gets ALL of the title elements while searching for one
       // title in a small subtree but it avoids the problem of using
       // Oracle's Hierarchical Query syntax which is not portable --
       // the commented out SQL that follows shows an equivalent query
       // using Oracle-specific hierarchical query
       /*
       pstmt = conn.prepareStatement(
               "SELECT nodedata FROM xml_nodes " +
               "WHERE nodetype = 'TEXT' " +
               "AND parentnodeid IN " +
               "(SELECT nodeid FROM xml_nodes " +
               "WHERE nodename = 'title' " +
               "START WITH nodeid = ? " +
               "CONNECT BY PRIOR nodeid = parentnodeid)");
       */
 /*
       // Bind the values to the query
       pstmt.setLong(1, rootnodeid);
       pstmt.setLong(2, rootnodeid);
       pstmt.execute();
       ResultSet rs = pstmt.getResultSet();
       boolean tableHasRows = rs.next();
       if (tableHasRows) {
         title = rs.getString(1);
+      }
       pstmt.close();
     } catch (SQLException e) {
       System.out.println("Error getting title: " + e.getMessage());
+    }
     // assign the new title
     this.setTitle(title);
+  }
 */
   /**
-            jones
+   * Write an XML file to the database, given a filename
             jones
-            jones
+   * @param conn the JDBC connection to the database
-            jones
+   * @param filename the filename to be loaded into the database
    * @param action the action to be performed (INSERT OR UPDATE)
    * @param docid the docid to use for the INSERT OR UPDATE
-            jones
+   */
-            jones
+  public static String write( Connection conn, String filename, String action,
-            bojilova
+                              String docid, String user, String group )
-            bojilova
+                throws Exception {
             bojilova
     return write(conn, new FileReader(new File(filename).toString()),
                   action, docid, user, group);
             jones
   /**
    * Write an XML file to the database, given a Reader
+   *
-            jones
+   * @param conn the JDBC connection to the database
-            jones
+   * @param xml the xml stream to be loaded into the database
    * @param action the action to be performed (INSERT OR UPDATE)
    * @param docid the docid to use for the INSERT OR UPDATE
    */
-            jones
+  public static String write( Connection conn, Reader xml, String action,
-            bojilova
+                              String docid, String user, String group )
-            bojilova
+                throws Exception {
             bojilova
-            bojilova
+    // Determine if the docid is OK for INSERT or UPDATE
-            bojilova
+    AccessionNumber ac = new AccessionNumber(conn);
-            bojilova
+    String newdocid = ac.generate(docid, action);
-            bojilova
+    if ( action.equals("UPDATE") ) {
-            bojilova
+      // check for 'write' permission for 'user' to update this document
       if ( !hasWritePermission(conn, docid, user, group) ) {
         throw new Exception("User " + user +
               " does not have permission to update XML Document #" + docid);
             bojilova
+    }
-            jones
+    try {
-            bojilova
+        XMLReader parser = initializeParser(conn, action, newdocid, user);
-            jones
+        conn.setAutoCommit(false);
         parser.parse(new InputSource(xml));
         conn.commit();
         conn.setAutoCommit(true);
-            bojilova
+        //return newdocid;
-            jones
+      } catch (SAXParseException e) {
         conn.rollback();
-            bojilova
+        conn.setAutoCommit(true);
-            jones
+        throw e;
       } catch (SAXException e) {
-            bojilova
+        conn.rollback();
         conn.setAutoCommit(true);
         throw e;
 /*
-            jones
+        // If its a problem with the accession number its ok, just the
         // accession number was regenerated
         AccessionNumberGeneratedException ang = null;
-            jones
+        try {
-            jones
+          Exception embedded = e.getException();
           if ((embedded != null) &&
               (embedded instanceof AccessionNumberGeneratedException)) {
             ang = (AccessionNumberGeneratedException)e.getException();
+          }
         } catch (ClassCastException cce) {
           // Do nothing and just fall through to the ang != null test
             jones
-            jones
+        if (ang != null) {
           conn.commit();
           conn.setAutoCommit(true);
           return (ang.getMessage());
         } else {
           conn.rollback();
           throw e;
+        }
-            bojilova
+*/
-            jones
+      } catch (Exception e) {
         conn.rollback();
-            bojilova
+        conn.setAutoCommit(true);
-            jones
+        throw e;
+      }
             bojilova
       if ( (docid != null) && !(newdocid.equals(docid)) ) {
         return new String("New document ID generated:" + newdocid);
       } else {
         return newdocid;
+      }
             jones
             jones
-            jones
+  /**
    * Delete an XML file from the database (actually, just make it a revision
    * in the xml_revisions table)
+   *
    * @param docid the ID of the document to be deleted from the database
    */
-            bojilova
+  public static void delete( Connection conn, String docid,
                                  String user, String group )
-            bojilova
+                throws Exception {
             jones
-            bojilova
+    // Determine if the docid is OK for DELETE
-            bojilova
+    AccessionNumber ac = new AccessionNumber(conn);
-            bojilova
+    String newdocid = ac.generate(docid, "DELETE");
             jones
-            bojilova
+    // check for 'write' permission for 'user' to delete this document
     if ( !hasWritePermission(conn, docid, user, group) ) {
       throw new Exception("User " + user +
               " does not have permission to delete XML Document #" + docid);
             bojilova
-            jones
+    conn.setAutoCommit(false);
     // Copy the record to the xml_revisions table
-            bojilova
+    DocumentImpl.archiveDocRevision( conn, docid, user );
             jones
-            jones
+    // Now delete it from the xml_documents table
     Statement stmt = conn.createStatement();
-            bojilova
+    stmt.execute("DELETE FROM xml_index WHERE docid = '" + docid + "'");
     stmt.execute("DELETE FROM xml_documents WHERE docid = '" + docid + "'");
-            jones
+    stmt.close();
     conn.commit();
-            bojilova
+    conn.setAutoCommit(true);
             jones
             bojilova
   /** Check for "write" permissions from DB connection */
   private static boolean hasWritePermission(Connection conn, String docid,
                                      String user, String group)
                                      throws SQLException {
-            bojilova
+    // b' of the command line invocation
     if ( (user == null) && (group == null) ) {
       return true;
+    }
-            bojilova
+    PreparedStatement pstmt;
     // checking if user is owner of docid
     try {
       pstmt = conn.prepareStatement(
-            bojilova
+                   "SELECT 'x' FROM xml_documents " +
-            bojilova
+                   "WHERE docid LIKE ? AND user_owner LIKE ?");
       // Bind the values to the query
       pstmt.setString(1, docid);
       pstmt.setString(2, user);
             jones
-            bojilova
+      pstmt.execute();
       ResultSet rs = pstmt.getResultSet();
       boolean hasRow = rs.next();
       pstmt.close();
       if (hasRow) {
         return true;
+      }
     } catch (SQLException e) {
       throw new
-            bojilova
+        SQLException("Error checking document's owner: " + e.getMessage());
             bojilova
     // checking access type from xml_access table
     int accesstype = 0;
     try {
       pstmt = conn.prepareStatement(
                    "SELECT access_type FROM xml_access " +
                    "WHERE docid LIKE ? " +
                    "AND principal_name LIKE ? " +
                    "AND principal_type = 'user' " +
-            bojilova
+                   "AND sysdate BETWEEN nvl(begin_time,sysdate) " +
                                    "AND nvl(end_time,sysdate) " +
-            bojilova
+                   "UNION " +
                    "SELECT access_type FROM xml_access " +
                    "WHERE docid LIKE ? " +
                    "AND principal_name LIKE ? " +
                    "AND principal_type = 'group' " +
-            bojilova
+                   "AND sysdate BETWEEN nvl(begin_time,sysdate) " +
                                    "AND nvl(end_time,sysdate)");
-            bojilova
+      // Bind the values to the query
       pstmt.setString(1, docid);
       pstmt.setString(2, user);
       pstmt.setString(3, docid);
       pstmt.setString(2, group);
       pstmt.execute();
       ResultSet rs = pstmt.getResultSet();
       boolean hasRows = rs.next();
-            bojilova
+      while ( hasRows ) {
         accesstype = rs.getInt(1);
         if ( (accesstype & WRITE) == WRITE ) {
           pstmt.close();
           return true;
+        }
         hasRows = rs.next();
             bojilova
       pstmt.close();
       return false;
     } catch (SQLException e) {
       throw new
       SQLException("Error getting document's permissions: " + e.getMessage());
+    }
+  }
-            jones
+  /**
-            jones
+   * Set up the parser handlers for writing the document to the database
    */
-            jones
+  private static XMLReader initializeParser(Connection conn,
-            bojilova
+                           String action, String docid, String user)
                            throws Exception {
-            jones
+    XMLReader parser = null;
     //
     // Set up the SAX document handlers for parsing
     //
     try {
-            bojilova
+      ContentHandler chandler   = new DBSAXHandler(conn, action, docid, user);
-            jones
+      EntityResolver dbresolver = new DBEntityResolver(conn,
                                       (DBSAXHandler)chandler);
       DTDHandler dtdhandler     = new DBDTDHandler(conn);
       // Get an instance of the parser
-            jones
+      MetaCatUtil util = new MetaCatUtil();
       String parserName = util.getOption("saxparser");
-            jones
+      parser = XMLReaderFactory.createXMLReader(parserName);
       // Turn off validation
       parser.setFeature("http://xml.org/sax/features/validation", false);
       // Set Handlers in the parser
       parser.setProperty("http://xml.org/sax/properties/declaration-handler",
                          chandler);
       parser.setProperty("http://xml.org/sax/properties/lexical-handler",
                          chandler);
       parser.setContentHandler((ContentHandler)chandler);
       parser.setEntityResolver((EntityResolver)dbresolver);
       parser.setDTDHandler((DTDHandler)dtdhandler);
       parser.setErrorHandler((ErrorHandler)chandler);
     } catch (Exception e) {
-            bojilova
+      throw e;
             jones
     return parser;
+  }
-            bojilova
+  /** Save a document entry in the xml_revisions table */
   private static void archiveDocRevision(Connection conn, String docid,
                                          String user) throws SQLException {
     // create a record in xml_revisions table
     // for that document as selected from xml_documents
     PreparedStatement pstmt = conn.prepareStatement(
       "INSERT INTO xml_revisions " +
         "(revisionid, docid, rootnodeid, docname, doctype, doctitle, " +
         "user_owner, user_updated, date_created, date_updated) " +
       "SELECT null, ?, rootnodeid, docname, doctype, doctitle," +
         "user_owner, ?, sysdate, sysdate "+
       "FROM xml_documents " +
       "WHERE docid = ?");
     // Bind the values to the query and execute it
     pstmt.setString(1, docid);
     pstmt.setString(2, user);
     pstmt.setString(3, docid);
     pstmt.execute();
     pstmt.close();
+  }
-            jones
+  /**
    * the main routine used to test the DBWriter utility.
    * <p>
    * Usage: java DocumentImpl <-f filename -a action -d docid>
+   *
    * @param filename the filename to be loaded into the database
    * @param action the action to perform (READ, INSERT, UPDATE, DELETE)
    * @param docid the id of the document to process
    */
   static public void main(String[] args) {
     try {
       String filename = null;
       String action   = null;
       String docid    = null;
-            jones
+      boolean showRuntime = false;
       boolean useOldReadAlgorithm = false;
             jones
-            jones
+      // Parse the command line arguments
-            jones
+      for ( int i=0 ; i < args.length; ++i ) {
         if ( args[i].equals( "-f" ) ) {
           filename =  args[++i];
         } else if ( args[i].equals( "-a" ) ) {
           action =  args[++i];
         } else if ( args[i].equals( "-d" ) ) {
           docid =  args[++i];
-            jones
+        } else if ( args[i].equals( "-t" ) ) {
           showRuntime = true;
         } else if ( args[i].equals( "-old" ) ) {
           useOldReadAlgorithm = true;
-            jones
+        } else {
           System.err.println
             ( "   args[" +i+ "] '" +args[i]+ "' ignored." );
+        }
+      }
-            jones
+      // Check if the required arguments are provided
-            jones
+      boolean argsAreValid = false;
       if (action != null) {
         if (action.equals("INSERT")) {
           if (filename != null) {
             argsAreValid = true;
+          }
         } else if (action.equals("UPDATE")) {
           if ((filename != null) && (docid != null)) {
             argsAreValid = true;
+          }
         } else if (action.equals("DELETE")) {
           if (docid != null) {
             argsAreValid = true;
+          }
         } else if (action.equals("READ")) {
           if (docid != null) {
             argsAreValid = true;
+          }
+        }
+      }
-            jones
+      // Print usage message if the arguments are not valid
-            jones
+      if (!argsAreValid) {
         System.err.println("Wrong number of arguments!!!");
         System.err.println(
-            jones
+          "USAGE: java DocumentImpl [-t] <-a INSERT> [-d docid] <-f filename>");
-            jones
+        System.err.println(
-            jones
+          "   OR: java DocumentImpl [-t] <-a UPDATE -d docid -f filename>");
-            jones
+        System.err.println(
-            jones
+          "   OR: java DocumentImpl [-t] <-a DELETE -d docid>");
-            jones
+        System.err.println(
-            jones
+          "   OR: java DocumentImpl [-t] [-old] <-a READ -d docid>");
-            jones
+        return;
+      }
             jones
       // Time the request if asked for
       double startTime = System.currentTimeMillis();
-            jones
+      // Open a connection to the database
       MetaCatUtil util = new MetaCatUtil();
       Connection dbconn = util.openDBConnection();
-            berkley
+      double connTime = System.currentTimeMillis();
-            jones
+      // Execute the action requested (READ, INSERT, UPDATE, DELETE)
-            jones
+      if (action.equals("READ")) {
           DocumentImpl xmldoc = new DocumentImpl( dbconn, docid );
-            jones
+          if (useOldReadAlgorithm) {
             System.out.println(xmldoc.readUsingSlowAlgorithm());
           } else {
             xmldoc.toXml(new PrintWriter(System.out));
+          }
-            jones
+      } else if (action.equals("DELETE")) {
-            bojilova
+        DocumentImpl.delete(dbconn, docid, null, null);
-            jones
+        System.out.println("Document deleted: " + docid);
-            jones
+      } else {
-            bojilova
+        String newdocid = DocumentImpl.write(dbconn, filename, action, docid,
                                                                   null, null);
-            jones
+        if ((docid != null) && (!docid.equals(newdocid))) {
           if (action.equals("INSERT")) {
             System.out.println("New document ID generated!!! ");
           } else if (action.equals("UPDATE")) {
             System.out.println("ERROR: Couldn't update document!!! ");
             jones
-            jones
+        } else if ((docid == null) && (action.equals("UPDATE"))) {
           System.out.println("ERROR: Couldn't update document!!! ");
             jones
-            jones
+        System.out.println("Document processing finished for: " + filename
               + " (" + newdocid + ")");
             jones
-            jones
+      double stopTime = System.currentTimeMillis();
-            berkley
+      double dbOpenTime = (connTime - startTime)/1000;
       double insertTime = (stopTime - connTime)/1000;
-            jones
+      double executionTime = (stopTime - startTime)/1000;
       if (showRuntime) {
-            berkley
+        System.out.println("\n\nTotal Execution time was: " +
                            executionTime + " seconds.");
         System.out.println("Time to open DB connection was: " + dbOpenTime +
                            " seconds.");
         System.out.println("Time to insert document was: " + insertTime +
                            " seconds.");
             jones
-            berkley
+      dbconn.close();
-            jones
+    } catch (McdbException me) {
       me.toXml(new PrintWriter(System.err));
     } catch (AccessionNumberException ane) {
       System.out.println("ERROR: Couldn't delete document!!! ");
       System.out.println(ane.getMessage());
     } catch (Exception e) {
       System.err.println("EXCEPTION HANDLING REQUIRED");
       System.err.println(e.getMessage());
       e.printStackTrace(System.err);
+    }
+  }
             jones

Project

General

Profile

Metacat