udata 10.4.2.dev35451__py2.py3-none-any.whl → 10.4.2.dev35475__py2.py3-none-any.whl

udata/core/activity/__init__.py

@@ -10,3 +10,4 @@ def init_app(app):
     import udata.core.dataset.activities  # noqa
     import udata.core.reuse.activities  # noqa
     import udata.core.organization.activities  # noqa
+    import udata.core.topic.activities  # noqa

udata/core/dataservices/api.py

@@ -1,7 +1,9 @@
 from datetime import datetime
+from typing import List
 
 import mongoengine
 from bson import ObjectId
+from feedgenerator.django.utils.feedgenerator import Atom1Feed
 from flask import make_response, redirect, request, url_for
 from flask_login import current_user
 
@@ -10,6 +12,9 @@ from udata.api_fields import patch
 from udata.core.dataservices.permissions import OwnablePermission
 from udata.core.dataset.models import Dataset
 from udata.core.followers.api import FollowAPI
+from udata.core.site.models import current_site
+from udata.frontend.markdown import md
+from udata.i18n import gettext as _
 from udata.rdf import RDF_EXTENSIONS, graph_response, negociate_content
 
 from .models import Dataservice
@@ -49,6 +54,44 @@ class DataservicesAPI(API):
         return dataservice, 201
 
 
+@ns.route("/recent.atom", endpoint="recent_dataservices_atom_feed")
+class DataservicesAtomFeedAPI(API):
+    @api.doc("recent_dataservices_atom_feed")
+    def get(self):
+        feed = Atom1Feed(
+            _("Latest APIs"), description=None, feed_url=request.url, link=request.url_root
+        )
+
+        dataservices: List[Dataservice] = (
+            Dataservice.objects.visible()
+            .order_by("-created_at_internal")
+            .limit(current_site.feed_size)
+        )
+        for dataservice in dataservices:
+            author_name = None
+            author_uri = None
+            if dataservice.organization:
+                author_name = dataservice.organization.name
+                author_uri = dataservice.organization.external_url
+            elif dataservice.owner:
+                author_name = dataservice.owner.fullname
+                author_uri = dataservice.owner.external_url
+            feed.add_item(
+                dataservice.title,
+                unique_id=dataservice.id,
+                description=dataservice.description,
+                content=md(dataservice.description),
+                author_name=author_name,
+                author_link=author_uri,
+                link=dataservice.url_for(external=True),
+                updateddate=dataservice.metadata_modified_at,
+                pubdate=dataservice.created_at,
+            )
+        response = make_response(feed.writeString("utf-8"))
+        response.headers["Content-Type"] = "application/atom+xml"
+        return response
+
+
 @ns.route("/<dataservice:dataservice>/", endpoint="dataservice")
 class DataserviceAPI(API):
     @api.doc("get_dataservice")

udata/core/dataset/api.py

@@ -20,9 +20,11 @@ These changes might lead to backward compatibility breakage meaning:
 import logging
 import os
 from datetime import datetime
+from typing import List
 
 import mongoengine
 from bson.objectid import ObjectId
+from feedgenerator.django.utils.feedgenerator import Atom1Feed
 from flask import abort, current_app, make_response, redirect, request, url_for
 from flask_restx.inputs import boolean
 from flask_security import current_user
@@ -39,8 +41,11 @@ from udata.core.dataset.models import CHECKSUM_TYPES
 from udata.core.followers.api import FollowAPI
 from udata.core.organization.models import Organization
 from udata.core.reuse.models import Reuse
+from udata.core.site.models import current_site
 from udata.core.storages.api import handle_upload, upload_parser
 from udata.core.topic.models import Topic
+from udata.frontend.markdown import md
+from udata.i18n import gettext as _
 from udata.linkchecker.checker import check_resource
 from udata.rdf import RDF_EXTENSIONS, graph_response, negociate_content
 from udata.utils import get_by
@@ -292,6 +297,45 @@ class DatasetListAPI(API):
         return dataset, 201
 
 
+@ns.route("/recent.atom", endpoint="recent_datasets_atom_feed")
+class DatasetsAtomFeedAPI(API):
+    @api.doc("recent_datasets_atom_feed")
+    def get(self):
+        feed = Atom1Feed(
+            _("Latest datasets"),
+            description=None,
+            feed_url=request.url,
+            link=request.url_root,
+        )
+
+        datasets: List[Dataset] = (
+            Dataset.objects.visible().order_by("-created_at_internal").limit(current_site.feed_size)
+        )
+        for dataset in datasets:
+            author_name = None
+            author_uri = None
+            if dataset.organization:
+                author_name = dataset.organization.name
+                author_uri = dataset.organization.external_url
+            elif dataset.owner:
+                author_name = dataset.owner.fullname
+                author_uri = dataset.owner.external_url
+            feed.add_item(
+                dataset.title,
+                unique_id=dataset.id,
+                description=dataset.description,
+                content=md(dataset.description),
+                author_name=author_name,
+                author_link=author_uri,
+                link=dataset.external_url,
+                updateddate=dataset.last_modified,
+                pubdate=dataset.created_at,
+            )
+        response = make_response(feed.writeString("utf-8"))
+        response.headers["Content-Type"] = "application/atom+xml"
+        return response
+
+
 @ns.route("/<dataset:dataset>/", endpoint="dataset", doc=common_doc)
 @api.response(404, "Dataset not found")
 @api.response(410, "Dataset has been deleted")

udata/core/post/api.py

@@ -1,4 +1,8 @@
 from datetime import datetime
+from typing import List
+
+from feedgenerator.django.utils.feedgenerator import Atom1Feed
+from flask import make_response, request
 
 from udata.api import API, api, fields
 from udata.auth import Permission as AdminPermission
@@ -11,6 +15,8 @@ from udata.core.storages.api import (
     uploaded_image_fields,
 )
 from udata.core.user.api_fields import user_ref_fields
+from udata.frontend.markdown import md
+from udata.i18n import gettext as _
 
 from .forms import PostForm
 from .models import Post
@@ -105,6 +111,34 @@ class PostsAPI(API):
         return form.save(), 201
 
 
+@ns.route("/recent.atom", endpoint="recent_posts_atom_feed")
+class PostsAtomFeedAPI(API):
+    @api.doc("recent_posts_atom_feed")
+    def get(self):
+        feed = Atom1Feed(
+            _("Latests posts"),
+            description=None,
+            feed_url=request.url,
+            link=request.url_root,
+        )
+
+        posts: List[Post] = Post.objects().published().order_by("-published").limit(15)
+        for post in posts:
+            feed.add_item(
+                post.name,
+                unique_id=post.id,
+                description=post.headline,
+                content=md(post.content),
+                author_name="data.gouv.fr",
+                link=post.external_url,
+                updateddate=post.last_modified,
+                pubdate=post.published,
+            )
+        response = make_response(feed.writeString("utf-8"))
+        response.headers["Content-Type"] = "application/atom+xml"
+        return response
+
+
 @ns.route("/<post:post>/", endpoint="post")
 @api.response(404, "Object not found")
 @api.param("post", "The post ID or slug")

udata/core/reuse/api.py

@@ -1,8 +1,10 @@
 from datetime import datetime
+from typing import List
 
 import mongoengine
 from bson.objectid import ObjectId
-from flask import request
+from feedgenerator.django.utils.feedgenerator import Atom1Feed
+from flask import make_response, request
 from flask_login import current_user
 
 from udata.api import API, api, errors
@@ -20,6 +22,8 @@ from udata.core.storages.api import (
     parse_uploaded_image,
     uploaded_image_fields,
 )
+from udata.frontend.markdown import md
+from udata.i18n import gettext as _
 from udata.models import Dataset
 from udata.utils import id_or_404
 
@@ -130,6 +134,43 @@ class ReuseListAPI(API):
         return patch_and_save(reuse, request), 201
 
 
+@ns.route("/recent.atom", endpoint="recent_reuses_atom_feed")
+class ReusesAtomFeedAPI(API):
+    @api.doc("recent_reuses_atom_feed")
+    def get(self):
+        feed = Atom1Feed(
+            _("Latests reuses"),
+            description=None,
+            feed_url=request.url,
+            link=request.url_root,
+        )
+
+        reuses: List[Reuse] = Reuse.objects.visible().order_by("-created_at").limit(15)
+        for reuse in reuses:
+            author_name = None
+            author_uri = None
+            if reuse.organization:
+                author_name = reuse.organization.name
+                author_uri = reuse.organization.external_url
+            elif reuse.owner:
+                author_name = reuse.owner.fullname
+                author_uri = reuse.owner.external_url
+            feed.add_item(
+                reuse.title,
+                unique_id=reuse.id,
+                description=reuse.description,
+                content=md(reuse.description),
+                author_name=author_name,
+                author_link=author_uri,
+                link=reuse.external_url,
+                updateddate=reuse.last_modified,
+                pubdate=reuse.created_at,
+            )
+        response = make_response(feed.writeString("utf-8"))
+        response.headers["Content-Type"] = "application/atom+xml"
+        return response
+
+
 @ns.route("/<reuse:reuse>/", endpoint="reuse", doc=common_doc)
 @api.response(404, "Reuse not found")
 @api.response(410, "Reuse has been deleted")

udata/core/topic/activities.py

@@ -0,0 +1,36 @@
+from flask_security import current_user
+
+from udata.i18n import lazy_gettext as _
+from udata.models import Activity, Topic, db
+
+__all__ = ("UserCreatedTopic", "UserUpdatedTopic", "TopicRelatedActivity")
+
+
+class TopicRelatedActivity(object):
+    related_to = db.ReferenceField("Topic")
+
+
+class UserCreatedTopic(TopicRelatedActivity, Activity):
+    key = "topic:created"
+    icon = "fa fa-plus"
+    badge_type = "success"
+    label = _("created a topic")
+
+
+class UserUpdatedTopic(TopicRelatedActivity, Activity):
+    key = "topic:updated"
+    icon = "fa fa-pencil"
+    label = _("updated a topic")
+
+
+@Topic.on_create.connect
+def on_user_created_topic(topic):
+    if current_user and current_user.is_authenticated:
+        UserCreatedTopic.emit(topic, topic.organization)
+
+
+@Topic.on_update.connect
+def on_user_updated_topic(topic, **kwargs):
+    changed_fields = kwargs.get("changed_fields", [])
+    if current_user and current_user.is_authenticated:
+        UserUpdatedTopic.emit(topic, topic.organization, changed_fields)

udata/core/topic/models.py

@@ -1,6 +1,9 @@
+from blinker import Signal
 from flask import url_for
-from mongoengine.signals import pre_save
+from mongoengine.signals import post_save, pre_save
 
+from udata.api_fields import field
+from udata.core.activity.models import Auditable
 from udata.core.owned import Owned, OwnedQuerySet
 from udata.models import SpatialCoverage, db
 from udata.search import reindex
@@ -8,24 +11,24 @@ from udata.search import reindex
 __all__ = ("Topic",)
 
 
-class Topic(db.Document, Owned, db.Datetimed):
-    name = db.StringField(required=True)
-    slug = db.SlugField(
-        max_length=255, required=True, populate_from="name", update=True, follow=True
+class Topic(db.Datetimed, Auditable, db.Document, Owned):
+    name = field(db.StringField(required=True))
+    slug = field(
+        db.SlugField(max_length=255, required=True, populate_from="name", update=True, follow=True),
+        auditable=False,
     )
-    description = db.StringField()
-    tags = db.ListField(db.StringField())
-    color = db.IntField()
+    description = field(db.StringField())
+    tags = field(db.ListField(db.StringField()))
+    color = field(db.IntField())
 
-    tags = db.ListField(db.StringField())
-    datasets = db.ListField(db.LazyReferenceField("Dataset", reverse_delete_rule=db.PULL))
-    reuses = db.ListField(db.LazyReferenceField("Reuse", reverse_delete_rule=db.PULL))
+    datasets = field(db.ListField(db.LazyReferenceField("Dataset", reverse_delete_rule=db.PULL)))
+    reuses = field(db.ListField(db.LazyReferenceField("Reuse", reverse_delete_rule=db.PULL)))
 
-    featured = db.BooleanField(default=False)
-    private = db.BooleanField()
-    extras = db.ExtrasField()
+    featured = field(db.BooleanField(default=False), auditable=False)
+    private = field(db.BooleanField())
+    extras = field(db.ExtrasField(), auditable=False)
 
-    spatial = db.EmbeddedDocumentField(SpatialCoverage)
+    spatial = field(db.EmbeddedDocumentField(SpatialCoverage))
 
     meta = {
         "indexes": ["$name", "created_at", "slug"] + Owned.meta["indexes"],
@@ -34,6 +37,10 @@ class Topic(db.Document, Owned, db.Datetimed):
         "queryset_class": OwnedQuerySet,
     }
 
+    after_save = Signal()
+    on_create = Signal()
+    on_update = Signal()
+
     def __str__(self):
         return self.name
 
@@ -60,3 +67,4 @@ class Topic(db.Document, Owned, db.Datetimed):
 
 
 pre_save.connect(Topic.pre_save, sender=Topic)
+post_save.connect(Topic.post_save, sender=Topic)