Extending temporal search

CHANGELOG.md

@@ -13,6 +13,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ### Changed
 
+- Extended Datetime Search to search on start_datetime and end_datetime as well as datetime fields. [#182](https://github.com/stac-utils/stac-fastapi-elasticsearch/pull/182)
+
 - Elasticsearch drivers from 7.17.9 to 8.11.0 [#169](https://github.com/stac-utils/stac-fastapi-elasticsearch/pull/169)
 
 ### Fixed

docker-compose.yml

@@ -14,7 +14,7 @@ services:
       - RELOAD=true
       - ENVIRONMENT=local
       - WEB_CONCURRENCY=10
-      - ES_HOST=172.17.0.1
+      - ES_HOST=elasticsearch
       - ES_PORT=9200
       - ES_USE_SSL=false
       - ES_VERIFY_CERTS=false
@@ -32,6 +32,7 @@ services:
   elasticsearch:
     container_name: es-container
     image: docker.elastic.co/elasticsearch/elasticsearch:${ELASTICSEARCH_VERSION:-8.11.0}
+    hostname: elasticsearch
     environment:
       ES_JAVA_OPTS: -Xms512m -Xmx1g
     volumes:

stac_fastapi/elasticsearch/stac_fastapi/elasticsearch/core.py

@@ -289,22 +289,10 @@ def _return_date(interval_str):
             datetime = f"{intervals[0][0:19]}Z"
             return {"eq": datetime}
         else:
-            start_date = intervals[0]
-            end_date = intervals[1]
-            if ".." not in intervals:
-                start_date = f"{start_date[0:19]}Z"
-                end_date = f"{end_date[0:19]}Z"
-            elif start_date != "..":
-                start_date = f"{start_date[0:19]}Z"
-                end_date = "2200-12-01T12:31:12Z"
-            elif end_date != "..":
-                start_date = "1900-10-01T00:00:00Z"
-                end_date = f"{end_date[0:19]}Z"
-            else:
-                start_date = "1900-10-01T00:00:00Z"
-                end_date = "2200-12-01T12:31:12Z"
+            start_date = f"{intervals[0][0:19]}Z" if intervals[0] != ".." else None
+            end_date = f"{intervals[1][0:19]}Z" if intervals[1] != ".." else None
 
-        return {"lte": end_date, "gte": start_date}
+            return {"lte": end_date, "gte": start_date}
 
     async def get_search(
         self,
@@ -457,9 +445,9 @@ async def post_search(
             )
 
         if search_request.query:
-            for (field_name, expr) in search_request.query.items():
+            for field_name, expr in search_request.query.items():
                 field = "properties__" + field_name
-                for (op, value) in expr.items():
+                for op, value in expr.items():
                     search = self.database.apply_stacql_filter(
                         search=search, op=op, field=field, value=value
                     )

stac_fastapi/elasticsearch/stac_fastapi/elasticsearch/database_logic.py

@@ -378,8 +378,8 @@ def apply_collections_filter(search: Search, collection_ids: List[str]):
         return search.filter("terms", collection=collection_ids)
 
     @staticmethod
-    def apply_datetime_filter(search: Search, datetime_search):
-        """Apply a filter to search based on datetime field.
+    def apply_datetime_filter(search: Search, datetime_search: dict):
+        """Apply a filter to search on datetime, start_datetime, and end_datetime fields.
 
         Args:
             search (Search): The search object to filter.
@@ -388,17 +388,101 @@ def apply_datetime_filter(search: Search, datetime_search):
         Returns:
             Search: The filtered search object.
         """
+        should = []
+
         if "eq" in datetime_search:
-            search = search.filter(
-                "term", **{"properties__datetime": datetime_search["eq"]}
+            should.extend(
+                [
+                    Q(
+                        "bool",
+                        filter=[
+                            Q(
+                                "term",
+                                properties__datetime=datetime_search["eq"],
+                            ),
+                        ],
+                    ),
+                    Q(
+                        "bool",
+                        filter=[
+                            Q(
+                                "range",
+                                properties__start_datetime={
+                                    "lte": datetime_search["eq"],
+                                },
+                            ),
+                            Q(
+                                "range",
+                                properties__end_datetime={
+                                    "gte": datetime_search["eq"],
+                                },
+                            ),
+                        ],
+                    ),
+                ]
             )
+
         else:
-            search = search.filter(
-                "range", properties__datetime={"lte": datetime_search["lte"]}
-            )
-            search = search.filter(
-                "range", properties__datetime={"gte": datetime_search["gte"]}
+            should.extend(
+                [
+                    Q(
+                        "bool",
+                        filter=[
+                            Q(
+                                "range",
+                                properties__datetime={
+                                    "gte": datetime_search["gte"],
+                                    "lte": datetime_search["lte"],
+                                },
+                            ),
+                        ],
+                    ),
+                    Q(
+                        "bool",
+                        filter=[
+                            Q(
+                                "range",
+                                properties__start_datetime={
+                                    "gte": datetime_search["gte"],
+                                    "lte": datetime_search["lte"],
+                                },
+                            ),
+                        ],
+                    ),
+                    Q(
+                        "bool",
+                        filter=[
+                            Q(
+                                "range",
+                                properties__end_datetime={
+                                    "gte": datetime_search["gte"],
+                                    "lte": datetime_search["lte"],
+                                },
+                            ),
+                        ],
+                    ),
+                    Q(
+                        "bool",
+                        filter=[
+                            Q(
+                                "range",
+                                properties__start_datetime={
+                                    "lte": datetime_search["gte"]
+                                },
+                            ),
+                            Q(
+                                "range",
+                                properties__end_datetime={
+                                    "gte": datetime_search["lte"]
+                                },
+                            ),
+                        ],
+                    ),
+                ]
             )
+
+        search = search.query(Q("bool", filter=[Q("bool", should=should)]))
+
         return search
 
     @staticmethod

stac_fastapi/elasticsearch/tests/api/test_api.py

@@ -191,7 +191,13 @@ async def test_app_fields_extension_return_all_properties(app_client, ctx, txn_c
     feature = resp_json["features"][0]
     assert len(feature["properties"]) >= len(item["properties"])
     for expected_prop, expected_value in item["properties"].items():
-        if expected_prop in ("datetime", "created", "updated"):
+        if expected_prop in (
+            "datetime",
+            "start_datetime",
+            "end_datetime",
+            "created",
+            "updated",
+        ):
             assert feature["properties"][expected_prop][0:19] == expected_value[0:19]
         else:
             assert feature["properties"][expected_prop] == expected_value

stac_fastapi/elasticsearch/tests/data/test_item.json

@@ -35,6 +35,8 @@
   },
   "properties": {
     "datetime": "2020-02-12T12:30:22Z",
+    "start_datetime": "2020-02-08T12:30:22Z",
+    "end_datetime": "2020-02-16T12:30:22Z",
     "landsat:scene_id": "LC82081612020043LGN00",
     "landsat:row": "161",
     "gsd": 15,

stac_fastapi/elasticsearch/tests/resources/test_item.py

@@ -385,6 +385,25 @@ async def test_item_search_temporal_window_post(app_client, ctx):
     assert resp_json["features"][0]["id"] == test_item["id"]
 
 
+@pytest.mark.asyncio
+async def test_item_search_temporal_intersecting_window_post(app_client, ctx):
+    """Test POST search with two-tailed spatio-temporal query (core)"""
+    test_item = ctx.item
+
+    item_date = rfc3339_str_to_datetime(test_item["properties"]["datetime"])
+    item_date_before = item_date - timedelta(days=10)
+    item_date_after = item_date - timedelta(days=2)
+
+    params = {
+        "collections": [test_item["collection"]],
+        "intersects": test_item["geometry"],
+        "datetime": f"{datetime_to_str(item_date_before)}/{datetime_to_str(item_date_after)}",
+    }
+    resp = await app_client.post("/search", json=params)
+    resp_json = resp.json()
+    assert resp_json["features"][0]["id"] == test_item["id"]
+
+
 @pytest.mark.asyncio
 @pytest.mark.skip(reason="KeyError: 'features")
 async def test_item_search_temporal_open_window(app_client, ctx):