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

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

-            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$'
             jones
  * 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
-            jones
+ */
 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;
-            berkley
+import java.io.InputStreamReader;
             jones
-            jones
+import java.util.Iterator;
-            jones
+import java.util.Stack;
-            jones
+import java.util.TreeSet;
-            berkley
+import java.util.Enumeration;
             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;
-            berkley
+import java.net.URL;
-            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;
-            bojilova
+// DOCTITLE attr cleared from the db
 //  private String doctitle = null;
-            berkley
+  private String createdate = null;
   private String updatedate = null;
-            jones
+  private String system_id = null;
-            berkley
+  private String userowner = null;
   private String userupdated = null;
-            berkley
+  private int rev;
-            berkley
+  private int serverlocation;
-            bojilova
+  private String publicaccess;
-            jones
+  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;
             berkley
       DocumentIdentifier id = new DocumentIdentifier(docid);
             jones
       // 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) {
-            berkley
+      throw new McdbException("Error reading document from " +
                               "DocumentImpl.DocumentImpl: " + docid);
             jones
+  }
-            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
-            bojilova
+   * @param docid the docid to use for the INSERT OR UPDATE
    * @param action the action to be performed (INSERT OR UPDATE)
    * @param user the user that owns the document
    * @param pub flag for public "read" access on document
    * @param serverCode the serverid from xml_replication on which this document
    *        resides.
             jones
    */
   public DocumentImpl(Connection conn, long rootnodeid, String docname,
-            berkley
+                      String doctype, String docid, String action, String user,
-            bojilova
+                      String pub, String catalogid, int serverCode)
-            berkley
+                      throws SQLException, Exception
+  {
     this.conn = conn;
     this.rootnodeid = rootnodeid;
     this.docname = docname;
     this.doctype = doctype;
     this.docid = docid;
-            bojilova
+    writeDocumentToDB(action, user, pub, catalogid, serverCode);
             berkley
-            bojilova
+// NOT USED ANY MORE
 //  public DocumentImpl(Connection conn, long rootnodeid, String docname,
 //                      String doctype, String docid, String action, String user)
 //                      throws SQLException, Exception
 //  {
 //    this.conn = conn;
 //    this.rootnodeid = rootnodeid;
 //    this.docname = docname;
 //    this.doctype = doctype;
 //    this.docid = docid;
 //    writeDocumentToDB(action, user);
 //  }
             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
-            bojilova
+// DOCTITLE attr cleared from the db
 //  /**
 //   *get the document title
 //   */
 //  public String getDocTitle() {
 //    return doctitle;
 //  }
             berkley
   public String getUserowner() {
     return userowner;
+  }
   public String getUserupdated() {
     return userupdated;
+  }
   public int getServerlocation() {
     return serverlocation;
+  }
-            bojilova
+  public String getPublicaccess() {
-            berkley
+    return publicaccess;
+  }
             berkley
   public int getRev() {
     return rev;
+  }
             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
-            berkley
+    while(!openElements.empty())
+    {
       NodeRecord currentElement = (NodeRecord)openElements.pop();
       util.debugMessage("\n POPPED: " + currentElement.nodename);
       out.print("</" + currentElement.nodename + ">" );
+    }
-            jones
+    out.flush();
+  }
             berkley
   private boolean isRevisionOnly(DocumentIdentifier docid) throws Exception
+  {
     //System.out.println("inRevisionOnly");
     PreparedStatement pstmt;
     String rev = docid.getRev();
     String newid = docid.getIdentifier();
     pstmt = conn.prepareStatement("select rev from xml_documents " +
                                   "where docid like '" + newid + "'");
     pstmt.execute();
     ResultSet rs = pstmt.getResultSet();
     boolean tablehasrows = rs.next();
     if(rev.equals("newest") || rev.equals("all"))
+    {
       return false;
+    }
     if(tablehasrows)
+    {
       int r = rs.getInt(1);
-            berkley
+      pstmt.close();
-            berkley
+      if(new Integer(rev).intValue() == r)
       { //the current revision in in xml_documents
         //System.out.println("returning false");
         return false;
+      }
       else if(new Integer(rev).intValue() < r)
       { //the current revision is in xml_revisions.
         //System.out.println("returning true");
         return true;
+      }
       else if(new Integer(rev).intValue() > r)
       { //error, rev cannot be greater than r
         throw new Exception("requested revision cannot be greater than " +
                             "the latest revision number.");
+      }
+    }
     throw new Exception("the requested docid '" + docid.toString() +
                         "' does not exist");
+  }
             jones
-            berkley
+  private void getDocumentInfo(String docid) throws McdbException,
                                                     AccessionNumberException
+  {
     getDocumentInfo(new DocumentIdentifier(docid));
+  }
-            jones
+  /**
-            jones
+   * Look up the document type information from the database
+   *
    * @param docid the id of the document to look up
    */
-            berkley
+  private void getDocumentInfo(DocumentIdentifier docid) throws McdbException
             jones
     PreparedStatement pstmt;
-            berkley
+    String table = "xml_documents";
     try
+    {
       if(isRevisionOnly(docid))
       { //pull the document from xml_revisions instead of from xml_documents;
         table = "xml_revisions";
+      }
+    }
     catch(Exception e)
+    {
-            berkley
+      System.out.println("error in DocumentImpl.getDocumentInfo: " +
                           e.getMessage());
             berkley
     //deal with the key words here.
     if(docid.getRev().equals("all"))
+    {
+    }
-            jones
+    try {
-            berkley
+      StringBuffer sql = new StringBuffer();
-            bojilova
+// DOCTITLE attr cleared from the db
 //      sql.append("SELECT docname, doctype, rootnodeid, doctitle, ");
       sql.append("SELECT docname, doctype, rootnodeid, ");
-            bojilova
+      sql.append("date_created, date_updated, user_owner, user_updated, ");
       sql.append("server_location, public_access, rev");
       sql.append(" FROM ").append(table);
-            berkley
+      sql.append(" WHERE docid LIKE '").append(docid.getIdentifier());
       sql.append("' and rev like '").append(docid.getRev()).append("'");
       //System.out.println(sql.toString());
-            jones
+      pstmt =
-            berkley
+        conn.prepareStatement(sql.toString());
-            jones
+      // Bind the values to the query
-            berkley
+      //pstmt.setString(1, docid.getIdentifier());
       //pstmt.setString(2, docid.getRev());
             jones
       pstmt.execute();
       ResultSet rs = pstmt.getResultSet();
       boolean tableHasRows = rs.next();
       if (tableHasRows) {
-            berkley
+        this.docname        = rs.getString(1);
         this.doctype        = rs.getString(2);
         this.rootnodeid     = rs.getLong(3);
-            bojilova
+// DOCTITLE attr cleared from the db
 //        this.doctitle       = rs.getString(4);
-            bojilova
+        this.createdate     = rs.getString(4);
         this.updatedate     = rs.getString(5);
         this.userowner      = rs.getString(6);
         this.userupdated    = rs.getString(7);
         this.serverlocation = rs.getInt(8);
-            bojilova
+        this.publicaccess   = rs.getString(9);
         this.rev            = rs.getInt(10);
             jones
       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);
+        }
-            berkley
+        //pstmt.close();
             jones
     } catch (SQLException e) {
-            berkley
+      System.out.println("error in DocumentImpl.getDocumentInfo: " +
                           e.getMessage());
-            berkley
+      e.printStackTrace(System.out);
-            berkley
+      throw new McdbException("Error accessing database connection in " +
                               "DocumentImpl.getDocumentInfo: ", e);
             jones
     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) {
-            berkley
+      throw new McdbException("Error accessing database connection from " +
                               "DocumentImpl.getNodeRecordList ", e);
             jones
     if (nodeRecordList != null) {
       return nodeRecordList;
     } else {
       throw new McdbException("Error getting node data: " + docid);
+    }
+  }
             berkley
-            bojilova
+// NOT USED ANY MORE
 //  /** creates SQL code and inserts new document into DB connection
 //   default serverCode of 1*/
 //  private void writeDocumentToDB(String action, String user)
 //               throws SQLException, Exception
 //  {
 //    writeDocumentToDB(action, user, null, 1);
 //  }
             jones
-            bojilova
+ /** creates SQL code and inserts new document into DB connection */
-            bojilova
+  private void writeDocumentToDB(String action, String user, String pub,
-            bojilova
+                                 String catalogid, int serverCode)
-            bojilova
+               throws SQLException, Exception {
     try {
       PreparedStatement pstmt = null;
       if (action.equals("INSERT")) {
         //AccessionNumber ac = new AccessionNumber();
         //this.docid = ac.generate(docid, "INSERT");
         pstmt = conn.prepareStatement(
-            bojilova
+                "INSERT INTO xml_documents " +
                 "(docid, rootnodeid, docname, doctype, " +
                 "user_owner, user_updated, date_created, date_updated, " +
                 "public_access, catalog_id, server_location) " +
                 "VALUES (?, ?, ?, ?, ?, ?, sysdate, sysdate, ?, ?, ?)");
-            berkley
+        //note that the server_location is set to 1.
         //this means that "localhost" in the xml_replication table must
         //always be the first entry!!!!!
-            bojilova
+        // 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);
-            bojilova
+        if ( pub == null ) {
           pstmt.setString(7, null);
-            bojilova
+        } else if ( pub.toUpperCase().equals("YES") || pub.equals("1") ) {
-            bojilova
+          pstmt.setInt(7, 1);
-            bojilova
+        } else if ( pub.toUpperCase().equals("NO") || pub.equals("0") ) {
-            bojilova
+          pstmt.setInt(7, 0);
+        }
-            bojilova
+        pstmt.setString(8, catalogid);
         pstmt.setInt(9, serverCode);
-            bojilova
+      } else if (action.equals("UPDATE")) {
         // Save the old document entry in a backup table
         DocumentImpl.archiveDocRevision( conn, docid, user );
-            berkley
+        DocumentImpl thisdoc = new DocumentImpl(conn, docid);
         int thisrev = thisdoc.getRev();
         thisrev++;
-            bojilova
+        // 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();
-            berkley
+        //pstmt.close();
             bojilova
         // Update the new document to reflect the new node tree
         pstmt = conn.prepareStatement(
             "UPDATE xml_documents " +
             "SET rootnodeid = ?, docname = ?, doctype = ?, " +
-            berkley
+            "user_updated = ?, date_updated = sysdate, " +
-            bojilova
+            "server_location = ?, rev = ?, public_access = ?, catalog_id = ? " +
-            bojilova
+            "WHERE docid LIKE ?");
-            bojilova
+        // Bind the values to the query
         pstmt.setLong(1, rootnodeid);
         pstmt.setString(2, docname);
         pstmt.setString(3, doctype);
         pstmt.setString(4, user);
-            berkley
+        pstmt.setInt(5, serverCode);
-            berkley
+        pstmt.setInt(6, thisrev);
-            bojilova
+        if ( pub == null ) {
           pstmt.setString(7, null);
-            bojilova
+        } else if ( pub.toUpperCase().equals("YES") || pub.equals("1") ) {
-            bojilova
+          pstmt .setInt(7, 1);
-            bojilova
+        } else if ( pub.toUpperCase().equals("NO") || pub.equals("0") ) {
-            bojilova
+          pstmt.setInt(7, 0);
+        }
-            bojilova
+        pstmt.setString(8, catalogid);
         pstmt.setString(9, this.docid);
             berkley
-            bojilova
+      } else {
         System.err.println("Action not supported: " + action);
+      }
       // Do the insertion
       pstmt.execute();
       pstmt.close();
     } catch (SQLException sqle) {
       throw sqle;
     } catch (Exception e) {
       throw e;
+    }
+  }
-            bojilova
+// DOCTITLE attr cleared from the db
 //  /**
 //   * Get the document title
 //   */
 //  public String getTitle() {
 //    return doctitle;
 //  }
             bojilova
-            bojilova
+// DOCTITLE attr cleared from the db
 //  /**
 //   * Set the document title
 //   *
 //   * @param title the new title for the document
 //   */
 //  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("Error in DocumentImpl.setTitle: " + e.getMessage());
 //    }
 //  }
             berkley
-            bojilova
+  /**
-            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
-            bojilova
+   * @param pub flag for public "read" access on document
    * @param dtdfilename the dtd to be uploaded on server's file system
-            jones
+   * @param action the action to be performed (INSERT OR UPDATE)
    * @param docid the docid to use for the INSERT OR UPDATE
-            bojilova
+   * @param user the user that owns the document
    * @param group the group to which user belongs
-            jones
+   */
-            bojilova
+  public static String write(Connection conn,String filename,
-            bojilova
+                             String pub, String dtdfilename,
-            bojilova
+                             String action, String docid, String user,
                              String group )
-            bojilova
+                throws Exception {
             bojilova
     Reader dtd = null;
     if ( dtdfilename != null ) {
       dtd = new FileReader(new File(dtdfilename).toString());
+    }
-            bojilova
+    return write ( conn, new FileReader(new File(filename).toString()),
-            bojilova
+                   pub, dtd, action, docid, user, group, false);
             jones
             bojilova
-            bojilova
+  public static String write(Connection conn,Reader xml,String pub,Reader dtd,
-            bojilova
+                             String action, String docid, String user,
-            bojilova
+                             String group, boolean validate)
-            berkley
+                throws Exception {
-            bojilova
+    return write(conn,xml,pub,dtd,action,docid,user,group,1,false,validate);
             bojilova
-            bojilova
+  public static String write(Connection conn, Reader xml, String pub,
-            bojilova
+                             String action, String docid, String user,
                              String group )
                 throws Exception {
-            berkley
+    if(action.equals("UPDATE"))
     {//if the document is being updated then use the servercode from the
      //originally inserted document.
       DocumentImpl doc = new DocumentImpl(conn, docid);
       int servercode = doc.getServerlocation();
-            bojilova
+      return write(conn, xml, pub, action, docid, user, group, servercode);
             berkley
     else
     {//if the file is being inserted then the servercode is always 1
-            bojilova
+      return write(conn, xml, pub, action, docid, user, group, 1);
             berkley
             berkley
-            berkley
+  public static String write( Connection conn, Reader xml,
                               String action, String docid, String user,
                               String group, int serverCode )
-            bojilova
+                throws Exception
             berkley
-            bojilova
+    return write(conn,xml,null,action,docid,user,group,serverCode);
             berkley
-            bojilova
+  public static String write( Connection conn, Reader xml, String pub,
-            berkley
+                              String action, String docid, String user,
-            bojilova
+                              String group, int serverCode)
                 throws Exception
             berkley
-            bojilova
+    return write(conn,xml,pub,null,action,docid,user,group,
                  serverCode,false,false);
             berkley
-            bojilova
+  public static String write( Connection conn, Reader xml, String pub,
-            bojilova
+                              String action, String docid, String user,
                               String group, int serverCode, boolean override)
                 throws Exception
+  {
-            bojilova
+    return write(conn,xml,pub,null,action,docid,user,group,
                  serverCode,override,false);
             bojilova
-            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
-            bojilova
+   * @param pub flag for public "read" access on xml document
    * @param dtd the dtd to be uploaded on server's file system
-            jones
+   * @param action the action to be performed (INSERT OR UPDATE)
    * @param docid the docid to use for the INSERT OR UPDATE
-            berkley
+   * @param user the user that owns the document
    * @param group the group to which user belongs
    * @param serverCode the serverid from xml_replication on which this document
    *        resides.
    * @param override flag to stop insert replication checking.
    *        if override = true then a document not belonging to the local server
    *        will not be checked upon update for a file lock.
    *        if override = false then a document not from this server, upon
    *        update will be locked and version checked.
-            jones
+   */
             berkley
-            bojilova
+  public static String write( Connection conn,Reader xml,String pub,Reader dtd,
-            bojilova
+                              String action, String docid, String user,
-            bojilova
+                              String group, int serverCode, boolean override,
                               boolean validate)
-            bojilova
+                throws Exception
             berkley
-            bojilova
+    //MOVED DOWN IN RelationHandler obj before write of relations
     //if(action.equals("UPDATE"))
     //{
     //  RelationHandler.deleteRelations(docid);
     //}
             berkley
-            berkley
+    int updaterev;
-            berkley
+    MetaCatUtil util = new MetaCatUtil();
-            berkley
+        // Determine if the docid is OK for INSERT or UPDATE
     AccessionNumber ac = new AccessionNumber(conn);
     String newdocid = ac.generate(docid, action);
             berkley
-            berkley
+    MetaCatUtil.debugMessage("action: " + action + " servercode: " +
                              serverCode + " override: " + override);
             berkley
-            berkley
+    if((serverCode != 1 && action.equals("UPDATE")) && !override)
-            berkley
+    { //if this document being written is not a resident of this server then
       //we need to try to get a lock from it's resident server.  If the
       //resident server will not give a lock then we send the user a message
       //saying that he/she needs to download a new copy of the file and
       //merge the differences manually.
-            berkley
+      int istreamInt;
-            berkley
+      char istreamChar;
       DocumentImpl newdoc = new DocumentImpl(conn, docid);
-            berkley
+      updaterev = newdoc.getRev();
-            berkley
+      String server = MetacatReplication.getServer(serverCode);
-            berkley
+      MetacatReplication.replLog("attempting to lock " + docid);
-            berkley
+      URL u = new URL("http://" + server + "?action=getlock&updaterev=" +
                       updaterev + "&docid=" + docid);
-            berkley
+      System.out.println("sending message: " + u.toString());
-            berkley
+      String serverResStr = MetacatReplication.getURLContent(u);
-            berkley
+      String openingtag = serverResStr.substring(0, serverResStr.indexOf(">")+1);
             berkley
-            berkley
+      if(openingtag.equals("<lockgranted>"))
       {//the lock was granted go ahead with the insert
-            berkley
+        try
+        {
-            berkley
+          MetacatReplication.replLog("lock granted for " + docid + " from " +
                                       server);
-            bojilova
+          XMLReader parser = initializeParser(conn, action, newdocid, validate,
-            bojilova
+                                              user, group, pub, serverCode, dtd);
-            berkley
+          conn.setAutoCommit(false);
-            bojilova
+          parser.parse(new InputSource(xml));
-            berkley
+          conn.commit();
           conn.setAutoCommit(true);
+        }
         catch (Exception e)
+        {
           conn.rollback();
           conn.setAutoCommit(true);
           throw e;
+        }
         //after inserting the document locally, tell the document's home server
         //to come get a copy from here.
-            berkley
+        ForceReplicationHandler frh = new ForceReplicationHandler(docid);
             berkley
-            berkley
+        if ( (docid != null) && !(newdocid.equals(docid)) )
+        {
           return new String("New document ID generated:" + newdocid);
+        }
         else
+        {
           return newdocid;
+        }
             berkley
       else if(openingtag.equals("<filelocked>"))
       {//the file is currently locked by another user
        //notify our user to wait a few minutes, check out a new copy and try
        //again.
-            berkley
+        //System.out.println("file locked");
         MetacatReplication.replLog("lock denied for " + docid + " on " +
                                    server + " reason: file already locked");
-            berkley
+        throw new Exception("The file specified is already locked by another " +
                             "user.  Please wait 30 seconds, checkout the " +
                             "newer document, merge your changes and try " +
                             "again.");
             berkley
       else if(openingtag.equals("<outdatedfile>"))
       {//our file is outdated.  notify our user to check out a new copy of the
        //file and merge his version with the new version.
-            berkley
+        //System.out.println("outdated file");
         MetacatReplication.replLog("lock denied for " + docid + " on " +
                                     server + " reason: local file outdated");
-            berkley
+        throw new Exception("The file you are trying to update is an outdated" +
                             " version.  Please checkout the newest document, " +
                             "merge your changes and try again.");
             berkley
             berkley
             berkley
-            bojilova
+    if ( action.equals("UPDATE") ) {
-            bojilova
+      // check for 'write' permission for 'user' to update this document
             berkley
-            bojilova
+      if ( !hasPermission(conn, user, group, docid) ) {
-            bojilova
+        throw new Exception("User " + user +
               " does not have permission to update XML Document #" + docid);
             bojilova
+    }
-            berkley
+    try
             bojilova
-            bojilova
+      XMLReader parser = initializeParser(conn, action, newdocid, validate,
-            bojilova
+                                          user, group, pub, serverCode, dtd);
-            bojilova
+      conn.setAutoCommit(false);
       parser.parse(new InputSource(xml));
       conn.commit();
       conn.setAutoCommit(true);
             berkley
     catch (Exception e)
+    {
-            bojilova
+      conn.rollback();
       conn.setAutoCommit(true);
       throw e;
+    }
             berkley
     //force replicate out the new document to each server in our server list.
     if(serverCode == 1)
-            berkley
+    { //start the thread to replicate this new document out to the other servers
       ForceReplicationHandler frh = new ForceReplicationHandler(newdocid,
                                                                 action);
             berkley
             bojilova
-            berkley
+    if ( (docid != null) && !(newdocid.equals(docid)) )
+    {
-            bojilova
+      return new String("New document ID generated:" + newdocid);
             berkley
     else
+    {
-            bojilova
+      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 {
-            berkley
+    DocumentIdentifier id = new DocumentIdentifier(docid);
     docid = id.getSiteCode() + id.getSeparator() + id.getUniqueId();
-            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
-            bojilova
+    if ( !hasPermission(conn, user, group, docid) ) {
-            bojilova
+      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
             berkley
-            jones
+    Statement stmt = conn.createStatement();
-            bojilova
+    stmt.execute("DELETE FROM xml_index WHERE docid = '" + docid + "'");
     stmt.execute("DELETE FROM xml_documents WHERE docid = '" + docid + "'");
-            bojilova
+    //stmt.execute("DELETE FROM xml_access WHERE docid = '" + docid + "'");
-            bojilova
+    stmt.execute("DELETE FROM xml_access WHERE accessfileid = '" + docid + "'");
     stmt.execute("DELETE FROM xml_relation WHERE docid = '" + docid + "'");
-            jones
+    stmt.close();
     conn.commit();
-            bojilova
+    conn.setAutoCommit(true);
-            berkley
+    //IF this is a package document:
     //delete all of the relations that this document created.
     //if the deleted document is a package document its relations should
     //no longer be active if it has been deleted from the system.
             bojilova
 //    MOVED UP IN THE TRANSACTION
 //    RelationHandler.deleteRelations(docid);
             jones
             bojilova
-            bojilova
+  /**
     * Check for "WRITE" permission on @docid for @user and/or @group
     * from DB connection
     */
   private static boolean hasPermission( Connection conn, String user,
                                         String group, String docid)
                          throws SQLException
+  {
-            bojilova
+    // b' of the command line invocation
     if ( (user == null) && (group == null) ) {
       return true;
+    }
-            bojilova
+    // Check for WRITE permission on @docid for @user and/or @group
     AccessControlList aclobj = new AccessControlList(conn);
     boolean hasPermission = aclobj.hasPermission("WRITE",user,docid);
     if ( !hasPermission && group != null ) {
       hasPermission = aclobj.hasPermission("WRITE",group,docid);
             bojilova
             bojilova
     return hasPermission;
             bojilova
-            jones
+  /**
-            jones
+   * Set up the parser handlers for writing the document to the database
    */
-            bojilova
+  private static XMLReader initializeParser(Connection conn, String action,
-            bojilova
+                                   String docid, boolean validate,
                                    String user, String group, String pub,
                                    int serverCode, Reader dtd)
-            bojilova
+                           throws Exception
+  {
-            jones
+    XMLReader parser = null;
     //
     // Set up the SAX document handlers for parsing
     //
     try {
-            bojilova
+      ContentHandler chandler = new DBSAXHandler(conn, action, docid,
-            bojilova
+                                                 user, group, pub, serverCode);
-            bojilova
+      EntityResolver eresolver= new DBEntityResolver(conn,
                                                  (DBSAXHandler)chandler, dtd);
-            bojilova
+      DTDHandler dtdhandler   = new DBDTDHandler(conn);
             jones
       // Get an instance of the parser
-            jones
+      MetaCatUtil util = new MetaCatUtil();
       String parserName = util.getOption("saxparser");
-            jones
+      parser = XMLReaderFactory.createXMLReader(parserName);
-            bojilova
+      // Turn on validation
-            bojilova
+      parser.setFeature("http://xml.org/sax/features/validation", validate);
-            bojilova
+      // Turn off Including all external parameter entities
       // (the external DTD subset also)
       // Doesn't work well, probably the feature name is not correct
       // parser.setFeature(
       //  "http://xml.org/sax/features/external-parameter-entities", false);
             jones
       // 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);
-            bojilova
+      parser.setEntityResolver((EntityResolver)eresolver);
-            jones
+      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,
-            berkley
+                                         String user)
                                          throws SQLException {
-            bojilova
+    // create a record in xml_revisions table
     // for that document as selected from xml_documents
     PreparedStatement pstmt = conn.prepareStatement(
       "INSERT INTO xml_revisions " +
-            bojilova
+        "(revisionid, docid, rootnodeid, docname, doctype, " +
-            bojilova
+        "user_owner, user_updated, date_created, date_updated, " +
         "server_location, rev, public_access, catalog_id) " +
-            bojilova
+      "SELECT null, ?, rootnodeid, docname, doctype, " +
-            bojilova
+        "user_owner, ?, sysdate, sysdate, server_location, rev, " +
         "public_access, catalog_id " +
-            bojilova
+      "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 {
-            bojilova
+      String filename    = null;
-            bojilova
+      String dtdfilename = null;
-            bojilova
+      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];
-            bojilova
+        } else if ( args[i].equals( "-r" ) ) {
           dtdfilename =  args[++i];
-            jones
+        } 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(
-            bojilova
+          "USAGE: java DocumentImpl [-t] <-a INSERT> [-d docid] <-f filename> "+
-            bojilova
+          "[-r dtdfilename]");
-            jones
+        System.err.println(
-            bojilova
+          "   OR: java DocumentImpl [-t] <-a UPDATE -d docid -f filename> " +
-            bojilova
+          "[-r dtdfilename]");
-            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, null,
-            bojilova
+                                             dtdfilename, 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