/* * Copyright 2013 gathanas. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package eu.dnetlib.espas.util; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; import java.util.HashMap; import java.util.Map; import java.util.logging.Level; import org.apache.log4j.Logger; import org.apache.log4j.Priority; import org.apache.xml.serialize.DOMSerializer; import org.apache.xml.serialize.XMLSerializer; import org.geotoolkit.factory.AuthorityFactoryFinder; import org.geotoolkit.factory.Hints; import org.geotoolkit.referencing.CRS; import org.geotoolkit.referencing.factory.web.WebCRSFactory; import org.geotoolkit.referencing.factory.wkt.DirectPostgisFactory; import org.geotoolkit.xml.MarshallerPool; import org.opengis.referencing.crs.CRSAuthorityFactory; import org.opengis.referencing.crs.CoordinateReferenceSystem; import org.w3c.dom.Element; import org.w3c.dom.Node; /** * * @author gathanas */ public class MetadataHandler { private static final Logger _logger = Logger.getLogger(MetadataHandler.class); protected static final String GMD_NAMESPACE = "http://www.isotc211.org/2005/gmd"; protected static final String GCO_NAMESPACE = "http://www.isotc211.org/2005/gco"; protected static final String GML32_NAMESPACE = "http://www.opengis.net/gml/3.2"; protected static final String XLINK1999_NAMESPACE = "http://www.w3.org/1999/xlink"; protected static final boolean USE_EWKT = false; /** This connection to an associated postgis db instance is used for retrieving the Coordinate System reference codes * defined in the spatial_ref_sys table. If codes defined in this table are expected to be used for the instantiation of * coordinate systems and related transformations then this connection should be initialized. */ // initializing the jdbc connection to the postgis db instnace protected static String connectionURL = "jdbc:postgresql://dl121.madgik.di.uoa.gr/dnet_espas_v2"; protected static String userName="dnet"; protected static String passwrd="dnetPwd"; protected static MarshallerPool metadataMarshPool; protected static Connection postgisDBConnection; private static Map supportedCRSMappings; protected static CRSAuthorityFactory authorityFactory; private static boolean inited=false; /** Statically initialize the MetadataHandler with a set of default properties. */ static { try { Class.forName("org.postgresql.Driver"); initializeDBConnection(null,null,null); } catch (ClassNotFoundException ex) { _logger.log(Priority.ERROR, "Postgress driver is not available", ex); } catch (SQLException ex) { _logger.log(Priority.ERROR, "Could not establish a connection to postgis db instnace. Connection url is:" + connectionURL, ex); } } private static void initializeDBConnection(String dbURL, String user, String pass) throws SQLException{ if (dbURL!=null) connectionURL=dbURL; if(user!=null) userName= user; if(pass!=null) passwrd = pass; postgisDBConnection = DriverManager.getConnection(connectionURL, userName, passwrd); loadCRSToSRIDMappings(); } /** Used for initializing the MetadataHandler with a set of specified properties. */ public static void initHandler(String connectionURL,String dbName, String userName, String passWord) { try { if (!inited || postgisDBConnection == null || postgisDBConnection.isClosed()) { initializeDBConnection(connectionURL+"/"+dbName, userName, passWord); inited=true; } } catch (SQLException ex) { _logger.log(Priority.ERROR, "Could not establish a connection to postgis db instnace. Connection url is:" + connectionURL, ex); } } ////////////////////////////////////////////////////////////////////////// /** Loads CRS mappings from the postgis database. Information is extracted from the values of the crs_spatial_ref_sys table */ protected static void loadCRSToSRIDMappings() throws SQLException { initCRSAuthorityFactory(); String retrieveCRSMappingsQuery = "select crs, srid, sridName, inverse_x_y_order, z_scale_factor from crs_spatial_ref_sys"; ResultSet queryResults = postgisDBConnection.createStatement().executeQuery(retrieveCRSMappingsQuery); if (queryResults != null) { supportedCRSMappings = new HashMap(); while (queryResults.next()) { CRSMapping mapping = new CRSMapping(queryResults.getString("crs"), queryResults.getInt("srid"), queryResults.getString("sridname"), queryResults.getBoolean("inverse_x_y_order"), queryResults.getDouble("z_scale_factor")); supportedCRSMappings.put(mapping.getEspasCRS(), mapping); } queryResults.close(); } _logger.debug("CRS to ESPAS SRS mappings have been initialized"); } /** Serializes the provided node elements to string representations that are latter on used for logging purposes. */ protected static String serializeNode(Node extentContent) throws IOException { XMLSerializer xmlSerializer = new XMLSerializer(); ByteArrayOutputStream btArrStream = new ByteArrayOutputStream(); xmlSerializer.setOutputByteStream(btArrStream); xmlSerializer.setNamespaces(true); DOMSerializer dmSerializer = xmlSerializer.asDOMSerializer(); _logger.info("DM serializer is :"+(dmSerializer==null)+" extent is :"+(extentContent==null)); String strCont=""; if(dmSerializer!=null && extentContent!=null){ dmSerializer.serialize((Element) extentContent); strCont = new String(btArrStream.toByteArray()); } return strCont; } /** Internal method used for retrieving an appropriate CRS out of a WTK factory that is */ static CoordinateReferenceSystem getCRSForSRSName(String srsCode) { try{ initCRSAuthorityFactory(); _logger.info("SRS Code is :"+srsCode+" is in the list :"+supportedCRSMappings.containsKey(srsCode)); CoordinateReferenceSystem result = null; if (srsCode.equals("http://ontology.espas-fp7.eu/crs/GEI") || srsCode.equals("http://ontology.espas-fp7.eu/crs/J2000spherical")) result = authorityFactory.createCoordinateReferenceSystem("EPSG:4326"); else if (supportedCRSMappings.containsKey(srsCode)) result = authorityFactory.createCoordinateReferenceSystem(supportedCRSMappings.get(srsCode).getSridCode()); return result; } catch(Exception ex){ _logger.error("Retrieval of Coordinate reference system failed! \n", ex); return null; } } public static void initCRSAuthorityFactory() { // Initialize either the Postgis factory if the connection is online or otherwise the WebFactory. Hints hintsforAuthorityFactory = new Hints(); if (postgisDBConnection != null) try { if(postgisDBConnection.isClosed()) initializeDBConnection(null,null,null); _logger.info("Initilizing PostgisFactory for CRS codes "); authorityFactory = new DirectPostgisFactory(hintsforAuthorityFactory, postgisDBConnection); _logger.info("PostgisFactory for CRS codes has been initialized"); } catch (Exception ex) { _logger.info("Postgis CRSFactory could not be initialized", ex); authorityFactory = new WebCRSFactory(hintsforAuthorityFactory); } else authorityFactory = new WebCRSFactory(hintsforAuthorityFactory); AuthorityFactoryFinder.addAuthorityFactory(authorityFactory); } public static String getComputationKind(String computationType){ String result = "Software"; try{ if(computationType.equalsIgnoreCase("http://ontology.espas-fp7.eu/computationType/Model")) result = "Model"; else if(computationType.equalsIgnoreCase("http://ontology.espas-fp7.eu/computationType/Software")) result="Software"; else if (postgisDBConnection != null){ Statement queryStatement = postgisDBConnection.createStatement(); String query="with recursive computationtype_tree(child, parent) as (" + " select ch.id, pr.parent from computationtype as ch, computationtype as pr" + " where ch.parent = pr.id and pr.parent!='NULL')" + " select parent from computationtype_tree where child='"+computationType+"'"; ResultSet rs = queryStatement.executeQuery(query); if(rs.next()){ result = rs.getString(1).replaceAll("http://ontology.espas-fp7.eu/computationType/", ""); result = (result!="-1")?result:"Software"; } } } catch(Exception exc){ _logger.info(null, exc); } finally{ return result; } } public static CRSMapping getSupportedCRSMapping(String espasCRSName){ try { loadCRSToSRIDMappings(); } catch (SQLException ex) { _logger.debug(null,ex); } return supportedCRSMappings.get(espasCRSName); } } /** Class used for holding mappings of ESPAS CRS to standard ones used in postgis. */ class CRSMapping { private String espasCRS; private String sridCode; private int srid; private boolean invertedXY; private double zScaleFactor; public CRSMapping(String espasCRS, int srid, String sridCode, boolean invertedXY, double zScaleFactor) { this.espasCRS = espasCRS; this.srid = srid; this.sridCode = sridCode; this.invertedXY = invertedXY; this.zScaleFactor = zScaleFactor; } public String getEspasCRS() { return espasCRS; } public int getSrid() { return srid; } public String getSridCode() { return sridCode; } public boolean isInvertedXY() { return invertedXY; } public double getzScaleFactor() { return zScaleFactor; } }