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

metacat/src/edu/ucsb/nceas/metacat/EmlSAXHandler.java @ 1543

-            tao
+/**
  *  '$RCSfile$'
  *    Purpose: A Class that handles the SAX XML events as they
  *             are generated from XML documents
  *  Copyright: 2000 Regents of the University of California and the
  *             National Center for Ecological Analysis and Synthesis
  *    Authors: Matt Jones, Jivka Bojilova
  *    Release: @release@
+ *
  *   '$Author$'
  *     '$Date$'
  * '$Revision$'
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 package edu.ucsb.nceas.metacat;
 import java.sql.*;
-            tao
+import java.io.BufferedReader;
-            tao
+import java.io.File;
-            tao
+import java.io.FileReader;
-            tao
+import java.io.FileWriter;
-            tao
+import java.io.StringReader;
 import java.util.Stack;
 import java.util.Vector;
 import java.util.Hashtable;
 import java.util.Enumeration;
 import java.util.EmptyStackException;
 import org.xml.sax.Attributes;
 import org.xml.sax.SAXException;
 import org.xml.sax.SAXParseException;
 import org.xml.sax.ext.DeclHandler;
 import org.xml.sax.ext.LexicalHandler;
 import org.xml.sax.helpers.DefaultHandler;
 /**
  * A database aware Class implementing callback bethods for the SAX parser to
  * call when processing the XML stream and generating events
  */
 public class EmlSAXHandler extends DBSAXHandler implements
                                                       AccessControlInterface
+{
    private Vector allowRules = new Vector();
    private Vector denyRules = new Vector();
    private String documentId = null;
    private Vector subDocumentIdList = new Vector();
-            tao
+   private boolean processTopLeverAccess = false;
    private boolean processAdditionalAccess = false;
-            tao
+   private boolean processOtherAccess = false;
-            tao
+   private AccessSection accessObject= null;
    private AccessRule accessRule = null;
-            tao
+   private Vector accessObjectList = new Vector(); // store every access rule
-            tao
+   private Hashtable topLevelAccessControlMap = new Hashtable();
-            tao
+   private Hashtable additionalAccessControlMap = new Hashtable();// store
                                                  //subtree access for single
                                                  // additionalmetacat
    private Vector additionalAccessMapList = new Vector();// store maps for
                                                        // every addionalmetadata
-            tao
+   private Vector describesId = new Vector(); // store the ids in
                                       //additionalmetadata/describes
-            tao
+   private Stack subTreeInfoStack = new Stack();
    private Vector subTreeList = new Vector();// store the final subtree
-            tao
+   private int inLineDataIndex = 1;
-            tao
+   private Hashtable unChangableSubTreeHash = new Hashtable();
-            tao
+   private Stack currentUnChangedableSubtreeNodeStack;
    private boolean startCriticalSubTree = false;
-            tao
+   private boolean firstElementForCriticalSubTree = false;
-            tao
+   private String firstElementNameForCriticalSubTree;
-            tao
+   private boolean needCheckingAccessModule = false;
    private Vector unChangableAccessSubTreeVector;
    private AccessSection topAccessSection;
             tao
             tao
-            tao
+   // Constant
-            tao
+   private static final String EML ="eml";
-            tao
+   private static final String DESCRIBES = "describes";
-            tao
+   private static final String ADDITIONALMETADATA = "additionalMetadata";
    private static final String ORDER = "order";
    private static final String ID ="id";
-            tao
+   private static final String REFERENCES = "references";
-            tao
+   public  static final String INLINE = "inline";
-            tao
+   private static final String PERMISSIONERROR ="User try to update a subtree"+
                                " which it doesn't have write permission!";
-            tao
+   private static final String TOPLEVEL = "top";
    private static final String SUBTREELEVEL ="subtree";
             tao
-            tao
+    /** Construct an instance of the handler class
     * In this constructor, user can specify the version need to upadate
+    *
     * @param conn the JDBC connection to which information is written
     * @param action - "INSERT" or "UPDATE"
     * @param docid to be inserted or updated into JDBC connection
     * @param revision, the user specified the revision need to be update
     * @param user the user connected to MetaCat servlet and owns the document
     * @param groups the groups to which user belongs
     * @param pub flag for public "read" access on document
     * @param serverCode the serverid from xml_replication on which this document
     *        resides.
+    *
     */
    public EmlSAXHandler(DBConnection conn, String action, String docid,
      String revision, String user, String[] groups, String pub, int serverCode)
-            tao
+                              throws SAXException
             tao
      super(conn, action, docid, revision, user, groups, pub, serverCode);
-            tao
+     // Get the unchangable subtrees (user doesn't have write permission)
      try
+     {
        PermissionController control = new PermissionController(docid);
-            tao
+       //unChangableSubTreeHash = getUnchangableSubTree(control, user, groups);
             tao
        //If the action is update and user doesn't have "ALL" permission
        // we need to check if user update access subtree
        if (action.equals("UPDATE") &&
          control.hasPermission(user, groups, AccessControlInterface.ALLSTRING))
+       {
          needCheckingAccessModule = true;
          unChangableAccessSubTreeVector = getAccessSubTreeListFromDB();
+       }
             tao
      catch (Exception e)
+     {
        throw new SAXException(e.getMessage());
+     }
             tao
-            tao
+   /* Pass a permission control and get the list of unchangable subtree*/
    private Hashtable getUnchangableSubTree(PermissionController controller,
                                            String user, String[]groups)
                                            throws Exception
+   {
      Hashtable list = null;
      Hashtable result = new Hashtable();
      // get unwritable sutree from controller
      list = controller.hasUnaccessableSubTree(user, groups,
                                           AccessControlInterface.WRITESTRING);
       if (list != null)
+      {
          Enumeration en = list.elements();
          while (en.hasMoreElements())
+         {
            // Get  a subtree without node record list
            SubTree treeWithoutStack = (SubTree)en.nextElement();
            String subTreeId   = treeWithoutStack.getSubTreeId();
            MetaCatUtil.debugMessage("unchangable subtree id: " + subTreeId, 40);
            long   startNodeId = treeWithoutStack.getStartNodeId();
            MetaCatUtil.debugMessage("unchangable subtree startnodeid: " +
                                     startNodeId, 40);
            long   endNodeId   = treeWithoutStack.getEndNodeId();
            MetaCatUtil.debugMessage("unchangable subtree endnodeid: " +
                                      endNodeId, 40);
            // Get a subtree has the nodelist
            SubTree tree = new SubTree(docid, subTreeId, startNodeId, endNodeId);
            // add this tree to the result
            result.put(subTreeId, tree);
           }//while
       }//if
       return result;
+   }
             tao
    /*
     * Get the subtree node info from xml_accesssubtree table
     */
    private Vector getAccessSubTreeListFromDB() throws Exception
+   {
       Vector result = new Vector();
       PreparedStatement pstmt = null;
       ResultSet rs = null;
       String sql = "SELECT controllevel, subtreeid, startnodeid, endnodeid) " +
                    "FROM xml_accesssubtree WHERE docid like ? " +
                    "ORDER BY startnodeid ASC";
       try
+      {
         pstmt = connection.prepareStatement(sql);
         // Increase DBConnection usage count
         connection.increaseUsageCount(1);
         // Bind the values to the query
         pstmt.setString(1, docid);
         pstmt.execute();
         // Get result set
         rs = pstmt.getResultSet();
         while (rs.next())
+        {
           String level = rs.getString(1);
           String sectionId = rs.getString(2);
           long startNodeId = rs.getLong(3);
           long endNodeId = rs.getLong(4);
           // create a new access section
           AccessSection accessObj = new AccessSection();
           accessObj.setControlLevel(level);
           accessObj.setDocId(docid);
           accessObj.setSubTreeId(sectionId);
           accessObj.setStartNodeId(startNodeId);
           accessObj.setEndNodeId(endNodeId);
           Stack nodeStack = accessObj.getSubTreeNodeList();
           accessObj.setSubTreeNodeStack(nodeStack);
           // add this access obj into vector
           result.add(accessObj);
           // Get the top level access subtree control
           if ( level != null && level.equals(TOPLEVEL))
+          {
             topAccessSection = accessObj;
+          }
+        }
         pstmt.close();
       }//try
       catch (SQLException e)
+      {
         throw new
         SAXException("EMLSAXHandler.getAccessSubTreeListFromDB(): " +
                       e.getMessage());
       }//catch
       finally
+      {
         try
+        {
           pstmt.close();
+        }
         catch(SQLException ee)
+        {
           throw new
           SAXException("EMLSAXHandler.getAccessSubTreeListFromDB(): " +
           ee.getMessage());
+        }
       }//finally
       return result;
+   }
-            tao
+   /** SAX Handler that is called at the start of each XML element */
    public void startElement(String uri, String localName,
                             String qName, Attributes atts)
                throws SAXException
+  {
       // for element <eml:eml...> qname is "eml:eml", local name is "eml"
      // for element <acl....> both qname and local name is "eml"
      // uri is namesapce
      MetaCatUtil.debugMessage("Start ELEMENT(qName) " + qName, 50);
      MetaCatUtil.debugMessage("Start ELEMENT(localName) " + localName, 50);
      MetaCatUtil.debugMessage("Start ELEMENT(uri) " + uri, 50);
      DBSAXNode parentNode = null;
      DBSAXNode currentNode = null;
      // Get a reference to the parent node for the id
-            tao
+     try
+     {
-            tao
+       parentNode = (DBSAXNode)nodeStack.peek();
             tao
      catch (EmptyStackException e)
+     {
-            tao
+       parentNode = null;
+     }
             tao
      // If hit a text node, we need write this text for current's parent node
      // This will happend if the element is mixted
      if (hitTextNode && parentNode != null)
+     {
-            tao
+       //compare text node data
-            tao
+       if (startCriticalSubTree)
             tao
             NodeRecord node = null;
             try
+            {
               node = (NodeRecord)currentUnChangedableSubtreeNodeStack.pop();
+            }
             catch (EmptyStackException ee)
+            {
-            tao
+              MetaCatUtil.debugMessage("Node stack is empty for text data in startElement", 35);
-            tao
+              throw new SAXException(PERMISSIONERROR);
+            }
-            tao
+            MetaCatUtil.debugMessage("current node type from xml is TEXT in start element", 40);
             MetaCatUtil.debugMessage("node type from stack: " +
                                         node.getNodeType(), 40);
             MetaCatUtil.debugMessage("current node data from xml is: " +
                                         textBuffer.toString(), 40);
             MetaCatUtil.debugMessage("node data from stack: " +
                                         node.getNodeData(), 40);
             MetaCatUtil.debugMessage("node name from stack: " +
                                         node.getNodeName(), 40);
             MetaCatUtil.debugMessage("node is: "+ node.getNodeId(), 40);
-            tao
+            if (!node.getNodeType().equals("TEXT") ||
                !(textBuffer.toString()).equals(node.getNodeData()))
+            {
               MetaCatUtil.debugMessage("current node type from xml is TEXT in start element", 40);
               MetaCatUtil.debugMessage("node type from stack: " +
                                         node.getNodeType(), 40);
               MetaCatUtil.debugMessage("current node data from xml is: " +
                                         textBuffer.toString(), 40);
               MetaCatUtil.debugMessage("node data from stack: " +
                                         node.getNodeData(), 40);
               MetaCatUtil.debugMessage("node name from stack: " +
                                         node.getNodeName(), 40);
               MetaCatUtil.debugMessage("node is: "+ node.getNodeId(), 40);
               throw new SAXException(PERMISSIONERROR);
             }//if
         }//if
-            tao
+       // write the textbuffer into db for parent node.
-            tao
+        endNodeId = writeTextForDBSAXNode(textBuffer, parentNode);
-            tao
+        // rest hitTextNode
         hitTextNode =false;
         // reset textbuffer
         textBuffer = null;
         textBuffer = new StringBuffer();
+     }
             tao
-            tao
+     // Document representation that points to the root document node
      if (atFirstElement)
+     {
        atFirstElement = false;
        // If no DOCTYPE declaration: docname = root element
        // doctype = root element name or name space
        if (docname == null)
+       {
          docname = localName;
          // if uri isn't null doctype = uri(namespace)
          // othewise root element
          if (uri != null && !(uri.trim()).equals(""))
+         {
            doctype = uri;
+         }
          else
+         {
            doctype = docname;
+         }
          MetaCatUtil.debugMessage("DOCNAME-a: " + docname, 30);
          MetaCatUtil.debugMessage("DOCTYPE-a: " + doctype, 30);
+       }
        else if (doctype == null)
+       {
          // because docname is not null and it is declared in dtd
          // so could not be in schema, no namespace
          doctype = docname;
          MetaCatUtil.debugMessage("DOCTYPE-b: " + doctype, 30);
+       }
        rootNode.writeNodename(docname);
-            tao
+       try
+       {
-            tao
+         // for validated XML Documents store a reference to XML DB Catalog
          // Because this is select statement and it needn't to roll back if
          // insert document action fialed.
          // In order to decrease DBConnection usage count, we get a new
          // dbconnection from pool
          String catalogid = null;
          DBConnection dbConn = null;
          int serialNumber = -1;
-            tao
+         if ( systemid != null )
+         {
-            tao
+           try
+           {
             // Get dbconnection
             dbConn=DBConnectionPool.getDBConnection
                                           ("DBSAXHandler.startElement");
             serialNumber=dbConn.getCheckOutSerialNumber();
             Statement stmt = dbConn.createStatement();
             ResultSet rs = stmt.executeQuery(
                           "SELECT catalog_id FROM xml_catalog " +
                           "WHERE entry_type = 'DTD' " +
                           "AND public_id = '" + doctype + "'");
             boolean hasRow = rs.next();
             if ( hasRow ) {
               catalogid = rs.getString(1);
+            }
             stmt.close();
            }//try
            finally
+           {
              // Return dbconnection
              DBConnectionPool.returnDBConnection(dbConn, serialNumber);
            }//finally
+         }
          //create documentImpl object by the constructor which can specify
          //the revision
          currentDocument = new DocumentImpl(connection, rootNode.getNodeID(),
                                docname, doctype, docid, revision, action, user,
                                this.pub, catalogid, this.serverCode);
             tao
        catch (Exception ane)
+       {
-            tao
+         throw (new SAXException("Error in DBSaxHandler.startElement " +
                                  action, ane));
+       }
+     }
      // Create the current node representation
      currentNode = new DBSAXNode(connection, qName, localName, parentNode,
                                  currentDocument.getRootNodeID(),docid,
                                  currentDocument.getDoctype());
-            tao
+     // Use a local variable to store the element node id
      // If this element is a start point of subtree(section), it will be stored
      // otherwise, it will be discated
      long startNodeId = currentNode.getNodeID();
-            tao
+     // Add all of the namespaces
      String prefix;
      String nsuri;
      Enumeration prefixes = namespaces.keys();
-            tao
+     while ( prefixes.hasMoreElements() )
+     {
-            tao
+       prefix = (String)prefixes.nextElement();
        nsuri = (String)namespaces.get(prefix);
-            tao
+       endNodeId = currentNode.setNamespace(prefix, nsuri, docid);
             tao
             tao
             tao
      // Add all of the attributes
      for (int i=0; i<atts.getLength(); i++)
+     {
        String attributeName = atts.getQName(i);
        String attributeValue = atts.getValue(i);
-            tao
+       endNodeId =
                 currentNode.setAttribute(attributeName, attributeValue, docid);
             tao
        // To handle name space and schema location if the attribute name is
        // xsi:schemaLocation. If the name space is in not in catalog table
        // it will be regeistered.
        if (attributeName != null &&
            attributeName.indexOf(MetaCatServlet.SCHEMALOCATIONKEYWORD) != -1)
+       {
          SchemaLocationResolver resolver =
                                   new SchemaLocationResolver(attributeValue);
          resolver.resolveNameSpace();
+       }
-            tao
+       else if (attributeName !=null && attributeName.equals(ID))
+       {
             tao
             tao
-            tao
+         //check unchangedable subtree hash if contains this subtree id
-            tao
+         if (unChangableSubTreeHash.containsKey(attributeValue))
             tao
-            tao
+           // this subtree couldn't be changed by the user and move it from hash
-            tao
+           SubTree currentUnChangedableSubtree = (SubTree)
-            tao
+                                  unChangableSubTreeHash.remove(attributeValue);
-            tao
+           currentUnChangedableSubtreeNodeStack = currentUnChangedableSubtree.
                                                          getSubTreeNodeStack();
            startCriticalSubTree = true;
            firstElementForCriticalSubTree = true;
+         }
-            tao
+         // handle subtree info
          SubTree subTress = new SubTree();
          // set sub tree id
          subTress.setSubTreeId(attributeValue);
          // set sub tree sstart lement name
          subTress.setStartElementName(currentNode.getTagName());
          // set start node number
          subTress.setStartNodeId(startNodeId);
          // add to stack, but it didn't get end node id yet
          subTreeInfoStack.push(subTress);
+       }
-            tao
+     }//for
             tao
-            tao
+     // handle access stuff
      if (localName.equals(ACCESS))
+     {
        // if it is in addtionalmetacat
-            tao
+       if (parentNode.getTagName() == ADDITIONALMETADATA)
             tao
-            tao
+         processAdditionalAccess = true;
             tao
             tao
-            tao
+       else
+       {
-            tao
+         //make sure the access is top level
          // this mean current node's parent's parent should be "eml"
          DBSAXNode tmpNode = (DBSAXNode) nodeStack.pop();// pop out parent node
          //peek out grandParentNode
          DBSAXNode grandParentNode = (DBSAXNode)nodeStack.peek();
          // put parent node back
          nodeStack.push(tmpNode);
          String grandParentTag = grandParentNode.getTagName();
          if (grandParentTag.equals(EML))
+         {
            processTopLeverAccess = true;
+         }
          else
+         {
            // process other access embedded into resource level module
            processOtherAccess = true;
+         }
             tao
+       }
        // create access object
-            tao
+       accessObject = new AccessSection();
-            tao
+         // set permission order
-            tao
+       String permOrder = currentNode.getAttribute(ORDER);
        accessObject.setPermissionOrder(permOrder);
        // set access id
        String accessId = currentNode.getAttribute(ID);
-            tao
+       accessObject.setSubTreeId(accessId);
        accessObject.setStartNodeId(startNodeId);
             tao
+     }
-            tao
+     // Set up a access rule for allow
-            tao
+     else if (parentNode.getTagName() != null &&
-            tao
+       (parentNode.getTagName()).equals(ACCESS) && localName.equals(ALLOW))
             tao
             tao
        accessRule = new AccessRule();
-            tao
+       //set permission type "allow"
        accessRule.setPermissionType(ALLOW);
             tao
             tao
-            tao
+     // set up an access rule for den
      else if (parentNode.getTagName() != null
-            tao
+       && (parentNode.getTagName()).equals(ACCESS) && localName.equals(DENY))
             tao
        accessRule = new AccessRule();
        //set permission type "allow"
        accessRule.setPermissionType(DENY);
+     }
             tao
-            tao
+     // Add the node to the stack, so that any text data can be
      // added as it is encountered
      nodeStack.push(currentNode);
      // Add the node to the vector used by thread for writing XML Index
      nodeIndex.addElement(currentNode);
             tao
-            tao
+    // handle critical subtree
     if (startCriticalSubTree && firstElementForCriticalSubTree)
+    {
       //store the element name
       firstElementNameForCriticalSubTree = qName;
-            tao
+      firstElementForCriticalSubTree = false;
-            tao
+    }//for first element
-            tao
+    // handle critical subtree
     if (startCriticalSubTree)
             tao
       //Get element subtree node stack (element node)
-            tao
+      NodeRecord elementNode = null;
       try
+      {
         elementNode= (NodeRecord) currentUnChangedableSubtreeNodeStack.pop();
+      }
       catch (EmptyStackException ee)
+      {
         MetaCatUtil.debugMessage("Node stack is empty for element data", 35);
         throw new SAXException(PERMISSIONERROR);
+      }
-            tao
+      MetaCatUtil.debugMessage("current node type from xml is ELEMENT", 40);
       MetaCatUtil.debugMessage("node type from stack: " +
                                   elementNode.getNodeType(), 40);
       MetaCatUtil.debugMessage("node name from xml document: " +
                                   localName, 40);
       MetaCatUtil.debugMessage("node name from stack: " +
                                   elementNode.getNodeName(), 40);
       MetaCatUtil.debugMessage("node data from stack: " +
                                   elementNode.getNodeData(), 40);
       MetaCatUtil.debugMessage("node is: "+ elementNode.getNodeId(), 40);
-            tao
+      // if this node is not element or local name not equal or name space not
       // equals, throw an exception
-            tao
+      if (!elementNode.getNodeType().equals("ELEMENT") ||
-            tao
+          !localName.equals(elementNode.getNodeName()))
         //  (uri != null && !uri.equals(elementNode.getNodePrefix())))
             tao
-            tao
+        MetaCatUtil.debugMessage("current node type from xml is ELEMENT", 40);
         MetaCatUtil.debugMessage("node type from stack: " +
                                   elementNode.getNodeType(), 40);
         MetaCatUtil.debugMessage("node name from xml document: " +
                                   localName, 40);
         MetaCatUtil.debugMessage("node name from stack: " +
                                   elementNode.getNodeName(), 40);
         MetaCatUtil.debugMessage("node data from stack: " +
                                   elementNode.getNodeData(), 40);
         MetaCatUtil.debugMessage("node is: "+ elementNode.getNodeId(), 40);
-            tao
+        throw new SAXException(PERMISSIONERROR);
+      }
             tao
       //compare namespace
      Enumeration nameEn = namespaces.keys();
      while ( nameEn.hasMoreElements() )
+     {
        //Get namespacke node stack (element node)
        NodeRecord nameNode = null;
        try
+       {
          nameNode = (NodeRecord) currentUnChangedableSubtreeNodeStack.pop();
+       }
        catch (EmptyStackException ee)
+       {
          MetaCatUtil.debugMessage("Node stack is empty for namespace data", 35);
          throw new SAXException(PERMISSIONERROR);
+       }
        String prefixName = (String)nameEn.nextElement();
        String nameSpaceUri = (String)namespaces.get(prefixName);
        if (!nameNode.getNodeType().equals("NAMESPACE") ||
            !prefixName.equals(nameNode.getNodeName()) ||
            !nameSpaceUri.equals(nameNode.getNodeData()))
+       {
          MetaCatUtil.debugMessage("current node type from xml is NAMESPACE", 40);
          MetaCatUtil.debugMessage("node type from stack: " +
                                   nameNode.getNodeType(), 40);
          MetaCatUtil.debugMessage("current node name from xml is: " +
                                    prefixName, 40);
          MetaCatUtil.debugMessage("node name from stack: " +
                                   nameNode.getNodeName(), 40);
          MetaCatUtil.debugMessage("current node data from xml is: " +
                                    nameSpaceUri, 40);
          MetaCatUtil.debugMessage("node data from stack: " +
                                   nameNode.getNodeData(), 40);
          MetaCatUtil.debugMessage("node is: "+ nameNode.getNodeId(), 40);
          throw new SAXException(PERMISSIONERROR);
+       }
-            tao
+     }//while
             tao
-            tao
+      //compare attributes
       for (int i=0; i<atts.getLength(); i++)
+      {
-            tao
+        NodeRecord attriNode = null;
         try
+        {
           attriNode = (NodeRecord)currentUnChangedableSubtreeNodeStack.pop();
             tao
             tao
         catch (EmptyStackException ee)
+        {
           MetaCatUtil.debugMessage("Node stack is empty for attribute data", 35);
           throw new SAXException(PERMISSIONERROR);
+        }
-            tao
+        String attributeName = atts.getQName(i);
         String attributeValue = atts.getValue(i);
-            tao
+        MetaCatUtil.debugMessage("current node type from xml is ATTRIBUTE ", 40);
         MetaCatUtil.debugMessage("node type from stack: " +
                                    attriNode.getNodeType(), 40);
         MetaCatUtil.debugMessage("current node name from xml is: " +
                                     attributeName, 40);
         MetaCatUtil.debugMessage("node name from stack: " +
                                     attriNode.getNodeName(), 40);
         MetaCatUtil.debugMessage("current node data from xml is: " +
                                     attributeValue, 40);
         MetaCatUtil.debugMessage("node data from stack: " +
                                     attriNode.getNodeData(), 40);
         MetaCatUtil.debugMessage("node is: "+ attriNode.getNodeId(), 40);
-            tao
+        if (!attriNode.getNodeType().equals("ATTRIBUTE") ||
             !attributeName.equals(attriNode.getNodeName()) ||
             !attributeValue.equals(attriNode.getNodeData()))
+        {
-            tao
+          MetaCatUtil.debugMessage("current node type from xml is ATTRIBUTE ", 40);
           MetaCatUtil.debugMessage("node type from stack: " +
                                    attriNode.getNodeType(), 40);
           MetaCatUtil.debugMessage("current node name from xml is: " +
                                     attributeName, 40);
           MetaCatUtil.debugMessage("node name from stack: " +
                                     attriNode.getNodeName(), 40);
           MetaCatUtil.debugMessage("current node data from xml is: " +
                                     attributeValue, 40);
           MetaCatUtil.debugMessage("node data from stack: " +
                                     attriNode.getNodeData(), 40);
           MetaCatUtil.debugMessage("node is: "+ attriNode.getNodeId(), 40);
-            tao
+          throw new SAXException(PERMISSIONERROR);
+        }
-            tao
+      }//for
             tao
             tao
     // reset name space
     namespaces = null;
     namespaces = new Hashtable();
             tao
             tao
             tao
-            tao
+  /** SAX Handler that is called at the end of each XML element */
    public void endElement(String uri, String localName,
                           String qName) throws SAXException
+  {
      MetaCatUtil.debugMessage("End ELEMENT " + qName, 50);
             tao
-            tao
+     // Get the node from the stack
      DBSAXNode currentNode = (DBSAXNode)nodeStack.pop();
-            tao
+     String currentTag = currentNode.getTagName();
             tao
      // If before the end element, the parser hit text nodes and store them
      // into the buffer, write the buffer to data base. The reason we put
      // write database here is for xerces some time split text node
      if (hitTextNode)
+     {
         // get access value
         String data = null;
         // add principal
        if (currentTag.equals(PRINCIPAL) && accessRule != null)
+       {
           data = (textBuffer.toString()).trim();
           accessRule.addPrincipal(data);
+       }
        else if (currentTag.equals(PERMISSION) && accessRule != null)
+       {
          data = (textBuffer.toString()).trim();
          // we conbine different a permission into one value
          int permission = accessRule.getPermission();
          // add permision
-            tao
+         if ( data.toUpperCase().equals(READSTRING) )
             tao
            permission = permission | READ;
+         }
-            tao
+         else if ( data.toUpperCase().equals(WRITESTRING) )
             tao
            permission = permission | WRITE;
+         }
-            tao
+         else if ( data.toUpperCase().equals(CHMODSTRING))
             tao
            permission = permission | CHMOD;
+         }
-            tao
+         else if ( data.toUpperCase().equals(ALLSTRING) )
             tao
           permission = permission | ALL;
+         }
          accessRule.setPermission(permission);
+       }
-            tao
+       // put additionalmetadata/describes into vector
        else if (currentTag.equals(DESCRIBES))
+       {
           data = (textBuffer.toString()).trim();
           describesId.add(data);
+       }
-            tao
+       else if (currentTag.equals(REFERENCES) &&
-            tao
+               (processTopLeverAccess ||
                 processAdditionalAccess || processOtherAccess))
             tao
          // get reference
          data = (textBuffer.toString()).trim();
-            tao
+         // put reference id into accessSection
          accessObject.setReferences(data);
             tao
+       }
-            tao
+       // write text to db if it is not inline data
        if (!localName.equals(INLINE))
+       {
           MetaCatUtil.debugMessage("Write text into DB in End Element", 50);
-            tao
+          //compare whitespace if need
           if (startCriticalSubTree)
+          {
             NodeRecord node = null;
             try
+            {
               node = (NodeRecord)currentUnChangedableSubtreeNodeStack.pop();
+            }
             catch (EmptyStackException ee)
+            {
               MetaCatUtil.debugMessage("the stack is empty for text data", 32);
               throw new SAXException(PERMISSIONERROR);
+            }
-            tao
+            MetaCatUtil.debugMessage("current node type from xml is TEXT in endElement", 40);
             MetaCatUtil.debugMessage("node type from stack: " +
                                         node.getNodeType(), 40);
             MetaCatUtil.debugMessage("current node data from xml is: " +
                                         textBuffer.toString(), 40);
             MetaCatUtil.debugMessage("node data from stack: " +
                                         node.getNodeData(), 40);
             MetaCatUtil.debugMessage("node name from stack: " +
                                         node.getNodeName(), 40);
             MetaCatUtil.debugMessage("node is from stack: " +
                                         node.getNodeId(), 40);
-            tao
+            if (!node.getNodeType().equals("TEXT") ||
                !(textBuffer.toString()).equals(node.getNodeData()))
+            {
               MetaCatUtil.debugMessage("current node type from xml is TEXT in endElement", 40);
               MetaCatUtil.debugMessage("node type from stack: " +
                                         node.getNodeType(), 40);
               MetaCatUtil.debugMessage("current node data from xml is: " +
                                         textBuffer.toString(), 40);
               MetaCatUtil.debugMessage("node data from stack: " +
                                         node.getNodeData(), 40);
               MetaCatUtil.debugMessage("node name from stack: " +
                                         node.getNodeName(), 40);
               MetaCatUtil.debugMessage("node is from stack: " +
                                         node.getNodeId(), 40);
               throw new SAXException(PERMISSIONERROR);
             }//if
           }//if
-            tao
+          endNodeId = writeTextForDBSAXNode(textBuffer, currentNode);
+       }
        else
+       {
-            tao
+          MetaCatUtil.debugMessage("Write inline data into file system", 35);
             tao
           //check if user changed inine data or not if user doesn't have
           // write permission
           if (startCriticalSubTree)
+          {
             NodeRecord node = null;
             String inlineData;
             try
+            {
               node = (NodeRecord)currentUnChangedableSubtreeNodeStack.pop();
               // get file name from db
               String fileName = node.getNodeData();
               MetaCatUtil.debugMessage("in handle inline data", 35);
               MetaCatUtil.debugMessage("the inline data file name from node is: "+
                                       fileName, 40);
               inlineData = readInlineDataFromFileSystem(fileName);
+            }
             catch (EmptyStackException ee)
+            {
               MetaCatUtil.debugMessage("the stack is empty for text data", 32);
               throw new SAXException(PERMISSIONERROR);
+            }
             catch (McdbException eee)
+            {
               throw new SAXException(eee.getMessage());
+            }
             if (!(textBuffer.toString()).equals(inlineData))
+            {
               MetaCatUtil.debugMessage("inline data was changed by a user" +
                                        " who doesn't have permission", 30);
               throw new SAXException(PERMISSIONERROR);
             }//if
           }//if
-            tao
+          // write inline data into file system and return file name
           textBuffer = writeInlineDataIntoFile(textBuffer);
           // write file name into db
           endNodeId = writeTextForDBSAXNode(textBuffer, currentNode);
+       }
-            tao
+     }//if
-            tao
+     //end crtical subtree(user doesn't have permission to write)
      //When reach the first element and stack is empty
      if (localName.equals(firstElementNameForCriticalSubTree) &&
          currentUnChangedableSubtreeNodeStack.isEmpty())
+     {
        startCriticalSubTree = false;
+     }
-            tao
+     //set hitText false
      hitTextNode = false;
      // reset textbuff
      textBuffer = null;
      textBuffer = new StringBuffer();
             tao
      // hand sub stree stuff
-            tao
+     if (!subTreeInfoStack.empty())
+     {
        SubTree tree = (SubTree)subTreeInfoStack.peek();// get last subtree
        if (tree != null && tree.getStartElementName() != null &&
-            tao
+         (tree.getStartElementName()).equals(currentTag))
             tao
          // find the end of sub tree and set the end node id
          tree.setEndNodeId(endNodeId);
          // add the subtree into the final store palace
          subTreeList.add(tree);
          // get rid of it from stack
          subTreeInfoStack.pop();
        }//if
      }//if
             tao
-            tao
+     // access stuff
-            tao
+     if (currentTag.equals(ALLOW) || currentTag.equals(DENY))
             tao
-            tao
+       // finish parser a ccess rule and  assign it to new one
        AccessRule newRule = accessRule;
-            tao
+       //add the new rule to access section object
        accessObject.addAccessRule(newRule);
-            tao
+       // reset access rule
-            tao
+       accessRule = null;
+     }
-            tao
+     else if (currentTag.equals(ACCESS))
             tao
-            tao
+       // finish parse a access setction and assign it to new one
-            tao
+       accessObject.setEndNodeId(endNodeId);
-            tao
+       AccessSection newAccessObject = accessObject;
-            tao
+       if (newAccessObject != null)
             tao
-            tao
+        // add the accessSection into a vector to store it
-            tao
+        // if it is not a reference, need to store it
         if ( newAccessObject.getReferences() == null)
+        {
           accessObjectList.add(newAccessObject);
+        }
-            tao
+        if (processTopLeverAccess)
+        {
           // top level access control will handle whole document -docid
           topLevelAccessControlMap.put(docid, newAccessObject);
           // reset processtopleveraccess tag
         }//if
         else if (processAdditionalAccess)
+        {
           // for additional control
           // put everything in describes value and access object into hash
             tao
-            tao
+          for ( int i=0; i<describesId.size(); i++)
+          {
             tao
-            tao
+            String subId = (String)describesId.elementAt(i);
             if (subId != null)
+            {
               additionalAccessControlMap.put(subId, newAccessObject);
             }//if
           }//for
-            tao
+          // add this hashtable in to vector
             tao
-            tao
+          additionalAccessMapList.add(additionalAccessControlMap);
           // reset this hashtable in order to store another additional
           //accesscontrol
           additionalAccessControlMap = null;
           additionalAccessControlMap = new Hashtable();
-            tao
+        }//if
        }//if
-            tao
+       //reset access section object
        accessObject = null;
-            tao
+       // reset flag
        processAdditionalAccess =false;
        processTopLeverAccess =false;
-            tao
+       processOtherAccess = false;
             tao
-            tao
+     else if (currentTag.equals(ADDITIONALMETADATA))
             tao
         //reset describesId
-            tao
+        describesId = null;
-            tao
+        describesId = new Vector();
+     }
             tao
             tao
-            tao
+   /**
     * SAX Handler that receives notification of comments in the DTD
     */
    public void comment(char[] ch, int start, int length) throws SAXException {
      MetaCatUtil.debugMessage("COMMENT", 50);
      if ( !processingDTD )
+     {
        DBSAXNode currentNode = (DBSAXNode)nodeStack.peek();
        String str = new String(ch, start, length);
        //compare comment if need
        if (startCriticalSubTree)
+       {
          NodeRecord node = null;
          try
+         {
            node = (NodeRecord)currentUnChangedableSubtreeNodeStack.pop();
+         }
          catch (EmptyStackException ee)
+         {
            MetaCatUtil.debugMessage("the stack is empty for comment data", 32);
            throw new SAXException(PERMISSIONERROR);
+         }
-            tao
+         MetaCatUtil.debugMessage("current node type from xml is COMMENT", 40);
          MetaCatUtil.debugMessage("node type from stack: " +
                                     node.getNodeType(), 40);
          MetaCatUtil.debugMessage("current node data from xml is: " +
                                     str, 40);
          MetaCatUtil.debugMessage("node data from stack: " +
                                     node.getNodeData(), 40);
          MetaCatUtil.debugMessage("node is from stack: " +
                                         node.getNodeId(), 40);
-            tao
+         if (!node.getNodeType().equals("COMMENT") ||
              !str.equals(node.getNodeData()))
+         {
           MetaCatUtil.debugMessage("current node type from xml is COMMENT", 40);
           MetaCatUtil.debugMessage("node type from stack: " +
                                     node.getNodeType(), 40);
           MetaCatUtil.debugMessage("current node data from xml is: " +
                                     str, 40);
           MetaCatUtil.debugMessage("node data from stack: " +
                                     node.getNodeData(), 40);
           MetaCatUtil.debugMessage("node is from stack: " +
                                         node.getNodeId(), 40);
           throw new SAXException(PERMISSIONERROR);
         }//if
        }//if
        endNodeId = currentNode.writeChildNodeToDB("COMMENT", null, str, docid);
+     }
+   }
       /**
     * SAX Handler that is called for each XML text node that is
     * Ignorable white space
     */
    public void ignorableWhitespace(char[] cbuf, int start, int len)
                throws SAXException
+  {
      // When validation is turned "on", white spaces are reported here
      // When validation is turned "off" white spaces are not reported here,
      // but through characters() callback
      MetaCatUtil.debugMessage("IGNORABLEWHITESPACE", 50);
      DBSAXNode currentNode = (DBSAXNode)nodeStack.peek();
      String data = null;
      int leftover = len;
      int offset = start;
      boolean moredata = true;
      // This loop deals with the case where there are more characters
      // than can fit in a single database text field (limit is
      // MAXDATACHARS).  If the text to be inserted exceeds MAXDATACHARS,
      // write a series of nodes that are MAXDATACHARS long, and then the
      // final node contains the remainder
      while (moredata)
+     {
        if (leftover > MAXDATACHARS)
+       {
          data = new String(cbuf, offset, MAXDATACHARS);
          leftover -= MAXDATACHARS;
          offset += MAXDATACHARS;
+       }
        else
+       {
          data = new String(cbuf, offset, leftover);
          moredata = false;
+       }
        //compare whitespace if need
        if (startCriticalSubTree)
+       {
          NodeRecord node = null;
          try
+         {
            node = (NodeRecord)currentUnChangedableSubtreeNodeStack.pop();
+         }
          catch (EmptyStackException ee)
+         {
            MetaCatUtil.debugMessage("the stack is empty for whitespace data", 32);
            throw new SAXException(PERMISSIONERROR);
+         }
          if (!node.getNodeType().equals("TEXT") ||
              !data.equals(node.getNodeData()))
+         {
           MetaCatUtil.debugMessage("current node type from xml is WHITESPACE TEXT", 40);
           MetaCatUtil.debugMessage("node type from stack: " +
                                     node.getNodeType(), 40);
           MetaCatUtil.debugMessage("current node data from xml is: " +
                                     data, 40);
           MetaCatUtil.debugMessage("node data from stack: " +
                                     node.getNodeData(), 40);
           MetaCatUtil.debugMessage("node is from stack: " +
                                         node.getNodeId(), 40);
           throw new SAXException(PERMISSIONERROR);
         }//if
        }//if
        // Write the content of the node to the database
        endNodeId = currentNode.writeChildNodeToDB("TEXT", null, data, docid);
+     }
+   }
-            tao
+   /** SAX Handler that receives notification of end of the document */
    public void endDocument() throws SAXException
             tao
-            tao
+     MetaCatUtil.debugMessage("end Document", 50);
-            tao
+     // There are some unchangable subtree didn't be compare
      // This maybe cause user change the subtree id
      if (!unChangableSubTreeHash.isEmpty())
+     {
        MetaCatUtil.debugMessage("The unChangealbe subtree is not empty", 40);
        throw new SAXException(PERMISSIONERROR);
+     }
-            tao
+     // write access rule to db
      writeAccessRuleToDB();
             tao
-            tao
+     // Starting new thread for writing XML Index.
      // It calls the run method of the thread.
      try
+     {
        xmlIndex.start();
+     }
      catch (NullPointerException e)
+     {
        xmlIndex = null;
        throw new
        SAXException("Problem with starting thread for writing XML Index. " +
                     e.getMessage());
+     }
             tao
             tao
             tao
   /* The method to write all access rule intodb */
-            tao
+  private void writeAccessRuleToDB() throws SAXException
+  {
-            tao
+    //Delete old permssion
     deletePermissionsInAccessTable(docid);
-            tao
+    //write top leve access rule
     writeTopLevelAccessRuleToDB();
     //write additional access rule
-            tao
+    //writeAddtionalAccessRuleToDB();
-            tao
+  }//writeAccessRuleToDB
   /* The method to write top level access rule into db. */
   private void writeTopLevelAccessRuleToDB() throws SAXException
+  {
             tao
-            tao
+    // for top document level
-            tao
+    Object accessSection = topLevelAccessControlMap.get(docid);
-            tao
+    boolean top = true;
     String subSectionId = null;
-            tao
+    if ( accessSection != null )
             tao
-            tao
+       AccessSection accessSectionObj = (AccessSection)accessSection;
-            tao
+       // write the top level access module into xml_accesssubtree to store info
        // and then when update to check if the user can update it or not
        deleteAccessSubTreeRecord(docid);
        writeAccessSubTreeIntoDB(accessSectionObj,TOPLEVEL);
-            tao
+       // if accessSection is not null and is not reference
        if ( accessSectionObj.getReferences() == null)
+       {
           writeGivenAccessRuleIntoDB(accessSectionObj, top, subSectionId);
+       }
        else
+       {
         // this is a reference and go trough the vector which contains all
         // access object
         String referenceId = accessSectionObj.getReferences();
         boolean findAccessObject = false;
         MetaCatUtil.debugMessage("referered id for top access: "+
                                referenceId, 35);
         for (int i=0; i<accessObjectList.size(); i++)
+        {
           AccessSection accessObj = (AccessSection)accessObjectList.elementAt(i);
-            tao
+          String accessObjId = accessObj.getSubTreeId();
-            tao
+          if (referenceId != null && accessObj != null &&
               referenceId.equals(accessObjId))
+          {
             writeGivenAccessRuleIntoDB(accessObj, top, subSectionId);
-            tao
+            // write the reference access into xml_accesssubtree too
             writeAccessSubTreeIntoDB(accessObj, SUBTREELEVEL);
-            tao
+            findAccessObject = true;
+          }
         }//for
         // if we couldn't find an access subtree id for this reference id
         if (!findAccessObject)
+        {
           throw new SAXException("The referenceid: " + referenceId +
                                " is not access subtree");
         }//if
       }//else
-            tao
+    }//if
     else
+    {
-            tao
+      // couldn't find a access section object
       MetaCatUtil.debugMessage("couldn't find access control for document: "+
                                 docid, 35);
             tao
             tao
   }//writeTopLevelAccessRuletoDB
             tao
-            tao
+   /* The method to write addtional access rule into db. */
   private void writeAddtionalAccessRuleToDB() throws SAXException
+  {
      PreparedStatement pstmt = null;
-            tao
+     boolean topLevel =false;
     // go through the vector which contains the additional access control
     //hashtable. Each hashtable has info for one additonalmetadata container
    for (int j= 0; j < additionalAccessMapList.size(); j++)
+   {
      Hashtable accessControlMap =
                                 (Hashtable)additionalAccessMapList.elementAt(j);
-            tao
+     // additional access rule
-            tao
+     Enumeration en = accessControlMap.keys();
-            tao
+     while(en.hasMoreElements())
             tao
-            tao
+       try
+       {
          // Get subsection id
           String subSectionId = (String)en.nextElement();
-            tao
+          MetaCatUtil.debugMessage("sub section id in additional access mapping"
-            tao
+                                   +"(go through): "+ subSectionId, 35);
             tao
           if (subSectionId == null)
+          {
-            tao
+            // if id is null, terminate the program
             throw new SAXException("subtree id is null");
             tao
           // Get AccessSection Object
-            tao
+          Object accessSectionObj = accessControlMap.get(subSectionId);
           if (accessSectionObj == null)
             tao
-            tao
+            // if accesssection is null, terminate the program
             throw new SAXException("access subtree is null");
             tao
           else
+          {
-            tao
+            AccessSection accessControlObj = (AccessSection)accessSectionObj;
             // if the access section is not references, write it to db
             if (accessControlObj.getReferences() == null)
             tao
-            tao
+              writeGivenAccessRuleIntoDB(accessControlObj, topLevel,
                                          subSectionId);
+            }
             else
+            {
               // this is a reference and go trough the vector which contains all
               // access object
               String referenceId = accessControlObj.getReferences();
               boolean findAccessObject = false;
               MetaCatUtil.debugMessage("referered id for additional access "+
                                      "mapping(go through): "+ referenceId, 35);
               for (int i=0; i<accessObjectList.size(); i++)
+              {
                 AccessSection accessObj =
-            tao
+                                (AccessSection)accessObjectList.elementAt(i);
-            tao
+                String accessObjId = accessObj.getSubTreeId();
-            tao
+                MetaCatUtil.debugMessage("access obj id in the list(go through): "
                                         + accessObjId, 35);
                 if (referenceId != null && accessObj != null &&
                     referenceId.equals(accessObjId))
+                {
                   writeGivenAccessRuleIntoDB(accessObj, topLevel, subSectionId);
                   findAccessObject = true;
                 }//if
               }//for
               // if we couldn't find an access subtree id for this reference id
               if (!findAccessObject)
             tao
-            tao
+                throw new SAXException("The referenceid: " + referenceId +
                                " is not access subtree");
-            tao
+              }//if
-            tao
+            }//else
           }//else
-            tao
+       }//try
        catch (Exception e)
+       {
             tao
-            tao
+         MetaCatUtil.debugMessage("error in EmlSAXHandler.writeAddtionalAccess"
                                    + ": "+e.getMessage(), 30);
-            tao
+         throw new SAXException(e.getMessage());
             tao
-            tao
+     }//while
     }//for
-            tao
+  }//writeAccessRuletoDB
   /* Write a gaven access rule into db*/
   private void writeGivenAccessRuleIntoDB(AccessSection accessSection,
                                          boolean topLevel, String subSectionId)
                                          throws SAXException
+  {
      if (accessSection == null)
+     {
        throw new SAXException("The access object is null");
+     }
             tao
-            tao
+      String permOrder = accessSection.getPermissionOrder();
       String sql = null;
       PreparedStatement pstmt = null;
       if (topLevel)
             tao
-            tao
+        sql = "INSERT INTO xml_access (docid, principal_name, permission, "+
                  "perm_type, perm_order, accessfileid) VALUES " +
                  " (?, ?, ?, ?, ?, ?)";
+      }
       else
             tao
-            tao
+        sql ="INSERT INTO xml_access (docid,principal_name, "+
              "permission, perm_type, perm_order, accessfileid, subtreeid, "+
              " startnodeid, endnodeid) VALUES" +
              " (?, ?, ?, ?, ?, ?, ?, ?, ?)";
             tao
-            tao
+      try
             tao
             tao
         pstmt = connection.prepareStatement(sql);
         // Increase DBConnection usage count
         connection.increaseUsageCount(1);
         // Bind the values to the query
         pstmt.setString(1, docid);
-            tao
+        MetaCatUtil.debugMessage("Docid in accesstable: "+ docid, 35);
-            tao
+        pstmt.setString(6, docid);
-            tao
+        MetaCatUtil.debugMessage("Accessfileid in accesstable: "+ docid, 35);
-            tao
+        pstmt.setString(5, permOrder);
-            tao
+        MetaCatUtil.debugMessage("PermOder in accesstable: "+ permOrder, 35);
-            tao
+        // if it is not top level, set subsection id
         if (!topLevel)
+        {
-            tao
+          long startNodeId = 0;
           long endNodeId = 0;
           // for subtree should specify the
           if (subSectionId == null)
+          {
             throw new SAXException("The subsection is null");
+          }
           // go through the substree list vector and found the start node id
           // and stop node id for this subtree id
           for (int i=0; i<subTreeList.size(); i++)
+          {
             SubTree tree = (SubTree)subTreeList.elementAt(i);
             String subTreeId = tree.getSubTreeId();
             if (subSectionId.equals(subTreeId))
+            {
               startNodeId = tree.getStartNodeId();
               endNodeId = tree.getEndNodeId();
             }//if
           }//for
           if (startNodeId == 0 || endNodeId == 0)
+          {
             throw new SAXException("Could find the subtree"
                                    + "for this id: "+subSectionId);
+          }
-            tao
+          pstmt.setString(7, subSectionId);
           MetaCatUtil.debugMessage("SubSectionId in accesstable: "+
-            tao
+                                    subSectionId, 35);
-            tao
+          pstmt.setLong(8, startNodeId);
-            tao
+          MetaCatUtil.debugMessage("Start node id is: " + startNodeId, 35);
-            tao
+          pstmt.setLong(9, endNodeId);
-            tao
+          MetaCatUtil.debugMessage("End node id is: " + endNodeId, 35);
             tao
             tao
         Vector accessRules = accessSection.getAccessRules();
         // go through every rule
         for (int i=0; i<accessRules.size(); i++)
+        {
           AccessRule rule = (AccessRule)accessRules.elementAt(i);
           String permType = rule.getPermissionType();
           int permission = rule.getPermission();
           pstmt.setInt(3, permission);
-            tao
+          MetaCatUtil.debugMessage("permission in accesstable: "+ permission, 35);
-            tao
+          pstmt.setString(4, permType);
-            tao
+          MetaCatUtil.debugMessage("Permtype in accesstable: "+ permType, 35);
-            tao
+          // go through every principle in rule
           Vector nameVector = rule.getPrincipal();
           for ( int j = 0; j < nameVector.size(); j++ )
+          {
             String prName = (String)nameVector.elementAt(j);
             pstmt.setString(2, prName);
-            tao
+            MetaCatUtil.debugMessage("Principal in accesstable: "+prName, 35);
-            tao
+            pstmt.execute();
           }//for
         }//for
         pstmt.close();
       }//try
       catch (SQLException e)
+      {
-            tao
+        throw new
-            tao
+        SAXException("EMLSAXHandler.writeAccessRuletoDB(): " + e.getMessage());
       }//catch
       finally
+      {
         try
+        {
           pstmt.close();
+        }
         catch(SQLException ee)
+        {
           throw new
           SAXException("EMLSAXHandler.writeAccessRuletoDB(): " +
           ee.getMessage());
+        }
       }//finally
             tao
-            tao
+  }//writeGivenAccessRuleIntoDB
   /* Delete from db all permission for resources related to @aclid if any.*/
   private void deletePermissionsInAccessTable(String aclid)
           throws SAXException
+  {
     Statement stmt = null;
     try
+    {
       // delete all acl records for resources related to @aclid if any
       stmt = connection.createStatement();
       // Increase DBConnection usage count
       connection.increaseUsageCount(1);
       stmt.execute("DELETE FROM xml_access WHERE accessfileid = '" + aclid +
                    "'");
+    }
     catch (SQLException e)
+    {
       throw new SAXException(e.getMessage());
+    }
     finally
+    {
       try
+      {
         stmt.close();
+      }
       catch (SQLException ee)
+      {
         throw new SAXException(ee.getMessage());
+      }
+    }
-            tao
+  }//deletePermissionsInAccessTable
             tao
   /* In order to make sure only usr has "all" permission can update access
    * subtree in eml document we need to keep access subtree info in
    * xml_accesssubtree table, such as docid, version, startnodeid, endnodeid
    */
   private void writeAccessSubTreeIntoDB(AccessSection accessSection,
                                          String level)
                                          throws SAXException
+  {
      if (accessSection == null)
+     {
        throw new SAXException("The access object is null");
+     }
       String sql = null;
       PreparedStatement pstmt = null;
       sql = "INSERT INTO xml_accesssubtree (docid, rev, controllevel, "+
                  "subtreeid, startnodeid, endnodeid) VALUES " +
                  " (?, ?, ?, ?, ?, ?)";
       try
+      {
         pstmt = connection.prepareStatement(sql);
         // Increase DBConnection usage count
         connection.increaseUsageCount(1);
         long startNodeId = accessSection.getStartNodeId();
         long endNodeId = accessSection.getEndNodeId();
         String sectionId = accessSection.getSubTreeId();
         // Bind the values to the query
         pstmt.setString(1, docid);
         MetaCatUtil.debugMessage("Docid in access-subtreetable: "+ docid, 35);
         pstmt.setString(2, revision );
         MetaCatUtil.debugMessage("rev in accesssubtreetable: "+ revision, 35);
         pstmt.setString(3, level);
         MetaCatUtil.debugMessage("contorl level in access-subtree table: "+
                                   level, 35);
         pstmt.setString(4, sectionId);
         MetaCatUtil.debugMessage("Subtree id in access-subtree table: "+
                                   sectionId, 35);
         pstmt.setLong(5, startNodeId);
         MetaCatUtil.debugMessage("Start node id is: " + startNodeId, 35);
         pstmt.setLong(6, endNodeId);
         MetaCatUtil.debugMessage("End node id is: " + endNodeId, 35);
         pstmt.execute();
         pstmt.close();
       }//try
       catch (SQLException e)
+      {
         throw new
         SAXException("EMLSAXHandler.writeAccessSubTreeIntoDB(): " +
                       e.getMessage());
       }//catch
       finally
+      {
         try
+        {
           pstmt.close();
+        }
         catch(SQLException ee)
+        {
           throw new
           SAXException("EMLSAXHandler.writeAccessSubTreeIntoDB(): " +
           ee.getMessage());
+        }
       }//finally
   }//writeAccessSubtreeIntoDB
    /* Delete every access subtree record from xml_accesssubtree.*/
   private void deleteAccessSubTreeRecord(String docId) throws SAXException
+  {
     Statement stmt = null;
     try
+    {
       // delete all acl records for resources related to @aclid if any
       stmt = connection.createStatement();
       // Increase DBConnection usage count
       connection.increaseUsageCount(1);
       stmt.execute("DELETE FROM xml_accesssubtree WHERE docid = '" + docId + "'");
+    }
     catch (SQLException e)
+    {
       throw new SAXException(e.getMessage());
+    }
     finally
+    {
       try
+      {
         stmt.close();
+      }
       catch (SQLException ee)
+      {
         throw new SAXException(ee.getMessage());
+      }
+    }
   }//deleteAccessSubTreeRecord
-            tao
+  // write inline data into file system and return file name(without path)
   private StringBuffer writeInlineDataIntoFile(StringBuffer data)
                                                throws SAXException
+  {
     StringBuffer fileNameBuffer = null;
     String fileName = null;
     String docidWithoutRev = MetaCatUtil.getDocIdFromString(docid);
     String path = MetaCatUtil.getOption("inlinedatafilepath");
     String seperator = MetaCatUtil.getOption("accNumSeparator");
     // the new file name will look like path/docid.rev.2
     fileName = docidWithoutRev + seperator+revision+seperator +inLineDataIndex;
     File inlineDataDirectory = new File(path);
     File newFile = new File(inlineDataDirectory, fileName);
     // incease inLinedataindex for next one
     inLineDataIndex++ ;
     try
+    {
       FileWriter writer = new FileWriter(newFile);
       writer.write(data.toString());
-            tao
+      writer.close();
             tao
     catch (Exception e)
+    {
       throw new SAXException(e.getMessage());
+    }
     fileNameBuffer = new StringBuffer(fileName);
     return fileNameBuffer;
             tao
             tao
   /* In eml2, the inline data wouldn't store in db, it store in file system
    * The db stores file name(without path).
    */
   public static String readInlineDataFromFileSystem(String fileName)
                                               throws McdbException
+  {
     String data = null;
     String path = MetaCatUtil.getOption("inlinedatafilepath");
     // the new file name will look like path/docid.rev.2
     File inlineDataDirectory = new File(path);
     File dataFile = new File(inlineDataDirectory, fileName);
     try
+    {
       FileReader fileReader = new FileReader(dataFile);
       BufferedReader stringReader = new BufferedReader(fileReader);
       // read first line of data
       String tmp = stringReader.readLine();
       // pass first line data to data varible
       data = tmp;
       // at the end tmp will be null
       while (tmp != null)
+      {
         // read a new line
         tmp = stringReader.readLine();
         // append new line to data
         if (tmp != null)
+        {
           data = data+tmp;
+        }
+      }
+    }
     catch (Exception e)
+    {
       throw new McdbException(e.getMessage());
+    }
     MetaCatUtil.debugMessage("the inline data retrieve from file: "+data, 50);
     return data;
+  }
             tao

Project

General

Profile

Metacat