Metacat

import edu.ucsb.nceas.metacat.shared.BaseException;

import edu.ucsb.nceas.metacat.shared.HandlerException;

import edu.ucsb.nceas.metacat.shared.MetacatUtilException;

import edu.ucsb.nceas.metacat.spatial.SpatialHarvester;

import edu.ucsb.nceas.metacat.spatial.SpatialQuery;

import edu.ucsb.nceas.metacat.util.AuthUtil;

			 * If spatial option is turned on and set to regenerate the spatial

			 * cache on restart, trigger the harvester regeneratation method

			 */

				// Begin timer

				long before = System.currentTimeMillis();

				// After running the first time, we want to to set

				// regenerateCacheOnRestart to false

				// so that it does not regenerate the cache every time tomcat is

				// restarted

				// End timer

				long after = System.currentTimeMillis();

                    serialNumber = dbConn.getCheckOutSerialNumber();

                    // write the document to the database and disk

                        newdocid = documentWrapper.write(dbConn, doctext[0], pub, dtd,

                                doAction, null, user, groups);

                        EventLog.getInstance().log(request.getRemoteAddr(),

                                user, "", action[0]);

                } finally {

                    // Return db connection

                    DBConnectionPool.returnDBConnection(dbConn, serialNumber);

                output += "<error>";

                output += npe.getMessage();

                output += "</error>";

                npe.printStackTrace();

            }

        } catch (Exception e) {

            output += "<error>";

            output += e.getMessage();

            output += "</error>";

            e.printStackTrace();

        }

      writeDTDNodeToDB(DocumentImpl.SYSTEMID, systemId, docid);

    }

  }

  /** creates SQL code and inserts new node into DB connection */

  public long writeChildNodeToDB(String nodetype, String nodename,

                                 String data, String docid)

                                 throws SAXException

  {

    long nid = -1;

        // Increase DBConnection usage count

        connection.increaseUsageCount(1);

      } else {

          if(data != null && !data.trim().equals("")

             && !data.trim().equals("NaN") && !data.trim().equalsIgnoreCase("Infinity")){

        pstmt.setString(3, null);

      }

      pstmt.setString(4, docid);

        if (nodetype == "ELEMENT") {

          pstmt.setLong(5, getRootNodeID());

          pstmt.setLong(6, getParentID());

        }

      }

      // Do the insertion

      pstmt.execute();

      pstmt.close();

      // get the generated unique id afterward

      nid = DatabaseService.getDBAdapter().getUniqueID(connection.getConnections(), "xml_nodes");

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

      }

    }

    return nid;

  }

    {

      PreparedStatement pstmt;

      if(data != null && !data.trim().equals("")){

            try{

                double numberData = Double.parseDouble(data);

        try {

        	separator = PropertyService.getProperty("document.accNumSeparator").charAt(0);

        } catch (PropertyNotFoundException pnfe) {

        			+ "Separator set to '.' : " + pnfe.getMessage());

        }

    }

        int count = 0; //keep track how many & was found

        Vector list = new Vector();// keep index number for &

        if (url == null) {

            return docid;

        }

        // the first element in list is 0

                // get substring beween two &

                String str = url.substring(

                        ((Integer) list.elementAt(count - 1)).intValue(), i);

                //if the subString contains docid, we got it

                if (str.indexOf(DOCID) != -1) {

                    //get index of '="

        // and

        // the end of string

        if (!find) {

            String str = url.substring(((Integer) list.elementAt(count))

                    .intValue() + 1, url.length());

            if (str.indexOf(DOCID) != -1) {

                //get index of '="

                int start = getIndexForGivenChar(str, '=') + 1;

                find = true;

            }//if

        }//if

        return docid.trim();

    }

        int end   = identifier.length();

        accessionNumber = identifier.substring(start, end);

      }

                                 accessionNumber);

      return accessionNumber;

    }

        int index = -1;

        // make sure str is not null

        if (str == null) {

                    "The given str is null and -1 will be returned");

            return index;

        }

                break;

            }//if

        }//for

        return index;

    }

    {

        String docId = null;

        if (str == null) {

                            + " in getDocIdfromString");

            return docId;

        } //make sure docid is not null

        if (accessionNumber == null) { return docid; }

        int indexOfLastSeperator = accessionNumber.lastIndexOf(separator);

        docid = accessionNumber.substring(0, indexOfLastSeperator);

                + docid);

        return docid;

    }

        accessionNumber = accessionNumber.substring(0, indexOfLastSeperator);

        indexOfLastSeperator = accessionNumber.lastIndexOf(separator);

        docid = accessionNumber.substring(0, indexOfLastSeperator) + version;

                                 + docid);

        return docid;

        if (docid == null) {

            docid = getDocIdFromAccessionNumber(str);

        }

                + docid);

        return docid;

    }

        rev = accessionNumber.substring(indexOfLastSeperator + 1,

                accessionNumber.length());

        revNumber = Integer.parseInt(rev);

                + revNumber);

        return revNumber;

    }

            }

        }

                + docidWithoutRev);

        return docidWithoutRev;

//    protected Stack textBufferStack = new Stack();

    //protected static final int MAXDATACHARS = 50;

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

    public void startDocument() throws SAXException

    {

        // Create the document node representation as root

        rootNode = new DBSAXNode(connection, this.docid);

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

	public void endDocument() throws SAXException {

		// Starting new thread for writing XML Index.

		// It calls the run method of the thread.

				}

			}

		} catch (Exception e) {

					+ e.getMessage());

			throw new SAXException("Failed to write triples into relation table "

					+ e.getMessage());

    public void startPrefixMapping(String prefix, String uri)

            throws SAXException

    {

        namespaces.put(prefix, uri);

    }

        // for element <eml:eml...> qname is "eml:eml", local name is "eml"

        // for element <acl....> both qname and local name is "eml"

        // uri is namespace

        DBSAXNode parentNode = null;

        DBSAXNode currentNode = null;

                } else {

                    doctype = docname;

                }

            } else if (doctype == null) {

                // because docname is not null and it is declared in dtd

                // so could not be in schema, no namespace

                doctype = docname;

            }

            rootNode.writeNodename(docname);

    /** SAX Handler that is called for each XML text node */

    public void characters(char[] cbuf, int start, int len) throws SAXException

    {

        // buffer all text nodes for same element. This is for if text was split

        // into different nodes

        textBuffer.append(new String(cbuf, start, len));

        // if text buffer .size is greater than max, write it to db.

        // so we can save memory

        if (textBuffer.length() > MAXDATACHARS) {

                    + " when text buffer size is greater than maxmum number");

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

            endNodeId = writeTextForDBSAXNode(endNodeId, textBuffer,

        // When validation is turned "on", white spaces are reported here

        // When validation is turned "off" white spaces are not reported here,

        // but through characters() callback

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

            // Write the content of the node to the database

                    docid);

    }

    /**

    public void processingInstruction(String target, String data)

            throws SAXException

    {

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

        endNodeId = currentNode.writeChildNodeToDB("PI", target, data, docid);

    }

    public void endElement(String uri, String localName, String qName)

            throws SAXException

    {

        // write buffered text nodes into db (so no splited)

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

        // into the buffer, write the buffer to data base. The reason we put

        // write database here is for xerces some time split text node

        if (hitTextNode) {

            endNodeId = writeTextForDBSAXNode(endNodeId, textBuffer,

                    currentNode);

        // we don't put the dtd node into node stack

        DBSAXNode dtdNode = new DBSAXNode(connection, name, publicId, systemId,

                currentNode, currentNode.getRootNodeID(), docid);

    }

    /**

    {

        processingDTD = false;

    }

    /**

     */

    public void comment(char[] ch, int start, int length) throws SAXException

    {

        if (!processingDTD) {

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

            endNodeId = currentNode.writeChildNodeToDB("COMMENT", null,

     */

    public void startCDATA() throws SAXException

    {

    }

    /**

     */

    public void endCDATA() throws SAXException

    {

    }

    /**

     */

    public void startEntity(String name) throws SAXException

    {

        //System.out.println("start ENTITY: " + name);

        if (name.equals("[dtd]")) {

            processingDTD = true;

     */

    public void endEntity(String name) throws SAXException

    {

        //System.out.println("end ENTITY: " + name);

        if (name.equals("[dtd]")) {

            processingDTD = false;

            throws org.xml.sax.SAXException

    {

        //System.out.println("ELEMENTDECL: " + name + " " + model);

    }

    /**

        //System.out.println("ATTRIBUTEDECL: " + eName + " "

        //                        + aName + " " + type + " " + valueDefault + " "

        //                        + value);

                + type + " " + valueDefault + " " + value);

    }

            throws org.xml.sax.SAXException

    {

        //System.out.println("INTERNENTITYDECL: " + name + " " + value);

    }

    /**

    {

        //System.out.println("EXTERNENTITYDECL: " + name + " " + publicId

        //                              + " " + systemId);

                + " " + systemId);

        // it processes other external entity, not the DTD;

        // it doesn't signal for the DTD here

     */

    public void fatalError(SAXParseException exception) throws SAXException

    {

        throw (new SAXException("Fatal processing error.", exception));

    }

     */

    public void error(SAXParseException exception) throws SAXException

    {

        throw (new SAXException("Error in processing EML.", exception));

    }

     */

    public void warning(SAXParseException exception) throws SAXException

    {

        throw (new SAXException("Warning.", exception));

    }

        // Check parameter

        if (strBuffer == null || node == null) { return nodeId; }

        boolean moredata = true;

        String normalizedData = strBuffer.toString();

        String afterNormalize = MetacatUtil.normalize(normalizedData);

        strBuffer = new StringBuffer(afterNormalize);;

        int bufferSize = strBuffer.length();

        // if there are some cotent in buffer, write it

        if (bufferSize > 0) {

                // Write the content of the node to the database

        }//if

        return nodeId;

    }

package edu.ucsb.nceas.metacat;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.io.FileWriter;

            // Bind the values to the query

            pstmt.setString(1, docid);

            pstmt.setString(2, TOPLEVEL);

            pstmt.execute();

            // Get result set

        // for element <eml:eml...> qname is "eml:eml", local name is "eml"

        // for element <acl....> both qname and local name is "eml"

        // uri is namesapce

        DBSAXNode parentNode = null;

        DBSAXNode currentNode = null;

                    //the revision

                    if (!super.getIsRevisionDoc())

                    {

                       currentDocument = new DocumentImpl(connection, rootNode

                            .getNodeID(), docname, doctype, docid, revision,

                            action, user, this.pub, catalogid, this.serverCode, 

                } catch (Exception ane) {

                }

            }

        logMetacat.info("IGNORABLEWHITESPACE");

        if (!handleInlineData) {

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

                //compare whitespace in access top module

                if (processTopLeverAccess && needCheckingAccessModule) {

                    /*compareWhiteSpace(currentUnchangableAccessModuleNodeStack,

                }

                endNodeId = currentNode.writeChildNodeToDB("TEXT", null, data,

                        docid);

        } else {

            //This is inline data write to file directly

            StringBuffer inlineWhiteSpace = new StringBuffer(new String(cbuf,

            logMetacat.info("Start node id is: " + startNodeId);

            pstmt.setLong(6, endNodeId);

            logMetacat.info("End node id is: " + endNodeId);

            pstmt.execute();

            pstmt.close();

        }//try

            //bind variable

            pStmt.setString(1, docid);

            //execute query

            pStmt.execute();

            pStmt.close();

        }//try

            pStmt.setString(4, RELATION);

            pStmt.setString(5, dataId);

            //execute query

            pStmt.execute();

            pStmt.close();

        }//try

					}

					if (revList.size() > 0) {

					} else {

					}

				} catch (Exception e) {

				}

			}

		logMetacat.debug("IGNORABLEWHITESPACE");

		if (!handleInlineData) {

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

				// compare whitespace in access top module

				if (processTopLevelAccess && needToCheckAccessModule) {

					compareWhiteSpace(currentUnchangeableAccessModuleNodeStack, data,

				}

				endNodeId = currentNode.writeChildNodeToDB("TEXT", null, data, docid);

		} else {

			// This is inline data write to file directly

			StringBuffer inlineWhiteSpace = new StringBuffer(new String(cbuf, start, len));