--- /dev/null
+package org.argeo.geotools.jcr;
+
+import java.io.IOException;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.Set;
+
+import javax.jcr.Node;
+import javax.jcr.Property;
+import javax.jcr.RepositoryException;
+import javax.jcr.Session;
+import javax.jcr.observation.Event;
+import javax.jcr.observation.EventIterator;
+import javax.jcr.observation.EventListener;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.argeo.ArgeoException;
+import org.argeo.geotools.GeoToolsUtils;
+import org.argeo.jcr.JcrUtils;
+import org.argeo.jcr.gis.GisNames;
+import org.argeo.jcr.gis.GisTypes;
+import org.argeo.security.SystemExecutionService;
+import org.geotools.data.DataStore;
+import org.geotools.data.DefaultTransaction;
+import org.geotools.data.FeatureStore;
+import org.geotools.data.Transaction;
+import org.geotools.feature.FeatureCollection;
+import org.geotools.feature.FeatureCollections;
+import org.geotools.feature.simple.SimpleFeatureBuilder;
+import org.geotools.feature.simple.SimpleFeatureTypeBuilder;
+import org.geotools.filter.FilterFactoryImpl;
+import org.geotools.referencing.CRS;
+import org.opengis.feature.simple.SimpleFeature;
+import org.opengis.feature.simple.SimpleFeatureType;
+import org.opengis.filter.FilterFactory2;
+import org.opengis.filter.identity.FeatureId;
+import org.opengis.geometry.DirectPosition;
+import org.opengis.referencing.crs.CoordinateReferenceSystem;
+import org.opengis.referencing.operation.MathTransform;
+
+import com.vividsolutions.jts.geom.Coordinate;
+import com.vividsolutions.jts.geom.GeometryFactory;
+import com.vividsolutions.jts.geom.Point;
+
+public class GeoJcrIndex implements EventListener {
+ public final static SimpleFeatureType JCR_POINT;
+
+ final static String JCR_POINT_NAME = "JCR_POINT";
+ // PostGIS convention
+ final static String DEFAULT_GEOM_NAME = "the_geom";
+
+ private final static Log log = LogFactory.getLog(GeoJcrIndex.class);
+
+ static {
+ SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder();
+ builder.setNamespaceURI(GisNames.GIS_NAMESPACE);
+ builder.setName(JCR_POINT_NAME);
+
+ builder.setDefaultGeometry(DEFAULT_GEOM_NAME);
+ builder.add(DEFAULT_GEOM_NAME, Point.class);
+
+ builder.add(JcrUtils.normalize(Property.JCR_UUID), String.class);
+ builder.add(JcrUtils.normalize(Property.JCR_PATH), String.class);
+ builder.add(JcrUtils.normalize(Property.JCR_PRIMARY_TYPE), String.class);
+ // mix:created
+ // builder.add(JcrUtils.normalize(Property.JCR_CREATED), Date.class);
+ // builder.add(JcrUtils.normalize(Property.JCR_CREATED_BY),
+ // String.class);
+ // mix:lastModified
+ builder.add(JcrUtils.normalize(Property.JCR_LAST_MODIFIED), Date.class);
+ builder.add(JcrUtils.normalize(Property.JCR_LAST_MODIFIED_BY),
+ String.class);
+
+ JCR_POINT = builder.buildFeatureType();
+ }
+
+ private DataStore dataStore;
+ private FeatureStore<SimpleFeatureType, SimpleFeature> pointsIndex;
+ private Session session;
+ private SystemExecutionService systemExecutionService;
+
+ // TODO: use common factory finder?
+ private FilterFactory2 ff = new FilterFactoryImpl();
+
+ // TODO: use finder?
+ private GeometryFactory geometryFactory = new GeometryFactory();
+
+ public void init() {
+ GeoToolsUtils.createSchemaIfNeeded(dataStore, JCR_POINT);
+ pointsIndex = GeoToolsUtils.getFeatureStore(dataStore,
+ JCR_POINT.getName());
+
+ systemExecutionService.executeAsSystem(new Runnable() {
+ public void run() {
+ try {
+ session.getWorkspace()
+ .getObservationManager()
+ .addEventListener(GeoJcrIndex.this,
+ Event.NODE_ADDED | Event.NODE_REMOVED, "/",
+ true, null,
+ new String[] { GisTypes.GIS_GEOMETRY },
+ false);
+ } catch (RepositoryException e) {
+ throw new ArgeoException("Cannot initialize GeoJcr index",
+ e);
+ }
+
+ }
+ });
+ }
+
+ public void dispose() {
+ }
+
+ public void onEvent(EventIterator events) {
+ FeatureCollection<SimpleFeatureType, SimpleFeature> pointsToAdd = FeatureCollections
+ .newCollection();
+ Set<FeatureId> pointsToRemove = new HashSet<FeatureId>();
+ while (events.hasNext()) {
+ Event event = events.nextEvent();
+ try {
+ Integer eventType = event.getType();
+ if (Event.NODE_ADDED == eventType) {
+ Node node = session.getNodeByIdentifier(event
+ .getIdentifier());
+ if (node.isNodeType(GisTypes.GIS_POINT)) {
+ Point point = nodeToPoint(node);
+ SimpleFeatureBuilder featureBuilder = new SimpleFeatureBuilder(
+ JCR_POINT);
+ featureBuilder.set(DEFAULT_GEOM_NAME, point);
+ mapNodeToFeature(node, featureBuilder);
+ pointsToAdd.add(featureBuilder.buildFeature(node
+ .getIdentifier()));
+ }
+ } else if (Event.NODE_REMOVED == eventType) {
+ String id = event.getIdentifier();
+ pointsToRemove.add(ff.featureId(id));
+ }
+ } catch (Exception e) {
+ log.error("Cannot process event " + event, e);
+ }
+ }
+
+ // persist
+ // TODO: this may be more optimal to persist in one single transaction,
+ // but we will loose modifications on all nodes if one fails
+ try {
+ Transaction transaction = new DefaultTransaction();
+ pointsIndex.setTransaction(transaction);
+ try {
+ // points
+ pointsIndex.addFeatures(pointsToAdd);
+ if (pointsToRemove.size() != 0)
+ pointsIndex.removeFeatures(ff.id(pointsToRemove));
+ transaction.commit();
+ } catch (Exception e) {
+ transaction.rollback();
+ throw new ArgeoException("Cannot persist changes", e);
+ } finally {
+ transaction.close();
+ }
+ } catch (ArgeoException e) {
+ throw e;
+ } catch (IOException e) {
+ throw new ArgeoException("Unexpected issue with the transaction", e);
+ }
+ }
+
+ protected void mapNodeToFeature(Node node,
+ SimpleFeatureBuilder featureBuilder) {
+ try {
+ featureBuilder.set(JcrUtils.normalize(Property.JCR_UUID),
+ node.getIdentifier());
+ featureBuilder.set(JcrUtils.normalize(Property.JCR_PATH),
+ node.getPath());
+ featureBuilder.set(JcrUtils.normalize(Property.JCR_PRIMARY_TYPE),
+ node.getPrimaryNodeType().getName());
+ if (node.hasProperty(Property.JCR_LAST_MODIFIED))
+ featureBuilder.set(
+ JcrUtils.normalize(Property.JCR_LAST_MODIFIED), node
+ .getProperty(Property.JCR_LAST_MODIFIED)
+ .getDate().getTime());
+ if (node.hasProperty(Property.JCR_LAST_MODIFIED_BY))
+ featureBuilder
+ .set(JcrUtils.normalize(Property.JCR_LAST_MODIFIED_BY),
+ node.getProperty(Property.JCR_LAST_MODIFIED_BY)
+ .getString());
+ } catch (RepositoryException e) {
+ throw new ArgeoException("Cannot map " + node + " to "
+ + featureBuilder.getFeatureType(), e);
+ }
+ }
+
+ /** Return the node as a point in the CRS of the related feature store. */
+ protected Point nodeToPoint(Node node) {
+ CoordinateReferenceSystem featureStoreCrs = pointsIndex.getSchema()
+ .getCoordinateReferenceSystem();
+ DirectPosition nodePosition = GeoJcrUtils.nodeToPosition(node);
+ CoordinateReferenceSystem nodeCrs = nodePosition
+ .getCoordinateReferenceSystem();
+
+ // transform if not same CRS
+ DirectPosition targetPosition;
+ if (!featureStoreCrs.getIdentifiers().contains(nodeCrs.getName())) {
+ MathTransform transform;
+ try {
+ transform = CRS.findMathTransform(nodeCrs, featureStoreCrs);
+ targetPosition = transform.transform(nodePosition, null);
+ } catch (Exception e) {
+ throw new ArgeoException("Cannot transform from " + nodeCrs
+ + " to " + featureStoreCrs, e);
+ }
+ } else {
+ targetPosition = nodePosition;
+ }
+ double[] coo = targetPosition.getCoordinate();
+ return geometryFactory.createPoint(new Coordinate(coo[0], coo[1]));
+ }
+
+ public void setDataStore(DataStore dataStore) {
+ this.dataStore = dataStore;
+ }
+
+ public void setSession(Session session) {
+ this.session = session;
+ }
+
+ public void setSystemExecutionService(
+ SystemExecutionService systemExecutionService) {
+ this.systemExecutionService = systemExecutionService;
+ }
+
+}
projects / lgpl / argeo-commons.git / blobdiff