Metacat

import edu.ucsb.nceas.metacat.client.MetacatFactory;

import edu.ucsb.nceas.metacat.client.MetacatInaccessibleException;

import edu.ucsb.nceas.metacat.properties.PropertyService;

import edu.ucsb.nceas.utilities.IOUtil;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

import junit.framework.Test;

    /**

     * Returns an xml squery that searches for the doc id in the

     * other eml versions, this function might have to modified.

     */

    	String docType;

    	if (emlVersion.equals(EML2_0_1)) {

        		"<returndoctype>" + docType + "</returndoctype>" +

        		"<querygroup operator=\"UNION\">" +

        			"<queryterm casesensitive=\"false\" searchmode=\"contains\">" +

        				"<pathexpr>dataset/title</pathexpr>" +

        			"</queryterm>" +

        		"</querygroup>" +

        suite.addTest(new NonAsciiCharacterTest("quote210Test"));

        suite.addTest(new NonAsciiCharacterTest("numericCharacterReferenceFormat201Test"));

        suite.addTest(new NonAsciiCharacterTest("numericCharacterReferenceFormat210Test"));*/

        //suite.addTest(new NonAsciiCharacterTest("nonLatinUnicodeCharacter210Test"));

        return suite;

    }

     * Test inserting and reading an EML 2.0.1 document with the code representation 

     * of a micro sign (&#181). Read should succeed since the same document should be 

     * read back from disk that was submitted.  Query should succeed because we look 

     */

    public void numericCharacterReferenceFormat201Test() {

    	debug("\nRunning: numericCharacterReferenceFormat201Test");

            m.login(username, password);

            String testTitle = "Checking µ in doc: " + newdocid  + ".1";

            testdocument = getTestEmlDoc(testTitle, EML2_0_1);

            insertDocid(newdocid + ".1", testdocument, SUCCESS, true);

     * Test inserting and reading an EML 2.1.0 document with the code representation 

     * of a micro sign (&#181). Read should succeed since the same document should be 

     * read back from disk that was submitted.  Query should succeed because we look 

     */

    public void numericCharacterReferenceFormat210Test() {

    	debug("\nRunning: numericCharacterReferenceFormat210Test");

            m.login(username, password);

            String testTitle = "Checking µ in doc: " + newdocid  + ".1";

            testdocument = getTestEmlDoc(testTitle, EML2_1_0);

            insertDocid(newdocid + ".1", testdocument, SUCCESS, true);

    }

    /**

     * Read should succeed since the same document should be read back from disk 

     * that was submitted.  Query should succeed because we look for the same 

     */

    public void nonLatinUnicodeCharacter201Test() {

    	debug("\nRunning: nonLatinUnicodeCharacter201Test");

            String testTitle = "Checking characters like µ in doc: " + newdocid  + ".1";

            testdocument = getTestEmlDoc(testTitle, EML2_0_1);

            insertDocid(newdocid + ".1", testdocument, SUCCESS, false);

            // this tests reading the document back from disk

            String newdocid = generateDocid();

            m.login(username, password);

            testdocument = getTestEmlDoc(testTitle, EML2_1_0);

            insertDocid(newdocid + ".1", testdocument, SUCCESS, false);

            fail("General exception:\n" + e.getMessage());

        }

    }

    /**

     * Insert a document into metacat. The expected result is passed as result

     */

                               boolean expectMetacatException) {

        String response = null;

        try {

            response = m.insert(docid,

                                new StringReader(docText), null);

            System.err.println(response);

    }

    /**

     * Then check if the testTitle exists in the doc.

     * @param testTitle the title containing special characters

     * @param result are we expecting SUCCESS or FAILURE

     * @param expextedKarmaFailure

     */

                                         String emlVersion, boolean result) {

        try {

        	Reader queryReader = new StringReader(sQuery);

            Reader resultReader = m.query(queryReader);

            String queryResult = IOUtil.getAsString(resultReader, true);

package edu.ucsb.nceas.metacat;

import java.io.IOException;

import java.io.PrintWriter;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

    private static final String TRUE  = "true";

    private static String LOG_CONFIG_NAME = null;

    public static final String APPLICATION_NAME = "metacat";

    /**

     * Initialize the servlet by creating appropriate database connections

			HttpServletResponse response) throws ServletException, IOException {

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

		// Update the last update time for this user if they are not new

		HttpSession httpSession = request.getSession(false);

		if (httpSession != null) {

			// Now that we know the session is valid, we can delegate the

			// request to a particular action handler

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

				handler.handleQuery(out, params, response, userName, groupNames, sessionId);

				out.close();

			} else if (action.equals("squery")) {

				if (params.containsKey("query")) {

					handler.handleSQuery(out, params, response, userName, groupNames, sessionId);

					out.close();

				} else {

					out.close();

				}

			} else if (action.trim().equals("spatial_query")) {

				logMetacat

						.debug("MetaCatServlet.handleGetOrPost - ******************* SPATIAL QUERY ********************");

				handler.handleSpatialQuery(out, params, response, userName, groupNames, sessionId);

				out.close();

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.Reader;

import java.io.StringReader;

import java.io.Writer;

import java.net.URL;

import java.sql.PreparedStatement;

import edu.ucsb.nceas.utilities.UtilException;

import org.apache.commons.io.IOUtils;

import org.apache.log4j.Logger;

import org.xml.sax.ContentHandler;

import org.xml.sax.DTDHandler;

    /**

     * Print a string representation of the XML document

     */

    public String toString(String user, String[] groups, boolean withInlinedata)

    {

        try {

        } catch (McdbException mcdbe) {

            return null;

        }

        return document;

    }

    /**

     * Print a string representation of the XML document

     */

    public String toString()

    {

        String[] groupNames = null;

        boolean withInlineData = true;

        try {

        } catch (McdbException mcdbe) {

        	logMetacat.warn("Could not convert documentImpl to xml: " + mcdbe.getMessage());

            return null;

        }

        return document;

    }

    /**

     * Get a text representation of the XML document as a string This older

	 *            matter withinInlineData's value, the document will

	 * 

	 */

			throws McdbException {

		String documentDir = null;

		String documentPath = null;

			if (FileUtil.getFileStatus(documentPath) == FileUtil.DOES_NOT_EXIST

					|| FileUtil.getFileSize(documentPath) == 0) {

			}

		} catch (PropertyNotFoundException pnfe) {

			throw new McdbException("Could not write file: " + documentPath + " : "

			throw new McdbException("Attempting to read a zero length document from disk: " + documentPath);

		}

	}

    /**

	 *            matter withinInlineData's value, the document will

	 * 

	 */

    {

        // flag for process eml2

        boolean proccessEml2 = false;

        boolean processInlineData = false;

        TreeSet<NodeRecord> nodeRecordLists = null;

        // Here add code to handle subtree access control

        /*

                        logMetacat.debug("\n POPPED: "

                                + currentElement.getNodeName());

                        if (previousNodeWasElement) {

                            previousNodeWasElement = false;

                        }

                        if (currentElement.getNodePrefix() != null) {

                                    + currentElement.getNodeName() + ">");

                        } else {

                        }

                        currentElement = openElements.peek();

                    }

            // Handle the DOCUMENT node

            if (currentNode.getNodeType().equals("DOCUMENT")) {

                // Handle the ELEMENT nodes

            } else if (currentNode.getNodeType().equals("ELEMENT")) {

                    atRootElement = false;

                } else {

                    if (previousNodeWasElement) {

                    }

                }

                            && validateType.equals(DTD)) {

                        if ((doctype != null) && (system_id != null)) {

                                    + doctype + "\" \"" + system_id + "\">");

                        } else {

                        }

                    }

                }

                logMetacat.debug("\n PUSHED: " + currentNode.getNodeName());

                previousNodeWasElement = true;

                if (currentNode.getNodePrefix() != null) {

                            + currentNode.getNodeName());

                } else {

                }

                // if currentNode is inline and handle eml2, set flag process

                // Handle the ATTRIBUTE nodes

            } else if (currentNode.getNodeType().equals("ATTRIBUTE")) {

                if (currentNode.getNodePrefix() != null) {

                            + currentNode.getNodeName() + "=\""

                            + currentNode.getNodeData() + "\"");

                } else {

                            + currentNode.getNodeData() + "\"");

                }

                  nsprefix = " xmlns";

                }

                          + currentNode.getNodeData() + "\"");

                // Handle the TEXT nodes

            } else if (currentNode.getNodeType().equals("TEXT")) {

                if (previousNodeWasElement) {

                }

                if (!processInlineData) {

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

                } else {

                    // if it is inline data first to get the inline data

                    // internal id

                    	// inline data file path, to get it

                        Reader reader = Eml200SAXHandler

                        char[] characterArray = new char[4 * 1024];

                        try {

                            int length = reader.read(characterArray);

                            while (length != -1) {

                                                length));

                                out.flush();

                                length = reader.read(characterArray);

                    else {

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

                        // string in inline element.

                    }// else can't read inlinedata

                    // reset proccess inline data false

                    processInlineData = false;

                // Handle the COMMENT nodes

            } else if (currentNode.getNodeType().equals("COMMENT")) {

                if (previousNodeWasElement) {

                }

                previousNodeWasElement = false;

                // Handle the PI nodes

            } else if (currentNode.getNodeType().equals("PI")) {

                if (previousNodeWasElement) {

                }

                        + currentNode.getNodeData() + "?>");

                previousNodeWasElement = false;

                // Handle the DTD nodes (docname, publicid, systemid)

                        if ((dbPublicID != null) && (dbSystemID != null)) {

                            out

                                            + " PUBLIC \"" + dbPublicID

                                            + "\" \"" + dbSystemID + "\">");

                        } else {

                        }

                    }

            NodeRecord currentElement = (NodeRecord) openElements.pop();

            logMetacat.debug("\n POPPED: " + currentElement.getNodeName());

            if (currentElement.getNodePrefix() != null) {

                        + currentElement.getNodeName() + ">");

            } else {

            }

        }

        out.flush();

	 *            the location of the document on disk

	 * 

	 */

		String xmlFileContents = "";

		try {

            xmlFileContents = FileUtil.readFileToString(documentPath);

			// get a list of inline data sections that are not readable

			// by this user

            Hashtable<String, String> unReadableInlineDataList =

				}

			}

            // write the doc

			pw.write(xmlFileContents);

			pw.close();	

	 * @param accNumber

	 *            the document id which is used to name the output file

	 */

		// write the document to disk

		String documentDir = null;

		String documentPath = null;

					&& (FileUtil.getFileStatus(documentPath) == FileUtil.DOES_NOT_EXIST 

							|| FileUtil.getFileSize(documentPath) == 0)) {

			    try

			    {

			        FileOutputStream fos = new FileOutputStream(documentPath);

			        fos.flush();

			        fos.close();

			    }

		} catch (PropertyNotFoundException pnfe) {

			throw new McdbException("Could not write file: " + documentPath + " : "

					+ pnfe.getMessage());

	}	

    /**

                    //System.out.println("In lockgranted");

                	logReplication.info("lock granted for " + accnum

                            + " from " + server);

                    /*

                     * XMLReader parser = initializeParser(conn, action, docid,

                     * updaterev, validate, user, groups, pub, serverCode, dtd);

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

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

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

                                   //null, null are createdate and updatedate

                                   //null will use current time as create date time

                    conn.setAutoCommit(false);

                    conn.setAutoCommit(true);

                    //write the file to disk

                    // write to xml_node complete. start the indexing thread.

                    addDocidToIndexingQueue(docid, rev);

        }

        XMLReader parser = null;

        try {

            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

            conn.setAutoCommit(true);

            //write the file to disk

            addDocidToIndexingQueue(docid, rev);

        } catch (Exception e) {

        	logMetacat.error("DocumentImpl.write - Problem with parsing: " + e.getMessage());

            {

                isRevision = true;

            }

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

                    pub, serverCode, dtd, ruleBase, needValidation, 

            conn.setAutoCommit(false);

            parser.parse(new InputSource(xmlReader));

            conn.setAutoCommit(true);

            // Write the file to disk

            // write to xml_node complete. start the indexing thread.

            // this only for xml_documents

            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 {

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

                        user, groups, pub, serverCode, createDate, updateDate);

                chandler.setIsRevisionDoc(isRevision);

                parser.setContentHandler((ContentHandler) chandler);

                parser.setErrorHandler((ErrorHandler) chandler);

                parser.setProperty(DECLARATIONHANDLERPROPERTY, chandler);

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

                        user, groups, pub, serverCode, createDate, updateDate);

                chandler.setIsRevisionDoc(isRevision);

                parser.setContentHandler((ContentHandler) chandler);

                parser.setErrorHandler((ErrorHandler) chandler);

                parser.setProperty(DECLARATIONHANDLERPROPERTY, chandler);

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

                        groups, pub, serverCode, createDate, updateDate);

                chandler.setIsRevisionDoc(isRevision);

                parser.setContentHandler((ContentHandler) chandler);

                parser.setErrorHandler((ErrorHandler) chandler);

                parser.setProperty(DECLARATIONHANDLERPROPERTY, chandler);

                if (useOldReadAlgorithm) {

                    logMetacat.error("DocumentImpl.main - " + xmldoc.readUsingSlowAlgorithm());

                } else {

                }

            } else if (action.equals("DELETE")) {

                DocumentImpl.delete(docid, null, null,null);

            }

            dbconn.close();

        } catch (McdbException me) {

        } catch (AccessionNumberException ane) {

            System.err.println(ane.getMessage());

        } catch (Exception e) {

import java.io.BufferedInputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.io.PrintWriter;

import java.io.StringReader;

import java.io.ByteArrayOutputStream;

import java.io.Writer;

import java.net.MalformedURLException;

import java.net.URL;

import java.util.zip.ZipEntry;

import java.util.zip.ZipOutputStream;

import javax.servlet.ServletOutputStream;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.servlet.http.HttpSession;

import javax.activation.MimetypesFileTypeMap;

import org.apache.log4j.Logger;

import org.ecoinformatics.eml.EMLParser;

import edu.ucsb.nceas.metacat.replication.ForceReplicationHandler;

import edu.ucsb.nceas.metacat.service.SessionService;

import edu.ucsb.nceas.metacat.service.XMLSchemaService;

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

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

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

public class MetacatHandler {

    private static boolean _sitemapScheduled = false;

    // Constants -- these should be final in a servlet    

    private static final String PROLOG = "<?xml version=\"1.0\"?>";

     * queries supported by the WFS / WMS standards

     * 

     * handleSQuery(out, params, response, username, groupnames, sess_id);

     */

            HttpServletResponse response,

            String username, String[] groupnames,

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

        if ( !PropertyService.getProperty("spatial.runSpatialOption").equals("true") ) {

            response.setContentType("text/html");

        }

        /*

     * @param response the response object linked to the client

     * @param conn the database connection

     */

            HttpServletResponse response, String user, String[] groups,

            String sessionid) throws PropertyNotFoundException {

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

     * @param params the Hashtable of parameters that should be included in the

     *            squery.

     * @param response the response object linked to the client

     */

            HttpServletResponse response, String user, String[] groups,

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

        long queryWarnLimit = Long.parseLong(PropertyService.getProperty("database.queryTimeWarnLimit"));

      throws Exception

    {

        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        handleQuery(out, params, null, username, groups, sessionid);

        out.flush();

        baos.flush();

        //baos.close(); 

        //System.out.println("result from query: " + baos.toString());

        return rs;

    }

                    // Try to get the metadata file from disk. If it isn't

                    // found, create it from the db and write it to disk then.

                    try {

                    } catch (McdbException e) {

                        // any exceptions in reading the xml from disc, and we go back to the

                        // old way of creating the xml directly.

                        logMetacat.error("MetaCatServlet.readFromMetacat - could not read from document file " + docid 

                                + ": " + e.getMessage());

                        e.printStackTrace(System.out);

                    }

                } else {

                    // TODO MCD, this should read from disk as well?

                        response.setContentType("text/html"); //MIME type

                    }

                    // Look up the document type

                    String doctype = doc.getDoctype();

                    // Transform the document to the new doctype

                    DBTransform dbt = new DBTransform();

                }

            }

                } else {

                    // this is metadata doc; add doc to zip

                    //use provided file name if given

                    if (providedFileName != null && providedFileName.length() > 1) {

                        zentry = new ZipEntry(providedFileName);

                logMetacat.info("MetaCatServlet.handleInsertMultipartAction - Uploading the following to Metacat:" +

                        fileName + ", " + docid + ", " +

                        username + ", " + groupnames);

                char[] c = new char[1024];

                int numread = fr.read(c, 0, 1024);

                StringBuffer sb = new StringBuffer();

     */

    protected void handleSetAccessAction(PrintWriter out, Hashtable<String, String[]> params,

            String username, HttpServletRequest request, HttpServletResponse response) {

        String permission = null;

        String permType = null;

        String permOrder = null;

                    //insert permission

                    AccessControlForSingleFile accessControl = 

                        new AccessControlForSingleFile(accessionNumber);

                    //System.out.println("permission in MetacatHandler: " + l.longValue());

                    //System.out.println("permission in MetacatHandler: " + Integer.valueOf(AccessControlList.intValue(permission)).longValue());

                    accessControl.insertPermissions(principal, Integer.valueOf(AccessControlList.intValue(permission)).longValue(), permType, permOrder);

     */

    private String getFieldValueForDoc(String accessionNumber, String fieldName)

    throws Exception {

        if (accessionNumber == null || accessionNumber.equals("")

        || fieldName == null || fieldName.equals("")) { throw new Exception(

                "Docid or field name was not specified"); }

     * A method to output setAccess action result

     */

    private void outputResponse(Vector<String> successList, Vector<String> errorList,

    }

    /*

     * append rev for it. The rev come from xml_documents

     */

    private static String appendRev(String docid) throws PropertyNotFoundException, SQLException, McdbDocNotFoundException {

        String newAccNum = null;

        String separator = PropertyService.getProperty("document.accNumSeparator");

        int firstIndex = docid.indexOf(separator);

     * @param request a servlet request, from which we determine the context

     */

    protected void scheduleSitemapGeneration(HttpServletRequest request) {

        if (!_sitemapScheduled) {

            String directoryName = null;

            String skin = null;

package edu.ucsb.nceas.metacat;

import java.io.PrintWriter;

/**

 * Exception thrown when an error occurs because a problem occurred in

   * is null, and if the tunnelled exception is not null, then

   * it returns the message from the tunnelled exception.

   */

    String msg = super.getMessage();

    if (msg == null && exception != null) {

      msg = exception.getMessage();

    }

  }

}

package edu.ucsb.nceas.metacat;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import javax.servlet.ServletOutputStream;

import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;

import edu.ucsb.nceas.metacat.accesscontrol.AccessControlInterface;

import edu.ucsb.nceas.metacat.database.DBConnection;

import edu.ucsb.nceas.metacat.database.DBConnectionPool;

     * the main routine used to test the DBQuery utility.

     * <p>

     * Usage: java DBQuery <xmlfile>

     * @param xmlfile the filename of the xml file containing the query

     */

    static public void main(String[] args)

                // Execute the query

                DBQuery queryobj = new DBQuery();

                Hashtable nodelist = null;

                //nodelist = queryobj.findDocuments(xml, null, null, useXMLIndex);

                //write into a file "result.txt"

                if (!showRuntime) {

                    File f = new File("./result.txt");

                    BufferedWriter out = new BufferedWriter(fw);

                    out.write(result.toString());

                    out.flush();

   * @param sessionid  the sessionid

   */

  public void findDocuments(HttpServletResponse response,

                                       String user, String[] groups,

                                       String sessionid) throws PropertyNotFoundException

  {

     * @param sessionid  the sessionid

     */

    public void findDocuments(HttpServletResponse response,

                                         String user, String[] groups,

                                         String sessionid, boolean useXMLIndex)

    {

      {

        //knb format, in this case we will get whole result and sent it out

        response.setContentType("text/html");

        StringBuffer xml = createResultDocument(xmlquery, qspec, nonout, user,

                                                groups, useXMLIndex, pagesize, 

                                                pagestart, sessionid, qformat);

   */

    public StringBuffer createResultDocument(String xmlquery,

                                              QuerySpecification qspec,

                                              String user, String[] groups,

                                              boolean useXMLIndex)

    {

   */

  public StringBuffer createResultDocument(String xmlquery,

                                            QuerySpecification qspec,

                                            String user, String[] groups,

                                            boolean useXMLIndex, int pagesize,

                                            int pagestart, String sessionid, 

    //send out a new query

    if (out != null)

    {

    }

    if (qspec != null)

    {

    resultset.append(closeRestultset);

    if (out != null)

    {

    }

    //default to returning the whole resultset

     * Find the doc list which match the query

     */

    private StringBuffer findResultDoclist(QuerySpecification qspec,

                                      String user, String[]groups,

                                      DBConnection dbconn, boolean useXMLIndex,

                                      int pagesize, int pagestart, String sessionid, 

   	    	logMetacat.info("DBQuery.findResultDoclist - result from cache !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");

   	    	 if (out != null)

   	         {

   	         }

   	    	 resultsetBuffer.append(cachedResult);

   	    	 return resultsetBuffer;

     resultsetBuffer.append("\n<lastpage>" + lastpage + "</lastpage>\n");

     if (out != null)

     {

     }

     // now we only cached none-paged query and user is public

     */

    private StringBuffer handleSubsetResult(QuerySpecification qspec,

                                           StringBuffer resultset,

                                           String user, String[]groups,

                                       DBConnection dbconn, boolean useXMLIndex,

                                       String qformat)

         //send single element to output

         if (out != null)

         {

         }

         resultset.append(xmlElement);

     }//while

         //send single element to output

         if (out != null)

         {

         }

         resultset.append(xmlElement);

     }//while

package edu.ucsb.nceas.metacat;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Iterator;

   */

  public void transformXMLDocument(String doc, String sourceType,

                                   String targetType, String qformat,

                                   String sessionid)

 {