udata 10.0.1.dev32350__py2.py3-none-any.whl → 10.0.1.dev32396__py2.py3-none-any.whl

udata/api_fields.py

@@ -94,6 +94,8 @@ def convert_db_to_field(key, field, info) -> tuple[Callable | None, Callable | N
         params["min_length"] = field.min_length
         params["max_length"] = field.max_length
         params["enum"] = field.choices
+        if field.validation:
+            params["validation"] = validation_to_type(field.validation)
     elif isinstance(field, mongo_fields.ObjectIdField):
         constructor = restx_fields.String
     elif isinstance(field, mongo_fields.FloatField):
@@ -287,7 +289,7 @@ def generate_fields(**kwargs) -> Callable:
                 if not isinstance(
                     field, mongo_fields.ReferenceField | mongo_fields.LazyReferenceField
                 ):
-                    raise Exception("Cannot use additional_filters on not a ref.")
+                    raise Exception("Cannot use additional_filters on a field that is not a ref.")
 
                 ref_model: db.Document = field.document_type
 
@@ -678,9 +680,34 @@ def compute_filter(column: str, field, info, filterable) -> dict:
             filterable["type"] = boolean
         else:
             filterable["type"] = str
+    if field.validation:
+        filterable["type"] = validation_to_type(field.validation)
 
     filterable["choices"] = info.get("choices", None)
     if hasattr(field, "choices") and field.choices:
         filterable["choices"] = field.choices
 
     return filterable
+
+
+def validation_to_type(validation: Callable) -> Callable:
+    """Convert a mongo field's validation function to a ReqParser's type.
+
+    In flask_restx.ReqParser, validation is done by setting the param's type to
+    a callable that will either raise, or return the parsed value.
+
+    In mongo, a field's validation function cannot return anything, so this
+    helper wraps the mongo field's validation to return the value if it validated.
+    """
+    from udata.models import db
+
+    def wrapper(value: str) -> str:
+        try:
+            validation(value)
+        except db.ValidationError:
+            raise
+        return value
+
+    wrapper.__schema__ = {"type": "string", "format": "my-custom-format"}
+
+    return wrapper

udata/core/badges/tests/test_model.py

@@ -15,8 +15,13 @@ BADGES = {
 }
 
 
+def validate_badge(value):
+    if value not in Fake.__badges__.keys():
+        raise db.ValidationError("Unknown badge type")
+
+
 class FakeBadge(Badge):
-    kind = db.StringField(required=True, choices=list(BADGES.keys()))
+    kind = db.StringField(required=True, validation=validate_badge)
 
 
 class FakeBadgeMixin(BadgeMixin):
@@ -34,12 +39,6 @@ class BadgeMixinTest(DBTestMixin, TestCase):
         fake = Fake.objects.create()
         self.assertIsInstance(fake.badges, (list, tuple))
 
-    def test_choices(self):
-        """It should have a choice list on the badge field."""
-        self.assertEqual(
-            Fake._fields["badges"].field.document_type.kind.choices, list(Fake.__badges__.keys())
-        )
-
     def test_get_badge_found(self):
         """It allow to get a badge by kind if present"""
         fake = Fake.objects.create()
@@ -155,3 +154,19 @@ class BadgeMixinTest(DBTestMixin, TestCase):
         with self.assertRaises(db.ValidationError):
             fake = Fake.objects.create()
             fake.add_badge("unknown")
+
+    def test_validation(self):
+        """It should validate default badges as well as extended ones"""
+        # Model badges can be extended in plugins, for example in udata-front
+        # for french only badges.
+        Fake.__badges__["new"] = "new"
+
+        fake = FakeBadge(kind="test")
+        fake.validate()
+
+        fake = FakeBadge(kind="new")
+        fake.validate()
+
+        with self.assertRaises(db.ValidationError):
+            fake = FakeBadge(kind="doesnotexist")
+            fake.validate()

udata/core/dataset/models.py

@@ -521,8 +521,13 @@ class Resource(ResourceMixin, WithMetrics, db.EmbeddedDocument):
         self.dataset.save(*args, **kwargs)
 
 
+def validate_badge(value):
+    if value not in Dataset.__badges__.keys():
+        raise db.ValidationError("Unknown badge type")
+
+
 class DatasetBadge(Badge):
-    kind = db.StringField(required=True, choices=list(BADGES.keys()))
+    kind = db.StringField(required=True, validation=validate_badge)
 
 
 class DatasetBadgeMixin(BadgeMixin):

udata/core/dataset/rdf.py

@@ -21,6 +21,7 @@ from udata.core.spatial.models import SpatialCoverage
 from udata.harvest.exceptions import HarvestSkipException
 from udata.models import db
 from udata.rdf import (
+    ADMS,
     DCAT,
     DCATAP,
     DCT,
@@ -200,16 +201,30 @@ def dataset_to_rdf(dataset, graph=None):
     # unless there is already an upstream URI
     id = dataset_to_graph_id(dataset)
 
+    graph = graph or Graph(namespace_manager=namespace_manager)
+    d = graph.resource(id)
+
     # Expose upstream identifier if present
     if dataset.harvest and dataset.harvest.dct_identifier:
-        identifier = dataset.harvest.dct_identifier
+        d.set(DCT.identifier, Literal(dataset.harvest.dct_identifier))
+
+        alt = graph.resource(BNode())
+        alternate_identifier = Literal(
+            endpoint_for(
+                "datasets.show_redirect",
+                "api.dataset",
+                dataset=dataset.id,
+                _external=True,
+            )
+        )
+        alt.set(RDF.type, ADMS.Identifier)
+        alt.set(DCT.creator, Literal(current_app.config["SITE_TITLE"]))
+        alt.set(SKOS.notation, alternate_identifier)
+        d.set(ADMS.identifier, alt)
     else:
-        identifier = dataset.id
-    graph = graph or Graph(namespace_manager=namespace_manager)
+        d.set(DCT.identifier, Literal(dataset.id))
 
-    d = graph.resource(id)
     d.set(RDF.type, DCAT.Dataset)
-    d.set(DCT.identifier, Literal(identifier))
     d.set(DCT.title, Literal(dataset.title))
     d.set(DCT.description, Literal(dataset.description))
     d.set(DCT.issued, Literal(dataset.created_at))

udata/core/organization/models.py

@@ -95,8 +95,13 @@ class OrganizationQuerySet(db.BaseQuerySet):
         return self(badges__kind=kind)
 
 
+def validate_badge(value):
+    if value not in Organization.__badges__.keys():
+        raise db.ValidationError("Unknown badge type")
+
+
 class OrganizationBadge(Badge):
-    kind = db.StringField(required=True, choices=list(BADGES.keys()))
+    kind = db.StringField(required=True, validation=validate_badge)
 
 
 class OrganizationBadgeMixin(BadgeMixin):

udata/core/reuse/models.py

@@ -35,8 +35,13 @@ def check_url_does_not_exists(url):
         raise FieldValidationError(_("This URL is already registered"), field="url")
 
 
+def validate_badge(value):
+    if value not in Reuse.__badges__.keys():
+        raise db.ValidationError("Unknown badge type")
+
+
 class ReuseBadge(Badge):
-    kind = db.StringField(required=True, choices=list(BADGES.keys()))
+    kind = db.StringField(required=True, validation=validate_badge)
 
 
 class ReuseBadgeMixin(BadgeMixin):

udata/rdf.py

@@ -49,6 +49,7 @@ DCT = DCTERMS  # More common usage
 VCARD = Namespace("http://www.w3.org/2006/vcard/ns#")
 
 namespace_manager = NamespaceManager(Graph())
+namespace_manager.bind("adms", ADMS)
 namespace_manager.bind("dcat", DCAT)
 namespace_manager.bind("dcatap", DCATAP)
 namespace_manager.bind("dct", DCT)