udata 12.0.2.dev10__py3-none-any.whl → 13.0.1.dev21__py3-none-any.whl

udata/core/badges/tasks.py

@@ -1,9 +1,15 @@
-from udata.tasks import get_logger, task
+from typing import Any
+
+from mongoengine.base import TopLevelDocumentMetaclass
+
+from udata.tasks import get_logger, job, task
 
 from .signals import on_badge_added
 
 log = get_logger(__name__)
 
+_badge_jobs: dict[tuple[TopLevelDocumentMetaclass, str], Any] = {}
+
 
 def notify_new_badge(cls, kind):
     def wrapper(func):
@@ -17,3 +23,31 @@ def notify_new_badge(cls, kind):
         return t
 
     return wrapper
+
+
+def register(model: TopLevelDocumentMetaclass, badge: str):
+    """Register a job to update some badge"""
+
+    def inner(func):
+        _badge_jobs[(model, badge)] = func
+        return func
+
+    return inner
+
+
+def get_badge_job(model, badge):
+    return _badge_jobs.get((model, badge))
+
+
+@job(name="update-badges")
+def update_badges(self, badges: list[str] = []) -> None:
+    from udata.core.dataservices.models import Dataservice
+    from udata.models import Dataset, Organization, Reuse
+
+    for model in [Dataset, Reuse, Organization, Dataservice]:
+        for badge in model.__badges__:
+            if badges and badge not in badges:
+                continue
+            if adapter := get_badge_job(model, badge):
+                log.info(f"Running {model.__name__} {badge} job")
+                adapter()

udata/core/badges/tests/test_commands.py

@@ -1,13 +1,11 @@
 from tempfile import NamedTemporaryFile
 
-import pytest
-
 from udata.core.organization.constants import CERTIFIED, PUBLIC_SERVICE
 from udata.core.organization.factories import OrganizationFactory
+from udata.tests.api import PytestOnlyDBTestCase
 
 
-@pytest.mark.usefixtures("clean_db")
-class BadgeCommandTest:
+class BadgeCommandTest(PytestOnlyDBTestCase):
     def toggle(self, path_or_id, kind):
         return self.cli("badges", "toggle", path_or_id, kind)
 

udata/core/badges/tests/test_model.py

@@ -2,7 +2,7 @@ from udata.api_fields import field
 from udata.auth import login_user
 from udata.core.user.factories import UserFactory
 from udata.mongo import db
-from udata.tests import DBTestMixin, TestCase
+from udata.tests.api import DBTestCase
 
 from ..models import Badge, BadgeMixin, BadgesList
 
@@ -33,7 +33,7 @@ class Fake(db.Document, FakeBadgeMixin):
     pass
 
 
-class BadgeMixinTest(DBTestMixin, TestCase):
+class BadgeMixinTest(DBTestCase):
     def test_attributes(self):
         """It should have a badge list"""
         fake = Fake.objects.create()

udata/core/badges/tests/test_tasks.py

@@ -0,0 +1,55 @@
+import udata.core.dataservices.tasks  # noqa
+import udata.core.dataset.tasks  # noqa
+from udata.core.badges.tasks import update_badges
+from udata.core.constants import HVD
+from udata.core.dataservices.factories import DataserviceFactory
+from udata.core.dataservices.models import Dataservice
+from udata.core.dataset.factories import DatasetFactory
+from udata.core.dataset.models import Dataset
+from udata.core.organization.constants import CERTIFIED, PUBLIC_SERVICE
+from udata.core.organization.factories import OrganizationFactory
+from udata.tests.api import DBTestCase
+
+
+class BadgeTasksTest(DBTestCase):
+    def test_update_badges(self):
+        """
+        Test update_badges run the appropriate badge update jobs.
+        In particular, test that the two following registered jobs run and work as expected:
+        - update_dataset_hvd_badge
+        - update_dataservice_hvd_badge
+        """
+        org = OrganizationFactory()
+        org.add_badge(PUBLIC_SERVICE)
+        org.add_badge(CERTIFIED)
+
+        datasets = [
+            DatasetFactory(organization=org, tags=["hvd"]),  # Should be badged HVD
+            DatasetFactory(organization=org, tags=["random"]),  # Should not be badged HVD
+            DatasetFactory(
+                organization=org,
+                tags=[],
+                badges=[Dataset.badges.field.document_type(kind=HVD)],
+            ),  # Badge should be remove
+        ]
+        dataservices = [
+            DataserviceFactory(organization=org, tags=["hvd"]),  # Should be badged HVD
+            DataserviceFactory(organization=org, tags=["random"]),  # Should not be badged HVD
+            DataserviceFactory(
+                organization=org,
+                tags=[],
+                badges=[Dataservice.badges.field.document_type(kind=HVD)],
+            ),  # Badge should be remove
+        ]
+
+        update_badges.run()
+
+        [model.reload() for model in (*datasets, *dataservices)]
+
+        assert datasets[0].badges[0].kind == HVD
+        assert datasets[1].badges == []
+        assert datasets[2].badges == []
+
+        assert dataservices[0].badges[0].kind == HVD
+        assert dataservices[1].badges == []
+        assert dataservices[2].badges == []

udata/core/constants.py

@@ -0,0 +1 @@
+HVD = "hvd"

udata/core/contact_point/models.py

@@ -9,6 +9,14 @@ CONTACT_ROLES = {
     "contact": _("Contact"),
     "creator": _("Creator"),
     "publisher": _("Publisher"),
+    "rightsHolder": _("Rights Holder"),
+    "custodian": _("Custodian"),
+    "distributor": _("Distributor"),
+    "originator": _("Originator"),
+    "principalInvestigator": _("Principal Investigator"),
+    "processor": _("Processor"),
+    "resourceProvider": _("Resource Provider"),
+    "user": _("User"),
 }
 
 

udata/core/dataservices/api.py

@@ -9,13 +9,13 @@ from flask_login import current_user
 from udata.api import API, api, fields
 from udata.api_fields import patch
 from udata.auth import admin_permission
-from udata.core.dataservices.constants import DATASERVICE_ACCESS_TYPE_RESTRICTED
+from udata.core.access_type.constants import AccessType
 from udata.core.dataset.models import Dataset
 from udata.core.followers.api import FollowAPI
-from udata.core.site.models import current_site
 from udata.frontend.markdown import md
 from udata.i18n import gettext as _
 from udata.rdf import RDF_EXTENSIONS, graph_response, negociate_content
+from udata.utils import get_rss_feed_list
 
 from .models import Dataservice
 from .rdf import dataservice_to_rdf
@@ -48,7 +48,7 @@ class DataservicesAPI(API):
         dataservice = patch(Dataservice(), request)
         if not dataservice.owner and not dataservice.organization:
             dataservice.owner = current_user._get_current_object()
-        if dataservice.access_type != DATASERVICE_ACCESS_TYPE_RESTRICTED:
+        if dataservice.access_type != AccessType.RESTRICTED:
             dataservice.access_audiences = []
         dataservice.save()
         return dataservice, 201
@@ -62,9 +62,7 @@ class DataservicesAtomFeedAPI(API):
             _("Latest APIs"), description=None, feed_url=request.url, link=request.url_root
         )
 
-        dataservices: list[Dataservice] = (
-            Dataservice.objects.visible().order_by("-created_at").limit(current_site.feed_size)
-        )
+        dataservices = get_rss_feed_list(Dataservice.objects.visible(), "created_at")
         for dataservice in dataservices:
             author_name = None
             author_uri = None
@@ -117,7 +115,7 @@ class DataserviceAPI(API):
 
         patch(dataservice, request)
         dataservice.metadata_modified_at = datetime.utcnow()
-        if dataservice.access_type != DATASERVICE_ACCESS_TYPE_RESTRICTED:
+        if dataservice.access_type != AccessType.RESTRICTED:
             dataservice.access_audiences = []
 
         dataservice.save()
@@ -238,19 +236,19 @@ class DataserviceDatasetAPI(API):
 class DataserviceRdfAPI(API):
     @api.doc("rdf_dataservice")
     def get(self, dataservice):
-        format = RDF_EXTENSIONS[negociate_content()]
-        url = url_for("api.dataservice_rdf_format", dataservice=dataservice.id, format=format)
+        _format = RDF_EXTENSIONS[negociate_content()]
+        url = url_for("api.dataservice_rdf_format", dataservice=dataservice.id, _format=_format)
         return redirect(url)
 
 
 @ns.route(
-    "/<dataservice:dataservice>/rdf.<format>", endpoint="dataservice_rdf_format", doc=common_doc
+    "/<dataservice:dataservice>/rdf.<_format>", endpoint="dataservice_rdf_format", doc=common_doc
 )
 @api.response(404, "Dataservice not found")
 @api.response(410, "Dataservice has been deleted")
 class DataserviceRdfFormatAPI(API):
     @api.doc("rdf_dataservice_format")
-    def get(self, dataservice: Dataservice, format):
+    def get(self, dataservice: Dataservice, _format):
         if not dataservice.permissions["edit"].can():
             if dataservice.private:
                 api.abort(404)
@@ -260,7 +258,7 @@ class DataserviceRdfFormatAPI(API):
         resource = dataservice_to_rdf(dataservice)
         # bypass flask-restplus make_response, since graph_response
         # is handling the content negociation directly
-        return make_response(*graph_response(resource, format))
+        return make_response(*graph_response(resource, _format))
 
 
 @ns.route("/<id>/followers/", endpoint="dataservice_followers")

udata/core/dataservices/apiv2.py

@@ -2,7 +2,8 @@ from flask import request
 
 from udata import search
 from udata.api import API, apiv2
-from udata.core.dataservices.models import AccessAudience, Dataservice, HarvestMetadata
+from udata.core.access_type.models import AccessAudience
+from udata.core.dataservices.models import Dataservice, HarvestMetadata
 from udata.utils import multi_to_dict
 
 from .models import dataservice_permissions_fields
@@ -11,6 +12,7 @@ from .search import DataserviceSearch
 apiv2.inherit("DataservicePermissions", dataservice_permissions_fields)
 apiv2.inherit("DataservicePage", Dataservice.__page_fields__)
 apiv2.inherit("Dataservice (read)", Dataservice.__read_fields__)
+apiv2.inherit("DataserviceReference", Dataservice.__ref_fields__)
 apiv2.inherit("HarvestMetadata (read)", HarvestMetadata.__read_fields__)
 apiv2.inherit("AccessAudience (read)", AccessAudience.__read_fields__)
 

udata/core/dataservices/constants.py

@@ -1,30 +1 @@
 DATASERVICE_FORMATS = ["REST", "WMS", "WSL"]
-
-
-DATASERVICE_ACCESS_TYPE_OPEN = "open"
-DATASERVICE_ACCESS_TYPE_OPEN_WITH_ACCOUNT = "open_with_account"
-DATASERVICE_ACCESS_TYPE_RESTRICTED = "restricted"
-DATASERVICE_ACCESS_TYPES = [
-    DATASERVICE_ACCESS_TYPE_OPEN,
-    DATASERVICE_ACCESS_TYPE_OPEN_WITH_ACCOUNT,
-    DATASERVICE_ACCESS_TYPE_RESTRICTED,
-]
-
-DATASERVICE_ACCESS_AUDIENCE_ADMINISTRATION = "local_authority_and_administration"
-DATASERVICE_ACCESS_AUDIENCE_COMPANY = "company_and_association"
-DATASERVICE_ACCESS_AUDIENCE_PRIVATE = "private"
-
-DATASERVICE_ACCESS_AUDIENCE_TYPES = [
-    DATASERVICE_ACCESS_AUDIENCE_ADMINISTRATION,
-    DATASERVICE_ACCESS_AUDIENCE_COMPANY,
-    DATASERVICE_ACCESS_AUDIENCE_PRIVATE,
-]
-
-DATASERVICE_ACCESS_AUDIENCE_YES = "yes"
-DATASERVICE_ACCESS_AUDIENCE_NO = "no"
-DATASERVICE_ACCESS_AUDIENCE_UNDER_CONDITIONS = "under_condition"
-DATASERVICE_ACCESS_AUDIENCE_CONDITIONS = [
-    DATASERVICE_ACCESS_AUDIENCE_YES,
-    DATASERVICE_ACCESS_AUDIENCE_NO,
-    DATASERVICE_ACCESS_AUDIENCE_UNDER_CONDITIONS,
-]

udata/core/dataservices/models.py

@@ -2,19 +2,17 @@ from datetime import datetime
 
 from blinker import Signal
 from flask import url_for
+from flask_babel import LazyString
 from mongoengine import Q
 from mongoengine.signals import post_save
 
 import udata.core.contact_point.api_fields as contact_api_fields
 from udata.api import api, fields
 from udata.api_fields import field, generate_fields
+from udata.core.access_type.models import WithAccessType
 from udata.core.activity.models import Auditable
-from udata.core.dataservices.constants import (
-    DATASERVICE_ACCESS_AUDIENCE_CONDITIONS,
-    DATASERVICE_ACCESS_AUDIENCE_TYPES,
-    DATASERVICE_ACCESS_TYPES,
-    DATASERVICE_FORMATS,
-)
+from udata.core.constants import HVD
+from udata.core.dataservices.constants import DATASERVICE_FORMATS
 from udata.core.dataset.api_fields import dataset_ref_fields
 from udata.core.dataset.models import Dataset
 from udata.core.linkable import Linkable
@@ -22,19 +20,12 @@ from udata.core.metrics.helpers import get_stock_metrics
 from udata.core.metrics.models import WithMetrics
 from udata.core.owned import Owned, OwnedQuerySet
 from udata.i18n import lazy_gettext as _
-from udata.models import Discussion, Follow, db
-from udata.mongo.errors import FieldValidationError
+from udata.models import Badge, BadgeMixin, BadgesList, Discussion, Follow, db
 from udata.uris import cdata_url
 
-# "frequency"
-# "harvest"
-# "internal"
-# "page"
-# "quality" # Peut-être pas dans une v1 car la qualité sera probablement calculé différemment
-# "datasets" # objet : liste de datasets liés à une API
-# "spatial"
-# "temporal_coverage"
-
+BADGES: dict[str, LazyString] = {
+    HVD: _("Dataservice serving high value datasets"),
+}
 
 dataservice_permissions_fields = api.model(
     "DataservicePermissions",
@@ -89,6 +80,20 @@ class DataserviceQuerySet(OwnedQuerySet):
         return self(dataservices_filter)
 
 
+def validate_badge(value):
+    if value not in Dataservice.__badges__.keys():
+        raise db.ValidationError("Unknown badge type")
+
+
+class DataserviceBadge(Badge):
+    kind = db.StringField(required=True, validation=validate_badge)
+
+
+class DataserviceBadgeMixin(BadgeMixin):
+    badges = field(BadgesList(DataserviceBadge), **BadgeMixin.default_badges_list_params)
+    __badges__ = BADGES
+
+
 @generate_fields()
 class HarvestMetadata(db.EmbeddedDocument):
     backend = field(db.StringField())
@@ -119,28 +124,13 @@ class HarvestMetadata(db.EmbeddedDocument):
     archived_reason = field(db.StringField())
 
 
-@generate_fields()
-class AccessAudience(db.EmbeddedDocument):
-    role = field(db.StringField(choices=DATASERVICE_ACCESS_AUDIENCE_TYPES), filterable={})
-    condition = field(db.StringField(choices=DATASERVICE_ACCESS_AUDIENCE_CONDITIONS), filterable={})
-
-
-def check_only_one_condition_per_role(access_audiences, **_kwargs):
-    roles = set(e["role"] for e in access_audiences)
-    if len(roles) != len(access_audiences):
-        raise FieldValidationError(
-            _("You can only set one condition for a given access audience role"),
-            field="access_audiences",
-        )
-
-
 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
+        return base_query
     else:
         return base_query.filter(
             id__in=[
@@ -150,18 +140,32 @@ def filter_by_topic(base_query, filter_value):
         )
 
 
+def filter_by_reuse(base_query, filter_value):
+    from udata.core.reuse.models import Reuse
+
+    try:
+        reuse = Reuse.objects.get(id=filter_value)
+    except Reuse.DoesNotExist:
+        return base_query
+    else:
+        return base_query.filter(id__in=[dataservice.id for dataservice in reuse.dataservices])
+
+
 @generate_fields(
     searchable=True,
     nested_filters={"organization_badge": "organization.badges"},
     standalone_filters=[
-        {"key": "topic", "constraints": "objectid", "query": filter_by_topic, "type": str}
+        {"key": "topic", "constraints": ["objectid"], "query": filter_by_topic, "type": str},
+        {"key": "reuse", "constraints": ["objectid"], "query": filter_by_reuse, "type": str},
     ],
     additional_sorts=[
         {"key": "followers", "value": "metrics.followers"},
         {"key": "views", "value": "metrics.views"},
     ],
 )
-class Dataservice(Auditable, WithMetrics, Linkable, Owned, db.Document):
+class Dataservice(
+    Auditable, WithMetrics, WithAccessType, DataserviceBadgeMixin, Linkable, Owned, db.Document
+):
     meta = {
         "indexes": [
             "$title",
@@ -212,14 +216,6 @@ class Dataservice(Auditable, WithMetrics, Linkable, Owned, db.Document):
     availability = field(db.FloatField(min=0, max=100), example="99.99")
     availability_url = field(db.URLField())
 
-    access_type = field(db.StringField(choices=DATASERVICE_ACCESS_TYPES), filterable={})
-    access_audiences = field(
-        db.EmbeddedDocumentListField(AccessAudience),
-        checks=[check_only_one_condition_per_role],
-    )
-
-    authorization_request_url = field(db.URLField())
-
     format = field(db.StringField(choices=DATASERVICE_FORMATS))
 
     license = field(
@@ -303,7 +299,7 @@ class Dataservice(Auditable, WithMetrics, Linkable, Owned, db.Document):
         auditable=False,
     )
 
-    @field(description="Link to the API endpoint for this dataservice")
+    @field(description="Link to the API endpoint for this dataservice", show_as_ref=True)
     def self_api_url(self, **kwargs):
         return url_for(
             "api.dataservice",
@@ -323,6 +319,10 @@ class Dataservice(Auditable, WithMetrics, Linkable, Owned, db.Document):
         "views",
     ]
 
+    @property
+    def is_visible(self):
+        return not self.is_hidden
+
     @property
     def is_hidden(self):
         return self.private or self.deleted_at or self.archived_at

udata/core/dataservices/rdf.py

@@ -1,6 +1,7 @@
 from flask import current_app
 from rdflib import RDF, BNode, Graph, Literal, URIRef
 
+from udata.core.constants import HVD
 from udata.core.dataservices.models import Dataservice
 from udata.core.dataservices.models import HarvestMetadata as HarvestDataserviceMetadata
 from udata.core.dataset.models import Dataset, License
@@ -146,7 +147,7 @@ def dataservice_to_rdf(dataservice: Dataservice, graph=None):
 
     # Add DCAT-AP HVD properties if the dataservice is tagged hvd.
     # See https://semiceu.github.io/DCAT-AP/releases/2.2.0-hvd/
-    is_hvd = current_app.config["HVD_SUPPORT"] and "hvd" in dataservice.tags
+    is_hvd = current_app.config["HVD_SUPPORT"] and any(b.kind == HVD for b in dataservice.badges)
     if is_hvd:
         d.add(DCATAP.applicableLegislation, URIRef(HVD_LEGISLATION))
 

udata/core/dataservices/search.py

@@ -5,11 +5,7 @@ from flask_restx.inputs import boolean
 
 from udata.api import api
 from udata.api.parsers import ModelApiParser
-from udata.core.dataservices.constants import (
-    DATASERVICE_ACCESS_TYPE_OPEN,
-    DATASERVICE_ACCESS_TYPE_OPEN_WITH_ACCOUNT,
-    DATASERVICE_ACCESS_TYPE_RESTRICTED,
-)
+from udata.core.access_type.constants import AccessType
 from udata.models import Dataservice, Organization, User
 from udata.search import (
     BoolFilter,
@@ -54,9 +50,9 @@ class DataserviceApiParser(ModelApiParser):
             dataservices = dataservices.filter(organization=args["organization"])
         if "is_restricted" in args:
             dataservices = dataservices.filter(
-                access_type__in=[DATASERVICE_ACCESS_TYPE_RESTRICTED]
+                access_type__in=[AccessType.RESTRICTED]
                 if boolean(args["is_restricted"])
-                else [DATASERVICE_ACCESS_TYPE_OPEN, DATASERVICE_ACCESS_TYPE_OPEN_WITH_ACCOUNT]
+                else [AccessType.OPEN, AccessType.OPEN_WITH_ACCOUNT]
             )
         if args.get("featured"):
             dataservices = dataservices.filter(featured=args["featured"])
@@ -79,7 +75,7 @@ class DataserviceSearch(ModelSearchAdapter):
 
     @classmethod
     def is_indexable(cls, dataservice: Dataservice) -> bool:
-        return dataservice.deleted_at is None and not dataservice.private
+        return dataservice.is_visible
 
     @classmethod
     def mongo_search(cls, args):
@@ -126,6 +122,6 @@ class DataserviceSearch(ModelSearchAdapter):
             "tags": dataservice.tags,
             "extras": extras,
             "followers": dataservice.metrics.get("followers", 0),
-            "is_restricted": dataservice.access_type == DATASERVICE_ACCESS_TYPE_RESTRICTED,
+            "is_restricted": dataservice.access_type == AccessType.RESTRICTED,
             "views": dataservice.metrics.get("views", 0),
         }

udata/core/dataservices/tasks.py

@@ -1,6 +1,11 @@
 from celery.utils.log import get_task_logger
+from flask import current_app
 
+from udata.core.badges import tasks as badge_tasks
+from udata.core.constants import HVD
 from udata.core.dataservices.models import Dataservice
+from udata.core.organization.constants import CERTIFIED, PUBLIC_SERVICE
+from udata.core.organization.models import Organization
 from udata.core.topic.models import TopicElement
 from udata.harvest.models import HarvestJob
 from udata.models import Discussion, Follow, Transfer
@@ -25,3 +30,31 @@ def purge_dataservices(self):
         TopicElement.objects(element=dataservice).update(element=None)
         # Remove dataservice
         dataservice.delete()
+
+
+@badge_tasks.register(model=Dataservice, badge=HVD)
+def update_dataservice_hvd_badge() -> None:
+    """
+    Update HVD badges to candidate dataservices, based on the hvd tag.
+    Only dataservices owned by certified and public service organizations are candidate to have a HVD badge.
+    """
+    if not current_app.config["HVD_SUPPORT"]:
+        log.error("You need to set HVD_SUPPORT if you want to update dataservice hvd badge")
+        return
+    public_certified_orgs = (
+        Organization.objects(badges__kind=PUBLIC_SERVICE).filter(badges__kind=CERTIFIED).only("id")
+    )
+
+    dataservices = Dataservice.objects(
+        tags="hvd", badges__kind__ne="hvd", organization__in=public_certified_orgs
+    )
+    log.info(f"Adding HVD badge to {dataservices.count()} dataservices")
+    for dataservice in dataservices:
+        dataservice.add_badge(HVD)
+
+    dataservices = Dataservice.objects(
+        tags__nin=["hvd"], badges__kind="hvd", organization__in=public_certified_orgs
+    )
+    log.info(f"Remove HVD badge from {dataservices.count()} dataservices")
+    for dataservice in dataservices:
+        dataservice.remove_badge(HVD)

udata/core/dataset/api.py

@@ -41,14 +41,12 @@ from udata.core.followers.api import FollowAPI
 from udata.core.followers.models import Follow
 from udata.core.organization.models import Organization
 from udata.core.reuse.models import Reuse
-from udata.core.site.models import current_site
 from udata.core.storages.api import handle_upload, upload_parser
 from udata.core.topic.models import Topic
 from udata.frontend.markdown import md
 from udata.i18n import gettext as _
-from udata.linkchecker.checker import check_resource
 from udata.rdf import RDF_EXTENSIONS, graph_response, negociate_content
-from udata.utils import get_by
+from udata.utils import get_by, get_rss_feed_list
 
 from .api_fields import (
     catalog_schema_fields,
@@ -291,6 +289,12 @@ community_parser.add_argument(
 
 common_doc = {"params": {"dataset": "The dataset ID or slug"}}
 
+# Build catalog_parser from DatasetApiParser parser with a default page_size of 100
+catalog_parser = DatasetApiParser().parser
+catalog_parser.replace_argument(
+    "page_size", type=int, location="args", default=100, help="The page size"
+)
+
 
 @ns.route("/", endpoint="datasets")
 class DatasetListAPI(API):
@@ -331,9 +335,10 @@ class DatasetsAtomFeedAPI(API):
             link=request.url_root,
         )
 
-        datasets: list[Dataset] = (
-            Dataset.objects.visible().order_by("-created_at_internal").limit(current_site.feed_size)
+        datasets: list[Dataset] = get_rss_feed_list(
+            Dataset.objects.visible(), "created_at_internal"
         )
+
         for dataset in datasets:
             author_name = None
             author_uri = None
@@ -432,17 +437,17 @@ class DatasetFeaturedAPI(API):
 class DatasetRdfAPI(API):
     @api.doc("rdf_dataset")
     def get(self, dataset):
-        format = RDF_EXTENSIONS[negociate_content()]
-        url = url_for("api.dataset_rdf_format", dataset=dataset.id, format=format)
+        _format = RDF_EXTENSIONS[negociate_content()]
+        url = url_for("api.dataset_rdf_format", dataset=dataset.id, _format=_format)
         return redirect(url)
 
 
-@ns.route("/<dataset:dataset>/rdf.<format>", endpoint="dataset_rdf_format", doc=common_doc)
+@ns.route("/<dataset:dataset>/rdf.<_format>", endpoint="dataset_rdf_format", doc=common_doc)
 @api.response(404, "Dataset not found")
 @api.response(410, "Dataset has been deleted")
 class DatasetRdfFormatAPI(API):
     @api.doc("rdf_dataset_format")
-    def get(self, dataset, format):
+    def get(self, dataset, _format):
         if not dataset.permissions["edit"].can():
             if dataset.private:
                 api.abort(404)
@@ -452,7 +457,7 @@ class DatasetRdfFormatAPI(API):
         resource = dataset_to_rdf(dataset)
         # bypass flask-restplus make_response, since graph_response
         # is handling the content negociation directly
-        return make_response(*graph_response(resource, format))
+        return make_response(*graph_response(resource, _format))
 
 
 @ns.route("/badges/", endpoint="available_dataset_badges")
@@ -902,20 +907,6 @@ class AllowedExtensionsAPI(API):
         return sorted(current_app.config["ALLOWED_RESOURCES_EXTENSIONS"])
 
 
-@ns.route(
-    "/<dataset:dataset>/resources/<uuid:rid>/check/",
-    endpoint="check_dataset_resource",
-    doc=common_doc,
-)
-@api.param("rid", "The resource unique identifier")
-class CheckDatasetResource(API, ResourceMixin):
-    @api.doc("check_dataset_resource")
-    def get(self, dataset, rid):
-        """Checks that a resource's URL exists and returns metadata."""
-        resource = self.get_resource_or_404(dataset, rid)
-        return check_resource(resource)
-
-
 @ns.route("/resource_types/", endpoint="resource_types")
 class ResourceTypesAPI(API):
     @api.doc("resource_types")