Metacat

                    response.setContentType("text/xml");

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

                    out.println("<error>");

                    out.println(ane.getMessage());

                    out.println("</error>");

                }

     * 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

        } catch (McdbException ex) {

            throw ex;

        } catch (Throwable t) {

        }

    }

    /**

     * Constructor, creates document from database connection, used for reading

     * the document

     * @param conn

     *            the database connection from which to read the document

     * @param docid

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

     * @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,

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

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

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

                sql.append("insert into xml_documents (docid, docname, " +

                           "doctype, ");

                           "rev,date_created");

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

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

    /**

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

    /**

     * 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

         * PermissionController control = new PermissionController(docid);

         * Hashtable unaccessableSubTree =control.hasUnaccessableSubTree(user,

         * groups, AccessControlInterface.READSTRING);

         * if (!unaccessableSubTree.isEmpty()) {

         * nodeRecordLists = getPartNodeRecordList(rootnodeid,

         * unaccessableSubTree);

         *  } else { nodeRecordLists = getNodeRecordList(rootnodeid); }

                    // check if user has read permision for this inline data

                    boolean readInlinedata = false;

                    try {

                            PermissionController

                                .getUnReadableInlineDataIdList(accessfileName,

                                        user, groups);

    /**

     * Look up the document type information from the database

     * @param docid

     *            the id of the document to look up

     */

            }

        }

            throw new McdbDocNotFoundException(

                "Document not found: " + docid, docid.getIdentifier(), docid

        }

    }

    /**

     * Look up the node data from the database, but some node would be shown

     * because of access control

     * @param rootnodeid

     *            the id of the root node of the node tree to look up

     * @param accessControl

    /**

     * Look up the node data from the database

     * @param rootnodeid

     *            the id of the root node of the node tree to look up

     */

    /**

     * Write an XML file to the database, given a filename

     * @param conn

     *            the JDBC connection to the database

     * @param filename

     * public static String write(DBConnection conn,String filename, String pub,

     * String dtdfilename, String action, String docid, String user, String[]

     * groups ) throws Exception {

     * Reader dtd = null; if ( dtdfilename != null ) { dtd = new FileReader(new

     * File(dtdfilename).toString()); } return write ( conn, new FileReader(new

     * File(filename).toString()), pub, dtd, action, docid, user, groups,

    /**

     * Write an XML file to the database, given a Reader

     * @param conn

     *            the JDBC connection to the database

     * @param xml

        MetaCatUtil.debugMessage("action: " + action + " servercode: "

                + serverCode + " override: " + override, 10);

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

            char istreamChar;

            // check for 'write' permission for 'user' to update this document

                throw new Exception(

                    "User " + user

                    + " does not have permission to update XML Document #"

            }

            DocumentIdentifier id = new DocumentIdentifier(accnum);

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

                // the file is currently locked by another user notify our

                // again.

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

                        + server + " reason: file already locked");

        if (action.equals("UPDATE")) {

            // check for 'write' permission for 'user' to update this document

                throw new Exception(

                    "User " + user

                    + " does not have permission to update XML Document #"

        runRelationAndAccessHandler(accnum, user, groups, serverCode);

        // Force replicate out the new document to each server in our server

        // metacat notify the force replication.

        ForceReplicationHandler frh = new ForceReplicationHandler(accnum,

                action, true, null);

    /**

     * Write an XML file to the database during replication

     * @param conn

     *            the JDBC connection to the database

     * @param xml

            Vector packagedoctypes = new Vector();

            packagedoctypes = MetaCatUtil.getOptionList(packagedoctype);

            String docIdWithoutRev = MetaCatUtil.getDocIdFromString(accnumber);

                    packagedoctypes.contains(documenttype)) {

                dbconn = DBConnectionPool.getDBConnection(

                        "DocumentImpl.runRelationAndAccessHandeler");

    /**

     * Delete an XML file from the database (actually, just make it a revision

     * in the xml_revisions table)

     * @param docid

     *            the ID of the document to be deleted from the database

     */

                    parser.setFeature(SCHEMAVALIDATIONFEATURE, true);

                    // From DB to find the register external schema location

                    String externalSchemaLocation = null;

                        new SchemaLocationResolver();

                    externalSchemaLocation = resolver

                            .getNameSpaceAndLocationString();

    /**

     * delete a entry in xml_table for given docid

     * @param docId,

     *            the id of the document need to be delete

     */

     * Get last revision number from database for a docid If couldn't find an

     * entry, -1 will return The return value is integer because we want compare

     * it to there new one

     * @param docid

     *            <sitecode>. <uniqueid>part of Accession Number

     */

    /**

     * Get server location form database for a accNum

     * @param accum

     *            <sitecode>. <uniqueid>. <rev>

     */

    /**

     * Given a server name, return its servercode in xml_replication table. If

     * no server is found, -1 will return

     * @param serverName,

     */

    private static int getServerCode(String serverName)

    /**

     * Insert a server into xml_replcation table

     * @param server,

     *            the name of server

     */

     * the main routine used to test the DBWriter utility.

     * <p>

     * Usage: java DocumentImpl <-f filename -a action -d docid>

     * @param filename

     *            the filename to be loaded into the database

     * @param action

    // INSERT

    if ( action.equals("INSERT")) {

      // check accession number for validness

      if ( docid == null ) {

      // rev is not provided; throw an exception to prevent the insertion

      } else if ( rev == null ) {

        throw new AccessionNumberException

      // docid is used; throw an exception to prevent the insertion

      } else if ( accNumberUsed(docid) ) {

        throw new AccessionNumberException

      // rev is <> 1; throw an exception to prevent the insertion

      } /*else if ( !rev.equals("1")) {

      }*/

    // UPDATE or DELETE

      int reversionNumber = 1;

      if(rev != null){

      }

      // Accession# is not provided; throw an exception to prevent the action

      if ( docid == null ) {

      // rev is not provided; throw an exception to prevent the action

      } else if ( rev == null ) {

        throw new AccessionNumberException

      // Accession# is not current (not in xml_documents); throw an exception

      } else if ( !accNumberIsCurrent(docid) ) {

        // docid is used; throw an exception to prevent the insertion

        } else if ( accNumberUsed(docid) ) {

          throw new AccessionNumberException

        // rev is <> 1; throw an exception to prevent the insertion

        } else if ( !rev.equals("1") ) {

          throw new AccessionNumberException

        // docid is not used and rev=1; return it

        } else {

          return docid;

        // Accession# is not provided; throw an exception to prevent the action

        if ( docid == null ) {

        // Accession# is not current (not in xml_documents); throw an exception

        } else if ( !accNumberIsCurrent(docid) ) {

        // Revision number is not the recent one; throw an exception

        } else if ( !rev.equals(getLastRevision(docid)) ) {

          throw new AccessionNumberException

        // Accession# is current (present in xml_documents); return it

        } else {

    // never comes here

    throw new

  }

  // get local sitecode