udata 9.1.4.dev31123__py2.py3-none-any.whl → 9.1.4.dev31168__py2.py3-none-any.whl

udata/api_fields.py

@@ -2,10 +2,10 @@ import flask_restx.fields as restx_fields
 import mongoengine
 import mongoengine.fields as mongo_fields
 from bson import ObjectId
+from flask_storage.mongo import ImageField as FlaskStorageImageField
 
 import udata.api.fields as custom_restx_fields
-from udata.api import api
-from udata.mongo.engine import db
+from udata.api import api, base_reference
 from udata.mongo.errors import FieldValidationError
 
 lazy_reference = api.model(
@@ -17,7 +17,7 @@ lazy_reference = api.model(
 )
 
 
-def convert_db_to_field(key, field, info={}):
+def convert_db_to_field(key, field, info):
     """
     This function maps a Mongo field to a Flask RestX field.
     Most of the types are a simple 1-to-1 mapping except lists and references that requires
@@ -28,8 +28,6 @@ def convert_db_to_field(key, field, info={}):
     params. Since merging the params involve a litte bit of work (merging default params with read/write params and then with
     user-supplied overrides, setting the readonly flag…), it's easier to have do this one time at the end of the function.
     """
-    info = {**getattr(field, "__additional_field_info__", {}), **info}
-
     params = {}
     params["required"] = field.required
 
@@ -45,7 +43,9 @@ def convert_db_to_field(key, field, info={}):
         # is always good enough.
         return info.get("convert_to"), info.get("convert_to")
     elif isinstance(field, mongo_fields.StringField):
-        constructor = restx_fields.String
+        constructor = (
+            custom_restx_fields.Markdown if info.get("markdown", False) else restx_fields.String
+        )
         params["min_length"] = field.min_length
         params["max_length"] = field.max_length
         params["enum"] = field.choices
@@ -61,11 +61,29 @@ def convert_db_to_field(key, field, info={}):
         constructor = custom_restx_fields.ISODateTime
     elif isinstance(field, mongo_fields.DictField):
         constructor = restx_fields.Raw
+    elif isinstance(field, mongo_fields.ImageField) or isinstance(field, FlaskStorageImageField):
+        size = info.get("size", None)
+        if size:
+            params["description"] = f"URL of the cropped and squared image ({size}x{size})"
+        else:
+            params["description"] = "URL of the image"
+
+        if info.get("is_thumbnail", False):
+            constructor_read = custom_restx_fields.ImageField
+            write_params["read_only"] = True
+        else:
+            constructor = custom_restx_fields.ImageField
+
     elif isinstance(field, mongo_fields.ListField):
         # For lists, we convert the inner value from Mongo to RestX then we create
         # the `List` RestX type with this converted inner value.
+        # There is three level of information, from most important to least
+        #     1. `inner_field_info` inside `__additional_field_info__` on the parent
+        #     2. `__additional_field_info__` of the inner field
+        #     3. `__additional_field_info__` of the parent
+        inner_info = getattr(field.field, "__additional_field_info__", {})
         field_read, field_write = convert_db_to_field(
-            f"{key}.inner", field.field, info.get("inner_field_info", {})
+            f"{key}.inner", field.field, {**info, **inner_info, **info.get("inner_field_info", {})}
         )
 
         def constructor_read(**kwargs):
@@ -114,13 +132,13 @@ def convert_db_to_field(key, field, info={}):
             )
 
     else:
-        raise ValueError(f"Unsupported MongoEngine field type {field.__class__.__name__}")
+        raise ValueError(f"Unsupported MongoEngine field type {field.__class__}")
 
     read_params = {**params, **read_params, **info}
     write_params = {**params, **write_params, **info}
 
     read = constructor_read(**read_params) if constructor_read else constructor(**read_params)
-    if write_params.get("readonly", False):
+    if write_params.get("readonly", False) or (constructor_write is None and constructor is None):
         write = None
     else:
         write = (
@@ -129,6 +147,26 @@ def convert_db_to_field(key, field, info={}):
     return read, write
 
 
+def get_fields(cls):
+    """
+    Returns all the exposed fields of the class (fields decorated with `field()`)
+    It also expends image fields to add thumbnail fields.
+    """
+    for key, field in cls._fields.items():
+        info: dict | None = getattr(field, "__additional_field_info__", None)
+        if info is None:
+            continue
+
+        yield key, field, info
+
+        if isinstance(field, mongo_fields.ImageField) or isinstance(field, FlaskStorageImageField):
+            yield (
+                f"{key}_thumbnail",
+                field,
+                {**info, **info.get("thumbnail_info", {}), "is_thumbnail": True, "attribute": key},
+            )
+
+
 def generate_fields(**kwargs):
     """
     This decorator will create two auto-generated attributes on the class `__read_fields__` and `__write_fields__`
@@ -138,18 +176,18 @@ def generate_fields(**kwargs):
     def wrapper(cls):
         read_fields = {}
         write_fields = {}
-        sortables = []
+        ref_fields = {}
+        sortables = kwargs.get("additionalSorts", [])
         filterables = []
 
-        read_fields["id"] = restx_fields.String(required=True)
-
-        for key, field in cls._fields.items():
-            info = getattr(field, "__additional_field_info__", None)
-            if info is None:
-                continue
+        read_fields["id"] = restx_fields.String(required=True, readonly=True)
 
-            if info.get("sortable", False):
-                sortables.append(key)
+        for key, field, info in get_fields(cls):
+            sortable_key = info.get("sortable", False)
+            if sortable_key:
+                sortables.append(
+                    {"key": sortable_key if isinstance(sortable_key, str) else key, "value": key}
+                )
 
             filterable = info.get("filterable", None)
             if filterable is not None:
@@ -166,18 +204,26 @@ def generate_fields(**kwargs):
                     ):
                         filterable["constraints"].append("objectid")
 
+                if "type" not in filterable:
+                    filterable["type"] = str
+                    if isinstance(field, mongo_fields.BooleanField):
+                        filterable["type"] = bool
+
                 # We may add more information later here:
                 # - type of mongo query to execute (right now only simple =)
 
                 filterables.append(filterable)
 
-            read, write = convert_db_to_field(key, field)
+            read, write = convert_db_to_field(key, field, info)
 
             if read:
                 read_fields[key] = read
             if write:
                 write_fields[key] = write
 
+            if read and info.get("show_as_ref", False):
+                ref_fields[key] = read
+
         # The goal of this loop is to fetch all functions (getters) of the class
         # If a function has an `__additional_field_info__` attribute it means
         # it has been decorated with `@function_field()` and should be included
@@ -209,9 +255,12 @@ def generate_fields(**kwargs):
             read_fields[method_name] = restx_fields.String(
                 attribute=make_lambda(method), **{"readonly": True, **info}
             )
+            if info.get("show_as_ref", False):
+                ref_fields[key] = read_fields[method_name]
 
         cls.__read_fields__ = api.model(f"{cls.__name__} (read)", read_fields, **kwargs)
         cls.__write_fields__ = api.model(f"{cls.__name__} (write)", write_fields, **kwargs)
+        cls.__ref_fields__ = api.inherit(f"{cls.__name__}Reference", base_reference, ref_fields)
 
         mask = kwargs.pop("mask", None)
         if mask is not None:
@@ -236,7 +285,9 @@ def generate_fields(**kwargs):
             )
 
         if sortables:
-            choices = sortables + ["-" + k for k in sortables]
+            choices = [sortable["key"] for sortable in sortables] + [
+                "-" + sortable["key"] for sortable in sortables
+            ]
             parser.add_argument(
                 "sort",
                 type=str,
@@ -245,8 +296,12 @@ def generate_fields(**kwargs):
                 help="The field (and direction) on which sorting apply",
             )
 
+        searchable = kwargs.pop("searchable", False)
+        if searchable:
+            parser.add_argument("q", type=str, location="args")
+
         for filterable in filterables:
-            parser.add_argument(filterable["key"], type=str, location="args")
+            parser.add_argument(filterable["key"], type=filterable["type"], location="args")
 
         cls.__index_parser__ = parser
 
@@ -254,7 +309,23 @@ def generate_fields(**kwargs):
             args = cls.__index_parser__.parse_args()
 
             if sortables and args["sort"]:
-                base_query = base_query.order_by(args["sort"])
+                negate = args["sort"].startswith("-")
+                sort_key = args["sort"][1:] if negate else args["sort"]
+
+                sort_by = next(
+                    (sortable["value"] for sortable in sortables if sortable["key"] == sort_key),
+                    None,
+                )
+
+                if sort_by:
+                    if negate:
+                        sort_by = "-" + sort_by
+
+                    base_query = base_query.order_by(sort_by)
+
+            if searchable and args.get("q"):
+                phrase_query = " ".join([f'"{elem}"' for elem in args["q"].split(" ")])
+                base_query = base_query.search_text(phrase_query)
 
             for filterable in filterables:
                 if args.get(filterable["key"]):
@@ -303,11 +374,16 @@ def patch(obj, request):
     Patch the object with the data from the request.
     Only fields decorated with the `field()` decorator will be read (and not readonly).
     """
+    from udata.mongo.engine import db
+
     for key, value in request.json.items():
         field = obj.__write_fields__.get(key)
         if field is not None and not field.readonly:
             model_attribute = getattr(obj.__class__, key)
-            if isinstance(model_attribute, mongoengine.fields.ListField) and isinstance(
+
+            if hasattr(model_attribute, "from_input"):
+                value = model_attribute.from_input(value)
+            elif isinstance(model_attribute, mongoengine.fields.ListField) and isinstance(
                 model_attribute.field, mongoengine.fields.ReferenceField
             ):
                 # TODO `wrap_primary_key` do Mongo request, do a first pass to fetch all documents before calling it (to avoid multiple queries).
@@ -333,7 +409,7 @@ def patch(obj, request):
             # `check` field attribute allows to do validation from the request before setting
             # the attribute
             check = info.get("check", None)
-            if check is not None:
+            if check is not None and value != getattr(obj, key):
                 check(**{key: value})  # TODO add other model attributes in function parameters
 
             setattr(obj, key, value)
@@ -341,10 +417,21 @@ def patch(obj, request):
     return obj
 
 
+def patch_and_save(obj, request):
+    obj = patch(obj, request)
+
+    try:
+        obj.save()
+    except mongoengine.errors.ValidationError as e:
+        api.abort(400, e.message)
+
+    return obj
+
+
 def wrap_primary_key(
     field_name: str,
     foreign_field: mongoengine.fields.ReferenceField | mongoengine.fields.GenericReferenceField,
-    value: str,
+    value: str | None,
     document_type=None,
 ):
     """
@@ -353,6 +440,12 @@ def wrap_primary_key(
 
     TODO: we only check the document reference if the ID is a `String` field (not in the case of a classic `ObjectId`).
     """
+    if value is None:
+        return value
+
+    if isinstance(value, dict) and "id" in value:
+        return wrap_primary_key(field_name, foreign_field, value["id"], document_type)
+
     document_type = document_type or foreign_field.document_type().__class__
     id_field_name = document_type._meta["id_field"]
 
@@ -375,7 +468,7 @@ def wrap_primary_key(
         return foreign_document
 
     if isinstance(id_field, mongoengine.fields.ObjectIdField):
-        return ObjectId(value)
+        return foreign_document.to_dbref()
     elif isinstance(id_field, mongoengine.fields.StringField):
         # Right now I didn't find a simpler way to make mongoengine happy.
         # For references, it expects `ObjectId`, `DBRef`, `LazyReference` or `document` but since

udata/core/activity/api.py

@@ -1,5 +1,6 @@
 import logging
 
+from bson import ObjectId
 from mongoengine.errors import DoesNotExist
 
 from udata.api import API, api, fields
@@ -61,13 +62,19 @@ activity_parser.add_argument(
     help="Filter activities for that particular organization",
     location="args",
 )
+activity_parser.add_argument(
+    "related_to",
+    type=str,
+    help="Filter activities for that particular object id (ex : reuse, dataset, etc.)",
+    location="args",
+)
 
 
 @api.route("/activity", endpoint="activity")
 class SiteActivityAPI(API):
     @api.doc("activity")
     @api.expect(activity_parser)
-    @api.marshal_list_with(activity_page_fields)
+    @api.marshal_with(activity_page_fields)
     def get(self):
         """Fetch site activity, optionally filtered by user of org."""
         args = activity_parser.parse_args()
@@ -79,6 +86,12 @@ class SiteActivityAPI(API):
         if args["user"]:
             qs = qs(actor=args["user"])
 
+        if args["related_to"]:
+            if not ObjectId.is_valid(args["related_to"]):
+                api.abort(400, "`related_to` arg must be an identifier")
+
+            qs = qs(related_to=args["related_to"])
+
         qs = qs.order_by("-created_at")
         qs = qs.paginate(args["page"], args["page_size"])
 

udata/core/badges/models.py

@@ -3,7 +3,9 @@ from datetime import datetime
 
 from mongoengine.signals import post_save
 
+from udata.api_fields import field
 from udata.auth import current_user
+from udata.core.badges.fields import badge_fields
 from udata.mongo import db
 
 from .signals import on_badge_added, on_badge_removed
@@ -40,7 +42,11 @@ class BadgesList(db.EmbeddedDocumentListField):
 
 
 class BadgeMixin(object):
-    badges = BadgesList()
+    badges = field(
+        BadgesList(),
+        readonly=True,
+        inner_field_info={"nested_fields": badge_fields},
+    )
 
     def get_badge(self, kind):
         """Get a badge given its kind if present"""

udata/core/metrics/models.py

@@ -5,7 +5,10 @@ __all__ = ("WithMetrics",)
 
 
 class WithMetrics(object):
-    metrics = field(db.DictField())
+    metrics = field(
+        db.DictField(),
+        readonly=True,
+    )
 
     __metrics_keys__ = []
 

udata/core/organization/api.py

@@ -16,7 +16,6 @@ from udata.core.dataset.models import Dataset
 from udata.core.discussions.api import discussion_fields
 from udata.core.discussions.models import Discussion
 from udata.core.followers.api import FollowAPI
-from udata.core.reuse.api_fields import reuse_fields
 from udata.core.reuse.models import Reuse
 from udata.core.storages.api import (
     image_parser,
@@ -462,7 +461,7 @@ class OrgDatasetsAPI(API):
 @ns.route("/<org:org>/reuses/", endpoint="org_reuses")
 class OrgReusesAPI(API):
     @api.doc("list_organization_reuses")
-    @api.marshal_list_with(reuse_fields)
+    @api.marshal_list_with(Reuse.__read_fields__)
     def get(self, org):
         """List organization reuses (including private ones when member)"""
         qs = Reuse.objects.owned_by(org)

udata/core/owned.py

@@ -32,7 +32,7 @@ def check_owner_is_current_user(owner):
         current_user.is_authenticated
         and owner
         and not admin_permission
-        and current_user.id != owner
+        and current_user.id != owner.id
     ):
         raise FieldValidationError(_("You can only set yourself as owner"), field="owner")
 
@@ -41,7 +41,7 @@ def check_organization_is_valid_for_current_user(organization):
     from udata.auth import current_user
     from udata.models import Organization
 
-    org = Organization.objects(id=organization).first()
+    org = Organization.objects(id=organization.id).first()
     if org is None:
         raise FieldValidationError(_("Unknown organization"), field="organization")
 
@@ -62,6 +62,7 @@ class Owned(object):
         description="Only present if organization is not set. Can only be set to the current authenticated user.",
         check=check_owner_is_current_user,
         allow_null=True,
+        filterable={},
     )
     organization = field(
         ReferenceField(Organization, reverse_delete_rule=NULLIFY),
@@ -69,6 +70,7 @@ class Owned(object):
         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,
         allow_null=True,
+        filterable={},
     )
 
     on_owner_change = signal("Owned.on_owner_change")

udata/core/post/api.py

@@ -3,7 +3,7 @@ from datetime import datetime
 from udata.api import API, api, fields
 from udata.auth import admin_permission
 from udata.core.dataset.api_fields import dataset_fields
-from udata.core.reuse.api_fields import reuse_fields
+from udata.core.reuse.models import Reuse
 from udata.core.storages.api import (
     image_parser,
     parse_uploaded_image,
@@ -29,7 +29,7 @@ post_fields = api.model(
         "credit_url": fields.String(description="An optional link associated to the credits"),
         "tags": fields.List(fields.String, description="Some keywords to help in search"),
         "datasets": fields.List(fields.Nested(dataset_fields), description="The post datasets"),
-        "reuses": fields.List(fields.Nested(reuse_fields), description="The post reuses"),
+        "reuses": fields.List(fields.Nested(Reuse.__read_fields__), description="The post reuses"),
         "owner": fields.Nested(
             user_ref_fields, description="The owner user", readonly=True, allow_null=True
         ),

udata/core/reuse/api.py

@@ -1,15 +1,19 @@
 from datetime import datetime
 
+import mongoengine
 from bson.objectid import ObjectId
 from flask import request
+from flask_login import current_user
 
 from udata.api import API, api, errors
 from udata.api.parsers import ModelApiParser
+from udata.api_fields import patch, patch_and_save
 from udata.auth import admin_permission
 from udata.core.badges import api as badges_api
 from udata.core.badges.fields import badge_fields
 from udata.core.dataset.api_fields import dataset_ref_fields
 from udata.core.followers.api import FollowAPI
+from udata.core.reuse.constants import REUSE_TOPICS, REUSE_TYPES
 from udata.core.storages.api import (
     image_parser,
     parse_uploaded_image,
@@ -19,14 +23,10 @@ from udata.models import Dataset
 from udata.utils import id_or_404
 
 from .api_fields import (
-    reuse_fields,
-    reuse_page_fields,
     reuse_suggestion_fields,
     reuse_topic_fields,
     reuse_type_fields,
 )
-from .constants import REUSE_TOPICS, REUSE_TYPES
-from .forms import ReuseForm
 from .models import Reuse
 from .permissions import ReuseEditPermission
 
@@ -96,24 +96,30 @@ reuse_parser = ReuseApiParser()
 @ns.route("/", endpoint="reuses")
 class ReuseListAPI(API):
     @api.doc("list_reuses")
-    @api.expect(reuse_parser.parser)
-    @api.marshal_with(reuse_page_fields)
+    @api.expect(Reuse.__index_parser__)
+    @api.marshal_with(Reuse.__page_fields__)
     def get(self):
-        args = reuse_parser.parse()
-        reuses = Reuse.objects(deleted=None, private__ne=True)
-        reuses = reuse_parser.parse_filters(reuses, args)
-        sort = args["sort"] or ("$text_score" if args["q"] else None) or DEFAULT_SORTING
-        return reuses.order_by(sort).paginate(args["page"], args["page_size"])
+        query = Reuse.objects(deleted=None, private__ne=True)
+
+        return Reuse.apply_sort_filters_and_pagination(query)
 
     @api.secure
     @api.doc("create_reuse")
-    @api.expect(reuse_fields)
+    @api.expect(Reuse.__write_fields__)
     @api.response(400, "Validation error")
-    @api.marshal_with(reuse_fields)
+    @api.marshal_with(Reuse.__read_fields__, code=201)
     def post(self):
-        """Create a new object"""
-        form = api.validate(ReuseForm)
-        return form.save(), 201
+        reuse = patch(Reuse(), request)
+
+        if not reuse.owner and not reuse.organization:
+            reuse.owner = current_user._get_current_object()
+
+        try:
+            reuse.save()
+        except mongoengine.errors.ValidationError as e:
+            api.abort(400, e.message)
+
+        return patch_and_save(reuse, request), 201
 
 
 @ns.route("/<reuse:reuse>/", endpoint="reuse", doc=common_doc)
@@ -121,7 +127,7 @@ class ReuseListAPI(API):
 @api.response(410, "Reuse has been deleted")
 class ReuseAPI(API):
     @api.doc("get_reuse")
-    @api.marshal_with(reuse_fields)
+    @api.marshal_with(Reuse.__read_fields__)
     def get(self, reuse):
         """Fetch a given reuse"""
         if reuse.deleted and not ReuseEditPermission(reuse).can():
@@ -130,8 +136,8 @@ class ReuseAPI(API):
 
     @api.secure
     @api.doc("update_reuse")
-    @api.expect(reuse_fields)
-    @api.marshal_with(reuse_fields)
+    @api.expect(Reuse.__write_fields__)
+    @api.marshal_with(Reuse.__read_fields__)
     @api.response(400, errors.VALIDATION_ERROR)
     def put(self, reuse):
         """Update a given reuse"""
@@ -139,8 +145,9 @@ class ReuseAPI(API):
         if reuse.deleted and request_deleted is not None:
             api.abort(410, "This reuse has been deleted")
         ReuseEditPermission(reuse).test()
-        form = api.validate(ReuseForm, reuse)
-        return form.save()
+
+        # This is a patch but old API acted like PATCH on PUT requests.
+        return patch_and_save(reuse, request)
 
     @api.secure
     @api.doc("delete_reuse")
@@ -160,8 +167,8 @@ class ReuseDatasetsAPI(API):
     @api.secure
     @api.doc("reuse_add_dataset", **common_doc)
     @api.expect(dataset_ref_fields)
-    @api.response(200, "The dataset is already present", reuse_fields)
-    @api.marshal_with(reuse_fields, code=201)
+    @api.response(200, "The dataset is already present", Reuse.__read_fields__)
+    @api.marshal_with(Reuse.__read_fields__, code=201)
     def post(self, reuse):
         """Add a dataset to a given reuse"""
         if "id" not in request.json:
@@ -211,7 +218,7 @@ class ReuseBadgeAPI(API):
 class ReuseFeaturedAPI(API):
     @api.doc("feature_reuse")
     @api.secure(admin_permission)
-    @api.marshal_with(reuse_fields)
+    @api.marshal_with(Reuse.__read_fields__)
     def post(self, reuse):
         """Mark a reuse as featured"""
         reuse.featured = True
@@ -220,7 +227,7 @@ class ReuseFeaturedAPI(API):
 
     @api.doc("unfeature_reuse")
     @api.secure(admin_permission)
-    @api.marshal_with(reuse_fields)
+    @api.marshal_with(Reuse.__read_fields__)
     def delete(self, reuse):
         """Unmark a reuse as featured"""
         reuse.featured = False