Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A class to asyncronously do delta-T replication checking

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

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Chad Berkley

 *

 *   '$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

 */

import java.io.StringReader;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.Hashtable;

import java.util.Vector;

import org.apache.xerces.parsers.DOMParser;

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 javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.transform.*;

import javax.xml.transform.stream.*;

import javax.xml.transform.dom.*;

/**

 * This class will figure out which content type it is for a given data file.

 * First, from xml_relation to get all relative files to this data file.

 * Then from xml_documents to get physical files. From physical file pull out

 * the content type

 */

public class ContentTypeProvider

{

  private String dataFileId = null;

  private String contentType = null;

  private String packageType = null;

  private Hashtable contentTypeHash = new Hashtable();

  private String BETA = "beta";

  private String EML2 = "eml2";

  private String DEFAULTCONTENTTYPE = MetaCatUtil.

                                           getOption("defaultcontenttype");

  private String FORMATPATH = "//format";

  private String TEXT       = "text";

  private String TEXTYPE    ="text/plain";

  private String XML        = "xml";

  private String XMLTYPE    = "text/xml";

  private String HTML       = "HTML";

  private String HTMLTYPE   = "text/html";

  private String GIF        = "gif";

  private String JPEGTYPE   = "image/jpeg";

  private String BMP        = "bmp";

  private String BMPTYPE    = "image/bmp";

  private String TAR        = "tar";

  private String TARTYPE    ="application/x-tar";

  private String ZIP        = "zip";

  private String ZIPTYPE    = "application/x-zip-compressed";

  private String BINARY     = "binary";

  private String BINARYTYPE = "application/octet-stream";

  private String PHYSICALDOCTYPE = "physicaldoctype";

  private String DATAFORMAT = "dataFormat";

  private String TEXTFORMAT = "textFormat";

  private String EXTENALFORMAT = "externallyDefinedFormat";

  private String FORMATNAME = "formatName";

  private String BINARYRASTERFORMAT = "binaryRasterFormat";

   * Constructor of ContentTypeProvider

   */

  public ContentTypeProvider(String docIdWithRevision)

  {

    dataFileId = MetaCatUtil.getDocIdFromString(docIdWithRevision);

    //get relative doclist for data file and package type

    Vector docLists = null;

    docLists = getRelativeDocIdList(dataFileId);

    {

      // other situation, contenetype is default value

      contentType = DEFAULTCONTENTTYPE;

    }

    else if (packageType.equals(BETA))

    {

      // for beta package and get entity docid for the data file

      String entityDocid = getTargetDocIdForBeta(docLists, ENTITYDOCTYPE);

      // get physical docid for data file

      docLists = getRelativeDocIdList(entityDocid);

      String physicalDocId = getTargetDocIdForBeta(docLists, PHYSICALDOCTYPE);

      // if no physical docid assign to this data file, content type is default

      if (physicalDocId == null)

      {

      }

      else

      {

      }

    }

    else if (packageType.equals(EML2))

    {

      // for eml2 package

      String eml2Docid = (String)docLists.elementAt(0);

  public String getContentType()

  {

    return contentType;

  }//getContentType

  private void findContentTypeInEML2(String eml2DocId)

  {

    {

      contentType = DEFAULTCONTENTTYPE;

      return;

    }

    String xmlString = null;

    StringReader read = null;

    InputSource in = null;

    DocumentBuilderFactory dfactory = null;

    Document doc = null;

    // create xml document

    try

    {

                    DBUtil.getLatestRevisionInDocumentTable(eml2DocId);

      //System.out.println("the acc number is !!!!!!!!!!!!!!!!!"+accNumber);

      xmlDoc = new DocumentImpl(accNumber);

      read = new StringReader(xmlString);

      in = new InputSource(read);

      dfactory = DocumentBuilderFactory.newInstance();

      dfactory.setNamespaceAware(false);

      doc = dfactory.newDocumentBuilder().parse(in);

    }

    catch (Exception e)

    {

      // if faild, set default value

      contentType = DEFAULTCONTENTTYPE;

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

    }

    {

      contentType = DEFAULTCONTENTTYPE;

    }

    // go through childList

    for (int i = 0; i<childList.getLength(); i++)

    {

      Node child = childList.item(i);

      if (child.getNodeName() != null && child.getNodeName().equals(TEXTFORMAT))

      {

      }

      if (child.getNodeName() != null && child.getNodeName().equals(EXTENALFORMAT))

      {

        contentType = (String)lookUpContentType(format);

        if (contentType == null)

        {

          contentType = BINARYTYPE;

        }

      }

      if (child.getNodeName() != null && child.getNodeName().

          equals(BINARYRASTERFORMAT))

      {

        contentType = BINARYTYPE;

      }//if

    }//for

    //if contentype still be null, set default value

    if (contentType == null)

    {

      contentType = DEFAULTCONTENTTYPE;

    }

  }

  {

    String textValue = null;

    NodeList childList = parentNode.getChildNodes();

    for (int i= 0; i<childList.getLength();i++)

    {

      Node child = childList.item(i);

      if (child.getNodeName() != null && child.getNodeName().equals(childTagName))

      {

        if (textNode.getNodeType() == Node.TEXT_NODE)

        {

          textValue = textNode.getNodeValue();

        }//if

      }//if

    }//for

                             " is " + textValue);

  }//getTExtValueForGivenChildTag

  {

    Node targetNode = null;

    Node node = findDataFileNodeInEML2(xml, xPath, targetDocId);

      // the grand'parent is physical

      Node phyicalNode = node.getParentNode().getParentNode().getParentNode();

      NodeList list = phyicalNode.getChildNodes();

      for (int i = 0; i < list.getLength(); i++)

        // find dataFormat node

        if (kid.getNodeType() == node.ELEMENT_NODE &&

            kid.getNodeName().equals(DATAFORMAT))

        {

          targetNode = kid;

          break;

        } //if

      } //for

      if (targetNode != null)

      {

                                 targetNode.getNodeName());

    }//if

  }

  /* Find the datafile node */

  {

    Node dataFileNode = null;

    NodeList list = null;

    try

    {

      list = XPathAPI.selectNodeList(xml, xPath);

    }

    catch (Exception e)

    {

      // catch an error and return null

    }

    // go through the list and find target docid in online/url

        Node textNode = node.getFirstChild();

        if (textNode.getNodeType() == node.TEXT_NODE)

          if (URLData.indexOf(DBSAXHandler.ECOGRID) != -1 )

            String docId = MetaCatUtil.

                               getAccessionNumberFromEcogridIdentifier(URLData);

            // Get rid of revision

            docId = MetaCatUtil.getDocIdFromAccessionNumber(docId);

                                     docId);

            if (docId != null && docId.equals(targetDocId))

            {

                                       docId);

              break;

            }

          } //if

        } //if

      } //for

    }//if

  }//findDataFileNode

    Vector docList = new Vector();

    ResultSet rs = null;

    PreparedStatement pStmt=null;

    DBConnection conn = null;

    int serialNumber = -1;

    try

    {

      //check out DBConnection

      conn=DBConnectionPool.getDBConnection

                                   ("ContentTypeProvider.getRelativeDocIdlist");

      serialNumber=conn.getCheckOutSerialNumber();

      pStmt = conn.prepareStatement(sql);

      // binding value

      pStmt.setString(1, id);

      //execute query

      pStmt.execute();

      rs = pStmt.getResultSet();

      // get result list

      String packType = null;

      while (rs.next())

      {

        packType = rs.getString(1);

        String subject = rs.getString(2);

        if (!docList.contains(subject))

        {

        }

      }//while

      if ((MetaCatUtil.getOptionList(MetaCatUtil.getOption("packagedoctype"))).

                                     contains(packType))

      {

        //this is beta4 or beta6 version

      }

      else if ((MetaCatUtil.getOptionList

        // this eml 2 document

      }

               (MetaCatUtil.getOption("eml2_0_1namespace"))).contains(packType))

      {

        // this eml 2 document

      }

    catch(SQLException e)

    {

                             e.getMessage());

    finally

    {

      try

      {

        pStmt.close();

      }

      catch (SQLException ee)

      {

                             ee.getMessage());

      finally

      {

        DBConnectionPool.returnDBConnection(conn, serialNumber);

      }

    }//finally

  }// getRelativeDocIdList

   * beta eml package

   */

  private String getTargetDocIdForBeta(Vector list, String targetType)

  {

    String docId = null;

    // make sure list is not empty

    if (list.isEmpty())

    {

    }

    // get sql command

    String sql = "SELECT doctype, docid from xml_documents where docid in (";

    // the first element

    sql = sql + "'"+(String)list.elementAt(0) + "'";

    for (int i=1; i<list.size(); i++)

    {

      String docid = (String) list.elementAt(i);

      sql = sql + ", '" + docid + "'";

    }//for

    // add parensis

    sql = sql + ")";

    PreparedStatement pStmt=null;

    DBConnection conn = null;

    int serialNumber = -1;

    try

    {

      //check out DBConnection

      conn=DBConnectionPool.getDBConnection

                                 ("ContentTypeProvider.setPhycialDocIdForBeta");

      serialNumber=conn.getCheckOutSerialNumber();

      pStmt = conn.prepareStatement(sql);

      //execute query

      pStmt.execute();

      rs = pStmt.getResultSet();

      // get result list

      while (rs.next())

      {

        String packType = rs.getString(1);

        String targetId  = rs.getString(2);

        // find physical document

        if ((MetaCatUtil.getOptionList(MetaCatUtil.getOption(targetType))).

                                     contains(packType))

       {

         // assign physical document and jump out the while loop

         docId = targetId;

         break;

       }

      }//while

    catch(SQLException e)

    {

                             e.getMessage());

    finally

    {

      try

      {

        pStmt.close();

      }

      catch(SQLException ee)

      {

                             ee.getMessage());

      finally

      {

        DBConnectionPool.returnDBConnection(conn, serialNumber);

      }

    }//finally

                             "for target doctype: "+targetType);

  }

  /* Parser the beta physical document and find the value in format element*/

  {

    String xmlDoc = null;

    try

    {

        DBUtil.getLatestRevisionInDocumentTable(physicalDocid);

      //System.out.println("the accenumber is !!!!!!!!!!!!!!!!!!" + accNumber);

      DocumentImpl doc = new DocumentImpl(accNumber);

    catch (Exception e)

    {

      contentType = DEFAULTCONTENTTYPE;

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

    }

      // get format element's text value

    String format = getTextValueFromPath(new StringReader(xmlDoc), FORMATPATH);

    {

      // if couldn't find the format, set contentype default value;

      contentType = DEFAULTCONTENTTYPE;

    }

    else

    {

      // if can find a format and look up from hash to get value

      contentType = lookUpContentType(format);

      // couldn't find the content type for this format in hash table

      if (contentType == null)

      {

        //set default vlaue

        contentType = DEFAULTCONTENTTYPE;

      }//if

    }//else

  }//parsePhysicalDocumentForBeta

  {

    String textValue = null;

    // get nodelist from doc by path

    try

    {

      NodeList list = EMLParser.getPathContent(xml, xPath);

      Node elementNode = list.item(0);

      Node textNode = elementNode.getFirstChild();

      if (textNode.getNodeType() == Node.TEXT_NODE)

      {

        textValue = textNode.getNodeValue();// get value

      }

    catch (Exception e)

    {

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

                              textValue);

  }//getTextValueFromPath

  private String lookUpContentType(String format)

  {

    String newFormat = null;

    constructContentHashTable();

    newFormat = format.toLowerCase().trim();

    String type = null;

    type = (String)contentTypeHash.get(newFormat);

                              type);

  }// lookupcontentypes

  private void constructContentHashTable()

  {

    contentTypeHash.put(TEXT, TEXTYPE);

    contentTypeHash.put(XML, XMLTYPE);

    contentTypeHash.put(HTML,HTMLTYPE);

    contentTypeHash.put(GIF, GIFTYPE);

    contentTypeHash.put(TAR, TARTYPE);

    contentTypeHash.put(ZIP, ZIPTYPE);

    contentTypeHash.put(BINARY, BINARYTYPE);

  {

     try

     {

       DBConnectionPool pool = DBConnectionPool.getInstance();

       ContentTypeProvider provider = new ContentTypeProvider("tao.0001");

     catch(Exception e)

     {

                                e.getMessage());

  }

}//ContentTypeProvider