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

udata/core/reuse/models.py

@@ -2,11 +2,15 @@ from blinker import Signal
 from mongoengine.signals import post_save, pre_save
 from werkzeug.utils import cached_property
 
+from udata.api_fields import field, function_field, generate_fields
+from udata.core.dataset.api_fields import dataset_fields
 from udata.core.owned import Owned, OwnedQuerySet
+from udata.core.reuse.api_fields import BIGGEST_IMAGE_SIZE
 from udata.core.storages import default_image_basename, images
 from udata.frontend.markdown import mdstrip
 from udata.i18n import lazy_gettext as _
 from udata.models import BadgeMixin, WithMetrics, db
+from udata.mongo.errors import FieldValidationError
 from udata.uris import endpoint_for
 from udata.utils import hash_url
 
@@ -23,32 +27,100 @@ 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):
+    """Ensure a reuse URL is not yet registered"""
+    if url and Reuse.url_exists(url):
+        raise FieldValidationError(_("This URL is already registered"), field="url")
+
+
+@generate_fields(
+    searchable=True,
+    additionalSorts=[
+        {"key": "datasets", "value": "metrics.datasets"},
+        {"key": "followers", "value": "metrics.followers"},
+        {"key": "views", "value": "metrics.views"},
+    ],
+)
 class Reuse(db.Datetimed, WithMetrics, BadgeMixin, Owned, db.Document):
-    title = db.StringField(required=True)
-    slug = db.SlugField(
-        max_length=255, required=True, populate_from="title", update=True, follow=True
+    title = field(
+        db.StringField(required=True),
+        sortable=True,
+        show_as_ref=True,
+    )
+    slug = field(
+        db.SlugField(
+            max_length=255, required=True, populate_from="title", update=True, follow=True
+        ),
+        readonly=True,
+    )
+    description = field(
+        db.StringField(required=True),
+        markdown=True,
+    )
+    type = field(
+        db.StringField(required=True, choices=list(REUSE_TYPES)),
+        filterable={},
+    )
+    url = field(
+        db.StringField(required=True),
+        description="The remote URL (website)",
+        check=check_url_does_not_exists,
     )
-    description = db.StringField(required=True)
-    type = db.StringField(required=True, choices=list(REUSE_TYPES))
-    url = db.StringField(required=True)
     urlhash = db.StringField(required=True, unique=True)
     image_url = db.StringField()
-    image = db.ImageField(
-        fs=images, basename=default_image_basename, max_size=IMAGE_MAX_SIZE, thumbnails=IMAGE_SIZES
+    image = field(
+        db.ImageField(
+            fs=images,
+            basename=default_image_basename,
+            max_size=IMAGE_MAX_SIZE,
+            thumbnails=IMAGE_SIZES,
+        ),
+        readonly=True,
+        show_as_ref=True,
+        thumbnail_info={
+            "size": BIGGEST_IMAGE_SIZE,
+        },
+    )
+    datasets = field(
+        db.ListField(
+            field(
+                db.ReferenceField("Dataset", reverse_delete_rule=db.PULL),
+                nested_fields=dataset_fields,
+            ),
+        ),
+        filterable={
+            "key": "dataset",
+        },
+    )
+    tags = field(
+        db.TagListField(),
+        filterable={
+            "key": "tag",
+        },
+    )
+    topic = field(
+        db.StringField(required=True, choices=list(REUSE_TOPICS)),
+        filterable={},
     )
-    datasets = db.ListField(db.ReferenceField("Dataset", reverse_delete_rule=db.PULL))
-    tags = db.TagListField()
-    topic = db.StringField(required=True, choices=list(REUSE_TOPICS))
     # badges = db.ListField(db.EmbeddedDocumentField(ReuseBadge))
 
-    private = db.BooleanField(default=False)
+    private = field(db.BooleanField(default=False))
 
     ext = db.MapField(db.GenericEmbeddedDocumentField())
-    extras = db.ExtrasField()
+    extras = field(db.ExtrasField())
 
-    featured = db.BooleanField()
-    deleted = db.DateTimeField()
-    archived = db.DateTimeField()
+    featured = field(
+        db.BooleanField(),
+        filterable={},
+        readonly=True,
+    )
+    deleted = field(
+        db.DateTimeField(),
+        readonly=True,
+    )
+    archived = field(
+        db.DateTimeField(),
+    )
 
     def __str__(self):
         return self.title or ""
@@ -110,6 +182,16 @@ class Reuse(db.Datetimed, WithMetrics, BadgeMixin, Owned, db.Document):
 
     display_url = property(url_for)
 
+    @function_field(description="Link to the API endpoint for this reuse", show_as_ref=True)
+    def uri(self):
+        return endpoint_for("api.reuse", reuse=self, _external=True)
+
+    @function_field(description="Link to the udata web page for this reuse", show_as_ref=True)
+    def page(self):
+        return endpoint_for(
+            "reuses.show", reuse=self, _external=True, fallback_endpoint="api.reuse"
+        )
+
     @property
     def is_visible(self):
         return not self.is_hidden

udata/core/site/api.py

@@ -6,7 +6,6 @@ from udata.api import API, api, fields
 from udata.auth import admin_permission
 from udata.core.dataservices.models import Dataservice
 from udata.core.dataset.api_fields import dataset_fields
-from udata.core.reuse.api_fields import reuse_fields
 from udata.models import Dataset, Reuse
 from udata.rdf import CONTEXT, RDF_EXTENSIONS, graph_response, negociate_content
 from udata.utils import multi_to_dict
@@ -62,7 +61,7 @@ class SiteHomeDatasetsAPI(API):
 class SiteHomeReusesAPI(API):
     @api.doc("get_home_reuses")
     @api.secure(admin_permission)
-    @api.marshal_list_with(reuse_fields)
+    @api.marshal_list_with(Reuse.__read_fields__)
     def get(self):
         """List homepage featured reuses"""
         return current_site.settings.home_reuses
@@ -70,7 +69,7 @@ class SiteHomeReusesAPI(API):
     @api.secure(admin_permission)
     @api.doc("set_home_reuses")
     @api.expect(([str], "Reuse IDs to put in homepage"))
-    @api.marshal_list_with(reuse_fields)
+    @api.marshal_list_with(Reuse.__read_fields__)
     def put(self):
         """Set the homepage reuses editorial selection"""
         if not isinstance(request.json, list):

udata/core/topic/api.py

@@ -2,7 +2,7 @@ from udata.api import API, api, fields
 from udata.core.dataset.api_fields import dataset_fields
 from udata.core.discussions.models import Discussion
 from udata.core.organization.api_fields import org_ref_fields
-from udata.core.reuse.api_fields import reuse_fields
+from udata.core.reuse.models import Reuse
 from udata.core.spatial.api_fields import spatial_coverage_fields
 from udata.core.topic.parsers import TopicApiParser
 from udata.core.topic.permissions import TopicEditPermission
@@ -33,7 +33,7 @@ topic_fields = api.model(
             attribute=lambda o: [d.fetch() for d in o.datasets],
         ),
         "reuses": fields.List(
-            fields.Nested(reuse_fields),
+            fields.Nested(Reuse.__read_fields__),
             description="The topic reuses",
             attribute=lambda o: [r.fetch() for r in o.reuses],
         ),

udata/core/topic/apiv2.py

@@ -10,7 +10,6 @@ from udata.core.dataset.apiv2 import dataset_page_fields
 from udata.core.dataset.models import Dataset
 from udata.core.organization.api_fields import org_ref_fields
 from udata.core.reuse.api import ReuseApiParser
-from udata.core.reuse.apiv2 import reuse_page_fields
 from udata.core.reuse.models import Reuse
 from udata.core.spatial.api_fields import spatial_coverage_fields
 from udata.core.topic.models import Topic
@@ -216,7 +215,7 @@ class TopicDatasetAPI(API):
 class TopicReusesAPI(API):
     @apiv2.doc("topic_reuses")
     @apiv2.expect(reuse_parser.parser)
-    @apiv2.marshal_with(reuse_page_fields)
+    @apiv2.marshal_with(Reuse.__page_fields__)
     def get(self, topic):
         """Get a given topic reuses, with filters"""
         args = reuse_parser.parse()

udata/core/user/api.py

@@ -8,7 +8,6 @@ from udata.core.dataset.api_fields import community_resource_fields, dataset_fie
 from udata.core.discussions.actions import discussions_for
 from udata.core.discussions.api import discussion_fields
 from udata.core.followers.api import FollowAPI
-from udata.core.reuse.api_fields import reuse_fields
 from udata.core.storages.api import (
     image_parser,
     parse_uploaded_image,
@@ -102,7 +101,7 @@ class AvatarAPI(API):
 class MyReusesAPI(API):
     @api.secure
     @api.doc("my_reuses")
-    @api.marshal_list_with(reuse_fields)
+    @api.marshal_list_with(Reuse.__read_fields__)
     def get(self):
         """List all my reuses (including private ones)"""
         return list(Reuse.objects.owned_by(current_user.id))
@@ -165,7 +164,7 @@ class MyOrgReusesAPI(API):
     @api.secure
     @api.doc("my_org_reuses")
     @api.expect(filter_parser)
-    @api.marshal_list_with(reuse_fields)
+    @api.marshal_list_with(Reuse.__read_fields__)
     def get(self):
         """List all reuses related to me and my organizations."""
         q = filter_parser.parse_args().get("q")

udata/features/transfer/api.py

@@ -3,7 +3,6 @@ from flask import request
 from udata.api import API, api, base_reference, fields
 from udata.core.dataset.api_fields import dataset_ref_fields
 from udata.core.organization.api_fields import org_ref_fields
-from udata.core.reuse.api_fields import reuse_ref_fields
 from udata.core.user.api_fields import user_ref_fields
 from udata.models import Dataset, Organization, Reuse, User, db
 from udata.utils import id_or_404
@@ -47,7 +46,7 @@ person_mapping = {
 
 subject_mapping = {
     Dataset: dataset_ref_fields,
-    Reuse: reuse_ref_fields,
+    Reuse: Reuse.__ref_fields__,
 }
 
 transfer_fields = api.model(

udata/mongo/datetime_fields.py

@@ -6,6 +6,7 @@ from mongoengine import EmbeddedDocument
 from mongoengine.fields import BaseField, DateTimeField
 from mongoengine.signals import pre_save
 
+from udata.api_fields import field
 from udata.i18n import lazy_gettext as _
 
 log = logging.getLogger(__name__)
@@ -55,11 +56,17 @@ class DateRange(EmbeddedDocument):
 
 
 class Datetimed(object):
-    created_at = DateTimeField(
-        verbose_name=_("Creation date"), default=datetime.utcnow, required=True
+    created_at = field(
+        DateTimeField(verbose_name=_("Creation date"), default=datetime.utcnow, required=True),
+        sortable="created",
+        readonly=True,
     )
-    last_modified = DateTimeField(
-        verbose_name=_("Last modification date"), default=datetime.utcnow, required=True
+    last_modified = field(
+        DateTimeField(
+            verbose_name=_("Last modification date"), default=datetime.utcnow, required=True
+        ),
+        sortable=True,
+        readonly=True,
     )
 
 

udata/mongo/document.py

@@ -11,6 +11,8 @@ log = logging.getLogger(__name__)
 def serialize(value):
     if hasattr(value, "to_dict"):
         return value.to_dict()
+    elif isinstance(value, dict):
+        return {key: serialize(val) for key, val in value.items()}
     elif isinstance(value, Iterable) and not isinstance(value, str):
         return [serialize(val) for val in value]
     else:

udata/mongo/taglist_field.py

@@ -1,12 +1,24 @@
 from mongoengine.fields import ListField, StringField
 from slugify import slugify
 
+from udata import tags
+from udata.i18n import lazy_gettext as _
+
 
 class TagListField(ListField):
     def __init__(self, **kwargs):
         self.tags = []
         super(TagListField, self).__init__(StringField(), **kwargs)
 
+    @staticmethod
+    def from_input(input):
+        if isinstance(input, list):
+            return [tags.slug(value) for value in input]
+        elif isinstance(input, str):
+            return tags.tags_list(input)
+        else:
+            return []
+
     def clean(self, value):
         return sorted(list(set([slugify(v, to_lower=True) for v in value])))
 
@@ -15,3 +27,17 @@ class TagListField(ListField):
 
     def to_mongo(self, value):
         return super(TagListField, self).to_mongo(self.clean(value))
+
+    def validate(self, values):
+        super(TagListField, self).validate(values)
+
+        for tag in values:
+            if not tags.MIN_TAG_LENGTH <= len(tag) <= tags.MAX_TAG_LENGTH:
+                self.error(
+                    _(
+                        '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,
+                    )
+                )