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

udata/core/dataset/api_fields.py

@@ -1,4 +1,5 @@
 from udata.api import api, base_reference, fields
+from udata.core.access_type.models import AccessAudience
 from udata.core.badges.fields import badge_fields
 from udata.core.contact_point.api_fields import contact_point_fields
 from udata.core.organization.api_fields import org_ref_fields
@@ -287,6 +288,11 @@ DEFAULT_MASK = ",".join(
         "temporal_coverage",
         "spatial",
         "license",
+        "access_type",
+        "access_audiences",
+        "authorization_request_url",
+        "access_type_reason_category",
+        "access_type_reason",
         "uri",
         "page",
         "last_update",
@@ -394,6 +400,11 @@ dataset_fields = api.model(
         "license": fields.String(
             attribute="license.id", default=DEFAULT_LICENSE["id"], description="The dataset license"
         ),
+        "access_type": fields.String(allow_null=True),
+        "access_audiences": fields.List(fields.Nested(AccessAudience.__read_fields__)),
+        "authorization_request_url": fields.String(allow_null=True),
+        "access_type_reason_category": fields.String(allow_null=True),
+        "access_type_reason": fields.String(allow_null=True),
         "uri": fields.String(
             attribute=lambda d: d.self_api_url(),
             description="The API URI for this dataset",

udata/core/dataset/apiv2.py

@@ -7,6 +7,7 @@ from flask_restx import marshal
 
 from udata import search
 from udata.api import API, apiv2, fields
+from udata.core.access_type.models import AccessAudience
 from udata.core.contact_point.api_fields import contact_point_fields
 from udata.core.dataset.api_fields import license_fields
 from udata.core.organization.api_fields import member_user_with_email_fields
@@ -62,6 +63,11 @@ DEFAULT_MASK_APIV2 = ",".join(
         "temporal_coverage",
         "spatial",
         "license",
+        "access_type",
+        "access_audiences",
+        "access_type_reason_category",
+        "access_type_reason",
+        "authorization_request_url",
         "uri",
         "page",
         "last_update",
@@ -202,6 +208,11 @@ dataset_fields = apiv2.model(
             default=DEFAULT_LICENSE["id"],
             description="The dataset license (full License object if `X-Get-Datasets-Full-Objects` is set, ID of the license otherwise)",
         ),
+        "access_type": fields.String(allow_null=True),
+        "access_audiences": fields.Nested(AccessAudience.__read_fields__),
+        "authorization_request_url": fields.String(allow_null=True),
+        "access_type_reason_category": fields.String(allow_null=True),
+        "access_type_reason": fields.String(allow_null=True),
         "uri": fields.String(
             attribute=lambda d: d.self_api_url(),
             description="The API URI for this dataset",

udata/core/dataset/constants.py

@@ -166,7 +166,6 @@ DEFAULT_CHECKSUM_TYPE = "sha1"
 PIVOTAL_DATA = "pivotal-data"
 SPD = "spd"
 INSPIRE = "inspire"
-HVD = "hvd"
 SL = "sl"
 SR = "sr"
 CLOSED_FORMATS = ("pdf", "doc", "docx", "word", "xls", "excel", "xlsx")

udata/core/dataset/forms.py

@@ -1,3 +1,10 @@
+from udata.core.access_type.constants import (
+    AccessAudienceCondition,
+    AccessAudienceType,
+    AccessType,
+    InspireLimitationCategory,
+)
+from udata.core.access_type.models import AccessAudience
 from udata.core.spatial.forms import SpatialCoverageField
 from udata.core.storages import resources
 from udata.forms import ModelForm, fields, validators
@@ -116,6 +123,8 @@ class CommunityResourceForm(BaseResourceForm):
 
 
 def unmarshal_frequency(form, field):
+    if field.data is None:
+        return
     # We don't need to worry about invalid field.data being fed to UpdateFrequency here,
     # since the API will already have ensured incoming data matches the field definition,
     # which in our case is an enum of valid UpdateFrequency values.
@@ -139,6 +148,13 @@ def validate_contact_point(form, field):
             )
 
 
+class AccessAudienceForm(ModelForm):
+    model_class = AccessAudience
+
+    role = fields.SelectField(choices=[(e.value, e.value) for e in AccessAudienceType])
+    condition = fields.SelectField(choices=[(e.value, e.value) for e in AccessAudienceCondition])
+
+
 class DatasetForm(ModelForm):
     model_class = Dataset
 
@@ -157,6 +173,19 @@ class DatasetForm(ModelForm):
         description=_("A short description of the dataset."),
     )
     license = fields.ModelSelectField(_("License"), model=License, allow_blank=True)
+    access_type = fields.SelectField(
+        choices=[(e.value, e.value) for e in AccessType],
+        default=AccessType.OPEN,
+        validators=[validators.optional()],
+    )
+    access_audiences = fields.NestedModelList(AccessAudienceForm)
+    authorization_request_url = fields.StringField(_("Authorization request URL"))
+    access_type_reason_category = fields.SelectField(
+        _("Access type reason category"),
+        choices=[(e.value, e.label) for e in InspireLimitationCategory],
+        validators=[validators.optional()],
+    )
+    access_type_reason = fields.StringField(_("Access type reason"))
     frequency = fields.SelectField(
         _("Update frequency"),
         choices=list(UpdateFrequency),

udata/core/dataset/models.py

@@ -1,6 +1,6 @@
 import logging
 import re
-from datetime import datetime, timedelta
+from datetime import datetime
 from pydoc import locate
 from typing import Self
 from urllib.parse import urlparse
@@ -8,8 +8,8 @@ from urllib.parse import urlparse
 import Levenshtein
 import requests
 from blinker import signal
-from dateutil.parser import parse as parse_dt
 from flask import current_app, url_for
+from flask_babel import LazyString
 from mongoengine import ValidationError as MongoEngineValidationError
 from mongoengine.fields import DateTimeField
 from mongoengine.signals import post_save, pre_init, pre_save
@@ -18,7 +18,10 @@ from werkzeug.utils import cached_property
 from udata.api_fields import field
 from udata.app import cache
 from udata.core import storages
+from udata.core.access_type.constants import AccessType
+from udata.core.access_type.models import WithAccessType, check_only_one_condition_per_role
 from udata.core.activity.models import Auditable
+from udata.core.constants import HVD
 from udata.core.dataset.preview import TabularAPIPreview
 from udata.core.linkable import Linkable
 from udata.core.metrics.helpers import get_stock_metrics
@@ -36,7 +39,6 @@ from .constants import (
     CLOSED_FORMATS,
     DEFAULT_LICENSE,
     DESCRIPTION_SHORT_SIZE_LIMIT,
-    HVD,
     INSPIRE,
     MAX_DISTANCE,
     PIVOTAL_DATA,
@@ -63,7 +65,7 @@ __all__ = (
     "ResourceSchema",
 )
 
-BADGES: dict[str, str] = {
+BADGES: dict[str, LazyString] = {
     PIVOTAL_DATA: _("Pivotal data"),
     SPD: _("Reference data public service"),
     INSPIRE: _("Inspire"),
@@ -369,7 +371,13 @@ class ResourceMixin(object):
     mime = db.StringField()
     filesize = db.IntField()  # `size` is a reserved keyword for mongoengine.
     fs_filename = db.StringField()
-    extras = db.ExtrasField()
+    extras = db.ExtrasField(
+        {
+            "check:available": db.BooleanField,
+            "check:status": db.IntField,
+            "check:date": db.DateTimeField,
+        }
+    )
     harvest = db.EmbeddedDocumentField(HarvestResourceMetadata)
     schema = db.EmbeddedDocumentField(Schema)
 
@@ -428,41 +436,6 @@ class ResourceMixin(object):
         """
         return self.extras.get("check:available", "unknown")
 
-    def need_check(self):
-        """Does the resource needs to be checked against its linkchecker?
-
-        We check unavailable resources often, unless they go over the
-        threshold. Available resources are checked less and less frequently
-        based on their historical availability.
-        """
-        min_cache_duration, max_cache_duration, ko_threshold = [
-            current_app.config.get(k)
-            for k in (
-                "LINKCHECKING_MIN_CACHE_DURATION",
-                "LINKCHECKING_MAX_CACHE_DURATION",
-                "LINKCHECKING_UNAVAILABLE_THRESHOLD",
-            )
-        ]
-        count_availability = self.extras.get("check:count-availability", 1)
-        is_available = self.check_availability()
-        if is_available == "unknown":
-            return True
-        elif is_available or count_availability > ko_threshold:
-            delta = min(min_cache_duration * count_availability, max_cache_duration)
-        else:
-            delta = min_cache_duration
-        if self.extras.get("check:date"):
-            limit_date = datetime.utcnow() - timedelta(minutes=delta)
-            check_date = self.extras["check:date"]
-            if not isinstance(check_date, datetime):
-                try:
-                    check_date = parse_dt(check_date)
-                except (ValueError, TypeError):
-                    return True
-            if check_date >= limit_date:
-                return False
-        return True
-
     @property
     def latest(self):
         """
@@ -560,7 +533,9 @@ class DatasetBadgeMixin(BadgeMixin):
     __badges__ = BADGES
 
 
-class Dataset(Auditable, WithMetrics, DatasetBadgeMixin, Owned, Linkable, db.Document):
+class Dataset(
+    Auditable, WithMetrics, WithAccessType, DatasetBadgeMixin, Owned, Linkable, db.Document
+):
     title = field(db.StringField(required=True))
     acronym = field(db.StringField(max_length=128))
     # /!\ do not set directly the slug when creating or updating a dataset
@@ -711,6 +686,10 @@ class Dataset(Auditable, WithMetrics, DatasetBadgeMixin, Owned, Linkable, db.Doc
 
         self.quality_cached = self.compute_quality()
 
+        check_only_one_condition_per_role(self.access_audiences)
+        if self.access_type and self.access_type != AccessType.OPEN:
+            self.license = None
+
         for key, value in self.extras.items():
             if not key.startswith("custom:"):
                 continue
@@ -810,10 +789,13 @@ class Dataset(Auditable, WithMetrics, DatasetBadgeMixin, Owned, Linkable, db.Doc
 
     def compute_last_update(self):
         """
-        Use the more recent date we would have on resources (harvest, modified).
+        If dataset is harvested and its metadata contains a modified_at date, use it.
+        Else, use the more recent date we would have at the resource level (harvest, modified).
         Default to dataset last_modified if no resource.
         Resources should be fetched when calling this method.
         """
+        if self.harvest and self.harvest.modified_at:
+            return self.harvest.modified_at
         if self.resources:
             return max([res.last_modified for res in self.resources])
         else:

udata/core/dataset/rdf.py

@@ -16,6 +16,7 @@ from rdflib.namespace import RDF
 from rdflib.resource import Resource as RdfResource
 
 from udata import i18n, uris
+from udata.core.constants import HVD
 from udata.core.dataset.models import HarvestDatasetMetadata, HarvestResourceMetadata
 from udata.core.spatial.models import SpatialCoverage
 from udata.harvest.exceptions import HarvestSkipException
@@ -330,7 +331,7 @@ def dataset_to_rdf(dataset: Dataset, graph: Graph | None = None) -> RdfResource:
 
     # Add DCAT-AP HVD properties if the dataset 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 dataset.tags
+    is_hvd = current_app.config["HVD_SUPPORT"] and any(b.kind == HVD for b in dataset.badges)
     if is_hvd:
         d.add(DCATAP.applicableLegislation, URIRef(HVD_LEGISLATION))
 

udata/core/dataset/search.py

@@ -54,8 +54,8 @@ class DatasetSearch(ModelSearchAdapter):
     }
 
     @classmethod
-    def is_indexable(cls, dataset):
-        return dataset.deleted is None and dataset.archived is None and not dataset.private
+    def is_indexable(cls, dataset: Dataset):
+        return dataset.is_visible
 
     @classmethod
     def mongo_search(cls, args):

udata/core/dataset/tasks.py

@@ -1,6 +1,6 @@
 import collections
 import os
-from datetime import datetime
+from datetime import date, datetime
 from tempfile import NamedTemporaryFile
 
 from celery.utils.log import get_task_logger
@@ -9,9 +9,15 @@ from mongoengine import ValidationError
 
 from udata import models as udata_models
 from udata.core import csv, storages
+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.dataset.constants import INSPIRE
+from udata.core.organization.constants import CERTIFIED, PUBLIC_SERVICE
+from udata.core.organization.models import Organization
 from udata.harvest.models import HarvestJob
 from udata.models import Activity, Discussion, Follow, TopicElement, Transfer, db
+from udata.storage.s3 import store_bytes
 from udata.tasks import job
 
 from .models import Checksum, CommunityResource, Dataset, Resource
@@ -85,12 +91,14 @@ def get_queryset(model_cls):
     return model_cls.objects.filter(**params).no_cache()
 
 
+def get_resource_for_csv_export_model(model, dataset):
+    for resource in dataset.resources:
+        if resource.extras.get("csv-export:model", "") == model:
+            return resource
+
+
 def get_or_create_resource(r_info, model, dataset):
-    resource = None
-    for r in dataset.resources:
-        if r.extras.get("csv-export:model", "") == model:
-            resource = r
-            break
+    resource = get_resource_for_csv_export_model(model, dataset)
     if resource:
         for k, v in r_info.items():
             setattr(resource, k, v)
@@ -121,11 +129,16 @@ def store_resource(csvfile, model, dataset):
     return get_or_create_resource(r_info, model, dataset)
 
 
-def export_csv_for_model(model, dataset):
+def export_csv_for_model(model, dataset, replace: bool = False):
     model_cls = getattr(udata_models, model.capitalize(), None)
     if not model_cls:
         log.error("Unknow model %s" % model)
         return
+
+    fs_filename_to_remove = None
+    if existing_resource := get_resource_for_csv_export_model(model, dataset):
+        fs_filename_to_remove = existing_resource.fs_filename
+
     queryset = get_queryset(model_cls)
     adapter = csv.get_adapter(model_cls)
     if not adapter:
@@ -151,6 +164,10 @@ def export_csv_for_model(model, dataset):
         else:
             dataset.last_modified_internal = datetime.utcnow()
             dataset.save()
+        # remove previous catalog if exists and replace is True
+        if replace and fs_filename_to_remove:
+            storages.resources.delete(fs_filename_to_remove)
+        return resource
     finally:
         csvfile.close()
         os.unlink(csvfile.name)
@@ -179,7 +196,23 @@ def export_csv(self, model=None):
 
     models = (model,) if model else ALLOWED_MODELS
     for model in models:
-        export_csv_for_model(model, dataset)
+        resource = export_csv_for_model(model, dataset, replace=True)
+
+        # If we are the first day of the month, archive today catalogs
+        if (
+            current_app.config["EXPORT_CSV_ARCHIVE_S3_BUCKET"]
+            and resource
+            and date.today().day == 1
+        ):
+            log.info(
+                f"Archiving {model} csv catalog on {current_app.config['EXPORT_CSV_ARCHIVE_S3_BUCKET']} bucket"
+            )
+            with storages.resources.open(resource.fs_filename, "rb") as f:
+                store_bytes(
+                    bucket=current_app.config["EXPORT_CSV_ARCHIVE_S3_BUCKET"],
+                    filename=f"{current_app.config['EXPORT_CSV_ARCHIVE_S3_FILENAME_PREFIX']}{resource.title}",
+                    bytes=f.read(),
+                )
 
 
 @job("bind-tabular-dataservice")
@@ -213,3 +246,48 @@ def bind_tabular_dataservice(self):
         log.error(exc_info=e)
 
     log.info(f"Bound {datasets.count()} datasets to TabularAPI dataservice")
+
+
+@badge_tasks.register(model=Dataset, badge=HVD)
+def update_dataset_hvd_badge() -> None:
+    """
+    Update HVD badges to candidate datasets, based on the hvd tag.
+    Only datasets 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 dataset hvd badge")
+        return
+    public_certified_orgs = (
+        Organization.objects(badges__kind=PUBLIC_SERVICE).filter(badges__kind=CERTIFIED).only("id")
+    )
+
+    datasets = Dataset.objects(
+        tags="hvd", badges__kind__ne="hvd", organization__in=public_certified_orgs
+    )
+    log.info(f"Adding HVD badge to {datasets.count()} datasets")
+    for dataset in datasets:
+        dataset.add_badge(HVD)
+
+    datasets = Dataset.objects(tags__nin=["hvd"], badges__kind="hvd")
+    log.info(f"Removing HVD badge from {datasets.count()} datasets")
+    for dataset in datasets:
+        dataset.remove_badge(HVD)
+
+
+@badge_tasks.register(model=Dataset, badge=INSPIRE)
+def update_dataset_inspire_badge() -> None:
+    """
+    Update INSPIRE badges to candidate datasets, based on the inspire tag.
+    """
+    if not current_app.config["INSPIRE_SUPPORT"]:
+        log.error("You need to set INSPIRE_SUPPORT if you want to update dataset INSPIRE badge")
+        return
+    datasets = Dataset.objects(tags="inspire", badges__kind__ne="inspire")
+    log.info(f"Adding INSPIRE badge to {datasets.count()} datasets")
+    for dataset in datasets:
+        dataset.add_badge(INSPIRE)
+
+    datasets = Dataset.objects(tags__nin=["inspire"], badges__kind="inspire")
+    log.info(f"Removing INSPIRE badge from {datasets.count()} datasets")
+    for dataset in datasets:
+        dataset.remove_badge(INSPIRE)

udata/core/discussions/mails.py

@@ -0,0 +1,63 @@
+from udata.core.discussions.models import Discussion, Message
+from udata.i18n import lazy_gettext as _
+from udata.mail import LabelledContent, MailCTA, MailMessage, ParagraphWithLinks
+
+
+def new_discussion(discussion: Discussion) -> MailMessage:
+    return MailMessage(
+        subject=_(
+            "A new discussion has been opened on your %(type)s",
+            type=discussion.subject.verbose_name,
+        ),
+        paragraphs=[
+            ParagraphWithLinks(
+                _(
+                    "You have a new discussion from %(user_or_org)s on your %(type)s %(object)s",
+                    user_or_org=discussion.organization or discussion.user,
+                    type=discussion.subject.verbose_name,
+                    object=discussion.subject,
+                )
+            ),
+            LabelledContent(_("Discussion title:"), discussion.title, inline=True),
+            LabelledContent(_("Comment:"), discussion.discussion[0].content),
+            MailCTA(_("Reply"), discussion.url_for()),
+        ],
+    )
+
+
+def new_discussion_comment(discussion: Discussion, comment: Message) -> MailMessage:
+    return MailMessage(
+        subject=_("A new comment has been added to a discussion"),
+        paragraphs=[
+            ParagraphWithLinks(
+                _(
+                    "You have a new comment from %(user_or_org)s on your %(type)s %(object)s",
+                    user_or_org=comment.posted_by_org_or_user,
+                    type=discussion.subject.verbose_name,
+                    object=discussion.subject,
+                )
+            ),
+            LabelledContent(_("Discussion title:"), discussion.title, inline=True),
+            LabelledContent(_("Comment:"), comment.content),
+            MailCTA(_("Reply"), discussion.url_for()),
+        ],
+    )
+
+
+def discussion_closed(discussion: Discussion, comment: Message | None) -> MailMessage:
+    return MailMessage(
+        subject=_("A discussion has been closed"),
+        paragraphs=[
+            ParagraphWithLinks(
+                _(
+                    "The discussion you participated in on the %(type)s %(object)s has been closed by %(user_or_org)s.",
+                    user_or_org=discussion.closed_by_org_or_user,
+                    type=discussion.subject.verbose_name,
+                    object=discussion.subject,
+                )
+            ),
+            LabelledContent(_("Discussion title:"), discussion.title, inline=True),
+            LabelledContent(_("Comment:"), comment.content) if comment else None,
+            MailCTA(_("View the discussion"), discussion.url_for()),
+        ],
+    )

udata/core/discussions/tasks.py

@@ -1,7 +1,6 @@
-from udata import mail
-from udata.i18n import lazy_gettext as _
 from udata.tasks import connect, get_logger
 
+from . import mails
 from .constants import NOTIFY_DISCUSSION_SUBJECTS
 from .models import Discussion
 from .signals import on_discussion_closed, on_new_discussion, on_new_discussion_comment
@@ -22,15 +21,7 @@ def owner_recipients(discussion):
 def notify_new_discussion(discussion_id):
     discussion = Discussion.objects.get(pk=discussion_id)
     if isinstance(discussion.subject, NOTIFY_DISCUSSION_SUBJECTS):
-        recipients = owner_recipients(discussion)
-        subject = _("Your %(type)s have a new discussion", type=discussion.subject.verbose_name)
-        mail.send(
-            subject,
-            recipients,
-            "new_discussion",
-            discussion=discussion,
-            message=discussion.discussion[0],
-        )
+        mails.new_discussion(discussion).send(owner_recipients(discussion))
     else:
         log.warning("Unrecognized discussion subject type %s", type(discussion.subject))
 
@@ -42,11 +33,7 @@ def notify_new_discussion_comment(discussion_id, message=None):
     if isinstance(discussion.subject, NOTIFY_DISCUSSION_SUBJECTS):
         recipients = owner_recipients(discussion) + [m.posted_by for m in discussion.discussion]
         recipients = list({u.id: u for u in recipients if u != message.posted_by}.values())
-        subject = _("%(user)s commented your discussion", user=message.posted_by_name)
-
-        mail.send(
-            subject, recipients, "new_discussion_comment", discussion=discussion, message=message
-        )
+        mails.new_discussion_comment(discussion, message).send(recipients)
     else:
         log.warning("Unrecognized discussion subject type %s", type(discussion.subject))
 
@@ -58,7 +45,6 @@ def notify_discussion_closed(discussion_id, message=None):
     if isinstance(discussion.subject, NOTIFY_DISCUSSION_SUBJECTS):
         recipients = owner_recipients(discussion) + [m.posted_by for m in discussion.discussion]
         recipients = list({u.id: u for u in recipients if u != discussion.closed_by}.values())
-        subject = _("A discussion has been closed")
-        mail.send(subject, recipients, "discussion_closed", discussion=discussion, message=message)
+        mails.discussion_closed(discussion, message).send(recipients)
     else:
         log.warning("Unrecognized discussion subject type %s", type(discussion.subject))

udata/core/metrics/__init__.py

@@ -1,6 +1,3 @@
-from udata import entrypoints
-
-
 def init_app(app):
     # Load all core metrics
     import udata.core.user.metrics  # noqa
@@ -9,6 +6,3 @@ def init_app(app):
     import udata.core.dataset.metrics  # noqa
     import udata.core.reuse.metrics  # noqa
     import udata.core.followers.metrics  # noqa
-
-    # Load metrics from plugins
-    entrypoints.get_enabled("udata.metrics", app)

udata/core/organization/api.py

@@ -13,7 +13,7 @@ from udata.core.contact_point.api import ContactPointApiParser
 from udata.core.contact_point.api_fields import contact_point_fields, contact_point_page_fields
 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 import DatasetApiParser, catalog_parser
 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
@@ -29,7 +29,6 @@ from udata.core.storages.api import (
 )
 from udata.models import ContactPoint
 from udata.rdf import RDF_EXTENSIONS, graph_response, negociate_content
-from udata.utils import multi_to_dict
 
 from .api_fields import (
     member_fields,
@@ -50,7 +49,7 @@ from .forms import (
 from .models import Member, MembershipRequest, Organization
 from .permissions import EditOrganizationPermission, OrganizationPrivatePermission
 from .rdf import build_org_catalog
-from .tasks import notify_membership_request, notify_membership_response
+from .tasks import notify_membership_request, notify_membership_response, notify_new_member
 
 DEFAULT_SORTING = "-created_at"
 SUGGEST_SORTING = "-metrics.followers"
@@ -234,32 +233,37 @@ class DatasetsResourcesCsvAPI(API):
 class OrganizationRdfAPI(API):
     @api.doc("rdf_organization")
     def get(self, org):
-        format = RDF_EXTENSIONS[negociate_content()]
-        url = url_for("api.organization_rdf_format", org=org.id, format=format)
+        _format = RDF_EXTENSIONS[negociate_content()]
+        # We sanitize the args used as kwargs in url_for
+        params = catalog_parser.parse_args()
+        url = url_for("api.organization_rdf_format", org=org.id, _format=_format, **params)
         return redirect(url)
 
 
-@ns.route("/<org:org>/catalog.<format>", endpoint="organization_rdf_format", doc=common_doc)
+@ns.route("/<org:org>/catalog.<_format>", endpoint="organization_rdf_format", doc=common_doc)
 @api.response(404, "Organization not found")
 @api.response(410, "Organization has been deleted")
 class OrganizationRdfFormatAPI(API):
     @api.doc("rdf_organization_format")
-    def get(self, org, format):
+    @api.expect(catalog_parser)
+    def get(self, org, _format):
         if org.deleted:
             api.abort(410)
-        params = multi_to_dict(request.args)
-        page = int(params.get("page", 1))
-        page_size = int(params.get("page_size", 100))
-        datasets = Dataset.objects(organization=org).visible().paginate(page, page_size)
+        params = catalog_parser.parse_args()
+        datasets = DatasetApiParser.parse_filters(
+            Dataset.objects(organization=org).visible(), params
+        )
+        datasets = datasets.paginate(params["page"], params["page_size"])
+
         dataservices = (
             Dataservice.objects(organization=org)
             .visible()
-            .filter_by_dataset_pagination(datasets, page)
+            .filter_by_dataset_pagination(datasets, params["page"])
         )
-        catalog = build_org_catalog(org, datasets, dataservices, format=format)
+        catalog = build_org_catalog(org, datasets, dataservices, _format=_format, **params)
         # bypass flask-restplus make_response, since graph_response
         # is handling the content negociation directly
-        return make_response(*graph_response(catalog, format))
+        return make_response(*graph_response(catalog, _format))
 
 
 @ns.route("/badges/", endpoint="available_organization_badges")
@@ -468,6 +472,8 @@ class MemberAPI(API):
         org.count_members()
         org.save()
 
+        notify_new_member.delay(str(org.id), str(member.user.email))
+
         return member, 201
 
     @api.secure