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;

    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;

    static {

    	String eml210NameSpace = null;

    	try {

    		eml210NameSpace = PropertyService.getProperty("xml.eml2_1_0namespace");

    	} catch (PropertyNotFoundException pnfe) {

    		System.err.println("Could not get property in static block: " 

					+ pnfe.getMessage());

    private String publicaccess;

    protected long rootnodeid;

    private ElementNode rootNode = null;

    private static Logger logMetacat = Logger.getLogger(DocumentImpl.class);

    /**

        {

          ForceReplicationHandler forceReplication = new ForceReplicationHandler(

                accnum, false, notificationServer);

        }

    }

        int revInDataBase =DBUtil.getLatestRevisionInDocumentTable(docid);

        logMetacat.warn("The rev in data base: " + revInDataBase);

        // String to store the revision

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

        //the document is a new one for local server, inert it into table

        //user specified rev should be great than 0

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

            // rev equals user specified

            // action should be INSERT

            action = "INSERT";

        }

        // it is a updated file

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

            // rev equals user specified

            // action should be update

            action = "UPDATE";

        }

     private static String checkXMLRevisionTable(String docid, int rev) throws Exception

     {

         String action = "INSERT";

         try

         {

            proccessEml2 = true;

        }

        // flag for process inline data

        PrintWriter out = null;

        if (pw instanceof PrintWriter) {

            out = (PrintWriter) pw;

        } else {

        	nodeRecordLists = this.nodeRecordList;

        }

        boolean atRootElement = true;

        boolean previousNodeWasElement = false;

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

        while (it.hasNext()) {

            logMetacat.debug("[Got Node ID: " + currentNode.getNodeId() + " ("

                    + currentNode.getParentNodeId() + ", " + currentNode.getNodeIndex()

                    + ", " + currentNode.getNodeType() + ", " + currentNode.getNodeName()

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

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

            if (!atRootElement) {

                if (currentNode.getParentNodeId() != currentElement.getNodeId()) {

                    while (currentNode.getParentNodeId() != currentElement.getNodeId()) {

                        currentElement = (NodeRecord) openElements.pop();

                        } else {

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

                        }

                    }

                }

            }

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

                }

                if (currentNode.getNodeName() != null

                        && currentNode.getNodeName().equals(Eml200SAXHandler.INLINE)

                        && proccessEml2) {

                }

                // Handle the ATTRIBUTE nodes

                if (previousNodeWasElement) {

                    out.print(">");

                }

                    // if it is not inline data just out put data

                    out.print(currentNode.getNodeData());

                } else {

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

                    boolean readInlinedata = false;

                    try {

                            PermissionController

                                .getUnReadableInlineDataIdList(accessfileName,

                                        user, groups, true);

                    }

                    if (readInlinedata) {

                        Reader reader = Eml200SAXHandler

                                .readInlineDataFromFileSystem(fileName);

                        try {

                            int length = reader.read(characterArray);

                            while (length != -1) {

                                                length));

                                out.flush();

                                length = reader.read(characterArray);

                    }//if can read inline data

                    else {

                        // if user can't read it, we only send it back a empty

                        out.print("");

                    }// else can't read inlinedata

                    // reset proccess inline data false

                }// in inlinedata part

                previousNodeWasElement = false;

                // Handle the COMMENT nodes

	 */

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

            String documentPath) throws McdbException {

		String xmlFileContents = "";

		try {			

                    .getUnReadableInlineDataIdList(docid,

                            user, groups, true);

            // write the doc

			pw.write(xmlFileContents);

    }

    /**

	 * distribution is the same as the subtreeid in the xml_access table.

	 * 

	 * @param xmlFileContents

	 * @param inLineKey

	 *            the unique key for this inline element

	 */

    	String changedString = xmlFileContents;

    	}	

    	return changedString;

    }

    {

    	logMetacat.warn("buildIndex called on docid " + docid);

    	double start = System.currentTimeMillis()/1000;

        boolean atRootElement = true;

        long rootNodeId = -1;

        // Build a map of the same records that are present in the

        // TreeSet so that any node can be easily accessed by nodeId

        while (it.hasNext()) {

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

            Long nodeId = new Long(currentNode.getNodeId());

            nodeRecordMap.put(nodeId, currentNode);

        }

      double afterPutNode = System.currentTimeMillis()/1000;

      logMetacat.info("The time for put node id into map is "+(afterPutNode - start));

      double afterDelete = 0;

            // TEXT nodes with their parent ELEMENT node ids to associate the

            // element with it's node data (stored in the text node)

            it = nodeRecordLists.iterator();

            while (it.hasNext()) {

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

                if ( currentNode.getNodeType().equals("ELEMENT") ||

                     currentNode.getNodeType().equals("ATTRIBUTE") ){

                  // with ELEMENT paths with TEXT nodedata (since it's modeled 

                  // this way in the DOM)

                  NodeRecord parentNode = 

                  if ( parentNode.getNodeType().equals("ELEMENT") ) {

	 * @param nodedata

	 *            the nodedata for the current node

	 */

        NodeRecord current = (NodeRecord)records.get(nodeId);

        long parentId = current.getParentNodeId();

        String currentName = current.getNodeName();

        NodeRecord leafRecord = (NodeRecord)records.get(new Long(leafNodeId));

        String leafData = leafRecord.getNodeData();

        long leafParentId = leafRecord.getParentNodeId();

     * @param pathList the hash of paths to insert

     * @throws SQLException if there is an error inserting into the db

     */

    	throws SQLException

    {

        // Create an insert statement to reuse for all of the path

        pstmt.setString(4, doctype);

        // Step through the hashtable and insert each of the path values

        while (it.hasNext()) {

        	 PathIndexEntry entry = (PathIndexEntry)it.next();

        	 logMetacat.debug("Inserting: " + entry.nodeId +

     * @param pathList the hash of paths to insert

     * @throws SQLException if there is an error inserting into the db

     */

        throws SQLException {

        // Increase usage count for the connection

        conn.increaseUsageCount(1);

                + " VALUES (?, ?, ?, ?, ?)");

        // Step through the hashtable and insert each of the path values

         while (it.hasNext()) {

             PathIndexEntry entry = (PathIndexEntry)it.next();

             pstmt.setString(1,entry.docid);

                //System.out.println("in revision table branch -------");

                // if we couldn't find it in xml_documents we 

                // need to find it in xml_revision table

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

                {

                }

                if (revList.contains(new Integer(revision)))

     * @param rootnodeid

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

     */

    {

        PreparedStatement pstmt = null;

        DBConnection dbconn = null;

        int serialNumber = -1;

        long nodeid = 0;

        long parentnodeid = 0;

        long nodeindex = 0;

        String nodeprefix = null;

        String nodedata = null;

        float nodedatanumerical = -1;

        String table = "xml_nodes";

        //System.out.println("in getNodeREcorelist !!!!!!!!!!!for root node id "+rootnodeid);

        try {

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

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

            if (!hasWritePermission(user, groups, accnum)) {

                // Force replication the docid

                ForceReplicationHandler frh = new ForceReplicationHandler(

                        accnum, true, null);

                return (accnum);

            }

        // metacat notify the force replication.

        ForceReplicationHandler frh = new ForceReplicationHandler(accnum,

                action, true, null);

        // clear cache after inserting or updating a document

        if (PropertyService.getProperty("database.queryCacheOn").equals("true"))

        {

        {

          ForceReplicationHandler forceReplication = new ForceReplicationHandler(

                accnum, action, true, notifyServer);

        }

        // clear cache after inserting or updating a document

    {

        DBConnection dbconn = null;

        int serialNumber = -1;

        String documenttype = getDocTypeFromDBForCurrentDocument(accnumber);

        try {

            String packagedoctype = PropertyService.getProperty("xml.packagedoctype");

            packagedoctypes = MetaCatUtil.getOptionList(packagedoctype);

            String docIdWithoutRev = MetaCatUtil.getDocIdFromAccessionNumber(accnumber);

            int revision = MetaCatUtil.getRevisionFromAccessionNumber(accnumber);

            double afterArchiveDocAndNode = System.currentTimeMillis()/1000;

            logMetacat.info("The time for archiveDocAndNodesRevision is "+(afterArchiveDocAndNode - start));

            // Now delete it from the xml_index table

            // add force delete replcation document here.

            ForceReplicationHandler frh = new ForceReplicationHandler(

                             accnum, ForceReplicationHandler.DELETE, isXML, notifyServer);

            // clear cache after inserting or updating a document

            if (PropertyService.getProperty("database.queryCacheOn").equals("true"))

            {

    {

        DBConnection dbconn = null;

        int serialNumber = -1;

        try 

        {

            //dbconn = util.openDBConnection();

     */

    static private void deleteXMLNodes(DBConnection dbconn, long rootId) throws Exception

    {

        PreparedStatement pstmt = null;

        double start = System.currentTimeMillis()/1000;

        String sql = "DELETE FROM xml_nodes WHERE rootnodeid ="+ rootId;