Metacat

				PrintWriter out = response.getWriter();

				if ((userName != null) && !userName.equals("public")) {

					handler.handleInsertOrUpdateAction(request.getRemoteAddr(), request.getHeader("User-Agent"), response, out, params, userName,

				} else {

					response.setContentType("text/xml");

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

     *            the user that owns the document

     * @param groups

     *            the groups to which user belongs

     */

    /*

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

    public static String write(DBConnection conn, String xmlString, String pub,

            Reader dtd, String action, String docid, String user,

            throws Exception

    {

        //this method will be called in handleUpdateOrInsert method

        // get server location for this doc

        int serverLocation = getServerLocationNumber(docid);

        return write(conn, xmlString, pub, dtd, action, docid, user, groups,

    }

    /**

     *            checked upon update for a file lock. if override = false then

     *            a document not from this server, upon update will be locked

     *            and version checked.

     */

    public static String write(DBConnection conn, String xmlString, String pub,

            Reader dtd, String action, String accnum, String user,

            String[] groups, int serverCode, boolean override, String ruleBase,

    {

        // NEW - WHEN CLIENT ALWAYS PROVIDE ACCESSION NUMBER INCLUDING REV IN IT

                    logMetacat.debug("DocumentImpl.write - initializing parser");

                    parser = initializeParser(conn, action, docid, xmlReader, updaterev,

                            user, groups, pub, serverCode, dtd, ruleBase,

                    	// false means it is not a revision doc

                                   //null, null are createdate and updatedate

                                   //null will use current time as create date time

	        String encoding = xsr.getEncoding();

            parser = initializeParser(conn, action, docid, xmlReader, rev, user, groups,

                    // null and null are createtime and updatetime

                    // null will create current time

                    //false means it is not a revision doc

            // detect encoding

            XmlStreamReader xsr = new XmlStreamReader(new ByteArrayInputStream(xmlString.getBytes()));

	        String encoding = xsr.getEncoding();

            parser = initializeParser(conn, action, docid, xmlReader, rev, user, groups,

                    pub, serverCode, dtd, ruleBase, needValidation, 

            conn.setAutoCommit(false);

            parser.parse(new InputSource(xmlReader));

    /**

     * Set up the parser handlers for writing the document to the database

     */

    private static XMLReader initializeParser(DBConnection dbconn,

            String action, String docid, Reader xml, String rev, String user,

            String[] groups, String pub, int serverCode, Reader dtd,

            String ruleBase, boolean needValidation, boolean isRevision,

    {

        XMLReader parser = null;

        try {

            if (ruleBase != null && ruleBase.equals(EML200)) {

                logMetacat.info("DocumentImpl.initalizeParser - Using eml 2.0.0 parser");

                chandler = new Eml200SAXHandler(dbconn, action, docid, rev,

                chandler.setIsRevisionDoc(isRevision);

                chandler.setEncoding(encoding);

                parser.setContentHandler((ContentHandler) chandler);

            } else if (ruleBase != null && ruleBase.equals(EML210)) {

                logMetacat.info("DocumentImpl.initalizeParser - Using eml 2.1.0 parser");

                chandler = new Eml210SAXHandler(dbconn, action, docid, rev,

                chandler.setIsRevisionDoc(isRevision);

                chandler.setEncoding(encoding);

                parser.setContentHandler((ContentHandler) chandler);

                //create a DBSAXHandler object which has the revision

                // specification

                chandler = new DBSAXHandler(dbconn, action, docid, rev, user,

                chandler.setIsRevisionDoc(isRevision);

                chandler.setEncoding(encoding);

                parser.setContentHandler((ContentHandler) chandler);

	/* Attributes */

	private String ruleBase = null;

	private boolean needValidation = false;

	/**

	 *  Constructor of DocumentImpleWrapper

	 *  @param myRuleBase  the xml is base on DTD or Schema

	 *  @param validation  if the xml document need to be validated

	 */

		ruleBase = myRuleBase;

		needValidation = validation;

	}//Constructor

	public String write(DBConnection conn, String xml, String pub, Reader dtd,

			String action, String docid, String user, String[] groups) throws Exception {

		return DocumentImpl.write(conn, xml, pub, dtd, action, docid, user, groups,

	}

	public String writeReplication(DBConnection conn, String xml, String pub, Reader dtd,

     */

    public String handleInsertOrUpdateAction(String ipAddress, String userAgent,

            HttpServletResponse response, PrintWriter out, Hashtable<String, String[]> params,

        Logger logMetacat = Logger.getLogger(MetacatHandler.class);

        DBConnection dbConn = null;

        int serialNumber = -1;

            if (validate) {

                // set a dtd base validation parser

                String rule = DocumentImpl.DTD;

            } else {

                namespace = XMLSchemaService.findDocumentNamespace(xmlReader);

                        // using emlparser to check id validation

                        @SuppressWarnings("unused")

                        EMLParser parser = new EMLParser(doctext[0]);

                    } else if (

                    		namespace.compareTo(DocumentImpl.EML2_1_0NAMESPACE) == 0

                    		|| namespace.compareTo(DocumentImpl.EML2_1_1NAMESPACE) == 0) {

                        // using emlparser to check id validation

                        @SuppressWarnings("unused")

                        EMLParser parser = new EMLParser(doctext[0]);

                    } else {

                        // set schema base validation parser

                        String rule = DocumentImpl.SCHEMA;

                    }

                } else {

                }

            }

                String[] doctextArr = new String[1];

                doctextArr[0] = doctext;

                params.put("doctext", doctextArr);

                //call the insert routine

                handleInsertOrUpdateAction(request.getRemoteAddr(), request.getHeader("User-Agent"), response, out, 

              }

              catch(Exception e)

              {

    	     String rule = DocumentImpl.EML210;

             // using emlparser to check id validation

             EMLParser parser = new EMLParser(eml210Content);

//             StringReader xml = new StringReader(eml210Content);

             String  doAction = "UPDATE";

             String pub = null;

    // do the insert or update action

    handler = new MetacatHandler(new Timer());

    String result = handler.handleInsertOrUpdateAction(request.getRemoteAddr(), request.getHeader("User-Agent"), null, 

    if(result.indexOf("<error>") != -1) {

    	String detailCode = "";

    boolean startParseTriple = false;

    boolean hasTriple = false;

    public static final String ECOGRID = "ecogrid://";

    private Logger logMetacat = Logger.getLogger(DBSAXHandler.class);

     */

    public DBSAXHandler(DBConnection conn, String action, String docid,

            String revision, String user, String[] groups, String pub,

    {

        this(conn, createDate, updateDate);

        this.action = action;

        this.groups = groups;

        this.pub = pub;

        this.serverCode = serverCode;

    }

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

     */

    public Eml200SAXHandler(DBConnection conn, String action, String docid,

            String revision, String user, String[] groups, String pub,

    {

        super(conn, action, docid, revision, user, groups, pub, 

        // Get the unchangable subtrees (user doesn't have write permission)

        try

        {

          // info into xml_accesssubtree about the top access, additional access

          // and some third place access modules which are referenced by top

          // level or additional level

          //delete relation table

          deleteRelations();

	 */

	public Eml210SAXHandler(DBConnection conn, String action, String docid,

			String revision, String user, String[] groups, String pub, int serverCode,

		super(conn, action, docid, revision, user, groups, pub, serverCode, createDate,

		// Get the unchangeable subtrees (user doesn't have write permission)

		try {

		// This maybe cause user change the subtree id

		if (!super.getIsRevisionDoc()) {

			// write access rule to db

			// delete relation table

			deleteRelations();

			// write relations

        parserBase = DocumentImpl.EML210;

      }

      // Write the document into local host

      String newDocid = wrapper.writeReplication(dbConn,

                              newxmldoc,

                              docinfoHash.get("public_access"),

					.getDBConnection("MetacatReplication.handleForceReplicateRequest");

			serialNumber = dbConn.getCheckOutSerialNumber();

			// write the document to local database

			//try this independently so we can set access even if the update action is invalid (i.e docid has not changed)

			try {

				wrapper.writeReplication(dbConn, xmldoc, null, null,