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: jones $'

 *     '$Date: 2004-09-16 16:40:02 -0700 (Thu, 16 Sep 2004) $'

 * '$Revision: 2297 $'

 *

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

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.PrintWriter;

import java.io.Reader;

import java.io.StringWriter;

import java.io.Writer;

import java.net.URL;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Stack;

import java.util.TreeSet;

import java.util.Vector;

import edu.ucsb.nceas.dbadapter.AbstractDatabase;

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

import org.xml.sax.XMLReader;

import org.xml.sax.helpers.XMLReaderFactory;

/**

 * 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 EML200 = "eml200";

    public static final String EML210 = "eml210";

    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 EML2_1_0NAMESPACE = MetaCatUtil

            .getOption("eml2_1_0namespace");

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

    public static final String EML2_0_1NAMESPACE = MetaCatUtil

            .getOption("eml2_0_1namespace");

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

    public static final String EML2_0_0NAMESPACE = MetaCatUtil

            .getOption("eml2_0_0namespace");

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

    public static final String DOCNAME = "docname";

    public static final String PUBLICID = "publicid";

    public static final String SYSTEMID = "systemid";

    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

    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;

    /**

     * 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: " + 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, String[] groupnames) throws SQLException,

            AccessionNumberException, Exception

    {

        try {

            // get server location for this doc

            int serverLocation = getServerLocationNumber(accnum);

            registerDocument(docname, doctype, accnum, user, groupnames,

                             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 groupnames

     *            the groups 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, String[] groups, int serverCode)

            throws SQLException, AccessionNumberException, Exception

    {

        DBConnection dbconn = null;

        int serialNumber = -1;

        PreparedStatement pstmt = null;

        //MetaCatUtil util = new MetaCatUtil();

        AccessionNumber ac;

        String action = null;

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

                action = "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) {

                if (!hasWritePermission(user, groups, accnum)) { throw new Exception(

                   "User " + user

                   + " does not have permission to update the document"

                   + accnum); }

                //archive the old entry

                archiveDocRevision(docIdWithoutRev, user);

                //delete the old entry in xml_documents

                //deleteXMLDocuments(docIdWithoutRev);

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

                action = "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 ("MM/dd/yy

             * HH:mm:ss"); Date localtime = new Date(); String dateString =

             * formatter.format(localtime); String

             * sqlDateString=dbAdapter.toDate(dateString, "MM/DD/YY

             * HH24:MI:SS");

             */

            String sqlDateString = dbAdapter.getDateTimeFunction();

            StringBuffer sql = new StringBuffer();

            if (action != null && action.equals("insert")) {

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

            } else if (action != null && action.equals("update")) {

                sql.append("update xml_documents set docname ='");

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

                sql.append("user_updated='");

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

                sql.append("server_location='");

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

                sql.append("rev='");

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

                sql.append("date_updated=");

                sql.append(sqlDateString);

                sql.append(" where docid='");

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

            }

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

            pstmt.execute();

            pstmt.close();

            //dbconn.close();

        } finally {

            try {

                if(pstmt != null){

                    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;

        String action = null;

        try {

            //dbconn = util.openDBConnection();

            dbconn = DBConnectionPool.getDBConnection(

                    "DocumentImpl.registerDocumentInReplication");

            serialNumber = dbconn.getCheckOutSerialNumber();

            String docIdWithoutRev = MetaCatUtil

                    .getDocIdFromAccessionNumber(accnum);

            int userSpecifyRev = MetaCatUtil

                    .getRevisionFromAccessionNumber(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");

                action = "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");

                action = "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 ("MM/dd/yy

             * HH:mm:ss"); Date localtime = new Date(); String dateString =

             * formatter.format(localtime); String

             * sqlDateString=dbAdapter.toDate(dateString, "MM/DD/YY

             * HH24:MI:SS");

             */

            String sqlDateString = dbAdapter.getDateTimeFunction();

            StringBuffer sql = new StringBuffer();

            if (action != null && action.equals("insert")) {

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

            } else if (action != null && action.equals("update")) {

                sql.append("update xml_documents set docname ='");

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

                sql.append("user_updated='");

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

                sql.append("server_location='");

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

                sql.append("rev='");

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

                sql.append("date_updated=");

                sql.append(sqlDateString);

                sql.append(" where docid='");

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

            }

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

    }

    /**

     * Get a lock for a given document.

     */

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

            }

        }

        return flag;

    }

    /**

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

    }

    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 = true;

        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 Now we decide no

     *            matter withinInlineData's value, the document will

     *

     */

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

            boolean withInLineData) throws McdbException

    {

        // flag for process eml2

        boolean proccessEml2 = false;

        boolean storedDTD = false;//flag to inidate publicid or system

        // id stored in db or not

        boolean firstElement = true;

        String dbDocName = null;

        String dbPublicID = null;

        String dbSystemID = null;

        if (doctype != null

                && (doctype.equals(EML2_0_0NAMESPACE)

                        || doctype.equals(EML2_0_1NAMESPACE) || doctype

                        .equals(EML2_1_0NAMESPACE))) {

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

         */

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