Map Filter search by resource layer feature

arches/app/datatypes/datatypes.py

@@ -998,7 +998,7 @@ def transform_value_for_tile(self, value, **kwargs):
                 geojson = json.loads(value)
                 if geojson["type"] == "FeatureCollection":
                     for feature in geojson["features"]:
-                        feature["id"] = str(uuid.uuid4())
+                        feature["id"] = feature.get("id", str(uuid.uuid4()))
                     arches_geojson = geojson
                 else:
                     raise TypeError

arches/app/media/js/utils/map-popup-provider.js

@@ -1,4 +1,5 @@
-define(['arches',
+define([
+    'arches',
     'knockout',
     'templates/views/components/map-popup.htm'
 ], function(arches, ko, popupTemplate) {
@@ -40,6 +41,32 @@ define(['arches',
             return features;
         },
 
+        /**
+         * This method enables custom logic for how the feature in the popup should be handled and/or mutated en route to the mapFilter.
+         * @param popupFeatureObject - the javascript object of the feature and its associated contexts (e.g. mapCard).
+         * @param featureGeomIndex - int index corresponding to the feature that was clicked, used for lookup against an arry of geoms
+         * @required @method mapCard.filterByFeatureGeom()
+         * @required @send argument: @param feature - a geojson feature object 
+         * with an @optional @property: feature.id corresponding to a uuid for that tile_geometrycollection_feature
+         * @optional @send argument: @param resourceid
+         */
+        sendFeatureToMapFilter: function(popupFeatureObject, featureGeomIndex)
+        {
+            let feature = popupFeatureObject.geometries()[featureGeomIndex].geom.features[0];
+            popupFeatureObject.mapCard.filterByFeatureGeom(feature, popupFeatureObject.resourceinstanceid);
+        },
+
+        /**
+         * Determines whether to show the button for Filter By Feature
+         * @param popupFeatureObject - the javascript object of the feature and its associated contexts (e.g. mapCard).
+         * @param featureGeomIndex - int index corresponding to the feature that was clicked, used for lookup against an arry of geoms
+         * @returns {boolean} - whether to show "Filter by Feature" on map popup
+         * typically dependent on at least 1 feature with a geometry and/or a featureid/resourceid combo
+         */
+        showFilterByFeature: function(popupFeatureObject, featureGeomIndex) {
+            return (ko.unwrap(popupFeatureObject.geometries) || []).length > 0;
+        },
+
     };
     return provider;
 });

arches/app/media/js/viewmodels/map.js

@@ -344,14 +344,17 @@ define([
                 var data = feature.properties;
                 var id = data.resourceinstanceid;
                 data.showEditButton = self.canEdit;
-                const descriptionProperties = ['displayname', 'graph_name', 'map_popup'];
+                data.sendFeatureToMapFilter = mapPopupProvider.sendFeatureToMapFilter;
+                data.showFilterByFeature = mapPopupProvider.showFilterByFeature;
+                const descriptionProperties = ['displayname', 'graph_name', 'map_popup', 'geometries'];
                 if (id) {
                     if (!self.resourceLookup[id]){
                         data = _.defaults(data, {
                             'loading': true,
                             'displayname': '',
                             'graph_name': '',
                             'map_popup': '',
+                            'geometries': [],
                             'feature': feature,
                         });
                         if (data.permissions) {

arches/app/media/js/views/components/search/map-filter.js

@@ -113,6 +113,7 @@ define([
             };
 
             this.searchGeometries = ko.observableArray(null);
+            this.searchGeometryFeature = ko.observable(null);
             this.searchAggregations = ko.observable();
             this.selectedTool = ko.observable();
             this.geoJSONString = ko.observable(undefined);
@@ -274,6 +275,35 @@ define([
                 }
             }, this);
 
+            this.filterByFeatureGeom = function(feature, resourceid=null) {
+                if (feature.geometry.type == 'Point' && this.buffer() == 0) { this.buffer(25); }
+                if (feature.id && resourceid) {
+                    self.searchGeometryFeature({
+                        "featureid": feature.id,
+                        "resourceid": resourceid,
+                        "buffer": {
+                            "width": this.buffer(),
+                            "unit": this.bufferUnit()
+                        },
+                        "inverted": this.filter.inverted()
+                    });
+                }
+                let currentSearchGeoms = self.searchGeometries();
+                this.draw.set({
+                    "type": "FeatureCollection",
+                    "features": [feature]
+                });
+                if (currentSearchGeoms != null) {
+                    currentSearchGeoms.push(feature);
+                } else {
+                    currentSearchGeoms = [feature];
+                }
+                self.searchGeometries(currentSearchGeoms);
+                self.updateFilter();
+                // if feature is not from a resource-layer, enable feature editing in map
+                if (!!self.searchGeometryFeature()) { self.draw.changeMode('static'); }
+            };
+
             var updateSearchResultPointLayer = function() {
                 var pointSource = self.map().getSource('search-results-points');
                 var agg = ko.unwrap(self.searchAggregations);
@@ -518,7 +548,11 @@ define([
                     this.getFilter('term-filter').addTag('Map Filter Enabled', this.name, this.filter.inverted);
                 }
                 this.filter.feature_collection().features[0].properties['inverted'] = this.filter.inverted();
-                queryObj[componentName] = ko.toJSON(this.filter.feature_collection());
+                if (!!this.searchGeometryFeature()) {
+                    queryObj[componentName] = ko.toJSON(this.searchGeometryFeature());
+                } else {
+                    queryObj[componentName] = ko.toJSON(this.filter.feature_collection());
+                }
             } else {
                 delete queryObj[componentName];
             }
@@ -533,7 +567,21 @@ define([
             var hasSpatialFilter = false;
             if (componentName in query) {
                 var mapQuery = JSON.parse(query[componentName]);
-                if (mapQuery.features.length > 0) {
+                if (mapQuery.featureid && mapQuery.resourceid) {
+                    buffer = mapQuery.buffer;
+                    bufferUnit = mapQuery.bufferUnit;
+                    inverted = mapQuery.inverted;
+                    this.searchGeometryFeature({
+                        "featureid": mapQuery.id,
+                        "resourceid": mapQuery.resourceid,
+                        "buffer": {
+                            "width": buffer,
+                            "unit": bufferUnit
+                        },
+                        "inverted": inverted
+                    });
+                    hasSpatialFilter = true;
+                } else if (mapQuery.features.length > 0) {
                     hasSpatialFilter = true;
                     var properties = mapQuery.features[0].properties;
                     inverted = properties.inverted;
@@ -573,6 +621,7 @@ define([
         },
 
         clear: function(reset_features) {
+            this.searchGeometryFeature(null);
             this.filter.feature_collection({
                 "type": "FeatureCollection",
                 "features": []

arches/app/search/components/map_filter.py

@@ -4,8 +4,10 @@
 from django.utils.translation import gettext as _
 from arches.app.models.system_settings import settings
 from arches.app.utils.betterJSONSerializer import JSONSerializer, JSONDeserializer
-from arches.app.search.elasticsearch_dsl_builder import Bool, Nested, Terms, GeoShape
+from arches.app.search.elasticsearch_dsl_builder import Bool, Match, Query, Nested, Term, Terms, GeoShape
 from arches.app.search.components.base import BaseSearchFilter
+from arches.app.search.search_engine_factory import SearchEngineFactory
+from arches.app.search.mappings import RESOURCES_INDEX
 
 logger = logging.getLogger(__name__)
 
@@ -28,46 +30,57 @@ def append_dsl(self, search_results_object, permitted_nodegroups, include_provis
         search_query = Bool()
         querysting_params = self.request.GET.get(details["componentname"], "")
         spatial_filter = JSONDeserializer().deserialize(querysting_params)
+        if details["componentname"] not in search_results_object:
+            search_results_object[details["componentname"]] = {}
+
         if "features" in spatial_filter:
             if len(spatial_filter["features"]) > 0:
                 feature_geom = spatial_filter["features"][0]["geometry"]
                 feature_properties = {}
                 if "properties" in spatial_filter["features"][0]:
                     feature_properties = spatial_filter["features"][0]["properties"]
-                buffer = {"width": 0, "unit": "ft"}
-                if "buffer" in feature_properties:
-                    buffer = feature_properties["buffer"]
-                search_buffer = _buffer(feature_geom, buffer["width"], buffer["unit"])
-                feature_geom = JSONDeserializer().deserialize(search_buffer.geojson)
-                geoshape = GeoShape(
-                    field="geometries.geom.features.geometry", type=feature_geom["type"], coordinates=feature_geom["coordinates"]
-                )
-
-                invert_spatial_search = False
-                if "inverted" in feature_properties:
-                    invert_spatial_search = feature_properties["inverted"]
-
-                spatial_query = Bool()
-                if invert_spatial_search is True:
-                    spatial_query.must_not(geoshape)
-                else:
-                    spatial_query.filter(geoshape)
-
-                # get the nodegroup_ids that the user has permission to search
-                spatial_query.filter(Terms(field="geometries.nodegroup_id", terms=permitted_nodegroups))
 
-                if include_provisional is False:
-                    spatial_query.filter(Terms(field="geometries.provisional", terms=["false"]))
-
-                elif include_provisional == "only provisional":
-                    spatial_query.filter(Terms(field="geometries.provisional", terms=["true"]))
-
-                search_query.filter(Nested(path="geometries", query=spatial_query))
-
-        search_results_object["query"].add_query(search_query)
-
-        if details["componentname"] not in search_results_object:
-            search_results_object[details["componentname"]] = {}
+                add_geoshape_query_to_search_query(feature_geom, feature_properties, permitted_nodegroups, include_provisional, search_query)
+                search_results_object["query"].add_query(search_query)
+
+        elif "featureid" in spatial_filter and "resourceid" in spatial_filter:
+            se = SearchEngineFactory().create()
+            main_query = Query(se)
+            nested_query = Nested(path="geometries")
+            match_feature = Match(field="geometries.geom.features.id", query=spatial_filter["featureid"])
+
+            # Create a Bool query for conditions inside the nested path
+            bool_nested_query = Bool()
+            bool_nested_query.must(match_feature.dsl)
+            nested_query.add_query(bool_nested_query.dsl)
+
+            bool_query = Bool()
+            match_resource = Term(field="resourceinstanceid", term=spatial_filter["resourceid"])
+            bool_query.must(match_resource.dsl)  # Match resource instance ID at the document level
+            bool_query.must(nested_query.dsl)  # Add the nested query
+
+            # Set the entire bool query to the main query object
+            main_query.add_query(bool_query.dsl)
+
+            response = main_query.search(index=RESOURCES_INDEX)
+            geometries = []
+            for hit in response['hits']['hits']:
+                if len(geometries) > 0:
+                    break
+                for geom in hit['_source']['geometries']:
+                    if len(geometries) > 0:
+                        break
+                    for feature in geom['geom']['features']:
+                        if len(geometries) > 0:
+                            break
+                        if feature['id'] == spatial_filter["featureid"]:
+                            geometries.append(feature)
+
+            if len(geometries) > 0:
+                feature_geom = geometries[0]["geometry"]
+                buffered_feature_geom = add_geoshape_query_to_search_query(feature_geom, spatial_filter, permitted_nodegroups, include_provisional, search_query)
+                search_results_object[details["componentname"]] = buffered_feature_geom
+                search_results_object["query"].add_query(search_query)
 
         try:
             search_results_object[details["componentname"]]["search_buffer"] = feature_geom
@@ -98,3 +111,37 @@ def _buffer(geojson, width=0, unit="ft"):
             res = cursor.fetchone()
             geom = GEOSGeometry(res[0], srid=4326)
     return geom
+
+def add_geoshape_query_to_search_query(feature_geom, feature_properties, permitted_nodegroups, include_provisional, search_query):
+
+    buffer = {"width": 0, "unit": "ft"}
+    if "buffer" in feature_properties:
+        buffer = feature_properties["buffer"]
+    # feature_geom = spatial_filter["features"][0]["geometry"]
+    search_buffer = _buffer(feature_geom, int(buffer["width"]), buffer["unit"])
+    feature_geom = JSONDeserializer().deserialize(search_buffer.geojson)
+    geoshape = GeoShape(
+        field="geometries.geom.features.geometry", type=feature_geom["type"], coordinates=feature_geom["coordinates"]
+    )
+    invert_spatial_search = False
+    if "inverted" in feature_properties:
+        invert_spatial_search = feature_properties["inverted"]
+
+    spatial_query = Bool()
+    if invert_spatial_search is True:
+        spatial_query.must_not(geoshape)
+    else:
+        spatial_query.filter(geoshape)
+
+    # get the nodegroup_ids that the user has permission to search
+    spatial_query.filter(Terms(field="geometries.nodegroup_id", terms=permitted_nodegroups))
+
+    if include_provisional is False:
+        spatial_query.filter(Terms(field="geometries.provisional", terms=["false"]))
+
+    elif include_provisional == "only provisional":
+        spatial_query.filter(Terms(field="geometries.provisional", terms=["true"]))
+
+    search_query.filter(Nested(path="geometries", query=spatial_query))
+
+    return feature_geom

arches/app/templates/javascript.htm

@@ -654,6 +654,7 @@
         map-add-line='{% trans "Add line" as mapAddLine %} "{{ mapAddLine|escapejs }}"'
         map-add-polygon='{% trans "Add polygon" as mapAddPolygon %} "{{ mapAddPolygon|escapejs }}"'
         map-select-drawing='{% trans "Select drawing" as mapSelectDrawing %} "{{ mapSelectDrawing|escapejs }}"'
+        filter-by-feature='{% trans "Filter by Feature" as filterByFeature %} "{{ filterByFeature|escapejs }}"'
         related-instance-map-sources='{% trans "Related instance map sources" as relatedInstanceMapSources %} "{{ relatedInstanceMapSources|escapejs }}"'
         related-instance-map-source-layers='{% trans "Related instance map source layers (optional)" as relatedInstanceMapSourceLayers %} "{{ relatedInstanceMapSourceLayers|escapejs }}"'
         intersection-layer-configuration='{% trans "Intersection layer configuration" as intersectionLayerConfiguration %} "{{ intersectionLayerConfiguration|escapejs }}"'