udata 11.0.2.dev18__py3-none-any.whl → 11.0.2.dev20__py3-none-any.whl

udata/api_fields.py

@@ -8,10 +8,11 @@ Main components:
 - `field()`: Universal function to add metadata to fields and methods
 
 The `@generate_fields` decorator parameters:
-- default_filterable_field: Default field for filtering (e.g., Badge.kind)
-- searchable: Enables full-text search with param `q` via MongoEngine on indexed text fields
-- additional_sorts: Custom sort options beyond field-based sorts
-- additional_filters: Cross-document filtering (e.g., Reuse__organization__badge)
+- default_filterable_field: which field in this document should be the default filter, eg when filtering by Badge, you're actually filtering on `Badge.kind`
+- searchable: boolean, if True, the document can be full-text searched using MongoEngine text search
+- additional_sorts: add more sorts than the already available ones based on fields (see below). Eg, sort by metrics.
+- nested_filters: filter on a field of a field (aka "join"), eg filter on `Reuse__organization__badge=PUBLIC_SERVICE`.
+- standalone_filters: filter on something else than a field. Should be a list of dicts with filterable attributes, as returned by `compute_filter`.
 
 Generated attributes on decorated classes:
 - ref_fields: Minimal fields for embedded/referenced documents
@@ -317,9 +318,9 @@ def generate_fields(**kwargs) -> Callable:
         ref_fields: dict = {}
         sortables: list = kwargs.get("additional_sorts", [])
 
-        filterables: list[dict] = []
-        additional_filters: dict[str, dict] = get_fields_with_additional_filters(
-            kwargs.get("additional_filters", {})
+        filterables: list[dict] = kwargs.get("standalone_filters", [])
+        nested_filters: dict[str, dict] = get_fields_with_nested_filters(
+            kwargs.get("nested_filters", {})
         )
 
         read_fields["id"] = restx_fields.String(required=True, readonly=True)
@@ -341,16 +342,16 @@ def generate_fields(**kwargs) -> Callable:
             if filterable is not None:
                 filterables.append(compute_filter(key, field, info, filterable))
 
-            additional_filter: dict | None = additional_filters.get(key, None)
-            if additional_filter:
+            nested_filter: dict | None = nested_filters.get(key, None)
+            if nested_filter:
                 if not isinstance(
                     field, mongo_fields.ReferenceField | mongo_fields.LazyReferenceField
                 ):
-                    raise Exception("Cannot use additional_filters on a field that is not a ref.")
+                    raise Exception("Cannot use nested_filters on a field that is not a ref.")
 
                 ref_model: db.Document = field.document_type
 
-                for child in additional_filter.get("children", []):
+                for child in nested_filter.get("children", []):
                     inner_field: str = getattr(ref_model, child["key"])
 
                     column: str = f"{key}__{child['key']}"
@@ -474,7 +475,7 @@ def generate_fields(**kwargs) -> Callable:
 
         for filterable in filterables:
             parser.add_argument(
-                # Use the custom label from `additional_filters` if there's one.
+                # Use the custom label from `nested_filters` if there's one.
                 filterable.get("label", filterable["key"]),
                 type=filterable["type"],
                 location="args",
@@ -505,7 +506,7 @@ def generate_fields(**kwargs) -> Callable:
                 base_query = base_query.search_text(phrase_query)
 
             for filterable in filterables:
-                # If it's from an `additional_filter`, use the custom label instead of the key,
+                # If it's from an `nested_filter`, use the custom label instead of the key,
                 # eg use `organization_badge` instead of `organization.badges` which is
                 # computed to `organization_badges`.
                 filter = args.get(filterable.get("label", filterable["key"]))
@@ -792,21 +793,18 @@ def wrap_primary_key(
         )
 
 
-def get_fields_with_additional_filters(additional_filters: dict[str, str]) -> dict[str, Any]:
+def get_fields_with_nested_filters(nested_filters: dict[str, str]) -> dict[str, Any]:
     """Filter on additional related fields.
 
-    Right now we only support additional filters with a depth of two, eg "organization.badges".
-
-    The goal of this function is to key by the additional filters by the first part (`organization`) to
     be able to compute them when we loop over all the fields (`title`, `organization`…)
 
 
-    The `additional_filters` property is a dict: {"label": "key"}, for example {"organization_badge": "organization.badges"}.
+    The `nested_filters` property is a dict: {"label": "key"}, for example {"organization_badge": "organization.badges"}.
     The `label` will be the name of the parser arg, like `?organization_badge=public-service`, which makes more
     sense than `?organization_badges=public-service`.
     """
     results: dict = {}
-    for label, key in additional_filters.items():
+    for label, key in nested_filters.items():
         parts = key.split(".")
         if len(parts) == 2:
             parent = parts[0]
@@ -824,7 +822,7 @@ def get_fields_with_additional_filters(additional_filters: dict[str, str]) -> di
                 }
             )
         else:
-            raise Exception(f"Do not support `additional_filters` without two parts: {key}.")
+            raise Exception(f"Do not support `nested_filters` without two parts: {key}.")
 
     return results
 

udata/core/dataservices/models.py

@@ -134,9 +134,29 @@ def check_only_one_condition_per_role(access_audiences, **_kwargs):
         )
 
 
+def filter_by_topic(base_query, filter_value):
+    from udata.core.topic.models import Topic
+
+    try:
+        topic = Topic.objects.get(id=filter_value)
+    except Topic.DoesNotExist:
+        pass
+    else:
+        return base_query.filter(
+            id__in=[
+                elt.element.id
+                for elt in topic.elements
+                if elt.element.__class__.__name__ == "Dataservice"
+            ]
+        )
+
+
 @generate_fields(
     searchable=True,
-    additional_filters={"organization_badge": "organization.badges"},
+    nested_filters={"organization_badge": "organization.badges"},
+    standalone_filters=[
+        {"key": "topic", "constraints": "objectid", "query": filter_by_topic, "type": str}
+    ],
     additional_sorts=[
         {"key": "followers", "value": "metrics.followers"},
         {"key": "views", "value": "metrics.views"},

udata/core/dataservices/tasks.py

@@ -1,6 +1,7 @@
 from celery.utils.log import get_task_logger
 
 from udata.core.dataservices.models import Dataservice
+from udata.core.topic.models import TopicElement
 from udata.harvest.models import HarvestJob
 from udata.models import Discussion, Follow, Transfer
 from udata.tasks import job
@@ -20,5 +21,7 @@ def purge_dataservices(self):
         HarvestJob.objects(items__dataservice=dataservice).update(set__items__S__dataservice=None)
         # Remove associated Transfers
         Transfer.objects(subject=dataservice).delete()
+        # Remove dataservices references in Topics
+        TopicElement.objects(element=dataservice).update(element=None)
         # Remove dataservice
         dataservice.delete()

udata/core/reuse/models.py

@@ -60,7 +60,7 @@ class ReuseBadgeMixin(BadgeMixin):
         {"key": "followers", "value": "metrics.followers"},
         {"key": "views", "value": "metrics.views"},
     ],
-    additional_filters={"organization_badge": "organization.badges"},
+    nested_filters={"organization_badge": "organization.badges"},
     mask="*,datasets{id,title,uri,page}",
 )
 class Reuse(db.Datetimed, Auditable, WithMetrics, ReuseBadgeMixin, Linkable, Owned, db.Document):

udata/core/topic/factories.py

@@ -1,6 +1,7 @@
 import factory
 
 from udata import utils
+from udata.core.dataservices.factories import DataserviceFactory
 from udata.core.dataset.factories import DatasetFactory
 from udata.core.reuse.factories import ReuseFactory
 from udata.factories import ModelFactory
@@ -38,6 +39,10 @@ class TopicElementReuseFactory(TopicElementFactory):
     element = factory.SubFactory(ReuseFactory)
 
 
+class TopicElementDataserviceFactory(TopicElementFactory):
+    element = factory.SubFactory(DataserviceFactory)
+
+
 class TopicFactory(ModelFactory):
     class Meta:
         model = Topic
@@ -58,9 +63,10 @@ class TopicWithElementsFactory(TopicFactory):
         # Create associated elements
         TopicElementDatasetFactory.create_batch(2, topic=self)
         TopicElementReuseFactory.create(topic=self)
+        TopicElementDataserviceFactory.create(topic=self)
 
     @classmethod
-    def elements_as_payload(cls, elements: list) -> dict:
+    def elements_as_payload(cls, elements: list) -> list[dict]:
         return [
             {
                 "element": {"id": str(elt.element.id), "class": elt.element.__class__.__name__},

udata/core/topic/models.py

@@ -4,10 +4,8 @@ from mongoengine.signals import post_delete, post_save
 
 from udata.api_fields import field
 from udata.core.activity.models import Auditable
-from udata.core.dataset.models import Dataset
 from udata.core.linkable import Linkable
 from udata.core.owned import Owned, OwnedQuerySet
-from udata.core.reuse.models import Reuse
 from udata.models import SpatialCoverage, db
 from udata.search import reindex
 from udata.tasks import as_task_param
@@ -20,7 +18,7 @@ class TopicElement(Auditable, db.Document):
     description = field(db.StringField(required=False))
     tags = field(db.ListField(db.StringField()))
     extras = field(db.ExtrasField())
-    element = field(db.GenericReferenceField(choices=[Dataset, Reuse]))
+    element = field(db.GenericReferenceField(choices=["Dataset", "Reuse", "Dataservice"]))
     # Made optional to allow proper form handling with commit=False
     topic = field(db.ReferenceField("Topic", required=False))