Map Filter search by resource layer feature

arches/app/datatypes/datatypes.py

@@ -998,7 +998,9 @@ 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", None)
+                        if not feature_id:
+                            feature["id"] = str(uuid.uuid4())
                     arches_geojson = geojson
                 else:
                     raise TypeError

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

@@ -344,14 +344,15 @@ define([
                 var data = feature.properties;
                 var id = data.resourceinstanceid;
                 data.showEditButton = self.canEdit;
-                const descriptionProperties = ['displayname', 'graph_name', 'map_popup'];
+                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,39 @@ define([
                 }
             }, this);
 
+            this.filterByFeatureGeom = function(resourceid, geoms) {
+                let feature = geoms[0].geom.features[0];
+                if (feature.geometry.type == 'Point') { self.buffer(100); }
+                if (feature.id) {
+                    self.searchGeometryFeature({
+                        "featureid": feature.id,
+                        "resourceid": resourceid,
+                        "buffer": {
+                            "width": this.buffer(),
+                            "unit": this.bufferUnit()
+                        },
+                        "inverted": this.filter.inverted()
+                    });
+                } else {
+                    const tolerance = 0.1; // Degree of Simplification: Lower numbers are less simplified, preserving more detail
+                    const highQuality = true; // Set to true for a slower but higher quality simplification
+                    turf.simplify(feature.geometry, {tolerance: tolerance, highQuality: highQuality, mutate: true});
+                }
+                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();
+                self.draw.changeMode('static');
+            };
+
             var updateSearchResultPointLayer = function() {
                 var pointSource = self.map().getSource('search-results-points');
                 var agg = ko.unwrap(self.searchAggregations);
@@ -518,7 +552,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];
             }
@@ -573,6 +611,7 @@ define([
         },
 
         clear: function(reset_features) {
+            this.searchGeometryFeature(null);
             this.filter.feature_collection({
                 "type": "FeatureCollection",
                 "features": []
@@ -584,6 +623,7 @@ define([
             this.getFilter('term-filter').removeTag('Map Filter Enabled');
             this.draw.deleteAll();
             this.searchGeometries([]);
+            this.setupDraw();
         },
 
         zoomToAllFeaturesHandler: function(){

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__)
 
@@ -34,35 +36,35 @@ def append_dsl(self, search_results_object, permitted_nodegroups, include_provis
                 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"]
+                add_geoshape_query_to_search_query(feature_geom, feature_properties, permitted_nodegroups, include_provisional, search_query)
 
-                spatial_query = Bool()
-                if invert_spatial_search is True:
-                    spatial_query.must_not(geoshape)
-                else:
-                    spatial_query.filter(geoshape)
+        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"])
 
-                # get the nodegroup_ids that the user has permission to search
-                spatial_query.filter(Terms(field="geometries.nodegroup_id", terms=permitted_nodegroups))
+            # 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)
 
-                if include_provisional is False:
-                    spatial_query.filter(Terms(field="geometries.provisional", terms=["false"]))
+            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)
 
-                elif include_provisional == "only provisional":
-                    spatial_query.filter(Terms(field="geometries.provisional", terms=["true"]))
+            response = main_query.search(index=RESOURCES_INDEX)
+            geometries = []
+            for hit in response['hits']['hits']:
+                geometries.extend(hit['_source']['geometries'][0]['geom']['features'])
 
-                search_query.filter(Nested(path="geometries", query=spatial_query))
+            feature_geom = geometries[0]["geometry"]
+            add_geoshape_query_to_search_query(feature_geom, spatial_filter, permitted_nodegroups, include_provisional, search_query)
 
         search_results_object["query"].add_query(search_query)
 
@@ -98,3 +100,35 @@ 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))

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 }}"'
+        search-near-here='{% trans "Search Near Here" as searchNearHere %} "{{ searchNearHere|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 }}"'

arches/app/templates/views/components/map-popup.htm

@@ -58,7 +58,15 @@
             <span data-bind="text: $root.translations.edit"></span>
         </a>
         <!--/ko-->
+        <!-- ko if: ko.unwrap(geometries).length -->
+        <a data-bind="click: function() {
+            mapCard.filterByFeatureGeom(ko.unwrap(resourceinstanceid), ko.unwrap(geometries)); 
+        }" href="#">
+            <i class="fa fa-map-pin"></i>
+            <span data-bind="text: $root.translations.searchNearHere"></span>
+        </a>
         </div>
+        <!-- /ko -->
         <!-- ko if: $parent.popupFeatures.length > 1 -->
         <div style="display: flex; flex-direction: row; width: 60px; justify-content: space-evenly; font-weight: 500;">
             <div class="hover-feature-instance-counter" data-bind="text: 1 + $parent.popupFeatures.findIndex(feature => feature.active());"></div>

tests/views/search_tests.py

@@ -146,6 +146,49 @@ def setUpClass(cls):
         cls.name_resource.tiles.append(tile)
         cls.name_resource.save()
 
+        # spatial filter test data
+        cls.spatial_filter_geom_resourceid = 'cbb1e9df-5110-4f22-933c-9ccbeb57431b'
+        cls.spatial_filter_geom_resource = Resource(graph_id=cls.search_model_graphid, resourceinstanceid=cls.spatial_filter_geom_resourceid)
+        cls.spatial_filter_geom_resource.save()
+        cls.polygon_feature_id = "2190cb9e-7c57-485c-bf1a-7b6f0389f8b1"
+
+        geom_poly = {
+            "type": "FeatureCollection",
+            "features": [
+                {
+                    "geometry": {"type": "Polygon", "coordinates": [[
+                            [-118.22687435396205, 34.04498354472949],
+                            [-118.22673462509519, 34.045024944460636],
+                            [-118.22661984555208, 34.044757071199754],
+                            [-118.22675979254618, 34.044715607647184],
+                            [-118.22687435396205, 34.04498354472949]
+                        ]]
+                    },
+                    "type": "Feature", 
+                    "id": cls.polygon_feature_id,
+                    "properties": {}
+                }
+            ]
+        }
+        tile = Tile.get_blank_tile(cls.search_model_geom_nodeid, resourceid=cls.spatial_filter_geom_resourceid)
+        tile.data[cls.search_model_geom_nodeid] = geom_poly
+        tile.save()
+        cls.point_feature_id = "d41e81ac-4a53-4049-b266-c459b7641bc1"
+        geom_point = {
+            "type": "FeatureCollection",
+            "features": [
+                {
+                    "geometry": {"type": "Point", "coordinates": [-118.22687435396206, 34.04498354472948]},
+                    "type": "Feature", 
+                    "id": cls.point_feature_id,
+                    "properties": {}
+                }
+            ]
+        }
+        tile = Tile.get_blank_tile(cls.search_model_geom_nodeid, resourceid=cls.spatial_filter_geom_resourceid)
+        tile.data[cls.search_model_geom_nodeid] = geom_point
+        tile.save()
+
         # add delay to allow for indexes to be updated
         time.sleep(1)
 
@@ -462,6 +505,35 @@ def test_spatial_search_2(self):
         self.assertEqual(response_json["results"]["hits"]["total"]["value"], 0)
         # self.assertCountEqual(extract_pks(response_json), [str(self.name_resource.pk)])
 
+    def test_spatial_search_by_featureid_and_resourceid(self):
+        """
+        Test spatial search functionality using featureid and resourceid to retrieve geometries.
+        """
+        # Simulate spatial filter with featureid and resourceid, not feature collection
+        spatial_filter_poly_feature = {
+            "featureid": self.polygon_feature_id,
+            "resourceid": self.spatial_filter_geom_resourceid,
+            "buffer": {
+                "width": 10,
+                "unit": 'ft'
+            },
+            "inverted": False
+        }
+        response_json = get_response_json(self.client, spatial_filter=spatial_filter_poly_feature)
+        self.assertEqual(response_json["results"]["hits"]["total"]["value"], 2)
+
+        spatial_filter_point_feature = {
+            "featureid": self.point_feature_id,
+            "resourceid": self.spatial_filter_geom_resourceid,
+            "buffer": {
+                "width": 10,
+                "unit": 'ft'
+            },
+            "inverted": False
+        }
+        response_json = get_response_json(self.client, spatial_filter=spatial_filter_point_feature)
+        self.assertEqual(response_json["results"]["hits"]["total"]["value"], 2)
+
     #
     # -- ADD TESTS THAT INCLUDE PERMISSIONS REQUIREMENTS -- #
     #