Metacat

/**

 *  '$RCSfile$'

 *  Copyright: 2000 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *

 * Author: John Harris

 * '$Date$'

 * '$Revision$'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat.spatial;

import java.util.Vector;

import org.apache.log4j.Logger;

/**

 * Class that reflects a dataset of Metacat Documents in a spatially represented

 * sense.  This dataset class is comprised of multiple MetacatSpatialDocument 

 * and uses the PersistentMetacatSpatialDataset class for IO with databases

 * and the file system

 */

public class MetacatSpatialDataset {

  private boolean initialized = false;

  private static Logger log = Logger.getLogger(MetacatSpatialDataset.class.getName());

  private Vector docs; // vector of MetacatSpatialDocument's 

  /** empty constructor **/

  public MetacatSpatialDataset() {

    this.initialized = true;

    docs = new Vector();

  }

  /*

   * Adds a new MetacatSpatialDocument to this dataset

   */

   public void add(MetacatSpatialDocument msdoc) {

    docs.add(msdoc);

   }

  /**

   * returns the data set as a flat-ascii table like:

   *

   * x y z segid 

   *

   * the data are delimited by spaces and each line is terminated bt '\n'

   */

  public StringBuffer getExtentsDataAsAscii() {

    StringBuffer _sb = new StringBuffer();

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

      MetacatSpatialDocument _doc = (MetacatSpatialDocument)docs.elementAt(i);

      if ( ! _doc.getIsPoint() ) {

        _sb.append( _doc.getXMin()+ " " + _doc.getYMin() + " 0 " + _doc.getDocid()+"\n");

        _sb.append( _doc.getXMax()+ " " + _doc.getYMin() + " 0 " + _doc.getDocid()+"\n");

        _sb.append( _doc.getXMax()+ " " + _doc.getYMax() + " 0 " + _doc.getDocid()+"\n");

        _sb.append( _doc.getXMin()+ " " + _doc.getYMax() + " 0 " + _doc.getDocid()+"\n");

      }

    }

    return _sb;

  }

  /*

   * Writes the dataset to the file system

   */

  public void writeTextQueryData() {

    // write the data stored in this object using the persistent layer

    PersistentMetacatSpatialDataset _writer = new PersistentMetacatSpatialDataset();

     _writer.writeTextQueryData(this);

  }

}

/**

 *  '$RCSfile$'

 *  Copyright: 2000 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *

 * Author: John Harris 

 * '$Date$'

 * '$Revision$'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat.spatial;

import org.apache.log4j.Logger;

/**

 * Class that reflects a query against Metacat to gatther spatial data  -- this

 * could be a text query that returns a spatial dataset or a spatial query that

 * returns a spatially-referenced dataset.

 */

public class MetacatSpatialQuery {

  private static Logger log = Logger.getLogger(MetacatSpatialQuery.class.getName());

  private MetacatSpatialDocument msd;

  private SpatialQueryProcessor mqp;

  public MetacatSpatialQuery() { }

  /**

   * returns the metacat spatial document retrieved by this query

   */

  public MetacatSpatialDocument getSpatialDocument(String docid) {

    msd = new MetacatSpatialDocument(docid);

    log.info("creating spatial reference for docid: " + docid);

    /** all database querying is carried out in the Query Processor */

    mqp = new  SpatialQueryProcessor();

    // this call will return the extents (a class) of the docid

    MetacatSpatialExtents _extents = mqp.queryExtentsByDocid(docid);

    //set the elements on the spatialdocument

    msd.setDocid(docid);

    msd.setExtents(_extents);

    // destroy the processor

    mqp.close();

   return msd; 

  }

}

/**

 *  '$RCSfile$'

 *  Copyright: 2003 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *

 * Author: John Harris

 * '$Date$'

 * '$Revision$'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat.spatial;

import java.io.*;

import java.net.URL;

import java.net.MalformedURLException;

import java.sql.*;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Stack;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.Transformer;

import javax.xml.transform.stream.StreamSource;

import javax.xml.transform.stream.StreamResult;

import javax.xml.transform.TransformerException;

import javax.xml.transform.TransformerConfigurationException;

import javax.xml.transform.URIResolver;

import org.apache.xerces.parsers.DOMParser;

import org.w3c.dom.Attr;

import org.w3c.dom.NamedNodeMap;

import org.w3c.dom.NodeList;

import org.w3c.dom.Document;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import org.w3c.dom.DocumentType;

import org.xml.sax.SAXException;

import org.xml.sax.InputSource;

import org.apache.xerces.dom.DocumentTypeImpl;

import org.apache.xpath.XPathAPI;

import org.w3c.dom.NamedNodeMap;

import org.w3c.dom.Document;

import org.w3c.dom.Node;

import org.w3c.dom.Element;

import org.xml.sax.SAXException;

//import edu.ucsb.nceas.utilities.IOUtil;

/**

 * A Class that transforms XML documents utitlizing XSL style sheets. This is

 * a convenience class that makes it easier to handle the location of

 * stylesheets and the mapping between a request and a particular stylesheet.

 */

public class XSLTransform {

    /**

     * Private constructor because all methids are static and do not need 

     * an instance.

     */

    public XSLTransform() 

    {

    }

    /**

     * Transform an XML document using an XSLT stylesheet to another format,

     * probably HTML or another XML document format.

     *

     * @param docString the document to be transformed

     * @param xslSystemId the system location of the stylesheet

     * @param pw the PrintWriter to which output is printed

     * @param params some parameters for inclusion to the transformation

     */

    public static void transform(String docString, String xslSystemId,

        PrintWriter pw, Hashtable param)

    {

        transform(new StringReader(docString), xslSystemId, pw, param);

    }

    /**

     * Transform an XML document using an XSLT stylesheet to another format,

     * probably HTML or another XML document format.

     *

     * @param doc the document to be transformed

     * @param xslSystemId the system location of the stylesheet

     * @param pw the PrintWriter to which output is printed

     * @param params some parameters for inclusion to the transformation

     */

    public static void transform(Reader doc, String xslSystemId,

        PrintWriter pw, Hashtable param)

    {

        try {

            StreamSource xslSource = 

                new StreamSource(xslSystemId);

            xslSource.setSystemId(xslSystemId);

            // Create a stylesheet from the system id that was found

            TransformerFactory tFactory = TransformerFactory.newInstance();

            Transformer transformer = tFactory.newTransformer(xslSource);

            // Set up parameters for transformation

            if ( param != null) {

                Enumeration en = param.keys();

                while (en.hasMoreElements()) {

                    String key =(String)en.nextElement();

                    String value = ((String)(param.get(key)));

                    transformer.setParameter(key, value);

                }

            }

            // Run the transform engine

            StreamSource ss = new StreamSource(doc);

            StreamResult sr = new StreamResult(pw);

            transformer.transform(ss, sr);

        } catch (Exception e) {

            pw.println("Error transforming document in " +

               "XSLTransform.transform:\n" + e.getMessage());

            e.printStackTrace(pw);

        }

    }

    /**

     * the main routine used to test the transform utility.

     *

     * Usage: java DBTransform

     */

    static public void main(String[] args) {

        if (args.length != 2)

        {

            System.err.println("Wrong number of arguments!!!");

            System.err.println("USAGE: java XSLTransform xml style");

            return;

        } else {

            String xmlfile = args[0];

            String xslfile = args[1];

            try {

                Reader r = new FileReader(xmlfile);

                XSLTransform.transform( r, xslfile, 

                        new PrintWriter(System.out), null);

            } catch (Exception e) {

                System.err.println("EXCEPTION HANDLING REQUIRED");

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

                e.printStackTrace(System.err);

            }

        }

    }

}

/**

 *  '$RCSfile$'

 *  Copyright: 2000 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *

 * Author: John Harris 

 * '$Date$'

 * '$Revision$'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat.spatial;

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.PrintStream;

import java.io.OutputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.FileNotFoundException;

import org.apache.log4j.Logger;

/**

 * Class for doing IO of spatial data from.  IO can be with the FS in the 

 * case of a shapefile, and or with a DB (as in the case of a PostGIS 

 * entry or a Metacat Entry)

 */

public class PersistentMetacatSpatialDataset {

  private String textQueryAsciiFile = "/tmp/mso_metacat_textquery.ascii";

  private static Logger log = Logger.getLogger(PersistentMetacatSpatialDataset.class.getName());

  /*

   * Writes the dataset to the file system

   */

  public void writeTextQueryData(MetacatSpatialDataset dataset) {

  try {

    PrintStream out = new PrintStream(new FileOutputStream(textQueryAsciiFile));

    out.println("#HEADER x y z segid");

    out.println( dataset.getExtentsDataAsAscii());

    out.close();

  } catch (FileNotFoundException fnfe) {

    log.fatal("ERROR: could not find the file ");

    fnfe.printStackTrace();

  }  

  }

}

/**

 *  '$RCSfile$'

 *  Copyright: 2003 Regents of the University of California.

 *

 * Author: John Harris

 * '$Date$'

 * '$Revision$'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat.spatial;

import java.io.File;

import java.io.FileReader;

import java.io.PrintWriter;

import java.io.IOException;

import java.io.StringReader;

import java.io.BufferedReader;

import java.io.Reader;

import java.io.FileInputStream;

import java.io.BufferedInputStream;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.ResourceBundle;

import java.util.Random;

import java.util.StringTokenizer;

import java.util.Properties;

import java.util.PropertyResourceBundle;

import java.util.Vector;

import java.util.Map;

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

import edu.ucsb.nceas.metacat.DBConnection;

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

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

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

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

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

import edu.ucsb.nceas.utilities.IOUtil;

import java.sql.ResultSet;

import java.sql.PreparedStatement;

import org.apache.log4j.Logger;

import org.apache.log4j.BasicConfigurator;

import org.apache.log4j.PropertyConfigurator;

public class SpatialQueryProcessor {

	private String METACATURL = "http://nebulous.msi.ucsb.edu:9999/knp/metacat";

  private File QUERYFILE = null;

	private String MCUSER = "uid=harris,o=NCEAS,dc=ecoinformatics,dc=org";

  private String MCPASS = "yeahRight";

  private  DBConnection dbconn;

	private static Logger log = Logger.getLogger(SpatialQueryProcessor.class.getName());

	/** constructor that uses the defaults **/

  public SpatialQueryProcessor() {

    try {

      dbconn = new DBConnection();

    } catch ( java.sql.SQLException se) { 

      log.fatal("Error connecting to the database ...");

      se.getMessage(); 

    } 

  } 

  /** call this after the processor is done **/

  protected void close() {

    try {

      dbconn.close();

    } catch ( java.sql.SQLException se) { 

      log.fatal("Error closing connecting to the database ...");

      se.getMessage(); 

    } 

  }

  public SpatialQueryProcessor(String mcUser, String mcPass, String metacatUrl,

	File queryFile) {

		log.debug("constructor called");

		this.METACATURL = metacatUrl;

		this.MCPASS =  mcPass;

		this.MCUSER = mcUser;

		this.QUERYFILE = queryFile;

	}

	public String execute() throws IOException {

		FileReader queryFileReader = new FileReader(QUERYFILE);

		String res = runQuery((Reader)queryFileReader);

		return res;

	}

  protected  MetacatSpatialExtents queryExtentsForDataset() {

  String query = "<?xml version=\"1.0\" ?> <pathquery version=\"1.2\"> " 

  +"<querytitle>Untitled-Search-2</querytitle>  "

  +"<returndoctype>-//ecoinformatics.org//eml-dataset-2.0.0beta6//EN</returndoctype> "

  +"<returndoctype>-//NCEAS//eml-dataset-2.0//EN</returndoctype> "

  +"<returndoctype>eml://ecoinformatics.org/eml-2.0.0</returndoctype> "

  +"<returnfield>dataset/title</returnfield> "

  +"<returnfield>individualName/surName</returnfield> "

  +"<returnfield>keyword</returnfield><returnfield>westBoundingCoordinate</returnfield>"

  +"<returnfield>eastBoundingCoordinate</returnfield><returnfield>northBoundingCoordinate"

  +"</returnfield><returnfield>southBoundingCoordinate</returnfield>"

  +"<returnfield>westbc</returnfield><returnfield>eastbc</returnfield>"

  +"<returnfield>northbc</returnfield><returnfield>southbc</returnfield>"

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

  +"<querygroup operator=\"UNION\"><queryterm searchmode=\"contains\" casesensitive=\"false\">"

  +"<value>%</value></queryterm></querygroup></querygroup></querygroup></pathquery>";

 StringReader _sr = new StringReader(query);

 String _result = runQuery(_sr);

 log.info("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$: result data: " + _result);

  return null;

 }

  /**

   * returns the north bounding coordinate -- this is a single point

   */

    private float queryNorthBoundingCoordinate(String docid) {

      float _coord = MetacatSpatialConstants.FLOAT_NULL; 

      PreparedStatement pstmt = null;

      ResultSet rs = null;

      String query = "select docid, nodedata, nodeid from xml_nodes where "

        +"nodeid =(select  nodeid from  xml_nodes where docid  like '"

        +docid.trim()+"' and nodename like 'north%')+1;";

      try {

        pstmt = dbconn.prepareStatement(query);

        pstmt.execute();

        rs = pstmt.getResultSet();

        if ( rs.next() )

         _coord = rs.getFloat(2);

        rs.close();

        pstmt.close();

      } catch (Exception e){

          log.error("Error getting docids from queryExtentsByDocid");

          e.printStackTrace();

      }

      return _coord;

    }

  /**

   * returns the east bounding coordinate -- this is a single point

   */

    private float queryEastBoundingCoordinate(String docid) {

      float _coord = MetacatSpatialConstants.FLOAT_NULL; 

      PreparedStatement pstmt = null;

      ResultSet rs = null;

      String query = "select docid, nodedata, nodeid from xml_nodes where "

        +"nodeid =(select  nodeid from  xml_nodes where docid  like '"

        +docid.trim()+"' and nodename like 'east%')+1;";

      try {

        pstmt = dbconn.prepareStatement(query);

        pstmt.execute();

        rs = pstmt.getResultSet();

        if ( rs.next() )

         _coord = rs.getFloat(2);

        rs.close();

        pstmt.close();

      } catch (Exception e){

          log.error("Error getting docids from queryExtentsByDocid");

          e.printStackTrace();

      }

      return _coord;

    }

  /**

   * returns the south bounding coordinate -- this is a single point

   */

    private float querySouthBoundingCoordinate(String docid) {

      float _coord = MetacatSpatialConstants.FLOAT_NULL; 

      PreparedStatement pstmt = null;

      ResultSet rs = null;

      String query = "select docid, nodedata, nodeid from xml_nodes where "

        +"nodeid =(select  nodeid from  xml_nodes where docid  like '"

        +docid.trim()+"' and nodename like 'south%')+1;";

      try {

        pstmt = dbconn.prepareStatement(query);

        pstmt.execute();

        rs = pstmt.getResultSet();

        if ( rs.next() )

         _coord = rs.getFloat(2);

        rs.close();

        pstmt.close();

      } catch (Exception e){

          log.error("Error getting docids from queryExtentsByDocid");

          e.printStackTrace();

      }

      return _coord;

    }

  /**

   * returns the west bounding coordinate -- this is a single point

   */

    private float queryWestBoundingCoordinate(String docid) {

      float _coord = MetacatSpatialConstants.FLOAT_NULL; 

      PreparedStatement pstmt = null;

      ResultSet rs = null;

      String query = "select docid, nodedata, nodeid from xml_nodes where "

        +"nodeid =(select  nodeid from  xml_nodes where docid  like '"

        +docid.trim()+"' and nodename like 'west%')+1;";

      try {

        pstmt = dbconn.prepareStatement(query);

        pstmt.execute();

        rs = pstmt.getResultSet();

        if ( rs.next() )

         _coord = rs.getFloat(2);

        rs.close();

        pstmt.close();

      } catch (Exception e){

          log.error("Error getting docids from queryExtentsByDocid");

          e.printStackTrace();

      }

      return _coord;

    }

  /**

   * Performs a spatial query given the docid as an input

   * 

   * @param docid -- the docid for which the extents are to be queried

   * @returns spatialextents -- the MetcataSpatialExtents object for this query

   */

    protected MetacatSpatialExtents queryExtentsByDocid(String docid) {

      MetacatSpatialExtents _extents = new MetacatSpatialExtents();

      float _northbc = queryNorthBoundingCoordinate(docid); 

      float _eastbc = queryEastBoundingCoordinate(docid); 

      float _southbc = querySouthBoundingCoordinate(docid); 

      float _westbc = queryWestBoundingCoordinate(docid); 

      if (( _northbc == _southbc) && (_eastbc == _westbc) ) {

       _extents.setIsPoint(true); } else { _extents.setIsPoint(false); }

      _extents.setYMin( (_southbc < _northbc?  _southbc :  _northbc) );

      _extents.setYMax( (_southbc > _northbc?  _southbc :  _northbc) );

      _extents.setXMin( (_westbc < _eastbc?  _westbc :  _eastbc) );

      _extents.setXMax( (_westbc > _eastbc?  _westbc :  _eastbc) );

      _extents.setDocid(docid);

      log.warn("**************************** > " + _extents.toString() );

      return _extents;

    }

	/**

		* Query the Metacat Server to get a list of documents, 

		* if it doesn't exist there, from the backend storage server.

		* 

		* @param query the xml description of the query to run

		* @return String the XML document string of the result set

		* @throws QueryFailedException when any thing happens to prevent a query

		*  returns

		*/

  private String runQuery(Reader query)

  {

    String document = null;

    Reader xdoc = null;

    String error = null;

    try {

      log.debug("creating metacat instance with: " + METACATURL);

      Metacat m = MetacatFactory.createMetacatConnection(METACATURL);

      m.login(MCUSER, MCPASS);

      log.debug("metacat instance: " + m);

      xdoc = m.query(query);

      document = IOUtil.getAsString(xdoc, true);

			m.logout();

      if (document == null) {

        throw new QueryFailedException("Document String Was null");

      }

    }

    catch(Exception e) {

      e.printStackTrace();

    }

    return document;

  }

}

/**

 *  '$RCSfile$'

 *  Copyright: 2000 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *

 * Author: John Harris 

 * '$Date$'

 * '$Revision$'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat.spatial;

import org.apache.log4j.Logger;

/**

 * Class that reflects a query against Metacat to gatther spatial data  -- this

 * could be a text query that returns a spatial dataset or a spatial query that

 * returns a spatially-referenced dataset.

 */

public class MetacatSpatialExtents {

  /** true if the document is represented by a single point and 

   *  false if is represented by a bouding box

   */

  private boolean isPoint = true;

  /** the coordinates of the bounding box, or of the point **/

  private float xmin, ymin, xmax, ymax; 

  /** the docid of the extents **/

  private String docid;

  private static Logger log = Logger.getLogger(MetacatSpatialExtents.class.getName());

  public MetacatSpatialExtents() {}

  public MetacatSpatialExtents(String _docid ) {

    setDocid(_docid);

  }

  public void setIsPoint(boolean valid) {

    this.isPoint = valid;

  }

  public boolean getIsPoint() {

    return this.isPoint;

  }

  public void setDocid(String _docid) {

    this.docid = _docid;

  }

  public String getDocid() {

    return docid;

  }

  public void setXMin(float _xmin) {

    this.xmin = _xmin;

  }

  public float getXMin() { return xmin; }

  public void setYMin(float _ymin) {

    this.ymin = _ymin;

  }

  public float getYMin() { return ymin; }

  public void setXMax(float _xmax) {

    this.xmax = _xmax;

  }

  public float getXMax() { return xmax; }

  public void setYMax(float _ymax) {

    this.ymax = _ymax;

  }

  public float getYMax() { return ymax; }

  public String toString() {

   return ("\n\n***************************************************************"

          +"\n docid: " +  docid + " \n is point: " + isPoint

          +"\n x min: " +  getXMin() + " \n x max: " + getXMax() 

          +"\n y min: " +  getYMin() + " \n y max: " + getYMax()

          +"\n***************************************************************\n"); 

  }

}

/**

 *  '$RCSfile$'

 *  Copyright: 2003 Regents of the University of California.

 *

 * Author: John Harris

 * '$Date$'

 * '$Revision$'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat.spatial;

public class MetacatSpatialConstants {

  public static final float FLOAT_NULL = (float)1e20;

}

/**

 *  '$RCSfile$'

 *  Copyright: 2000 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *

 * Author: John Harris

 * '$Date$'

 * '$Revision$'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat.spatial;

import org.apache.log4j.Logger;

/**

 * Exception thrown when an error occurs trying to query for the

 * list of meeting document

 */

public class QueryFailedException extends Exception {

    /**

     * Create a new QueryFailedException.

     *

     * @param message The error or warning message.

     */

    public QueryFailedException(String message) {

        super(message);

    }

}

/**

 *  '$RCSfile$'

 *  Copyright: 2000 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *

 * Author: John Harris

 * '$Date$'

 * '$Revision$'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat.spatial;

import org.apache.log4j.Logger;

/**

 * Class that reflects a Metacat Document in a spatially represented sense.

 */

public class MetacatSpatialDocument {

  private static Logger log = Logger.getLogger(MetacatSpatialDocument.class.getName());

  private String docid;

  private MetacatSpatialExtents extents;

  public MetacatSpatialDocument(String  docid) {

    setDocid(docid);

  }

  /**

   * function that registers the document with the Spatial system.  This is 

   * to be called when the document is inserted to the Metacat system.  At

   * registration time, this the Metacat Spatial Elements are requeruried, 

   * and the spatial database is repopulated

   */

  public void registerSpatialDocument() {

   log.info("Dataset " + docid + " is being registered with the metacat spatial system" ); 

  }

  public void setDocid(String _docid) {

    this.docid = _docid;

  }

  public void setExtents(MetacatSpatialExtents _extents) {

    this.extents = _extents;

  }

  public float getXMin() { return extents.getXMin(); }

  public float getYMin() { return extents.getYMin(); }

  public float getXMax() { return extents.getXMax(); }

  public float getYMax() { return extents.getYMax(); }

  public String getDocid() { return this.docid; }

  public boolean getIsPoint() { return extents.getIsPoint(); }

}

/**

 *  '$RCSfile$'

 *  Copyright: 2003 Regents of the University of California.

 *

 *   '$Author$'

 *     '$Date$'

 * '$Revision$'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat.spatial;

import java.io.File;

import java.io.FileReader;

import java.io.PrintWriter;

import java.io.IOException;

import java.io.StringReader;

import java.io.BufferedReader;

import java.io.Reader;

import java.io.FileInputStream;

import java.io.BufferedInputStream;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.ResourceBundle;

import java.util.Random;

import java.util.StringTokenizer;

import java.util.Properties;

import java.util.PropertyResourceBundle;

import java.util.Vector;

import java.util.Map;

import java.net.MalformedURLException;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.Connection;

import java.sql.SQLException;

import java.lang.reflect.*;

import java.net.*;

import java.util.zip.*;

import javax.servlet.ServletConfig;

import javax.servlet.ServletContext;

import javax.servlet.ServletException;

import javax.servlet.ServletInputStream;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.servlet.http.HttpSession;

import javax.servlet.http.HttpUtils;

import javax.servlet.ServletOutputStream;

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

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

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

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

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

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

import edu.ucsb.nceas.utilities.IOUtil;

import org.apache.log4j.Logger;

import org.apache.log4j.BasicConfigurator;

import org.apache.log4j.PropertyConfigurator;

/**

 * An application that manages the registration of ecological networks using the

 * metacat technology

 */

public class SpatialQueryManager extends HttpServlet

{

  private ServletConfig config = null;

  private ServletContext context = null;

  private Properties appConfig = null;

  private static final String CONFIG_DIR = "WEB-INF";

  private static final String CONFIG_NAME = "econet.properties";

  private static final String STYLE_DIR = "WEB-INF/";

  private String defaultStyle = null;

  private String metacatUrl = null;

  private String queryName = null;

  private String invalidRegistrationErrorPage = null;

// private EcoNetwork network;

  private String mcUser = "uid=jones,o=NCEAS,dc=ecoinformatics,dc=org";

  private String mcPass = "@mcpass@";

//	private  EconetCache cache;

  protected SpatialQueryProcessor queryProcessor;

	// this is the key val for the econet summary to be in the cache and 

	// it must be the same value as the value in the manager

//	private static String ECONET_SUMMARY_KEY = "econet_summary"; 

  private static Logger log = Logger.getLogger(SpatialQueryManager.class.getName());

  /**

   * Initialize the servlet during container startup

   */

  public void init(ServletConfig config) throws ServletException

  {

    try

    {

      super.init(config);

      this.config = config;

      this.context = config.getServletContext();

      //BasicConfigurator.configure();

      String prefix = getServletContext().getRealPath("/");

      System.out.println("SpatialQueryManager servlet context path  ####################### >>> " + prefix);

      String file = getInitParameter("log4j-init-file");

      System.out.println("SpatialQueryManager log4j-init-file  ####################### >>> " + file);

      System.out.println("SpatialQueryManager econet - metacat acct:  ####################### >>> " + mcUser);

      // if the log4j-init-file is not set, then no point in trying

      if (file != null)

      {

        PropertyConfigurator.configure(prefix + file);

      }

      try

      {

        // locate, open, and read the properties

        appConfig = new Properties();

        String dirPath = context.getRealPath(CONFIG_DIR);

        File propertyFile = new File(dirPath, CONFIG_NAME);

        FileInputStream fis = new FileInputStream(propertyFile);

				appConfig.load(fis);

				fis.close();

				defaultStyle = (String) appConfig.get("defaultStyle");

				metacatUrl = (String) appConfig.get("metacatUrl");

				System.out.println("SpatialQueryManager using metacat at url:  ####################### >>> " + metacatUrl);

				queryName = (String)appConfig.get("queryName");

				System.out.println("SpatialQueryManager query name :  ####################### >>> " + queryName);

				invalidRegistrationErrorPage = (String) appConfig.get("invalidRegistrationErrorPage");

      }

      catch(Throwable t)

      {

        throw new ServletException(t.getMessage());

      }

    }

    catch(ServletException ex) {

      throw ex;

    }

  }

  /** Handle "GET" method requests from HTTP clients */

  public void doGet(HttpServletRequest request, HttpServletResponse response)

  throws ServletException, IOException

  {

    handleGetOrPost(request, response);

  }

  /** Handle "POST" method requests from HTTP clients */

  public void doPost(HttpServletRequest request, HttpServletResponse response)

  throws ServletException, IOException

  {

    handleGetOrPost(request, response);

  }

  /**

   * Control servlet response depending on the action parameter specified

   */

  private void handleGetOrPost(HttpServletRequest request, HttpServletResponse response)

  throws ServletException, IOException

  {

    Hashtable params = getParamHash(request);

    String action = getAction(request);

      log.debug(">> action " + action);

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

      handleListAction(request, response);

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

      //handleRegisterAction(request, response);

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

      handleDeleteAction(request, response);

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

      handleDisplayDocAction(request, response);

    } else {

      handleListAction(request, response);

    }

  }

  /**

    * Reads a document from metacat and displays the information to the browser

    * @param request -- the HTTP request object

    * @param response -- the HTTP response object

    */

  private void handleDisplayDocAction(HttpServletRequest request, HttpServletResponse response)

  throws IOException

  {

    Hashtable params = getParamHash(request);

    String contextPath = request.getContextPath();

    String action = getAction(request);

    String styleSystemId = getStyleSystemId(action, defaultStyle);

    String docid = (String) getParamHash(request).get("docId");

    PrintWriter out = response.getWriter();

    ServletContext servletContext = getServletContext();

    response.setContentType ("text/html");

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

    {

      try {

				String doc = null;

	//			if ( cache.recover(docid) == null ) {

					log.debug("docid in the cache is null ... going to the db");

					Metacat m = MetacatFactory.createMetacatConnection(metacatUrl);

					m.login(mcUser, mcPass);

					Reader r = m.read(docid);

					doc = IOUtil.getAsString(r, true);

					r.close();

					m.logout();

					// adding this was giving a concurrent modification exception

					//cache.admit(docid, doc);

	//			} else {

//					log.debug("docid in the cache is valid");

//					doc = (String)cache.recover(docid);

//				}

        String dirPath = context.getRealPath(CONFIG_DIR);

				XSLTransform.transform(doc, styleSystemId, out, params);

				out.close();	

      }

      catch(Exception e) { e.printStackTrace(); }

    } else {

      out.println("no such docid!");

    }

    out.close();

  }

  /**

    * Deletes a network from the registration system.  This is called by the 

    * administrator to delete a registry from metacat. There is no response to 

    * the calling device - instead details are written to the logger 

    * @param request -- the HTTP request object

    * @param response -- the HTTP response object

    */

  private void handleDeleteAction(HttpServletRequest request, HttpServletResponse response) throws IOException

  {

    Hashtable params = getParamHash(request);

    String docId = (String)params.get("docId");

    // for the Metacat.delete request to be called the password needs to be the 

    // same as the mcpass var.

    String pass = (String)params.get("password");

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

      if ( pass.equals(mcPass) ) {

        log.info(">> deleting docid: " + docId);

        // add a lookup for an issued password.

        try

        {

         Metacat m = MetacatFactory.createMetacatConnection(metacatUrl);

         log.info(mcUser + " " + mcPass);

         m.login(mcUser, mcPass);

         String resp = m.delete(docId);

         log.info(">>deletion success is: " + resp);

        }

        catch(Exception e) { e.printStackTrace(); }

      }

    else { log.fatal("attempt to delete a registry with invalid pass"); }

    }

    else { log.fatal("attempt to delete a registry with NO pass"); }

  }

  /**

    *  Display the registered networks.  This is called when a list of 

    * regestered networks is requested for display and a transformation

    * is needed.  It queries the registered networks and then transforms the 

    * network docs using XSLT and displays the networks.

    * @param request -- the HTTP request object

    * @param response -- the HTTP response object

    */

  private void handleListAction(HttpServletRequest request, HttpServletResponse response) throws IOException

  {

    Hashtable params = getParamHash(request);

    String contextPath = request.getContextPath();

    String action = getAction(request);

    String styleSystemId = getStyleSystemId(action, defaultStyle);

    //String style = (String)pathData.get(1);

    PrintWriter out = response.getWriter();

    ServletContext servletContext = getServletContext();

    response.setContentType ("text/html");

    // get the query document

    String dirPath = context.getRealPath(CONFIG_DIR);

    File queryFile = new File(dirPath, queryName);

    // Query for the documents from the server

    String queryResult = null;

    try {

      // if the cache doesnt have the summary then get it from the database

//		if ( cache.recover(ECONET_SUMMARY_KEY) == null ) {

//			log.debug("summary in the cache is null ... going to the db");

				queryResult = queryProcessor.execute();

//				cache.admit(ECONET_SUMMARY_KEY, queryResult);

//			} else {

//				log.debug("summary in the cache is valid");

//				queryResult = (String)cache.recover(ECONET_SUMMARY_KEY);

//			}

    } catch(Exception e) { e.printStackTrace(); }

    log.debug("query result >> " + queryResult);

    XSLTransform.transform(queryResult, styleSystemId, out, params);

    out.close();

  }

  /**

    *  Register the network.  This is called when the attributes of a network 

    *  are submitted to the system.

    *

    * @param request -- the HTTP request object

    * @param response -- the HTTP response object

    */

/**  private void handleRegisterAction(HttpServletRequest request, HttpServletResponse response) throws IOException

  {

    Map params = getParamHash(request);

    String contextPath = request.getContextPath();

    String action = getAction(request);

    network = new EcoNetwork((Map) params);

    // add a validation step here 

    if (network.isValid() == true)

    {

      PrintWriter out = response.getWriter();

      response.setContentType ("text/html");

        log.info("about to insert: " + network.toXML());

      String metacatResponse = insertEcoNetwork(network.toXML());

        log.info("metacat response: " + metacatResponse);

      String styleSystemId = getStyleSystemId(action, defaultStyle);

        log.info("registration system id  " + styleSystemId);

        XSLTransform.transform(metacatResponse, styleSystemId, out, (Hashtable) params);

        // clear the summary from the cache which will be recovered either next

        // time the show all docs function is called or the ttl in the cache is

        // achived.

				cache.clear();

        out.close();