Metacat

/**

 *  '$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: tao $'

 *     '$Date: 2003-03-18 14:14:15 -0800 (Tue, 18 Mar 2003) $'

 * '$Revision: 1481 $'

 *

 * 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.*;

import java.io.File;

import java.io.FileWriter;

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();

   private boolean processTopLeverAccess = false;

   private boolean processAdditionalAccess = false;

   private AccessSection accessObject= null;

   private AccessRule accessRule = null;

   private Vector accessObjectList = new Vector(); // store every access rule

   private Hashtable topLevelAccessControlMap = new Hashtable();

   private Hashtable additionalAccessControlMap = new Hashtable();// store 

                                                 //subtree access for single

                                                 // additionalmetacat

   private Vector additionalAccessMapList = new Vector();// store maps for 

                                                       // every addionalmetadata

   private Vector describesId = new Vector(); // store the ids in

                                      //additionalmetadata/describes

   private Stack subTreeInfoStack = new Stack();

   private Vector subTreeList = new Vector();// store the final subtree

   private int inLineDataIndex = 1;

   // Constant

   private static final String DESCRIBES = "describes";

   private static final String ADDITIONALMETADATA = "additionalMetadata";

   private static final String ORDER = "order";

   private static final String ID ="id";

   private static final String REFERENCES = "references";

   public  static final String INLINE = "inline";

    /** 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)

   {

     super(conn, action, docid, revision, user, groups, pub, serverCode);

   }

   /** 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

     try 

     {

       parentNode = (DBSAXNode)nodeStack.peek();

     } 

     catch (EmptyStackException e) 

     {

       parentNode = null;

     }

     // 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)

     {

       // write the textbuffer into db for parent node.

        endNodeId = writeTextForDBSAXNode(textBuffer, parentNode);

        // rest hitTextNode

        hitTextNode =false;

        // reset textbuffer

        textBuffer = null;

        textBuffer = new StringBuffer();

     }

     // 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);

       try 

       {

         // 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;

         if ( systemid != null ) 

         {

           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);

       } 

       catch (Exception ane) 

       {

         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());

     // 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();

     // Add all of the namespaces

     String prefix;

     String nsuri;

     Enumeration prefixes = namespaces.keys();

     while ( prefixes.hasMoreElements() ) 

     {

       prefix = (String)prefixes.nextElement();

       nsuri = (String)namespaces.get(prefix);

       endNodeId = currentNode.setNamespace(prefix, nsuri, docid);

     }

     namespaces = null;

     namespaces = new Hashtable();

     // Add all of the attributes

     for (int i=0; i<atts.getLength(); i++) 

     {

       String attributeName = atts.getQName(i);

       String attributeValue = atts.getValue(i);

       endNodeId = 

                currentNode.setAttribute(attributeName, attributeValue, docid);

       // 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();

       }

       else if (attributeName !=null && attributeName.equals(ID))

       {

         // 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);

       }

     }

     // handle access stuff

     if (localName.equals(ACCESS))

     {

       // if it is in addtionalmetacat

       if (parentNode.getTagName() == ADDITIONALMETADATA)

       {

         processAdditionalAccess = true;

       }

       else

       {

         processTopLeverAccess = true;

       }

       // create access object 

        accessObject = new AccessSection();

         // set permission order

       String permOrder = currentNode.getAttribute(ORDER);

       accessObject.setPermissionOrder(permOrder);

       // set access id

       String accessId = currentNode.getAttribute(ID);

       accessObject.setAccessSectionId(accessId);

     }

     // Set up a access rule for allow

     else if (parentNode.getTagName() != null && 

       (parentNode.getTagName()).equals(ACCESS) && localName.equals(ALLOW))

     {

       accessRule = new AccessRule(); 

       //set permission type "allow"

       accessRule.setPermissionType(ALLOW);

     }

     // set up an access rule for den

     else if (parentNode.getTagName() != null 

       && (parentNode.getTagName()).equals(ACCESS) && localName.equals(DENY))

     {

       accessRule = new AccessRule();

       //set permission type "allow"

       accessRule.setPermissionType(DENY);

     }

     // 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);

  }

  /** 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);

     // Get the node from the stack

     DBSAXNode currentNode = (DBSAXNode)nodeStack.pop();

     String currentTag = currentNode.getTagName();

     // 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

         if ( data.toUpperCase().equals(READSTRING) ) 

         {

           permission = permission | READ;

         } 

         else if ( data.toUpperCase().equals(WRITESTRING) ) 

         {

           permission = permission | WRITE;

         } 

         else if ( data.toUpperCase().equals(CHMODSTRING)) 

         {

           permission = permission | CHMOD;

         } 

         else if ( data.toUpperCase().equals(ALLSTRING) ) 

         {

          permission = permission | ALL;

         }

         accessRule.setPermission(permission);

       }

       // put additionalmetadata/describes into vector

       else if (currentTag.equals(DESCRIBES))

       {

          data = (textBuffer.toString()).trim();

          describesId.add(data);

       }

       else if (currentTag.equals(REFERENCES) && 

               (processTopLeverAccess||processAdditionalAccess))

       {

         // get reference 

         data = (textBuffer.toString()).trim();

         // put reference id into accessSection

         accessObject.setReferences(data);

       }

       // write text to db if it is not inline data

       if (!localName.equals(INLINE))

       {

          MetaCatUtil.debugMessage("Write text into DB in End Element", 50);

          endNodeId = writeTextForDBSAXNode(textBuffer, currentNode);

       }

       else

       {

          MetaCatUtil.debugMessage("Write inline data into file system", 35);

          // write inline data into file system and return file name

          textBuffer = writeInlineDataIntoFile(textBuffer);

          // write file name into db

          endNodeId = writeTextForDBSAXNode(textBuffer, currentNode);

       }

     }//if

     //set hitText false

     hitTextNode = false;

     // reset textbuff

     textBuffer = null;

     textBuffer = new StringBuffer();

     // hand sub stree stuff

     if (!subTreeInfoStack.empty())

     {

       SubTree tree = (SubTree)subTreeInfoStack.peek();// get last subtree

       if (tree != null && tree.getStartElementName() != null && 

         (tree.getStartElementName()).equals(currentTag))

       {

         // 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

     // access stuff

     if (currentTag.equals(ALLOW) || currentTag.equals(DENY))

     {

       // finish parser a ccess rule and  assign it to new one

       AccessRule newRule = accessRule;

       //add the new rule to access section object

       accessObject.addAccessRule(newRule);

       // reset access rule

       accessRule = null;

     }

     else if (currentTag.equals(ACCESS))

     {

       // finish parse a access setction and assign it to new one

       AccessSection newAccessObject = accessObject;

       if (newAccessObject != null)

       {

        // add the accessSection into a vector to store it

        // if it is not a reference, need to store it

        if ( newAccessObject.getReferences() == null)

        {

          accessObjectList.add(newAccessObject);

        }

        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

          for ( int i=0; i<describesId.size(); i++)

          {

            String subId = (String)describesId.elementAt(i);

            if (subId != null)

            {

              additionalAccessControlMap.put(subId, newAccessObject);

            }//if

          }//for

          // add this hashtable in to vector

          additionalAccessMapList.add(additionalAccessControlMap);

          // reset this hashtable in order to store another additional 

          //accesscontrol

          additionalAccessControlMap = null;

          additionalAccessControlMap = new Hashtable();

        }//if

       }//if

       //reset access section object

       accessObject = null;

       // reset flag

       processAdditionalAccess =false;

       processTopLeverAccess =false;

     }

     else if (currentTag.equals(ADDITIONALMETADATA))

     {

        //reset describesId

        describesId = null;

        describesId = new Vector();

     }

   }

   /** SAX Handler that receives notification of end of the document */

   public void endDocument() throws SAXException 

   {

     MetaCatUtil.debugMessage("end Document", 50);

     // write access rule to db

     writeAccessRuleToDB();

     // 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());

     }

   }

  /* The method to write all access rule intodb */

  private void writeAccessRuleToDB() throws SAXException

  {

    //Delete old permssion

    deletePermissionsInAccessTable(docid);

    //write top leve access rule

    writeTopLevelAccessRuleToDB();

    //write additional access rule

    writeAddtionalAccessRuleToDB();

  }//writeAccessRuleToDB

  /* The method to write top level access rule into db. */

  private void writeTopLevelAccessRuleToDB() throws SAXException

  {

    // for top document level

    Object accessSection = topLevelAccessControlMap.get(docid);

    boolean top = true;

    String subSectionId = null;

    if ( accessSection != null )

    {

       AccessSection accessSectionObj = (AccessSection)accessSection;

       // 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);

          String accessObjId = accessObj.getAccessSectionId();

          if (referenceId != null && accessObj != null &&

              referenceId.equals(accessObjId))

          {

            writeGivenAccessRuleIntoDB(accessObj, top, subSectionId);

            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

    }//if

    else

    {

      // couldn't find a access section object 

      MetaCatUtil.debugMessage("couldn't find access control for document: "+

                                docid, 35);

    }

  }//writeTopLevelAccessRuletoDB

   /* The method to write addtional access rule into db. */

  private void writeAddtionalAccessRuleToDB() throws SAXException

  {

     PreparedStatement pstmt = null;

     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);

     // additional access rule

     Enumeration en = accessControlMap.keys();

     while(en.hasMoreElements())

     {

       try

       {

         // Get subsection id

          String subSectionId = (String)en.nextElement();

          MetaCatUtil.debugMessage("sub section id in additional access mapping"

                                   +"(go through): "+ subSectionId, 35);

          if (subSectionId == null)

          {

            // if id is null, terminate the program

            throw new SAXException("subtree id is null");

          }

          // Get AccessSection Object

          Object accessSectionObj = accessControlMap.get(subSectionId);

          if (accessSectionObj == null)

          {

            // if accesssection is null, terminate the program

            throw new SAXException("access subtree is null");

          }

          else

          {

            AccessSection accessControlObj = (AccessSection)accessSectionObj;

            // if the access section is not references, write it to db

            if (accessControlObj.getReferences() == null)

            {

              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 = 

                                (AccessSection)accessObjectList.elementAt(i);

                String accessObjId = accessObj.getAccessSectionId();

                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)

              {

                throw new SAXException("The referenceid: " + referenceId +

                               " is not access subtree");

              }//if

            }//else

          }//else

       }//try

       catch (Exception e)

       {

         MetaCatUtil.debugMessage("error in EmlSAXHandler.writeAddtionalAccess"

                                   + ": "+e.getMessage(), 30);

         throw new SAXException(e.getMessage());

       }

     }//while

    }//for

  }//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");

     }

      String permOrder = accessSection.getPermissionOrder();

      String sql = null;

      PreparedStatement pstmt = null;

      if (topLevel)

      {

        sql = "INSERT INTO xml_access (docid, principal_name, permission, "+

                 "perm_type, perm_order, accessfileid) VALUES " +

                 " (?, ?, ?, ?, ?, ?)";

      }

      else

      {

        sql ="INSERT INTO xml_access (docid,principal_name, "+ 

             "permission, perm_type, perm_order, accessfileid, subtreeid, "+

             " startnodeid, endnodeid) VALUES" +

             " (?, ?, ?, ?, ?, ?, ?, ?, ?)";

      }

      try 

      {

        pstmt = connection.prepareStatement(sql);

        // Increase DBConnection usage count

        connection.increaseUsageCount(1);

        // Bind the values to the query

        pstmt.setString(1, docid);

        MetaCatUtil.debugMessage("Docid in accesstable: "+ docid, 35);

        pstmt.setString(6, docid);

        MetaCatUtil.debugMessage("Accessfileid in accesstable: "+ docid, 35);

        pstmt.setString(5, permOrder);

        MetaCatUtil.debugMessage("PermOder in accesstable: "+ permOrder, 35);

        // if it is not top level, set subsection id

        if (!topLevel)

        {

          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);

          }

          pstmt.setString(7, subSectionId);

          MetaCatUtil.debugMessage("SubSectionId in accesstable: "+ 

                                    subSectionId, 35);

          pstmt.setLong(8, startNodeId);

          MetaCatUtil.debugMessage("Start node id is: " + startNodeId, 35);

          pstmt.setLong(9, endNodeId);

          MetaCatUtil.debugMessage("End node id is: " + endNodeId, 35);

        }

        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);

          MetaCatUtil.debugMessage("permission in accesstable: "+ permission, 35);

          pstmt.setString(4, permType);

          MetaCatUtil.debugMessage("Permtype in accesstable: "+ permType, 35);

          // 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);

            MetaCatUtil.debugMessage("Principal in accesstable: "+prName, 35);

            pstmt.execute();

          }//for

        }//for

        pstmt.close();

      }//try 

      catch (SQLException e) 

      {

        throw new 

        SAXException("EMLSAXHandler.writeAccessRuletoDB(): " + e.getMessage());

      }//catch

      finally

      {

        try

        {

          pstmt.close();

        }

        catch(SQLException ee)

        {

          throw new 

          SAXException("EMLSAXHandler.writeAccessRuletoDB(): " + 

          ee.getMessage());

        }

      }//finally

  }//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());

      }

    }

  }//deletePermissionsInAccessTable

  // 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());

      writer.close();

    }

    catch (Exception e)

    {

      throw new SAXException(e.getMessage());

    }

    fileNameBuffer = new StringBuffer(fileName);

    return fileNameBuffer;

  }

}