gis/runtime/org.argeo.gis.geotools/src/main/java/org/argeo/geotools/jcr/SimpleGeoJcrMapper.java

   1 package org.argeo.geotools.jcr;
   2
   3 import java.io.IOException;
   4 import java.util.ArrayList;
   5 import java.util.Collections;
   6 import java.util.List;
   7 import java.util.Map;
   8 import java.util.TreeMap;
   9
  10 import javax.jcr.Binary;
  11 import javax.jcr.Node;
  12 import javax.jcr.RepositoryException;
  13 import javax.jcr.Session;
  14
  15 import org.apache.commons.logging.Log;
  16 import org.apache.commons.logging.LogFactory;
  17 import org.argeo.ArgeoException;
  18 import org.argeo.geotools.GeoToolsConstants;
  19 import org.argeo.geotools.GeoToolsUtils;
  20 import org.argeo.jcr.JcrUtils;
  21 import org.argeo.jcr.gis.GisNames;
  22 import org.argeo.jcr.gis.GisTypes;
  23 import org.argeo.jts.jcr.JtsJcrUtils;
  24 import org.geotools.data.DataStore;
  25 import org.geotools.data.FeatureSource;
  26 import org.opengis.feature.simple.SimpleFeature;
  27 import org.opengis.feature.simple.SimpleFeatureType;
  28 import org.opengis.feature.type.Name;
  29
  30 import com.vividsolutions.jts.geom.Geometry;
  31
  32 public class SimpleGeoJcrMapper implements GeoJcrMapper {
  33         private final static Log log = LogFactory.getLog(SimpleGeoJcrMapper.class);
  34
  35         private String dataStoresBasePath = "/gis/dataStores";
  36
  37         private Map<String, DataStore> registeredDataStores = Collections
  38                         .synchronizedSortedMap(new TreeMap<String, DataStore>());
  39
  40         // private Session session;
  41
  42         public Map<String, List<FeatureSource<SimpleFeatureType, SimpleFeature>>> getPossibleFeatureSources() {
  43                 Map<String, List<FeatureSource<SimpleFeatureType, SimpleFeature>>> res = new TreeMap<String, List<FeatureSource<SimpleFeatureType, SimpleFeature>>>();
  44                 dataStores: for (String alias : registeredDataStores.keySet()) {
  45                         DataStore dataStore = registeredDataStores.get(alias);
  46                         List<Name> names;
  47                         try {
  48                                 names = dataStore.getNames();
  49                         } catch (IOException e) {
  50                                 log.warn("Cannot list features sources of data store " + alias,
  51                                                 e);
  52                                 continue dataStores;
  53                         }
  54                         List<FeatureSource<SimpleFeatureType, SimpleFeature>> lst = new ArrayList<FeatureSource<SimpleFeatureType, SimpleFeature>>();
  55                         for (Name name : names) {
  56                                 try {
  57                                         lst.add(dataStore.getFeatureSource(name));
  58                                 } catch (IOException e) {
  59                                         if (log.isTraceEnabled())
  60                                                 log.trace("Skipping " + name + " of data store "
  61                                                                 + alias + " because it is probably"
  62                                                                 + " not a feature source", e);
  63                                 }
  64                         }
  65                         res.put(alias, lst);
  66                 }
  67                 return res;
  68         }
  69
  70         // public Node getNode(String dataStoreAlias,
  71         // FeatureSource<SimpleFeatureType, SimpleFeature> featureSource,
  72         // SimpleFeature feature) {
  73         // StringBuffer pathBuf = new StringBuffer(dataStoresBasePath);
  74         // pathBuf.append('/').append(dataStoreAlias);
  75         // pathBuf.append('/').append(featureSource.getName());
  76         //
  77         // // TODO: use centroid or bbox to create some depth
  78         // // Geometry geometry = (Geometry)feature.getDefaultGeometry();
  79         // // Point centroid = geometry.getCentroid();
  80         //
  81         // pathBuf.append('/').append(feature.getID());
  82         //
  83         // String path = pathBuf.toString();
  84         // try {
  85         // if (session.itemExists(path))
  86         // return session.getNode(path);
  87         // else
  88         // return JcrUtils.mkdirs(session, path);
  89         // } catch (RepositoryException e) {
  90         // throw new ArgeoException("Cannot get feature node for " + path, e);
  91         // }
  92         // }
  93
  94         public Node getFeatureNode(Node featureSourceNode, String featureId) {
  95                 Binary bbox = null;
  96                 Binary centroid = null;
  97                 try {
  98                         if (!featureSourceNode.hasNode(featureId)) {
  99                                 FeatureSource<SimpleFeatureType, SimpleFeature> featureSource = getFeatureSource(featureSourceNode);
 100                                 SimpleFeature feature = GeoToolsUtils.querySingleFeature(
 101                                                 featureSource, featureId);
 102                                 Node featureNode = featureSourceNode.addNode(featureId);
 103                                 featureNode.addMixin(GisTypes.GIS_FEATURE);
 104                                 Geometry geometry = (Geometry) feature.getDefaultGeometry();
 105                                 featureNode.setProperty(GisNames.GIS_SRS, featureSource
 106                                                 .getSchema().getCoordinateReferenceSystem().getName()
 107                                                 .toString());
 108
 109                                 bbox = JtsJcrUtils.writeWkb(featureNode.getSession(),
 110                                                 geometry.getEnvelope());
 111                                 featureNode.setProperty(GisNames.GIS_BBOX, bbox);
 112                                 centroid = JtsJcrUtils.writeWkb(featureNode.getSession(),
 113                                                 geometry.getCentroid());
 114                                 featureNode.setProperty(GisNames.GIS_CENTROID, centroid);
 115                                 featureSourceNode.getSession().save();
 116                                 return featureNode;
 117                         } else {
 118                                 return featureSourceNode.getNode(featureId);
 119                         }
 120                 } catch (RepositoryException e) {
 121                         throw new ArgeoException("Cannot get feature node for feature "
 122                                         + featureId + " from " + featureSourceNode, e);
 123                 } finally {
 124                         JcrUtils.closeQuietly(bbox);
 125                         JcrUtils.closeQuietly(centroid);
 126                 }
 127         }
 128
 129         protected Node getNode(Session session, String dataStoreAlias) {
 130                 try {
 131                         Node dataStores;
 132                         if (!session.itemExists(dataStoresBasePath)) {
 133                                 dataStores = JcrUtils.mkdirs(session, dataStoresBasePath);
 134                                 dataStores.getSession().save();
 135                         } else
 136                                 dataStores = session.getNode(dataStoresBasePath);
 137
 138                         Node dataStoreNode;
 139                         if (dataStores.hasNode(dataStoreAlias))
 140                                 dataStoreNode = dataStores.getNode(dataStoreAlias);
 141                         else {
 142                                 dataStoreNode = dataStores.addNode(dataStoreAlias,
 143                                                 GisTypes.GIS_DATA_STORE);
 144                                 dataStoreNode.getSession().save();
 145                         }
 146                         return dataStoreNode;
 147                 } catch (RepositoryException e) {
 148                         throw new ArgeoException("Cannot get node for data store "
 149                                         + dataStoreAlias, e);
 150                 }
 151         }
 152
 153         public Node getFeatureSourceNode(Session session, String dataStoreAlias,
 154                         FeatureSource<SimpleFeatureType, SimpleFeature> featureSource) {
 155                 try {
 156                         String name = featureSource.getName().toString();
 157                         Node dataStoreNode = getNode(session, dataStoreAlias);
 158                         if (dataStoreNode.hasNode(name))
 159                                 return dataStoreNode.getNode(name);
 160                         else {
 161                                 Node featureSourceNode = dataStoreNode.addNode(name);
 162                                 featureSourceNode.addMixin(GisTypes.GIS_FEATURE_SOURCE);
 163                                 featureSourceNode.getSession().save();
 164                                 return featureSourceNode;
 165                         }
 166                 } catch (RepositoryException e) {
 167                         throw new ArgeoException(
 168                                         "Cannot get feature source node for data store "
 169                                                         + dataStoreAlias + " and feature source "
 170                                                         + featureSource.getName(), e);
 171                 }
 172         }
 173
 174         public FeatureSource<SimpleFeatureType, SimpleFeature> getFeatureSource(
 175                         Node node) {
 176                 try {
 177                         Node dataStoreNode = node.getParent();
 178                         // TODO: check a dataStore type
 179                         if (!registeredDataStores.containsKey(dataStoreNode.getName()))
 180                                 throw new ArgeoException("No data store registered under "
 181                                                 + dataStoreNode);
 182                         DataStore dataStore = registeredDataStores.get(dataStoreNode
 183                                         .getName());
 184                         return dataStore.getFeatureSource(node.getName());
 185                 } catch (Exception e) {
 186                         throw new ArgeoException("Cannot find feature source " + node, e);
 187                 }
 188         }
 189
 190         public SimpleFeature getFeature(Node node) {
 191                 // TODO Auto-generated method stub
 192                 return null;
 193         }
 194
 195         public void register(DataStore dataStore, Map<String, String> properties) {
 196                 if (!properties.containsKey(GeoToolsConstants.ALIAS_KEY)) {
 197                         log.warn("Cannot register data store " + dataStore
 198                                         + " since it has no '" + GeoToolsConstants.ALIAS_KEY
 199                                         + "' property");
 200                         return;
 201                 }
 202                 registeredDataStores.put(properties.get(GeoToolsConstants.ALIAS_KEY),
 203                                 dataStore);
 204         }
 205
 206         public void unregister(DataStore dataStore, Map<String, String> properties) {
 207                 if (!properties.containsKey(GeoToolsConstants.ALIAS_KEY)) {
 208                         log.warn("Cannot unregister data store " + dataStore
 209                                         + " since it has no '" + GeoToolsConstants.ALIAS_KEY
 210                                         + "' property");
 211                         return;
 212                 }
 213                 registeredDataStores
 214                                 .remove(properties.get(GeoToolsConstants.ALIAS_KEY));
 215         }
 216
 217         // public void setSession(Session session) {
 218         // this.session = session;
 219         // }
 220
 221 }