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

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,7 +9,7 @@ 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.frontend.markdown import md
@@ -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
@@ -115,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()

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_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

@@ -9,6 +9,7 @@ import Levenshtein
 import requests
 from blinker import signal
 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
@@ -17,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
@@ -35,7 +39,6 @@ from .constants import (
     CLOSED_FORMATS,
     DEFAULT_LICENSE,
     DESCRIPTION_SHORT_SIZE_LIMIT,
-    HVD,
     INSPIRE,
     MAX_DISTANCE,
     PIVOTAL_DATA,
@@ -62,7 +65,7 @@ __all__ = (
     "ResourceSchema",
 )
 
-BADGES: dict[str, str] = {
+BADGES: dict[str, LazyString] = {
     PIVOTAL_DATA: _("Pivotal data"),
     SPD: _("Reference data public service"),
     INSPIRE: _("Inspire"),
@@ -530,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
@@ -681,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
@@ -780,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))