feat: search filter on sensor API

flexmeasures/api/v3_0/sensors.py

@@ -38,7 +38,11 @@
 from flexmeasures.data.queries.utils import simplify_index
 from flexmeasures.data.schemas.sensors import SensorSchema, SensorIdField
 from flexmeasures.data.schemas.times import AwareDateTimeField, PlanningDurationField
-from flexmeasures.data.services.sensors import get_sensors, get_sensor_stats
+from flexmeasures.data.services.sensors import (
+    get_sensors,
+    get_sensor_stats,
+    get_all_accessible_sensors,
+)
 from flexmeasures.data.services.scheduling import (
     create_scheduling_job,
     get_data_source_for_job,
@@ -65,12 +69,16 @@ class SensorAPI(FlaskView):
             "account": AccountIdField(
                 data_key="account_id", load_default=AccountIdField.load_current
             ),
+            "all_accessible": fields.Boolean(required=False, missing=False),
+            "filter": fields.Str(load_default=None),
         },
         location="query",
     )
     @permission_required_for_context("read", ctx_arg_name="account")
     @as_json
-    def index(self, account: Account):
+    def index(
+        self, account: Account, all_accessible: bool = False, filter: str | None = None
+    ):
         """API endpoint to list all sensors of an account.
 
         .. :quickref: Sensor; Download sensor list
@@ -106,7 +114,11 @@ def index(self, account: Account):
         :status 403: INVALID_SENDER
         :status 422: UNPROCESSABLE_ENTITY
         """
-        sensors = get_sensors(account=account)
+        if all_accessible:
+            sensors = get_all_accessible_sensors(account, filter)
+        else:
+            sensors = get_sensors(account, filter=filter)
+
         return sensors_schema.dump(sensors), 200
 
     @route("/data", methods=["POST"])

flexmeasures/data/services/sensors.py

@@ -22,13 +22,47 @@
 from flexmeasures.data.models.generic_assets import GenericAsset
 from flexmeasures.data.schemas.reporting import StatusSchema
 from flexmeasures.utils.time_utils import server_now
+from flexmeasures.auth.policy import check_access
+
+
+def get_all_accessible_sensors(account: Account, filter: str | None = None):
+    accounts: list = [account] if account else []
+    account_ids: list = [acc.id for acc in accounts]
+    consultancy_account_ids: list = [acc.consultancy_account_id for acc in accounts]
+    account_ids.extend(consultancy_account_ids)
+
+    sensor_query = (
+        sa.select(Sensor)
+        .join(GenericAsset, Sensor.generic_asset_id == GenericAsset.id)
+        .join(Account, GenericAsset.owner)
+        .filter(
+            sa.or_(
+                GenericAsset.account_id.in_(account_ids),
+                GenericAsset.account_id.is_(None),
+            )
+        )
+    )
+
+    if filter:
+        filter_statement = f"%{filter}%"
+        sensor_query = sensor_query.filter(
+            sa.or_(
+                Sensor.name.ilike(filter_statement),
+                Account.name.ilike(filter_statement),
+            )
+        )
+
+    sensors = db.session.scalars(sensor_query).all()
+
+    return [sensor for sensor in sensors if check_access(sensor, "read") is None]
 
 
 def get_sensors(
     account: Account | list[Account] | None,
     include_public_assets: bool = False,
     sensor_id_allowlist: list[int] | None = None,
     sensor_name_allowlist: list[str] | None = None,
+    filter: str | None = None,
 ) -> list[Sensor]:
     """Return a list of Sensor objects that belong to the given account, and/or public sensors.
 
@@ -60,6 +94,15 @@ def get_sensors(
         sensor_query = sensor_query.filter(Sensor.id.in_(sensor_id_allowlist))
     if sensor_name_allowlist:
         sensor_query = sensor_query.filter(Sensor.name.in_(sensor_name_allowlist))
+
+    if filter:
+        print("===================filter:", filter)
+        sensor_query = sensor_query.join(Account, GenericAsset.owner).filter(
+            sa.or_(
+                Sensor.name.ilike(filter),
+                Account.name.ilike(filter),
+            )
+        )
     return db.session.scalars(sensor_query).all()