udata 10.3.1.dev34878__py2.py3-none-any.whl → 10.3.2__py2.py3-none-any.whl

udata/__init__.py

@@ -4,5 +4,5 @@
 udata
 """
 
-__version__ = "10.3.1.dev"
+__version__ = "10.3.2"
 __description__ = "Open data portal"

udata/core/activity/api.py

@@ -70,7 +70,7 @@ activity_parser.add_argument(
 )
 
 
-@api.route("/activity", endpoint="activity")
+@api.route("/activity/", endpoint="activity")
 class SiteActivityAPI(API):
     @api.doc("activity")
     @api.expect(activity_parser)

udata/{frontend → core}/csv.py

@@ -240,7 +240,7 @@ def stream(queryset_or_adapter, basename=None):
         cls = _adapters.get(queryset_or_adapter._document)
         adapter = cls(queryset_or_adapter)
     else:
-        raise ValueError("Unsupported object type")
+        raise ValueError(f"Unsupported object type {queryset_or_adapter}")
 
     timestamp = datetime.utcnow().strftime("%Y-%m-%d-%H-%M")
     headers = {

udata/core/dataservices/csv.py

@@ -1,4 +1,4 @@
-from udata.frontend import csv
+from udata.core import csv
 
 from .models import Dataservice
 

udata/core/dataset/api.py

@@ -38,6 +38,7 @@ from udata.core.dataservices.models import Dataservice
 from udata.core.dataset.models import CHECKSUM_TYPES
 from udata.core.followers.api import FollowAPI
 from udata.core.organization.models import Organization
+from udata.core.reuse.models import Reuse
 from udata.core.storages.api import handle_upload, upload_parser
 from udata.core.topic.models import Topic
 from udata.linkchecker.checker import check_resource
@@ -122,6 +123,7 @@ class DatasetApiParser(ModelApiParser):
         self.parser.add_argument("topic", type=str, location="args")
         self.parser.add_argument("credit", type=str, location="args")
         self.parser.add_argument("dataservice", type=str, location="args")
+        self.parser.add_argument("reuse", type=str, location="args")
         self.parser.add_argument(
             "archived",
             type=boolean,
@@ -200,6 +202,15 @@ class DatasetApiParser(ModelApiParser):
                 pass
             else:
                 datasets = datasets.filter(id__in=[d.id for d in dataservice.datasets])
+        if args.get("reuse"):
+            if not ObjectId.is_valid(args["reuse"]):
+                api.abort(400, "Reuse arg must be an identifier")
+            try:
+                reuse = Reuse.objects.get(id=args["reuse"])
+            except Reuse.DoesNotExist:
+                pass
+            else:
+                datasets = datasets.filter(id__in=[d.id for d in reuse.datasets])
         if args.get("archived") is not None:
             if current_user.is_anonymous:
                 abort(401)

udata/core/dataset/csv.py

@@ -1,8 +1,8 @@
 # for backwards compatibility (see https://github.com/opendatateam/udata/pull/3152)
 import json
 
+from udata.core import csv
 from udata.core.discussions.csv import DiscussionCsvAdapter  # noqa: F401
-from udata.frontend import csv
 
 from .models import Dataset, Resource
 

udata/core/dataset/tasks.py

@@ -9,9 +9,8 @@ from mongoengine import ValidationError
 
 from udata import mail
 from udata import models as udata_models
-from udata.core import storages
+from udata.core import csv, storages
 from udata.core.dataservices.models import Dataservice
-from udata.frontend import csv
 from udata.harvest.models import HarvestJob
 from udata.i18n import lazy_gettext as _
 from udata.models import Activity, Discussion, Follow, Organization, Topic, Transfer, db

udata/core/discussions/csv.py

@@ -1,4 +1,4 @@
-from udata.frontend import csv
+from udata.core import csv
 
 from .models import Discussion
 

udata/core/organization/api.py

@@ -1,3 +1,4 @@
+import itertools
 from datetime import datetime
 
 from flask import make_response, redirect, request, url_for
@@ -6,6 +7,7 @@ from mongoengine.queryset.visitor import Q
 from udata.api import API, api, errors
 from udata.api.parsers import ModelApiParser
 from udata.auth import admin_permission, current_user
+from udata.core import csv
 from udata.core.badges import api as badges_api
 from udata.core.badges.fields import badge_fields
 from udata.core.contact_point.api import ContactPointApiParser
@@ -13,8 +15,10 @@ from udata.core.contact_point.api_fields import contact_point_page_fields
 from udata.core.dataservices.models import Dataservice
 from udata.core.dataset.api import DatasetApiParser
 from udata.core.dataset.api_fields import dataset_page_fields
+from udata.core.dataset.csv import DatasetCsvAdapter, ResourcesCsvAdapter
 from udata.core.dataset.models import Dataset
 from udata.core.discussions.api import discussion_fields
+from udata.core.discussions.csv import DiscussionCsvAdapter
 from udata.core.discussions.models import Discussion
 from udata.core.followers.api import FollowAPI
 from udata.core.reuse.models import Reuse
@@ -164,6 +168,42 @@ class OrganizationAPI(API):
         return "", 204
 
 
+@ns.route("/<org:org>/datasets.csv", endpoint="organization_datasets_csv", doc=common_doc)
+@api.response(404, "Organization not found")
+@api.response(410, "Organization has been deleted")
+class DatasetsCsvAPI(API):
+    def get(self, org):
+        datasets = Dataset.objects(organization=str(org.id)).visible()
+        adapter = DatasetCsvAdapter(datasets)
+        return csv.stream(adapter, "{0}-datasets".format(org.slug))
+
+
+@ns.route("/<org:org>/discussions.csv", endpoint="organization_discussions_csv", doc=common_doc)
+@api.response(404, "Organization not found")
+@api.response(410, "Organization has been deleted")
+class DiscussionsCsvAPI(API):
+    def get(self, org):
+        datasets = Dataset.objects.filter(organization=str(org.id))
+        discussions = [Discussion.objects.filter(subject=dataset) for dataset in datasets]
+        # Turns a list of lists into a flat list.
+        adapter = DiscussionCsvAdapter(itertools.chain(*discussions))
+        return csv.stream(adapter, "{0}-discussions".format(org.slug))
+
+
+@ns.route(
+    "/<org:org>/datasets-resources.csv",
+    endpoint="organization_datasets_resources_csv",
+    doc=common_doc,
+)
+@api.response(404, "Organization not found")
+@api.response(410, "Organization has been deleted")
+class DatasetsResourcesCsvAPI(API):
+    def get(self, org):
+        datasets = Dataset.objects(organization=str(org.id)).visible()
+        adapter = ResourcesCsvAdapter(datasets)
+        return csv.stream(adapter, "{0}-datasets-resources".format(org.slug))
+
+
 @ns.route("/<org:org>/catalog", endpoint="organization_rdf", doc=common_doc)
 @api.response(404, "Organization not found")
 @api.response(410, "Organization has been deleted")

udata/core/organization/csv.py

@@ -1,5 +1,5 @@
+from udata.core import csv
 from udata.core.dataset.models import Dataset
-from udata.frontend import csv
 
 from .models import Organization
 

udata/core/reuse/csv.py

@@ -1,4 +1,4 @@
-from udata.frontend import csv
+from udata.core import csv
 
 from .models import Reuse
 

udata/core/site/api.py

@@ -1,10 +1,23 @@
 from bson import ObjectId
-from flask import json, make_response, redirect, request, url_for
+from flask import current_app, json, make_response, redirect, request, url_for
 
 from udata.api import API, api, fields
 from udata.auth import admin_permission
+from udata.core import csv
+from udata.core.dataservices.csv import DataserviceCsvAdapter
 from udata.core.dataservices.models import Dataservice
+from udata.core.dataset.api import DatasetApiParser
 from udata.core.dataset.api_fields import dataset_fields
+from udata.core.dataset.csv import ResourcesCsvAdapter
+from udata.core.dataset.search import DatasetSearch
+from udata.core.dataset.tasks import get_queryset as get_csv_queryset
+from udata.core.organization.api import OrgApiParser
+from udata.core.organization.csv import OrganizationCsvAdapter
+from udata.core.organization.models import Organization
+from udata.core.reuse.api import ReuseApiParser
+from udata.core.reuse.csv import ReuseCsvAdapter
+from udata.harvest.csv import HarvestSourceCsvAdapter
+from udata.harvest.models import HarvestSource
 from udata.models import Dataset, Reuse
 from udata.rdf import CONTEXT, RDF_EXTENSIONS, graph_response, negociate_content
 from udata.utils import multi_to_dict
@@ -114,9 +127,101 @@ class SiteRdfCatalogFormat(API):
         return make_response(*graph_response(catalog, format))
 
 
+@api.route("/site/datasets.csv", endpoint="site_datasets_csv")
+class SiteDatasetsCsv(API):
+    def get(self):
+        # redirect to EXPORT_CSV dataset if feature is enabled and no filter is set
+        exported_models = current_app.config.get("EXPORT_CSV_MODELS", [])
+        if not request.args and "dataset" in exported_models:
+            return redirect(get_export_url("dataset"))
+        search_parser = DatasetSearch.as_request_parser(store_missing=False)
+        params = search_parser.parse_args()
+        params["facets"] = False
+        datasets = DatasetApiParser.parse_filters(get_csv_queryset(Dataset), params)
+        adapter = csv.get_adapter(Dataset)
+        return csv.stream(adapter(datasets), "datasets")
+
+
+@api.route("/site/resources.csv", endpoint="site_datasets_resources_csv")
+class SiteResourcesCsv(API):
+    def get(self):
+        # redirect to EXPORT_CSV dataset if feature is enabled and no filter is set
+        exported_models = current_app.config.get("EXPORT_CSV_MODELS", [])
+        if not request.args and "resource" in exported_models:
+            return redirect(get_export_url("resource"))
+        search_parser = DatasetSearch.as_request_parser(store_missing=False)
+        params = search_parser.parse_args()
+        params["facets"] = False
+        datasets = DatasetApiParser.parse_filters(get_csv_queryset(Dataset), params)
+        return csv.stream(ResourcesCsvAdapter(datasets), "resources")
+
+
+@api.route("/site/organizations.csv", endpoint="site_organizations_csv")
+class SiteOrganizationsCsv(API):
+    def get(self):
+        params = multi_to_dict(request.args)
+        # redirect to EXPORT_CSV dataset if feature is enabled and no filter is set
+        exported_models = current_app.config.get("EXPORT_CSV_MODELS", [])
+        if not params and "organization" in exported_models:
+            return redirect(get_export_url("organization"))
+        params["facets"] = False
+        organizations = OrgApiParser.parse_filters(get_csv_queryset(Organization), params)
+        return csv.stream(OrganizationCsvAdapter(organizations), "organizations")
+
+
+@api.route("/site/reuses.csv", endpoint="site_reuses_csv")
+class SiteReusesCsv(API):
+    def get(self):
+        params = multi_to_dict(request.args)
+        # redirect to EXPORT_CSV dataset if feature is enabled and no filter is set
+        exported_models = current_app.config.get("EXPORT_CSV_MODELS", [])
+        if not params and "reuse" in exported_models:
+            return redirect(get_export_url("reuse"))
+        params["facets"] = False
+        reuses = ReuseApiParser.parse_filters(get_csv_queryset(Reuse), params)
+        return csv.stream(ReuseCsvAdapter(reuses), "reuses")
+
+
+@api.route("/site/dataservices.csv", endpoint="site_dataservices_csv")
+class SiteDataservicesCsv(API):
+    def get(self):
+        params = multi_to_dict(request.args)
+        # redirect to EXPORT_CSV dataset if feature is enabled and no filter is set
+        exported_models = current_app.config.get("EXPORT_CSV_MODELS", [])
+        if not params and "dataservice" in exported_models:
+            return redirect(get_export_url("dataservice"))
+        params["facets"] = False
+        dataservices = Dataservice.apply_sort_filters(get_csv_queryset(Dataservice))
+        return csv.stream(DataserviceCsvAdapter(dataservices), "dataservices")
+
+
+@api.route("/site/harvests.csv", endpoint="site_harvests_csv")
+class SiteHarvestsCsv(API):
+    def get(self):
+        # redirect to EXPORT_CSV dataset if feature is enabled
+        exported_models = current_app.config.get("EXPORT_CSV_MODELS", [])
+        if "harvest" in exported_models:
+            return redirect(get_export_url("harvest"))
+        adapter = HarvestSourceCsvAdapter(get_csv_queryset(HarvestSource).order_by("created_at"))
+        return csv.stream(adapter, "harvest")
+
+
 @api.route("/site/context.jsonld", endpoint="site_jsonld_context")
 class SiteJsonLdContext(API):
     def get(self):
         response = make_response(json.dumps(CONTEXT))
         response.headers["Content-Type"] = "application/ld+json"
         return response
+
+
+def get_export_url(model):
+    did = current_app.config["EXPORT_CSV_DATASET_ID"]
+    dataset = Dataset.objects.get_or_404(id=did)
+    resource = None
+    for r in dataset.resources:
+        if r.extras.get("csv-export:model", "") == model:
+            resource = r
+            break
+    if not resource:
+        api.abort(404)
+    return resource.url

udata/core/tags/csv.py

@@ -1,4 +1,4 @@
-from udata.frontend import csv
+from udata.core import csv
 
 from .models import Tag
 

udata/core/tags/views.py

@@ -1,6 +1,6 @@
 import logging
 
-from udata.frontend import csv
+from udata.core import csv
 from udata.i18n import I18nBlueprint
 
 from .csv import TagCsvAdapter

udata/core/topic/models.py

@@ -21,7 +21,7 @@ class Topic(db.Document, Owned, db.Datetimed):
     datasets = db.ListField(db.LazyReferenceField("Dataset", reverse_delete_rule=db.PULL))
     reuses = db.ListField(db.LazyReferenceField("Reuse", reverse_delete_rule=db.PULL))
 
-    featured = db.BooleanField()
+    featured = db.BooleanField(default=False)
     private = db.BooleanField()
     extras = db.ExtrasField()
 

udata/core/topic/parsers.py

@@ -1,4 +1,5 @@
 from bson.objectid import ObjectId
+from flask_restx.inputs import boolean
 
 from udata.api import api
 from udata.api.parsers import ModelApiParser
@@ -20,6 +21,7 @@ class TopicApiParser(ModelApiParser):
         self.parser.add_argument("granularity", type=str, location="args")
         self.parser.add_argument("organization", type=str, location="args")
         self.parser.add_argument("owner", type=str, location="args")
+        self.parser.add_argument("featured", type=boolean, location="args")
 
     @staticmethod
     def parse_filters(topics, args):
@@ -38,6 +40,8 @@ class TopicApiParser(ModelApiParser):
             topics = topics.filter(spatial__zones=args["geozone"])
         if args.get("granularity"):
             topics = topics.filter(spatial__granularity=args["granularity"])
+        if args.get("featured") is not None:
+            topics = topics.filter(featured=args["featured"])
         if args.get("organization"):
             if not ObjectId.is_valid(args["organization"]):
                 api.abort(400, "Organization arg must be an identifier")

udata/harvest/csv.py

@@ -1,4 +1,4 @@
-from udata.frontend import csv
+from udata.core import csv
 
 from .models import HarvestSource
 

udata/migrations/2025-04-24-topic-featured-default-false.py

@@ -0,0 +1,15 @@
+"""
+This migration updates Topic.featured to False when it is None.
+"""
+
+import logging
+
+from udata.models import Topic
+
+log = logging.getLogger(__name__)
+
+
+def migrate(db):
+    log.info("Processing topics...")
+    count = Topic.objects(featured__exists=False).update(featured=False)
+    log.info(f"\tConverted {count} topics from `featured=None` to `featured=False`")

udata/routing.py

@@ -12,6 +12,7 @@ from udata.core.dataservices.models import Dataservice
 from udata.core.spatial.models import GeoZone
 from udata.i18n import ISO_639_1_CODES
 from udata.mongo import db
+from udata.uris import endpoint_for
 
 
 class LazyRedirect(object):
@@ -247,3 +248,5 @@ def init_app(app):
     app.url_map.converters["territory"] = TerritoryConverter
     app.url_map.converters["contact_point"] = ContactPointConverter
     app.url_map.converters["report"] = ReportConverter
+
+    app.jinja_env.globals["endpoint_for"] = endpoint_for

udata/templates/mail/account_inactivity.html

@@ -4,17 +4,19 @@
 {% block body %}
 <p style="margin: 0;padding: 0;">
     {{ _(
-            'Your account  (%(user_email)s) has been inactive for %(inactivity_years)d years or more.',
+            'We have noticed that your account associated to (%(user_email)s) has been inactive for %(inactivity_years)d years or more'
+            ' on %(site)s, the open platform for public data.',
             user_email=user.email,
-            inactivity_years=config.YEARS_OF_INACTIVITY_BEFORE_DELETION
+            inactivity_years=config.YEARS_OF_INACTIVITY_BEFORE_DELETION,
+            site=config.SITE_TITLE
         )
     }}
 </p>
 <br/>
 <p style="margin: 0;padding: 0;"><b>
     {{ _(
-        'If you want to keep your account, please log in with your account on %(site)s.',
-        site=config.SITE_TITLE
+        'If you want to keep your account, please log in with your account on %(home)s.',
+        home=endpoint_for("site.home_redirect", "api.site", _external=True)
         )
     }}
 </b></p>
@@ -26,4 +28,13 @@
         )
     }}
 </p>
+<br/>
+<p style="margin: 0;padding: 0;">
+    {{ _(
+        'This account is not tied to your other administration accounts and '
+        'you can always re-create an account on the %(site)s platform if necessary.',
+        site=config.SITE_TITLE
+        )
+    }}
+</p>
 {% endblock %}

udata/templates/mail/account_inactivity.txt

@@ -2,15 +2,17 @@
 
 {% block body %}
 {{ _(
-      'Your account  (%(user_email)s) has been inactive for %(inactivity_years)d years or more.',
+      'We have noticed that your account associated to (%(user_email)s) has been inactive for %(inactivity_years)d years or more'
+      ' on %(site)s, the open platform for public data.',
       user_email=user.email,
-      inactivity_years=config.YEARS_OF_INACTIVITY_BEFORE_DELETION
+      inactivity_years=config.YEARS_OF_INACTIVITY_BEFORE_DELETION,
+      site=config.SITE_TITLE
     )
 }}
 
 {{ _(
-      'If you want to keep your account, please log in with your account on %(site)s.',
-      site=config.SITE_TITLE
+      'If you want to keep your account, please log in with your account on %(home)s.',
+      home=endpoint_for("site.home_redirect", "api.site", _external=True)
     )
 }}
 
@@ -19,4 +21,11 @@
       notify_delay=config.DAYS_BEFORE_ACCOUNT_INACTIVITY_NOTIFY_DELAY
     )
 }}
+{{
+  _(
+      'This account is not tied to your other administration accounts and '
+      'you can always re-create an account on the %(site)s platform if necessary',
+      site=config.SITE_TITLE
+  )
+}}
 {% endblock %}

udata/tests/api/test_organizations_api.py

@@ -1,12 +1,15 @@
 from datetime import datetime
+from io import StringIO
 
 import pytest
 from flask import url_for
 
 import udata.core.organization.constants as org_constants
+from udata.core import csv
 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
+from udata.core.dataset.factories import DatasetFactory, ResourceFactory
+from udata.core.discussions.factories import DiscussionFactory
 from udata.core.organization.factories import OrganizationFactory
 from udata.core.reuse.factories import ReuseFactory
 from udata.core.user.factories import AdminFactory, UserFactory
@@ -22,6 +25,7 @@ from udata.tests.helpers import (
     assert410,
     assert_emit,
     assert_not_emit,
+    assert_starts_with,
     assert_status,
 )
 from udata.utils import faker
@@ -967,3 +971,96 @@ class OrganizationContactPointsAPITest:
 
         assert response.json["data"][0]["name"] == data["name"]
         assert response.json["data"][0]["email"] == data["email"]
+
+
+class OrganizationCsvExportsTest:
+    modules = []
+
+    def test_datasets_csv(self, api):
+        org = OrganizationFactory()
+        [DatasetFactory(organization=org, resources=[ResourceFactory()]) for _ in range(3)]
+
+        response = api.get(url_for("api.organization_datasets_csv", org=org))
+
+        assert200(response)
+        assert response.mimetype == "text/csv"
+        assert response.charset == "utf-8"
+
+        csvfile = StringIO(response.data.decode("utf-8"))
+        reader = csv.get_reader(csvfile)
+        header = next(reader)
+
+        assert header[0] == "id"
+        assert "title" in header
+        assert "url" in header
+        assert "description" in header
+        assert "created_at" in header
+        assert "last_modified" in header
+        assert "tags" in header
+        assert "metric.reuses" in header
+
+    def test_resources_csv(self, api):
+        org = OrganizationFactory()
+        datasets = [
+            DatasetFactory(organization=org, resources=[ResourceFactory(), ResourceFactory()])
+            for _ in range(3)
+        ]
+        not_org_dataset = DatasetFactory(resources=[ResourceFactory()])
+        hidden_dataset = DatasetFactory(private=True)
+
+        response = api.get(url_for("api.organization_datasets_resources_csv", org=org))
+
+        assert200(response)
+        assert response.mimetype == "text/csv"
+        assert response.charset == "utf-8"
+
+        csvfile = StringIO(response.data.decode("utf-8"))
+        reader = csv.get_reader(csvfile)
+        header = next(reader)
+
+        assert header[0] == "dataset.id"
+        assert "dataset.title" in header
+        assert "dataset.url" in header
+        assert "title" in header
+        assert "filetype" in header
+        assert "url" in header
+        assert "created_at" in header
+        assert "modified" in header
+        assert "downloads" in header
+
+        resource_id_index = header.index("id")
+
+        rows = list(reader)
+        ids = [(row[0], row[resource_id_index]) for row in rows]
+
+        assert len(rows) == sum(len(d.resources) for d in datasets)
+        for dataset in datasets:
+            for resource in dataset.resources:
+                assert (str(dataset.id), str(resource.id)) in ids
+
+        dataset_ids = set(row[0] for row in rows)
+        assert str(hidden_dataset.id) not in dataset_ids
+        assert str(not_org_dataset.id) not in dataset_ids
+
+    def test_discussions_csv_content_empty(self, api):
+        organization = OrganizationFactory()
+        response = api.get(url_for("api.organization_discussions_csv", org=organization))
+        assert200(response)
+
+        assert response.data.decode("utf8") == (
+            '"id";"user";"subject";"subject_class";"subject_id";"title";"size";"participants";'
+            '"messages";"created";"closed";"closed_by";"closed_by_id";"closed_by_organization";'
+            '"closed_by_organization_id"\r\n'
+        )
+
+    def test_discussions_csv_content_filled(self, api):
+        organization = OrganizationFactory()
+        dataset = DatasetFactory(organization=organization)
+        user = UserFactory(first_name="John", last_name="Snow")
+        discussion = DiscussionFactory(subject=dataset, user=user)
+        response = api.get(url_for("api.organization_discussions_csv", org=organization))
+        assert200(response)
+
+        headers, data = response.data.decode("utf-8").strip().split("\r\n")
+        expected = '"{discussion.id}";"{discussion.user}"'
+        assert_starts_with(data, expected.format(discussion=discussion))

udata/tests/api/test_topics_api.py

@@ -28,12 +28,13 @@ class TopicsAPITest(APITestCase):
         private_topic = TopicFactory(private=True)
         geozone_topic = TopicFactory(spatial=SpatialCoverageFactory(zones=[paca.id]))
         granularity_topic = TopicFactory(spatial=SpatialCoverageFactory(granularity="country"))
+        featured_topic = TopicFactory(featured=True)
         owner_topic = TopicFactory(owner=owner)
         org_topic = TopicFactory(organization=org)
 
         response = self.get(url_for("api.topics"))
         self.assert200(response)
-        self.assertEqual(len(response.json["data"]), 7)
+        self.assertEqual(len(response.json["data"]), 8)
 
         response = self.get(url_for("api.topics", q="topic-for"))
         self.assert200(response)
@@ -69,7 +70,7 @@ class TopicsAPITest(APITestCase):
 
         response = self.get(url_for("api.topics", include_private="true"))
         self.assert200(response)
-        self.assertEqual(len(response.json["data"]), 7)
+        self.assertEqual(len(response.json["data"]), 8)
         # we're not logged in, so the private topic does not appear
         self.assertNotIn(str(private_topic.id), [t["id"] for t in response.json["data"]])
 
@@ -83,6 +84,16 @@ class TopicsAPITest(APITestCase):
         self.assertEqual(len(response.json["data"]), 1)
         self.assertIn(str(granularity_topic.id), [t["id"] for t in response.json["data"]])
 
+        response = self.get(url_for("api.topics", featured="true"))
+        self.assert200(response)
+        self.assertEqual(len(response.json["data"]), 1)
+        self.assertIn(str(featured_topic.id), [t["id"] for t in response.json["data"]])
+
+        response = self.get(url_for("api.topics", featured="false"))
+        self.assert200(response)
+        self.assertEqual(len(response.json["data"]), 7)
+        self.assertNotIn(str(featured_topic.id), [t["id"] for t in response.json["data"]])
+
         response = self.get(url_for("api.topics", owner=owner.id))
         self.assert200(response)
         self.assertEqual(len(response.json["data"]), 1)

udata/tests/apiv2/test_datasets.py

@@ -11,6 +11,7 @@ from udata.core.dataset.factories import (
 )
 from udata.core.dataset.models import ResourceMixin
 from udata.core.organization.factories import Member, OrganizationFactory
+from udata.core.reuse.factories import ReuseFactory
 from udata.models import Dataset, db
 from udata.tests.api import APITestCase
 from udata.tests.helpers import assert_not_emit
@@ -43,6 +44,21 @@ class DatasetAPIV2Test(APITestCase):
         assert data["data"][1]["community_resources"]["total"] == 0
         assert data["data"][0]["community_resources"]["total"] == 0
 
+    def test_filter_by_reuse(self):
+        DatasetFactory(title="Dataset without reuse")
+
+        dataset_with_reuse = DatasetFactory(title="Dataset with reuse")
+        archived_dataset_with_reuse = DatasetFactory(
+            title="Dataset with reuse", archived=datetime(2022, 2, 22)
+        )
+        reuse = ReuseFactory(datasets=[dataset_with_reuse.id, archived_dataset_with_reuse.id])
+
+        response = self.get(url_for("apiv2.datasets", reuse=reuse.id))
+        self.assert200(response)
+        data = response.json
+        assert len(data["data"]) == 1
+        assert data["data"][0]["title"] == dataset_with_reuse.title
+
     def test_get_dataset(self):
         resources = [ResourceFactory() for _ in range(2)]
         dataset = DatasetFactory(resources=resources)