Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class that represents an XML document

 *  Copyright: 2000 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Matt Jones

 *    Release: @release@

 *

 *   '$Author: tao $'

 *     '$Date: 2003-04-19 19:08:23 -0700 (Sat, 19 Apr 2003) $'

 * '$Revision: 1591 $'

 *

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

import java.io.IOException;

import java.io.PrintWriter;

import java.io.Reader;

import java.io.StringWriter;

import java.io.Writer;

import java.io.InputStreamReader;

import java.io.*;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.Stack;

import java.util.TreeSet;

import java.util.Vector;

import java.util.Enumeration;

import org.xml.sax.AttributeList;

import org.xml.sax.ContentHandler;

import org.xml.sax.DTDHandler;

import org.xml.sax.EntityResolver;

import org.xml.sax.ErrorHandler;

import org.xml.sax.InputSource;

import org.xml.sax.XMLReader;

import org.xml.sax.SAXException;

import org.xml.sax.SAXParseException;

import org.xml.sax.helpers.XMLReaderFactory;

import java.net.URL;

import edu.ucsb.nceas.dbadapter.AbstractDatabase;

/**

 * A class that represents an XML document. It can be created with a simple

 * document identifier from a database connection.  It also will write an

 * XML text document to a database connection using SAX.

 */

public class DocumentImpl {

   /* Constants */

   public static final String SCHEMA                 = "Schema";

   public static final String DTD                    = "DTD";

   public static final String EML2                   = "eml2";

   public static final String EXTERNALSCHEMALOCATIONPROPERTY = 

              "http://apache.org/xml/properties/schema/external-schemaLocation";

   /*public static final String EXTERNALSCHEMALOCATION = 

     "eml://ecoinformatics.org/eml-2.0.0 http://dev.nceas.ucsb.edu/tao/schema/eml.xsd"+

      " http://www.xml-cml.org/schema/stmml http://dev.nceas.ucsb.edu/tao/schema/stmml.xsd";*/

   public static final String DECLARATIONHANDLERPROPERTY =

                            "http://xml.org/sax/properties/declaration-handler";

   public static final String LEXICALPROPERTY =

                             "http://xml.org/sax/properties/lexical-handler";

   public static final String VALIDATIONFEATURE = 

                             "http://xml.org/sax/features/validation";

   public static final String SCHEMAVALIDATIONFEATURE = 

                             "http://apache.org/xml/features/validation/schema";

   public static final String NAMESPACEFEATURE = 

                              "http://xml.org/sax/features/namespaces";

   public static final String NAMESPACEPREFIXESFEATURE = 

                              "http://xml.org/sax/features/namespace-prefixes";

   public static final String EMLNAMESPACE =

                                         MetaCatUtil.getOption("eml2namespace"); 

                                         // "eml://ecoinformatics.org/eml-2.0.0";

  static final int ALL = 1;

  static final int WRITE = 2;

  static final int READ = 4;

  private static final AbstractDatabase dbAdapter = MetaCatUtil.dbAdapter;

  private DBConnection connection = null;

  private String docid = null;

  private String updatedVersion=null;

  private String docname = null;

  private String doctype = null;

  private String validateType = null; //base on dtd or schema

// DOCTITLE attr cleared from the db

//  private String doctitle = null;

  private String createdate = null;

  private String updatedate = null;

  private String system_id = null;

  private String userowner = null;

  private String userupdated = null;

  private int rev;

  private int serverlocation;

  private String docHomeServer;

  private String publicaccess; 

  private long rootnodeid;

  private ElementNode rootNode = null;

  private TreeSet nodeRecordList = null;

  //private static 

  //ReplicationServerList serverList = new ReplicationServerList();

  /**

   * Constructor used to create a document and read the document information

   * from the database.  If readNodes is false, then the node data is not 

   * read at this time, but is deferred until it is needed (such as when a 

   * call to toXml() is made).  

   *

   * @param conn the database connection from which to read the document

   * @param docid the identifier of the document to be created

   * @param readNodes flag indicating whether the xmlnodes should be read

   */

  public DocumentImpl(String docid, boolean readNodes) 

         throws McdbException 

  {

    try {

      //this.conn = conn;

      this.docid = docid;

      // Look up the document information

      getDocumentInfo(docid);

      if (readNodes) {

        // Download all of the document nodes using a single SQL query

        // The sort order of the records is determined by the NodeComparator

        // class, and needs to represent a depth-first traversal for the

        // toXml() method to work properly

        nodeRecordList = getNodeRecordList(rootnodeid);

      }

    } catch (McdbException ex) {

      throw ex;

    } catch (Throwable t) {

      throw new McdbException("Error reading document from " +

                              "DocumentImpl.DocumentImpl: " + docid);

    }

  }

  /**

   * Constructor, creates document from database connection, used 

   * for reading the document

   *

   * @param conn the database connection from which to read the document

   * @param docid the identifier of the document to be created

   */

  public DocumentImpl(String docid) throws McdbException 

  {

    this(docid, true);

  }

  /** 

   * Construct a new document instance, writing the contents to the database.

   * This method is called from DBSAXHandler because we need to know the

   * root element name for documents without a DOCTYPE before creating it.

   *

   * In this constructor, the docid is without rev. There is a string rev to 

   * specify the revision user want to upadate. The revion is only need to be

   * greater than current one. It is not need to be sequent number just after

   * current one. So it is only used in update action

   * @param conn the JDBC Connection to which all information is written

   * @param rootnodeid - sequence id of the root node in the document

   * @param docname - the name of DTD, i.e. the name immediately following 

   *        the DOCTYPE keyword ( should be the root element name ) or

   *        the root element name if no DOCTYPE declaration provided

   *        (Oracle's and IBM parsers are not aware if it is not the 

   *        root element name)

   * @param doctype - Public ID of the DTD, i.e. the name immediately 

   *                  following the PUBLIC keyword in DOCTYPE declaration or

   *                  the docname if no Public ID provided or

   *                  null if no DOCTYPE declaration provided

   * @param docid the docid to use for the UPDATE, no version number

   * @param version, need to be update

   * @param action the action to be performed (INSERT OR UPDATE)

   * @param user the user that owns the document

   * @param pub flag for public "read" access on document

   * @param serverCode the serverid from xml_replication on which this document

   *        resides.

   *

   */

  public DocumentImpl(DBConnection conn, long rootNodeId, String docName, 

                      String docType, String docId, String newRevision, 

                      String action, String user,

                      String pub, String catalogId, int serverCode)

                      throws SQLException, Exception

  {

    this.connection = conn;

    this.rootnodeid = rootNodeId;

    this.docname = docName;

    this.doctype = docType;

    this.docid = docId;

    this.updatedVersion = newRevision;

    writeDocumentToDB(action, user, pub, catalogId, serverCode);

  }

  /**

   * This method will be call in handleUploadRequest in MetacatServlet class

   */

  public static void registerDocument(

                     String docname, String doctype, String accnum, String user)

                     throws SQLException, AccessionNumberException, Exception

  {

    try

    {

       // get server location for this doc

      int serverLocation=getServerLocationNumber(accnum);

      registerDocument(docname, doctype,accnum, user, serverLocation);

    }

    catch (Exception e)

    {

      throw e;

    }

  }

  /**

   * Register a document that resides on the filesystem with the database.

   * (ie, just an entry in xml_documents, nothing in xml_nodes).

   * Creates a reference to a filesystem document (used for non-xml data files).

   * This class only be called in MetaCatServerlet.

   * @param conn the JDBC Connection to which all information is written

   * @param docname - the name of DTD, i.e. the name immediately following 

   *        the DOCTYPE keyword ( should be the root element name ) or

   *        the root element name if no DOCTYPE declaration provided

   *        (Oracle's and IBM parsers are not aware if it is not the 

   *        root element name)

   * @param doctype - Public ID of the DTD, i.e. the name immediately 

   *                  following the PUBLIC keyword in DOCTYPE declaration or

   *                  the docname if no Public ID provided or

   *                  null if no DOCTYPE declaration provided

   * @param accnum the accession number to use for the INSERT OR UPDATE, which 

   *               includes a revision number for this revision of the document 

   *               (e.g., knb.1.1)

   * @param user the user that owns the document

   * @param serverCode the serverid from xml_replication on which this document

   *        resides.

   */

  public static void registerDocument(

                     String docname, String doctype, String accnum, 

                     String user, int serverCode)

                     throws SQLException, AccessionNumberException, Exception

  {

    DBConnection dbconn = null;

    int serialNumber = -1;

    PreparedStatement pstmt = null;

    //MetaCatUtil util = new MetaCatUtil();

    AccessionNumber ac;

    try {

      //dbconn = util.openDBConnection();

      //check out DBConnection

      dbconn=DBConnectionPool.

                    getDBConnection("DocumentImpl.registerDocument");

      serialNumber=dbconn.getCheckOutSerialNumber();

      String docIdWithoutRev=MetaCatUtil.getDocIdFromString(accnum);

      int userSpecifyRev=MetaCatUtil.getVersionFromString(accnum);

      int revInDataBase=getLatestRevisionNumber(docIdWithoutRev);

      //revIndataBase=-1, there is no record in xml_documents table

      //the data file is a new one, inert it into table

      //user specified rev should be great than 0

      if (revInDataBase==-1 && userSpecifyRev>0 )

      {

        ac = new AccessionNumber(accnum, "insert");

      }

      //rev is greater the last revsion number and revInDataBase isn't -1

      // it is a updated data file

      else if (userSpecifyRev>revInDataBase && revInDataBase>0)

      {

        //archive the old entry 

        archiveDocRevision(docIdWithoutRev, user);

        //delete the old entry in xml_documents

        deleteXMLDocuments(docIdWithoutRev);

        ac = new AccessionNumber(accnum, "update");

      }

      //other situation

      else

      {

        throw new Exception("Revision number couldn't be "

                    +userSpecifyRev);

      }

      String docid = ac.getDocid();

      String rev = ac.getRev();

      SimpleDateFormat formatter = new SimpleDateFormat ("yy-MM-dd HH:mm:ss");

      Date localtime = new Date();

      String dateString = formatter.format(localtime);

      String sqlDateString = "to_date('" + dateString + 

                                          "', 'YY-MM-DD HH24:MI:SS')";

      StringBuffer sql = new StringBuffer();

      sql.append("insert into xml_documents (docid, docname, doctype, ");

      sql.append("user_owner, user_updated, server_location, rev,date_created");

      sql.append(", date_updated, public_access) values ('");

      sql.append(docid).append("','");

      sql.append(docname).append("','");

      sql.append(doctype).append("','");

      sql.append(user).append("','");

      sql.append(user).append("','");

      sql.append(serverCode).append("','");

      sql.append(rev).append("',");

      sql.append(sqlDateString).append(",");

      sql.append(sqlDateString).append(",");

      sql.append("'0')");

      pstmt = dbconn.prepareStatement(sql.toString());

      pstmt.execute();

      pstmt.close();

      //dbconn.close();

    } 

    finally 

    {

      try

      {

        pstmt.close();

      }

      finally

      {

        DBConnectionPool.returnDBConnection(dbconn, serialNumber);

      }

    }    

  }

    /**

   * Register a document that resides on the filesystem with the database.

   * (ie, just an entry in xml_documents, nothing in xml_nodes).

   * Creates a reference to a filesystem document (used for non-xml data files)

   * This method will be called for register data file in xml_documents in 

   * Replication.

   * This method is revised from registerDocument.

   *

   * @param conn the JDBC Connection to which all information is written

   * @param docname - the name of DTD, i.e. the name immediately following 

   *        the DOCTYPE keyword ( should be the root element name ) or

   *        the root element name if no DOCTYPE declaration provided

   *        (Oracle's and IBM parsers are not aware if it is not the 

   *        root element name)

   * @param doctype - Public ID of the DTD, i.e. the name immediately 

   *                  following the PUBLIC keyword in DOCTYPE declaration or

   *                  the docname if no Public ID provided or

   *                  null if no DOCTYPE declaration provided

   * @param accnum the accession number to use for the INSERT OR UPDATE, which 

   *               includes a revision number for this revision of the document 

   *               (e.g., knb.1.1)

   * @param user the user that owns the document

   * @param serverCode the serverid from xml_replication on which this document

   *        resides.

   */

  public static void registerDocumentInReplication(

                     String docname, String doctype, String accnum, 

                     String user, int serverCode)

                     throws SQLException, AccessionNumberException, Exception

  {

    DBConnection dbconn = null;

    int serialNumber = -1;

    //MetaCatUtil util = new MetaCatUtil();

    AccessionNumber ac;

    PreparedStatement pstmt = null;

    try {

      //dbconn = util.openDBConnection();

       dbconn=DBConnectionPool.

                  getDBConnection("DocumentImpl.registerDocumentInReplication");

      serialNumber=dbconn.getCheckOutSerialNumber();

      String docIdWithoutRev=MetaCatUtil.getDocIdFromString(accnum);

      int userSpecifyRev=MetaCatUtil.getVersionFromString(accnum);

      int revInDataBase=getLatestRevisionNumber(docIdWithoutRev);

      //revIndataBase=-1, there is no record in xml_documents table

      //the data file is a new one, inert it into table

      //user specified rev should be great than 0

      if (revInDataBase==-1 && userSpecifyRev>0 )

      {

        ac = new AccessionNumber(accnum, "insert");

      }

      //rev is greater the last revsion number and revInDataBase isn't -1

      // it is a updated data file

      else if (userSpecifyRev>revInDataBase && revInDataBase>0)

      {

        //archive the old entry 

        archiveDocRevision(docIdWithoutRev, user);

        //delete the old entry in xml_documents

        deleteXMLDocuments(docIdWithoutRev);

        ac = new AccessionNumber(accnum, "update");

      }

      // local server has newer version, then notify the remote server

      else if ( userSpecifyRev < revInDataBase && revInDataBase > 0)

      {

        throw new Exception("Local server: "+MetaCatUtil.getOption("server")+

                 " has newer revision of doc: "+docIdWithoutRev+"."

                  +revInDataBase+". Please notify it.");

      }

      //other situation

      else

      {

        throw new Exception("Revision number couldn't be "

                    +userSpecifyRev);

      }

      String docid = ac.getDocid();

      String rev = ac.getRev();

      SimpleDateFormat formatter = new SimpleDateFormat ("yy-MM-dd HH:mm:ss");

      Date localtime = new Date();

      String dateString = formatter.format(localtime);

      String sqlDateString = "to_date('" + dateString + 

                                          "', 'YY-MM-DD HH24:MI:SS')";

      StringBuffer sql = new StringBuffer();

      sql.append("insert into xml_documents (docid, docname, doctype, ");

      sql.append("user_owner, user_updated, server_location, rev,date_created");

      sql.append(", date_updated, public_access) values ('");

      sql.append(docid).append("','");

      sql.append(docname).append("','");

      sql.append(doctype).append("','");

      sql.append(user).append("','");

      sql.append(user).append("','");

      sql.append(serverCode).append("','");

      sql.append(rev).append("',");

      sql.append(sqlDateString).append(",");

      sql.append(sqlDateString).append(",");

      sql.append("'0')");

      // Set auto commit fasle

      dbconn.setAutoCommit(false);

      pstmt = dbconn.prepareStatement(sql.toString());

      pstmt.execute();

      // Commit the insert

      dbconn.commit();

      pstmt.close();

      //dbconn.close();

    } 

    finally 

    {

      // Set DBConnection auto commit true

      dbconn.setAutoCommit(true);

      pstmt.close();

      DBConnectionPool.returnDBConnection(dbconn, serialNumber);

    }    

  }

 /**

   * This method will register a data file entry in xml_documents and save a

   * data file input Stream into file system.. It is only used in replication

   *

   * @param  input, the input stream which contain the file content.

   * @param  , the input stream which contain the file content

   * @param docname - the name of DTD, for data file, it is a docid number.

   * @param doctype - "BIN" for data file

   * @param accnum the accession number to use for the INSERT OR UPDATE, which 

   *               includes a revision number for this revision of the document 

   *               (e.g., knb.1.1)

   * @param user the user that owns the document

   * @param docHomeServer, the home server of the docid

   * @param notificationServer, the server to notify force replication info to 

   *                            local metacat

   */

 public static void writeDataFileInReplication(InputStream input, 

                 String filePath, String docname, String doctype, String accnum, 

                   String user, String docHomeServer, String notificationServer)

                     throws SQLException, AccessionNumberException, Exception

 {

    int serverCode=-2;

    if (filePath==null||filePath.equals(""))

    {

      throw new 

            Exception("Please specify the directory where file will be store");

    }

    if (accnum==null||accnum.equals(""))

    {

      throw new Exception("Please specify the stored file name");

    }

    // If server is not int the xml replication talbe, insert it into 

    // xml_replication table

    //serverList.addToServerListIfItIsNot(docHomeServer);

    insertServerIntoReplicationTable(docHomeServer);

    // Get server code again

    serverCode = getServerCode(docHomeServer);

    //register data file into xml_documents table

    registerDocumentInReplication(docname, doctype, accnum, user, serverCode);

    //write inputstream into file system.

    File dataDirectory = new File(filePath);

    File newFile = new File(dataDirectory, accnum); 

    // create a buffered byte output stream

    // that uses a default-sized output buffer

    FileOutputStream fos = new FileOutputStream(newFile);

    BufferedOutputStream outPut = new BufferedOutputStream(fos);

    BufferedInputStream bis = null;

    bis = new BufferedInputStream(input);

    byte[] buf = new byte[4 * 1024]; // 4K buffer

    int b = bis.read(buf);

    while (b != -1) 

    {

        outPut.write(buf, 0, b);

        b = bis.read(buf);

    }

    bis.close();

	  outPut.close();

	  fos.close();

    // Force replicate data file

    ForceReplicationHandler forceReplication = new ForceReplicationHandler

                                    (accnum, false, notificationServer);

 }

  public static boolean getDataFileLockGrant(String accnum) 

                                                  throws Exception

  { 

    try

    {

      int serverLocation=getServerLocationNumber(accnum);

      return getDataFileLockGrant(accnum,serverLocation);

    }

    catch (Exception e)

    {

      throw e;

    }

  }

  /**

   * The method will check if metacat can get data file lock grant

   * If server code is 1, it get.

   * If server code is not 1 but call replication getlock successfully,

   * it get

   * else, it didn't get

   * @param accnum, the ID of the document 

   * @param action, the action to the document

   * @param serverCode, the server location code

   */

  public static boolean getDataFileLockGrant(String accnum, int serverCode)

                                          throws Exception 

  {

    boolean flag=true;

    //MetaCatUtil util = new MetaCatUtil();

    String docid = MetaCatUtil.getDocIdFromString(accnum);

    int rev = MetaCatUtil.getVersionFromString(accnum);

    if (serverCode == 1)

    {

      flag=true;

      return flag;

    }

    //if((serverCode != 1 && action.equals("UPDATE")) )

    if (serverCode != 1)

    { //if this document being written is not a resident of this server then

      //we need to try to get a lock from it's resident server.  If the

      //resident server will not give a lock then we send the user a message

      //saying that he/she needs to download a new copy of the file and

      //merge the differences manually.

      String server=MetacatReplication.getServerNameForServerCode(serverCode);

      MetacatReplication.replLog("attempting to lock " + accnum);

      URL u = new URL("https://" + server + "?server=" +

        MetaCatUtil.getLocalReplicationServerName()+"&action=getlock&updaterev=" 

           +rev + "&docid=" + docid);

      //System.out.println("sending message: " + u.toString());

      String serverResStr = MetacatReplication.getURLContent(u);

      String openingtag =serverResStr.substring(0, serverResStr.indexOf(">")+1);

      if(openingtag.equals("<lockgranted>"))

      {

        //the lock was granted go ahead with the insert

        //System.out.println("In lockgranted");

        MetacatReplication.replLog("lock granted for " + accnum + " from " +

                                      server);

        flag=true;  

        return flag;

      }//if

      else if(openingtag.equals("<filelocked>"))

      {//the file is currently locked by another user

       //notify our user to wait a few minutes, check out a new copy and try

       //again.

        //System.out.println("file locked");

        MetacatReplication.replLog("lock denied for " + accnum + " on " +

                                   server + " reason: file already locked");

        throw new Exception("The file specified is already locked by another " +

                            "user.  Please wait 30 seconds, checkout the " +

                            "newer document, merge your changes and try " +

                            "again.");

      }

      else if(openingtag.equals("<outdatedfile>"))

      {//our file is outdated.  notify our user to check out a new copy of the

       //file and merge his version with the new version.

        //System.out.println("outdated file");

        MetacatReplication.replLog("lock denied for " + accnum + " on " +

                                    server + " reason: local file outdated");

        throw new Exception("The file you are trying to update is an outdated" +

                            " version.  Please checkout the newest document, " +

                            "merge your changes and try again.");

      }//else if

    }//if

   return flag;

  }//getDataFileLockGrant

  /**

   * get the document name

   */

  public String getDocname() {

    return docname;

  }

  /**

   * get the document type (which is the PublicID)

   */

  public String getDoctype() {

    return doctype;

  }

  /**

   * get the system identifier

   */

  public String getSystemID() {

    return system_id;

  }

  /**

   * get the root node identifier

   */

  public long getRootNodeID() {

    return rootnodeid;

  }

  /**

   * get the creation date

   */

  public String getCreateDate() {

    return createdate;

  }

  /**

   * get the update date

   */

  public String getUpdateDate() {

    return updatedate;

  }

  /** 

   * Get the document identifier (docid)

   */

  public String getDocID() {

    return docid;

  }

// DOCTITLE attr cleared from the db

//  /**

//   *get the document title

//   */

//  public String getDocTitle() {

//    return doctitle;

//  }

  public String getUserowner() {

    return userowner;

  }

  public String getUserupdated() {

    return userupdated;

  }

  public int getServerlocation() {

    return serverlocation;

  }

  public String getDocHomeServer() {

    return docHomeServer;

  }

  public String getPublicaccess() {

    return publicaccess;

  }

  public int getRev() {

    return rev;

  }

  public String getValidateType()

  {

    return validateType;

  }

  /**

   * Print a string representation of the XML document

   */

  public String toString(String user, String[] groups, boolean withInlinedata)

  {

    StringWriter docwriter = new StringWriter();

    try 

    {

      this.toXml(docwriter, user, groups, withInlinedata);

    } 

    catch (McdbException mcdbe) 

    {

      return null;

    }

    String document = docwriter.toString();

    return document;

  }

   /**

   * Print a string representation of the XML document

   */

  public String toString()

  {

    StringWriter docwriter = new StringWriter();

    String userName = null;

    String[] groupNames = null;

    boolean withInlineData = false;

    try 

    {

      this.toXml(docwriter, userName, groupNames, withInlineData);

    } 

    catch (McdbException mcdbe) 

    {

      return null;

    }

    String document = docwriter.toString();

    return document;

  }

  /**

   * Get a text representation of the XML document as a string

   * This older algorithm uses a recursive tree of Objects to represent the

   * nodes of the tree.  Each object is passed the data for the document 

   * and searches all of the document data to find its children nodes and

   * recursively build.  Thus, because each node reads the whole document,

   * this algorithm is extremely slow for larger documents, and the time

   * to completion is O(N^N) wrt the number of nodes.  See toXml() for a

   * better algorithm.

   */

  public String readUsingSlowAlgorithm() throws McdbException

  {

    StringBuffer doc = new StringBuffer();

    // First, check that we have the needed node data, and get it if not

    if (nodeRecordList == null) {

      nodeRecordList = getNodeRecordList(rootnodeid);

    }

    // Create the elements from the downloaded data in the TreeSet

    rootNode = new ElementNode(nodeRecordList, rootnodeid);

    // Append the resulting document to the StringBuffer and return it

    doc.append("<?xml version=\"1.0\"?>\n");

    if (docname != null) {

      if ((doctype != null) && (system_id != null)) {

        doc.append("<!DOCTYPE " + docname + " PUBLIC \"" + doctype + 

                   "\" \"" + system_id + "\">\n");

      } else {

        doc.append("<!DOCTYPE " + docname + ">\n");

      }

    }

    doc.append(rootNode.toString());

    return (doc.toString());

  }

  /**

   * Print a text representation of the XML document to a Writer

   *

   * @param pw the Writer to which we print the document

   */

  public void toXml(Writer pw, String user, String[] groups, boolean withInLineData) 

                                                          throws McdbException

  {

    // flag for process  eml2

    boolean proccessEml2 = false;

    if (doctype != null && doctype.equals(EMLNAMESPACE))

    {

      proccessEml2 = true;

    }

    // flag for process inline data

    boolean prcocessInlineData = false;

    TreeSet nodeRecordLists = null;

    PrintWriter out = null;

    if (pw instanceof PrintWriter) {

      out = (PrintWriter)pw;

    } else {

      out = new PrintWriter(pw);

    }

    MetaCatUtil util = new MetaCatUtil();

    // Here add code to handle subtree access control

    PermissionController control = new PermissionController(docid);

    Hashtable unaccessableSubTree =control.hasUnaccessableSubTree(user, groups, 

                                             AccessControlInterface.READSTRING);

    if (!unaccessableSubTree.isEmpty())

    {

      nodeRecordLists = getPartNodeRecordList(rootnodeid, unaccessableSubTree);

    }

    else 

    {

      nodeRecordLists = getNodeRecordList(rootnodeid);

    }

    Stack openElements = new Stack();

    boolean atRootElement = true;

    boolean previousNodeWasElement = false;

    // Step through all of the node records we were given

    Iterator it = nodeRecordLists.iterator();

    while (it.hasNext()) 

    {

      NodeRecord currentNode = (NodeRecord)it.next();

      util.debugMessage("[Got Node ID: " + currentNode.nodeid +

                          " (" + currentNode.parentnodeid +

                          ", " + currentNode.nodeindex + 

                          ", " + currentNode.nodetype + 

                          ", " + currentNode.nodename + 

                          ", " + currentNode.nodedata + ")]", 50);

      // Print the end tag for the previous node if needed

      //

      // This is determined by inspecting the parent nodeid for the

      // currentNode.  If it is the same as the nodeid of the last element

      // that was pushed onto the stack, then we are still in that previous

      // parent element, and we do nothing.  However, if it differs, then we

      // have returned to a level above the previous parent, so we go into

      // a loop and pop off nodes and print out their end tags until we get

      // the node on the stack to match the currentNode parentnodeid

      //

      // So, this of course means that we rely on the list of elements

      // having been sorted in a depth first traversal of the nodes, which

      // is handled by the NodeComparator class used by the TreeSet

      if (!atRootElement) {

        NodeRecord currentElement = (NodeRecord)openElements.peek();

        if ( currentNode.parentnodeid != currentElement.nodeid ) {

          while ( currentNode.parentnodeid != currentElement.nodeid ) {

            currentElement = (NodeRecord)openElements.pop();

            util.debugMessage("\n POPPED: " + currentElement.nodename, 50);

            if (previousNodeWasElement) {

              out.print(">");

              previousNodeWasElement = false;

            }  

            if ( currentElement.nodeprefix != null ) {

              out.print("</" + currentElement.nodeprefix + ":" + 

                        currentElement.nodename + ">" );

            } else {

              out.print("</" + currentElement.nodename + ">" );

            }

            currentElement = (NodeRecord)openElements.peek();

          }

        }

      }

      // Handle the DOCUMENT node

      if (currentNode.nodetype.equals("DOCUMENT")) {

        out.println("<?xml version=\"1.0\"?>");

        if (docname != null && validateType != null && validateType.equals(DTD)) 

        {

          if ((doctype != null) && (system_id != null)) 

          {

            out.println("<!DOCTYPE " + docname + " PUBLIC \"" + doctype + 

                       "\" \"" + system_id + "\">");

          } 

          else 

          {

            out.println("<!DOCTYPE " + docname + ">");

          }

        }

      // Handle the ELEMENT nodes

      } else if (currentNode.nodetype.equals("ELEMENT")) {

        if (atRootElement) {

          atRootElement = false;

        } else {

          if (previousNodeWasElement) {

            out.print(">");

          }

        }

        openElements.push(currentNode);

        util.debugMessage("\n PUSHED: " + currentNode.nodename, 50);

        previousNodeWasElement = true;

        if ( currentNode.nodeprefix != null ) {

          out.print("<" + currentNode.nodeprefix + ":" + currentNode.nodename);

        } else {

          out.print("<" + currentNode.nodename);

        }

        // if currentNode is inline and handle eml2, set flag proccess in

        if (currentNode.nodename != null && 

            currentNode.nodename.equals(EmlSAXHandler.INLINE) && proccessEml2)

        {

          prcocessInlineData = true;

        }

      // Handle the ATTRIBUTE nodes

      } else if (currentNode.nodetype.equals("ATTRIBUTE")) {

        if ( currentNode.nodeprefix != null ) {

          out.print(" " + currentNode.nodeprefix + ":" + currentNode.nodename +

                    "=\"" + currentNode.nodedata + "\"");

        } else {

          out.print(" " + currentNode.nodename + "=\"" +

                    currentNode.nodedata + "\"");

        }

      // Handle the NAMESPACE nodes

      } else if (currentNode.nodetype.equals("NAMESPACE")) {

        out.print(" xmlns:" + currentNode.nodename + "=\""

                 + currentNode.nodedata + "\"");