udata 10.0.8.dev33663__py2.py3-none-any.whl → 10.0.8.dev33704__py2.py3-none-any.whl

udata/api_fields.py

@@ -42,7 +42,7 @@ from typing import Any, Callable, Iterable
 import flask_restx.fields as restx_fields
 import mongoengine
 import mongoengine.fields as mongo_fields
-from bson import ObjectId
+from bson import DBRef, ObjectId
 from flask_restx.inputs import boolean
 from flask_restx.reqparse import RequestParser
 from flask_storage.mongo import ImageField as FlaskStorageImageField
@@ -446,7 +446,7 @@ def generate_fields(**kwargs) -> Callable:
                         if constraint == "objectid" and not ObjectId.is_valid(
                             args[filterable["key"]]
                         ):
-                            api.abort(400, f'`{filterable["key"]}` must be an identifier')
+                            api.abort(400, f"`{filterable['key']}` must be an identifier")
 
                     query = filterable.get("query", None)
                     if query:
@@ -534,17 +534,37 @@ def patch(obj, request) -> type:
 
             info = getattr(model_attribute, "__additional_field_info__", {})
 
-            # `check` field attribute allows to do validation from the request before setting
+            # `checks` field attribute allows to do validation from the request before setting
             # the attribute
-            check = info.get("check", None)
-            if check is not None and value != getattr(obj, key):
-                check(**{key: value})  # TODO add other model attributes in function parameters
+            checks = info.get("checks", [])
+
+            if is_value_modified(getattr(obj, key), value):
+                for check in checks:
+                    check(
+                        value,
+                        **{
+                            "is_creation": obj._created,
+                            "is_update": not obj._created,
+                            "field": key,
+                        },
+                    )  # TODO add other model attributes in function parameters
 
             setattr(obj, key, value)
 
     return obj
 
 
+def is_value_modified(old_value, new_value) -> bool:
+    # If we want to modify a reference, the new_value may be a DBRef.
+    # `wrap_primary_key` can also return the `foreign_document` (see :WrapToForeignDocument)
+    # and it is not currently taken into account here…
+    # Maybe we can do another type of check to check if the reference changes in the future…
+    if isinstance(new_value, DBRef):
+        return not old_value or new_value.id != old_value.id
+
+    return new_value != old_value
+
+
 def patch_and_save(obj, request) -> type:
     obj = patch(obj, request)
 
@@ -587,6 +607,7 @@ def wrap_primary_key(
         raise FieldValidationError(field=field_name, message=f"Unknown reference '{value}'")
 
     # GenericReferenceField only accepts document (not dbref / objectid)
+    # :WrapToForeignDocument
     if isinstance(
         foreign_field,
         (

udata/core/dataservices/rdf.py

@@ -181,3 +181,24 @@ def dataservice_to_rdf(dataservice: Dataservice, graph=None):
         d.set(DCAT.contactPoint, contact_point)
 
     return d
+
+
+def dataservice_as_distribution_to_rdf(
+    dataservice: Dataservice, graph: Graph = None, is_hvd: bool = True
+):
+    """
+    Create a blank distribution pointing towards a dataservice with DCAT.accessService property
+    """
+    id = BNode()
+    distribution = graph.resource(id)
+    distribution.set(RDF.type, DCAT.Distribution)
+    distribution.add(DCT.title, Literal(dataservice.title))
+    distribution.add(DCAT.accessURL, URIRef(dataservice.base_api_url))
+
+    if is_hvd:
+        # DCAT-AP HVD applicable legislation is also expected at the distribution level
+        distribution.add(DCATAP.applicableLegislation, URIRef(HVD_LEGISLATION))
+
+    distribution.add(DCAT.accessService, dataservice_to_rdf(dataservice, graph))
+
+    return distribution

udata/core/dataset/rdf.py

@@ -340,6 +340,20 @@ def dataset_to_rdf(dataset: Dataset, graph: Optional[Graph] = None) -> RdfResour
     for resource in dataset.resources:
         d.add(DCAT.distribution, resource_to_rdf(resource, dataset, graph, is_hvd))
 
+    if is_hvd:
+        from udata.core.dataservices.models import Dataservice
+        from udata.core.dataservices.rdf import dataservice_as_distribution_to_rdf
+
+        # Add a blank distribution pointing to a DataService using the distribution DCAT.accessService.
+        # Useful for HVD reporting since DataService are not currently harvested by
+        # data.europa.eu as first class entities.
+        # Should be removed once supported by data.europa.eu harvesting.
+        for service in Dataservice.objects.filter(datasets=dataset, tags="hvd"):
+            d.add(
+                DCAT.distribution,
+                dataservice_as_distribution_to_rdf(service, graph),
+            )
+
     if dataset.temporal_coverage:
         d.set(DCT.temporal, temporal_to_rdf(dataset.temporal_coverage, graph))
 

udata/core/owned.py

@@ -41,7 +41,12 @@ class OwnedQuerySet(UDataQuerySet):
         return self(visible_query | owned_qs._query_obj)
 
 
-def check_owner_is_current_user(owner):
+def only_creation(_value, is_update, field, **_kwargs):
+    if is_update:
+        raise FieldValidationError(_(f"Cannot modify {field} after creation"), field=field)
+
+
+def check_owner_is_current_user(owner, **_kwargs):
     from udata.auth import admin_permission, current_user
 
     if (
@@ -53,7 +58,7 @@ def check_owner_is_current_user(owner):
         raise FieldValidationError(_("You can only set yourself as owner"), field="owner")
 
 
-def check_organization_is_valid_for_current_user(organization):
+def check_organization_is_valid_for_current_user(organization, **_kwargs):
     from udata.auth import current_user
     from udata.models import Organization
 
@@ -76,7 +81,7 @@ class Owned(object):
         ReferenceField(User, reverse_delete_rule=NULLIFY),
         nested_fields=user_ref_fields,
         description="Only present if organization is not set. Can only be set to the current authenticated user.",
-        check=check_owner_is_current_user,
+        checks=[check_owner_is_current_user, only_creation],
         allow_null=True,
         filterable={},
     )
@@ -84,7 +89,7 @@ class Owned(object):
         ReferenceField(Organization, reverse_delete_rule=NULLIFY),
         nested_fields=org_ref_fields,
         description="Only present if owner is not set. Can only be set to an organization of the current authenticated user.",
-        check=check_organization_is_valid_for_current_user,
+        checks=[check_organization_is_valid_for_current_user, only_creation],
         allow_null=True,
         filterable={},
     )

udata/core/reuse/models.py

@@ -30,7 +30,7 @@ class ReuseQuerySet(OwnedQuerySet):
         return self(db.Q(private=True) | db.Q(datasets__0__exists=False) | db.Q(deleted__ne=None))
 
 
-def check_url_does_not_exists(url):
+def check_url_does_not_exists(url, **_kwargs):
     """Ensure a reuse URL is not yet registered"""
     if url and Reuse.url_exists(url):
         raise FieldValidationError(_("This URL is already registered"), field="url")
@@ -82,7 +82,7 @@ class Reuse(db.Datetimed, WithMetrics, ReuseBadgeMixin, Owned, db.Document):
     url = field(
         db.URLField(required=True),
         description="The remote URL (website)",
-        check=check_url_does_not_exists,
+        checks=[check_url_does_not_exists],
     )
     urlhash = db.StringField(required=True, unique=True)
     image_url = db.StringField()

udata/forms/fields.py

@@ -418,7 +418,7 @@ class TagField(Field):
         for tag in self.data:
             if not tags.MIN_TAG_LENGTH <= len(tag) <= tags.MAX_TAG_LENGTH:
                 message = _(
-                    'Tag "%(tag)s" must be between %(min)d ' "and %(max)d characters long.",
+                    'Tag "%(tag)s" must be between %(min)d and %(max)d characters long.',
                     min=tags.MIN_TAG_LENGTH,
                     max=tags.MAX_TAG_LENGTH,
                     tag=tag,
@@ -728,6 +728,16 @@ class CurrentUserField(ModelFieldMixin, Field):
         return super(CurrentUserField, self).process(formdata, data, **kwargs)
 
     def pre_validate(self, form):
+        if (
+            isinstance(form, ModelForm)  # Some forms (like HarvestSourceForm) are not model forms
+            and form.instance
+            and self.name in form.instance
+            and getattr(form.instance, self.name).id != self.data.id
+        ):
+            raise validators.ValidationError(
+                _("Cannot change owner after creation. Please use transfer feature.")
+            )
+
         if self.data:
             if current_user.is_anonymous:
                 raise validators.ValidationError(_("You must be authenticated"))
@@ -749,6 +759,16 @@ class PublishAsField(ModelFieldMixin, Field):
         return len(current_user.organizations) <= 0
 
     def pre_validate(self, form):
+        if (
+            isinstance(form, ModelForm)  # Some forms (like HarvestSourceForm) are not model forms
+            and form.instance
+            and self.name in form.instance
+            and getattr(form.instance, self.name).id != self.data.id
+        ):
+            raise validators.ValidationError(
+                _("Cannot change owner after creation. Please use transfer feature.")
+            )
+
         if self.data:
             if not current_user.is_authenticated:
                 raise validators.ValidationError(_("You must be authenticated"))