udata 9.1.2.dev30454__py2.py3-none-any.whl → 9.1.2.dev30483__py2.py3-none-any.whl

udata/api_fields.py

@@ -5,8 +5,17 @@ from bson import ObjectId
 
 import udata.api.fields as custom_restx_fields
 from udata.api import api
+from udata.mongo.engine import db
 from udata.mongo.errors import FieldValidationError
 
+lazy_reference = api.model(
+    "LazyReference",
+    {
+        "class": restx_fields.Raw(attribute=lambda ref: ref.document_type.__name__),
+        "id": restx_fields.Raw(attribute=lambda ref: ref.pk),
+    },
+)
+
 
 def convert_db_to_field(key, field, info={}):
     """
@@ -60,6 +69,10 @@ def convert_db_to_field(key, field, info={}):
         )
         constructor_read = lambda **kwargs: restx_fields.List(field_read, **kwargs)
         constructor_write = lambda **kwargs: restx_fields.List(field_write, **kwargs)
+    elif isinstance(
+        field, (mongo_fields.GenericReferenceField, mongoengine.fields.GenericLazyReferenceField)
+    ):
+        constructor = lambda **kwargs: restx_fields.Nested(lazy_reference, **kwargs)
     elif isinstance(field, mongo_fields.ReferenceField):
         # For reference we accept while writing a String representing the ID of the referenced model.
         # For reading, if the user supplied a `nested_fields` (RestX model), we use it to convert
@@ -289,8 +302,21 @@ def patch(obj, request):
             ):
                 # TODO `wrap_primary_key` do Mongo request, do a first pass to fetch all documents before calling it (to avoid multiple queries).
                 value = [wrap_primary_key(key, model_attribute.field, id) for id in value]
-            if isinstance(model_attribute, mongoengine.fields.ReferenceField):
+            elif isinstance(model_attribute, mongoengine.fields.ReferenceField):
                 value = wrap_primary_key(key, model_attribute, value)
+            elif isinstance(
+                model_attribute,
+                (
+                    mongoengine.fields.GenericReferenceField,
+                    mongoengine.fields.GenericLazyReferenceField,
+                ),
+            ):
+                value = wrap_primary_key(
+                    key,
+                    model_attribute,
+                    value["id"],
+                    document_type=db.resolve_model(value["class"]),
+                )
 
             info = getattr(model_attribute, "__additional_field_info__", {})
 
@@ -305,24 +331,39 @@ def patch(obj, request):
     return obj
 
 
-def wrap_primary_key(field_name: str, foreign_field: mongoengine.fields.ReferenceField, value: str):
+def wrap_primary_key(
+    field_name: str,
+    foreign_field: mongoengine.fields.ReferenceField | mongoengine.fields.GenericReferenceField,
+    value: str,
+    document_type: type = None,
+):
     """
     We need to wrap the `String` inside an `ObjectId` most of the time. If the foreign ID is a `String` we need to get
     a `DBRef` from the database.
 
     TODO: we only check the document reference if the ID is a `String` field (not in the case of a classic `ObjectId`).
     """
-    document_type = foreign_field.document_type()
-    id_field_name = document_type.__class__._meta["id_field"]
+    document_type = document_type or foreign_field.document_type().__class__
+    id_field_name = document_type._meta["id_field"]
 
-    id_field = getattr(document_type.__class__, id_field_name)
+    id_field = getattr(document_type, id_field_name)
 
     # Get the foreign document from MongoDB because the othewise it fails during read
     # Also useful to get a DBRef for non ObjectId references (see below)
-    foreign_document = document_type.__class__.objects(**{id_field_name: value}).first()
+    foreign_document = document_type.objects(**{id_field_name: value}).first()
     if foreign_document is None:
         raise FieldValidationError(field=field_name, message=f"Unknown reference '{value}'")
 
+    # GenericReferenceField only accepts document (not dbref / objectid)
+    if isinstance(
+        foreign_field,
+        (
+            mongoengine.fields.GenericReferenceField,
+            mongoengine.fields.GenericLazyReferenceField,
+        ),
+    ):
+        return foreign_document
+
     if isinstance(id_field, mongoengine.fields.ObjectIdField):
         return ObjectId(value)
     elif isinstance(id_field, mongoengine.fields.StringField):
@@ -336,5 +377,5 @@ def wrap_primary_key(field_name: str, foreign_field: mongoengine.fields.Referenc
         return foreign_document.to_dbref()
     else:
         raise ValueError(
-            f"Unknown ID field type {id_field.__class__} for {document_type.__class__} (ID field name is {id_field_name}, value was {value})"
+            f"Unknown ID field type {id_field.__class__} for {document_type} (ID field name is {id_field_name}, value was {value})"
         )

udata/core/reports/api.py

@@ -21,13 +21,13 @@ class ReportsAPI(API):
 
         return Report.apply_sort_filters_and_pagination(query)
 
-    @api.secure
     @api.doc("create_report", responses={400: "Validation error"})
     @api.expect(Report.__write_fields__)
     @api.marshal_with(Report.__read_fields__, code=201)
     def post(self):
         report = patch(Report(), request)
-        report.by = current_user._get_current_object()
+        if current_user.is_authenticated:
+            report.by = current_user._get_current_object()
 
         try:
             report.save()

udata/core/reports/constants.py

@@ -1,4 +1,8 @@
+from udata.core.dataservices.models import Dataservice
 from udata.core.dataset.models import Dataset
+from udata.core.discussions.models import Discussion
+from udata.core.organization.models import Organization
+from udata.core.reuse.models import Reuse
 from udata.i18n import lazy_gettext as _
 
 REASON_PERSONAL_DATA = "personal_data"
@@ -25,4 +29,4 @@ def reports_reasons_translations() -> list:
 
 
 REPORT_REASONS_CHOICES: list[str] = [item["value"] for item in reports_reasons_translations()]
-REPORTABLE_MODELS = [Dataset]
+REPORTABLE_MODELS = [Dataset, Reuse, Discussion, Organization, Dataservice]

udata/core/reports/models.py

@@ -1,6 +1,7 @@
 from datetime import datetime
 
-from mongoengine import NULLIFY, signals
+from bson import DBRef
+from mongoengine import DO_NOTHING, NULLIFY, signals
 
 from udata.api_fields import field, generate_fields
 from udata.core.user.api_fields import user_ref_fields
@@ -20,9 +21,13 @@ class Report(db.Document):
         allow_null=True,
     )
 
-    object_type = field(db.StringField(choices=[m.__name__ for m in REPORTABLE_MODELS]))
-    object_id = field(db.ObjectIdField())
-    object_deleted_at = field(
+    # Here we use the lazy version of `GenericReferenceField` because we could point to a
+    # non existant model (if it was deleted we want to keep the report data).
+    subject = field(
+        db.GenericLazyReferenceField(reverse_delete_rule=DO_NOTHING, choices=REPORTABLE_MODELS)
+    )
+
+    subject_deleted_at = field(
         db.DateTimeField(),
         allow_null=True,
         readonly=True,
@@ -42,15 +47,25 @@ class Report(db.Document):
 
     @classmethod
     def mark_as_deleted_soft_delete(cls, sender, document, **kwargs):
-        if document.deleted:
-            Report.objects(
-                object_type=sender.__name__, object_id=document.id, object_deleted_at=None
-            ).update(object_deleted_at=datetime.utcnow)
+        """
+        Called when updating a model (maybe updating the `deleted` date)
+        Some documents like Discussion do not have a `deleted` attribute.
+        """
+        if hasattr(document, "deleted") and document.deleted:
+            Report.objects(subject=document, subject_deleted_at=None).update(
+                subject_deleted_at=datetime.utcnow
+            )
 
-    def mark_as_deleted_hard_delete(cls, document, **kwargs):
+    @classmethod
+    def mark_as_deleted_hard_delete(cls, sender, document, **kwargs):
+        """
+        Call when really deleting a model from the database.
+        """
+        # Here we are forced to do a manual `DBRef(sender.__name__.lower(), document.id)`
+        # because the document doesn't exist anymore…
         Report.objects(
-            object_type=document.__class__.__name__, object_id=document.id, object_deleted_at=None
-        ).update(object_deleted_at=datetime.utcnow)
+            subject=DBRef(sender.__name__.lower(), document.id), subject_deleted_at=None
+        ).update(subject_deleted_at=datetime.utcnow)
 
 
 for model in REPORTABLE_MODELS: