udata 9.2.5.dev32170__py2.py3-none-any.whl → 9.2.5.dev32190__py2.py3-none-any.whl

udata/core/organization/models.py

@@ -5,7 +5,8 @@ from blinker import Signal
 from mongoengine.signals import post_save, pre_save
 from werkzeug.utils import cached_property
 
-from udata.core.badges.models import BadgeMixin
+from udata.api_fields import field
+from udata.core.badges.models import Badge, BadgeMixin, BadgesList
 from udata.core.metrics.models import WithMetrics
 from udata.core.storages import avatars, default_image_basename
 from udata.frontend.markdown import mdstrip
@@ -29,6 +30,14 @@ from .constants import (
 
 __all__ = ("Organization", "Team", "Member", "MembershipRequest")
 
+BADGES: dict[str, str] = {
+    PUBLIC_SERVICE: _("Public Service"),
+    CERTIFIED: _("Certified"),
+    ASSOCIATION: _("Association"),
+    COMPANY: _("Company"),
+    LOCAL_AUTHORITY: _("Local authority"),
+}
+
 
 class Team(db.EmbeddedDocument):
     name = db.StringField(required=True)
@@ -82,8 +91,20 @@ class OrganizationQuerySet(db.BaseQuerySet):
     def get_by_id_or_slug(self, id_or_slug):
         return self(slug=id_or_slug).first() or self(id=id_or_slug).first()
 
+    def with_badge(self, kind):
+        return self(badges__kind=kind)
+
+
+class OrganizationBadge(Badge):
+    kind = db.StringField(required=True, choices=list(BADGES.keys()))
+
 
-class Organization(WithMetrics, BadgeMixin, db.Datetimed, db.Document):
+class OrganizationBadgeMixin(BadgeMixin):
+    badges = field(BadgesList(OrganizationBadge), **BadgeMixin.default_badges_list_params)
+    __badges__ = BADGES
+
+
+class Organization(WithMetrics, OrganizationBadgeMixin, db.Datetimed, db.Document):
     name = db.StringField(required=True)
     acronym = db.StringField(max_length=128)
     slug = db.SlugField(
@@ -126,14 +147,6 @@ class Organization(WithMetrics, BadgeMixin, db.Datetimed, db.Document):
     def __str__(self):
         return self.name or ""
 
-    __badges__ = {
-        PUBLIC_SERVICE: _("Public Service"),
-        CERTIFIED: _("Certified"),
-        ASSOCIATION: _("Association"),
-        COMPANY: _("Company"),
-        LOCAL_AUTHORITY: _("Local authority"),
-    }
-
     __metrics_keys__ = [
         "datasets",
         "members",

udata/core/organization/search.py

@@ -3,7 +3,7 @@ import datetime
 from udata import search
 from udata.core.organization.api import DEFAULT_SORTING, OrgApiParser
 from udata.models import Organization
-from udata.search.fields import Filter
+from udata.search.fields import ModelTermsFilter
 from udata.utils import to_iso_datetime
 
 __all__ = ("OrganizationSearch",)
@@ -22,7 +22,11 @@ class OrganizationSearch(search.ModelSearchAdapter):
         "created": "created_at",
     }
 
-    filters = {"badge": Filter()}
+    filters = {
+        "badge": ModelTermsFilter(
+            model=Organization, field_name="badges", choices=list(Organization.__badges__)
+        ),
+    }
 
     @classmethod
     def is_indexable(cls, org):

udata/core/reuse/api.py

@@ -13,6 +13,7 @@ from udata.core.badges import api as badges_api
 from udata.core.badges.fields import badge_fields
 from udata.core.dataset.api_fields import dataset_ref_fields
 from udata.core.followers.api import FollowAPI
+from udata.core.organization.models import Organization
 from udata.core.reuse.constants import REUSE_TOPICS, REUSE_TYPES
 from udata.core.storages.api import (
     image_parser,
@@ -49,6 +50,12 @@ class ReuseApiParser(ModelApiParser):
         self.parser.add_argument("dataset", type=str, location="args")
         self.parser.add_argument("tag", type=str, location="args")
         self.parser.add_argument("organization", type=str, location="args")
+        self.parser.add_argument(
+            "organization_badge",
+            type=str,
+            choices=list(Organization.__badges__),
+            location="args",
+        )
         self.parser.add_argument("owner", type=str, location="args")
         self.parser.add_argument("type", type=str, location="args")
         self.parser.add_argument("topic", type=str, location="args")
@@ -79,6 +86,9 @@ class ReuseApiParser(ModelApiParser):
             if not ObjectId.is_valid(args["organization"]):
                 api.abort(400, "Organization arg must be an identifier")
             reuses = reuses.filter(organization=args["organization"])
+        if args.get("organization_badge"):
+            orgs = Organization.objects.with_badge(args["organization_badge"])
+            reuses = reuses.filter(organization__in=orgs)
         if args.get("owner"):
             if not ObjectId.is_valid(args["owner"]):
                 api.abort(400, "Owner arg must be an identifier")

udata/core/reuse/models.py

@@ -9,7 +9,7 @@ from udata.core.reuse.api_fields import BIGGEST_IMAGE_SIZE
 from udata.core.storages import default_image_basename, images
 from udata.frontend.markdown import mdstrip
 from udata.i18n import lazy_gettext as _
-from udata.models import BadgeMixin, WithMetrics, db
+from udata.models import Badge, BadgeMixin, BadgesList, WithMetrics, db
 from udata.mongo.errors import FieldValidationError
 from udata.uris import endpoint_for
 from udata.utils import hash_url
@@ -18,6 +18,8 @@ from .constants import IMAGE_MAX_SIZE, IMAGE_SIZES, REUSE_TOPICS, REUSE_TYPES
 
 __all__ = ("Reuse",)
 
+BADGES: dict[str, str] = {}
+
 
 class ReuseQuerySet(OwnedQuerySet):
     def visible(self):
@@ -33,15 +35,25 @@ def check_url_does_not_exists(url):
         raise FieldValidationError(_("This URL is already registered"), field="url")
 
 
+class ReuseBadge(Badge):
+    kind = db.StringField(required=True, choices=list(BADGES.keys()))
+
+
+class ReuseBadgeMixin(BadgeMixin):
+    badges = field(BadgesList(ReuseBadge), **BadgeMixin.default_badges_list_params)
+    __badges__ = BADGES
+
+
 @generate_fields(
     searchable=True,
-    additionalSorts=[
+    additional_sorts=[
         {"key": "datasets", "value": "metrics.datasets"},
         {"key": "followers", "value": "metrics.followers"},
         {"key": "views", "value": "metrics.views"},
     ],
+    additional_filters={"organization_badge": "organization.badges"},
 )
-class Reuse(db.Datetimed, WithMetrics, BadgeMixin, Owned, db.Document):
+class Reuse(db.Datetimed, WithMetrics, ReuseBadgeMixin, Owned, db.Document):
     title = field(
         db.StringField(required=True),
         sortable=True,
@@ -124,8 +136,6 @@ class Reuse(db.Datetimed, WithMetrics, BadgeMixin, Owned, db.Document):
     def __str__(self):
         return self.title or ""
 
-    __badges__ = {}
-
     __metrics_keys__ = [
         "discussions",
         "datasets",

udata/core/reuse/search.py

@@ -29,9 +29,10 @@ class ReuseSearch(ModelSearchAdapter):
     filters = {
         "tag": Filter(),
         "organization": ModelTermsFilter(model=Organization),
+        "organization_badge": Filter(choices=list(Organization.__badges__)),
         "owner": ModelTermsFilter(model=User),
         "type": Filter(),
-        "badge": Filter(),
+        "badge": Filter(choices=list(Reuse.__badges__)),
         "featured": BoolFilter(),
         "topic": Filter(),
         "archived": BoolFilter(),
@@ -65,6 +66,7 @@ class ReuseSearch(ModelSearchAdapter):
                 "name": org.name,
                 "public_service": 1 if org.public_service else 0,
                 "followers": org.metrics.get("followers", 0),
+                "badges": [badge.kind for badge in org.badges],
             }
         elif reuse.owner:
             owner = User.objects(id=reuse.owner.id).first()

udata/search/fields.py

@@ -19,8 +19,12 @@ OR_SEPARATOR = "|"
 
 
 class Filter:
-    @staticmethod
-    def as_request_parser_kwargs():
+    def __init__(self, choices=None):
+        self.choices = choices
+
+    def as_request_parser_kwargs(self):
+        if self.choices:
+            return {"type": clean_string, "choices": self.choices}
         return {"type": clean_string}
 
 
@@ -31,9 +35,10 @@ class BoolFilter(Filter):
 
 
 class ModelTermsFilter(Filter):
-    def __init__(self, model, field_name="id"):
+    def __init__(self, model, field_name="id", choices=None):
         self.model = model
         self.field_name = field_name
+        super().__init__(choices=choices)
 
     @property
     def model_field(self):

udata/tests/api/test_dataservices_api.py

@@ -3,6 +3,7 @@ from xml.etree.ElementTree import XML
 import pytest
 from flask import url_for
 
+import udata.core.organization.constants as org_constants
 from udata.core.dataservices.factories import DataserviceFactory
 from udata.core.dataservices.models import Dataservice
 from udata.core.dataset.factories import DatasetFactory, LicenseFactory
@@ -10,7 +11,7 @@ from udata.core.organization.factories import OrganizationFactory
 from udata.core.organization.models import Member
 from udata.core.user.factories import UserFactory
 from udata.i18n import gettext as _
-from udata.tests.helpers import assert200, assert_redirects
+from udata.tests.helpers import assert200, assert400, assert_redirects
 
 from . import APITestCase
 
@@ -18,6 +19,25 @@ from . import APITestCase
 class DataserviceAPITest(APITestCase):
     modules = []
 
+    def test_dataservices_api_list_with_filters(self):
+        """Should filters dataservices results based on query filters"""
+        org = OrganizationFactory()
+        org_public_service = OrganizationFactory()
+        org_public_service.add_badge(org_constants.PUBLIC_SERVICE)
+
+        _dataservice = DataserviceFactory(organization=org)
+        dataservice_public_service = DataserviceFactory(organization=org_public_service)
+
+        response = self.get(
+            url_for("api.dataservices", organization_badge=org_constants.PUBLIC_SERVICE)
+        )
+        assert200(response)
+        assert len(response.json["data"]) == 1
+        assert response.json["data"][0]["id"] == str(dataservice_public_service.id)
+
+        response = self.get(url_for("api.dataservices", organization_badge="bad-badge"))
+        assert400(response)
+
     def test_dataservice_api_create(self):
         user = self.login()
         datasets = DatasetFactory.create_batch(3)

udata/tests/api/test_datasets_api.py

@@ -8,6 +8,7 @@ import pytz
 import requests_mock
 from flask import url_for
 
+import udata.core.organization.constants as org_constants
 from udata.api import fields
 from udata.app import cache
 from udata.core import storages
@@ -148,6 +149,8 @@ class DatasetAPITest(APITestCase):
         """Should filters datasets results based on query filters"""
         owner = UserFactory()
         org = OrganizationFactory()
+        org_public_service = OrganizationFactory()
+        org_public_service.add_badge(org_constants.PUBLIC_SERVICE)
 
         [DatasetFactory() for i in range(2)]
 
@@ -167,6 +170,7 @@ class DatasetAPITest(APITestCase):
 
         owner_dataset = DatasetFactory(owner=owner)
         org_dataset = DatasetFactory(organization=org)
+        org_dataset_public_service = DatasetFactory(organization=org_public_service)
 
         schema_dataset = DatasetFactory(
             resources=[
@@ -247,6 +251,17 @@ class DatasetAPITest(APITestCase):
         response = self.get(url_for("api.datasets", organization="org-id"))
         self.assert400(response)
 
+        # filter on organization badge
+        response = self.get(
+            url_for("api.datasets", organization_badge=org_constants.PUBLIC_SERVICE)
+        )
+        self.assert200(response)
+        self.assertEqual(len(response.json["data"]), 1)
+        self.assertEqual(response.json["data"][0]["id"], str(org_dataset_public_service.id))
+
+        response = self.get(url_for("api.datasets", organization_badge="bad-badge"))
+        self.assert400(response)
+
         # filter on schema
         response = self.get(url_for("api.datasets", schema="my-schema"))
         self.assert200(response)

udata/tests/api/test_organizations_api.py

@@ -3,6 +3,7 @@ from datetime import datetime
 import pytest
 from flask import url_for
 
+import udata.core.organization.constants as org_constants
 from udata.core.badges.factories import badge_factory
 from udata.core.badges.signals import on_badge_added, on_badge_removed
 from udata.core.dataset.factories import DatasetFactory
@@ -41,6 +42,20 @@ class OrganizationAPITest:
         assert200(response)
         len(response.json["data"]) == len(organizations)
 
+    def test_organization_api_list_with_filters(self, api):
+        """It should filter the organization list"""
+        _org = OrganizationFactory()
+        org_public_service = OrganizationFactory()
+        org_public_service.add_badge(org_constants.PUBLIC_SERVICE)
+
+        response = api.get(url_for("api.organizations", badge=org_constants.PUBLIC_SERVICE))
+        assert200(response)
+        assert len(response.json["data"]) == 1
+        assert response.json["data"][0]["id"] == str(org_public_service.id)
+
+        response = api.get(url_for("api.organizations", badge="bad-badge"))
+        assert400(response)
+
     def test_organization_role_api_get(self, api):
         """It should fetch an organization's roles list from the API"""
         response = api.get(url_for("api.org_roles"))
@@ -818,10 +833,6 @@ class OrganizationBadgeAPITest:
 
     @pytest.fixture(autouse=True)
     def setUp(self, api, clean_db):
-        # Register at least two badges
-        Organization.__badges__["test-1"] = "Test 1"
-        Organization.__badges__["test-2"] = "Test 2"
-
         self.factory = badge_factory(Organization)
         self.user = api.login(AdminFactory())
         self.organization = OrganizationFactory()

udata/tests/api/test_reuses_api.py

@@ -4,6 +4,7 @@ import pytest
 from flask import url_for
 from werkzeug.test import TestResponse
 
+import udata.core.organization.constants as org_constants
 from udata.core.badges.factories import badge_factory
 from udata.core.dataset.factories import DatasetFactory
 from udata.core.organization.factories import OrganizationFactory
@@ -67,12 +68,17 @@ class ReuseAPITest:
         """Should filters reuses results based on query filters"""
         owner = UserFactory()
         org = OrganizationFactory()
+        org_public_service = OrganizationFactory()
+        org_public_service.add_badge(org_constants.PUBLIC_SERVICE)
 
         [ReuseFactory(topic="health", type="api") for i in range(2)]
 
         tag_reuse = ReuseFactory(tags=["my-tag", "other"], topic="health", type="api")
         owner_reuse = ReuseFactory(owner=owner, topic="health", type="api")
         org_reuse = ReuseFactory(organization=org, topic="health", type="api")
+        org_reuse_public_service = ReuseFactory(
+            organization=org_public_service, topic="health", type="api"
+        )
         featured_reuse = ReuseFactory(featured=True, topic="health", type="api")
         topic_reuse = ReuseFactory(topic="transport_and_mobility", type="api")
         type_reuse = ReuseFactory(topic="health", type="application")
@@ -125,6 +131,15 @@ class ReuseAPITest:
         response = api.get(url_for("api.reuses", organization="org-id"))
         assert400(response)
 
+        # filter on organization badge
+        response = api.get(url_for("api.reuses", organization_badge=org_constants.PUBLIC_SERVICE))
+        assert200(response)
+        assert len(response.json["data"]) == 1
+        assert response.json["data"][0]["id"] == str(org_reuse_public_service.id)
+
+        response = api.get(url_for("api.reuses", organization_badge="bad-badge"))
+        assert400(response)
+
     def test_reuse_api_list_filter_private(self, api) -> None:
         """Should filters reuses results based on the `private` filter"""
         user = UserFactory()

udata/tests/apiv2/test_datasets.py

@@ -2,6 +2,7 @@ from datetime import datetime
 
 from flask import url_for
 
+import udata.core.organization.constants as org_constants
 from udata.core.dataset.apiv2 import DEFAULT_PAGE_SIZE
 from udata.core.dataset.factories import (
     CommunityResourceFactory,
@@ -44,6 +45,22 @@ class DatasetAPIV2Test(APITestCase):
         assert data["community_resources"]["type"] == "GET"
         assert data["community_resources"]["total"] == 0
 
+    def test_search_dataset(self):
+        org = OrganizationFactory()
+        org.add_badge(org_constants.CERTIFIED)
+        org_public_service = OrganizationFactory()
+        org_public_service.add_badge(org_constants.PUBLIC_SERVICE)
+        _dataset_org = DatasetFactory(organization=org)
+        dataset_org_public_service = DatasetFactory(organization=org_public_service)
+
+        response = self.get(
+            url_for("apiv2.dataset_search", organization_badge=org_constants.PUBLIC_SERVICE)
+        )
+        self.assert200(response)
+        data = response.json["data"]
+        assert len(data) == 1
+        assert data[0]["id"] == str(dataset_org_public_service.id)
+
 
 class DatasetResourceAPIV2Test(APITestCase):
     def test_get_specific(self):

udata/tests/organization/test_organization_model.py

@@ -1,8 +1,10 @@
 from datetime import datetime
 
+import udata.core.organization.constants as org_constants
 from udata.core.dataset.factories import DatasetFactory, HiddenDatasetFactory
 from udata.core.followers.signals import on_follow, on_unfollow
 from udata.core.organization.factories import OrganizationFactory
+from udata.core.organization.models import Organization
 from udata.core.reuse.factories import ReuseFactory, VisibleReuseFactory
 from udata.core.user.factories import UserFactory
 from udata.models import Dataset, Follow, Member, Reuse
@@ -50,3 +52,22 @@ class OrganizationModelTest(TestCase, DBTestMixin):
         assert org.get_metrics()["datasets"] == 0
         assert org.get_metrics()["reuses"] == 0
         assert org.get_metrics()["followers"] == 0
+
+    def test_organization_queryset_with_badge(self):
+        org_public_service = OrganizationFactory()
+        org_public_service.add_badge(org_constants.PUBLIC_SERVICE)
+        org_certified_association = OrganizationFactory()
+        org_certified_association.add_badge(org_constants.CERTIFIED)
+        org_certified_association.add_badge(org_constants.ASSOCIATION)
+
+        public_services = list(Organization.objects.with_badge(org_constants.PUBLIC_SERVICE))
+        assert len(public_services) == 1
+        assert org_public_service in public_services
+
+        certified = list(Organization.objects.with_badge(org_constants.CERTIFIED))
+        assert len(certified) == 1
+        assert org_certified_association in certified
+
+        associations = list(Organization.objects.with_badge(org_constants.ASSOCIATION))
+        assert len(associations) == 1
+        assert org_certified_association in associations

udata/tests/site/test_site_metrics.py

@@ -9,7 +9,6 @@ from udata.core.organization.constants import PUBLIC_SERVICE
 from udata.core.reuse.factories import VisibleReuseFactory
 from udata.core.site.factories import SiteFactory
 from udata.harvest.tests.factories import HarvestSourceFactory
-from udata.models import Badge
 
 
 @pytest.mark.usefixtures("clean_db")
@@ -52,8 +51,7 @@ class SiteMetricTest:
     def test_badges_metric(self, app):
         site = SiteFactory.create(id=app.config["SITE_ID"])
 
-        ps_badge = Badge(kind=PUBLIC_SERVICE)
-        public_services = [OrganizationFactory(badges=[ps_badge]) for _ in range(2)]
+        public_services = [OrganizationFactory().add_badge(PUBLIC_SERVICE) for _ in range(2)]
         for _ in range(3):
             OrganizationFactory()
 

{udata-9.2.5.dev32170.dist-info → udata-9.2.5.dev32190.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: udata
-Version: 9.2.5.dev32170
+Version: 9.2.5.dev32190
 Summary: Open data portal
 Home-page: https://github.com/opendatateam/udata
 Author: Opendata Team
@@ -146,6 +146,7 @@ It is collectively taken care of by members of the
 - Fix flaky "duplicated email" importing fixtures tests [#3176](https://github.com/opendatateam/udata/pull/3176)
 - Fix deprecated CircleCI config [#3181](https://github.com/opendatateam/udata/pull/3181)
 - Use proper RESTful Hydra API endpoints [#3178](https://github.com/opendatateam/udata/pull/3178)
+- Add a "filter by organization badge" for datasets, dataservices, reuses and organizations [#3155](https://github.com/opendatateam/udata/pull/3155]
 
 ## 9.2.4 (2024-10-22)