udata 10.4.1.dev35211__py2.py3-none-any.whl → 10.4.2__py2.py3-none-any.whl

udata/core/dataset/rdf.py

@@ -769,7 +769,7 @@ def dataset_from_rdf(graph: Graph, dataset=None, node=None, remote_url_prefix: s
     # Support dct:abstract if dct:description is missing (sometimes used instead)
     description = d.value(DCT.description) or d.value(DCT.abstract)
     dataset.description = sanitize_html(description)
-    dataset.frequency = frequency_from_rdf(d.value(DCT.accrualPeriodicity))
+    dataset.frequency = frequency_from_rdf(d.value(DCT.accrualPeriodicity)) or dataset.frequency
     roles = [  # Imbricated list of contact points for each role
         contact_points_from_rdf(d, rdf_entity, role, dataset)
         for rdf_entity, role in CONTACT_POINT_ENTITY_TO_ROLE.items()

udata/core/metrics/commands.py

@@ -60,6 +60,7 @@ def update(
             site.count_max_org_followers()
             site.count_max_org_reuses()
             site.count_max_org_datasets()
+            site.count_stock_metrics()
         except Exception as e:
             log.info(f"Error during update: {e}")
 

udata/core/metrics/helpers.py

@@ -0,0 +1,102 @@
+import logging
+from collections import OrderedDict
+from datetime import datetime, timedelta
+from typing import Dict, List, Union
+
+import requests
+from bson import ObjectId
+from dateutil.rrule import MONTHLY, rrule
+from flask import current_app
+from mongoengine import QuerySet
+from pymongo.command_cursor import CommandCursor
+
+log = logging.getLogger(__name__)
+
+
+def get_last_13_months() -> List[str]:
+    dstart = datetime.today().replace(day=1) - timedelta(days=365)
+    months = rrule(freq=MONTHLY, count=13, dtstart=dstart)
+    return [month.strftime("%Y-%m") for month in months]
+
+
+def compute_monthly_metrics(metrics_data: List[Dict], metrics_labels: List[str]) -> OrderedDict:
+    # Initialize default monthly_metrics
+    monthly_metrics = OrderedDict(
+        (month, {label: 0 for label in metrics_labels}) for month in get_last_13_months()
+    )
+    # Update monthly_metrics with metrics_data values
+    for entry in metrics_data:
+        entry_month = entry["metric_month"]
+        if entry_month in monthly_metrics:
+            for metric_label in metrics_labels:
+                label = f"monthly_{metric_label}"
+                monthly_metrics[entry_month][metric_label] = entry.get(label) or 0
+    return monthly_metrics
+
+
+def metrics_by_label(monthly_metrics: Dict, metrics_labels: List[str]) -> List[OrderedDict]:
+    metrics_by_label = []
+    for label in metrics_labels:
+        metrics_by_label.append(
+            OrderedDict((month, monthly_metrics[month][label]) for month in monthly_metrics)
+        )
+    return metrics_by_label
+
+
+def get_metrics_for_model(
+    model: str, id: Union[str, ObjectId, None], metrics_labels: List[str]
+) -> List[OrderedDict]:
+    """
+    Get distant metrics for a particular model object
+    """
+    if not current_app.config["METRICS_API"]:
+        # TODO: How to best deal with no METRICS_API, prevent calling or return empty?
+        # raise ValueError("missing config METRICS_API to use this function")
+        return [{} for _ in range(len(metrics_labels))]
+    models = model + "s" if id else model  # TODO: not clean of a hack
+    model_metrics_api = f"{current_app.config['METRICS_API']}/{models}/data/"
+    try:
+        params = {"metric_month__sort": "desc"}
+        if id:
+            params[f"{model}_id__exact"] = id
+        res = requests.get(model_metrics_api, params)
+        res.raise_for_status()
+        monthly_metrics = compute_monthly_metrics(res.json()["data"], metrics_labels)
+        return metrics_by_label(monthly_metrics, metrics_labels)
+    except requests.exceptions.RequestException as e:
+        log.exception(f"Error while getting metrics for {model}({id}): {e}")
+        return [{} for _ in range(len(metrics_labels))]
+
+
+def compute_monthly_aggregated_metrics(aggregation_res: CommandCursor) -> OrderedDict:
+    monthly_metrics = OrderedDict((month, 0) for month in get_last_13_months())
+    for monthly_count in aggregation_res:
+        year, month = monthly_count["_id"].split("-")
+        monthly_label = year + "-" + month.zfill(2)
+        if monthly_label in monthly_metrics:
+            monthly_metrics[monthly_label] = monthly_count["count"]
+    return monthly_metrics
+
+
+def get_stock_metrics(objects: QuerySet, date_label: str = "created_at") -> OrderedDict:
+    """
+    Get stock metrics for a particular model object
+    """
+    pipeline = [
+        {"$match": {date_label: {"$gte": datetime.now() - timedelta(days=365)}}},
+        {
+            "$group": {
+                "_id": {
+                    "$concat": [
+                        {"$substr": [{"$year": f"${date_label}"}, 0, 4]},
+                        "-",
+                        {"$substr": [{"$month": f"${date_label}"}, 0, 12]},
+                    ]
+                },
+                "count": {"$sum": 1},
+            }
+        },
+    ]
+    aggregation_res = objects.aggregate(*pipeline)
+
+    return compute_monthly_aggregated_metrics(aggregation_res)

udata/core/metrics/models.py

@@ -8,6 +8,7 @@ class WithMetrics(object):
     metrics = field(
         db.DictField(),
         readonly=True,
+        auditable=False,
     )
 
     __metrics_keys__ = []

udata/core/metrics/tasks.py

@@ -24,5 +24,6 @@ def compute_site_metrics(self):
     site.count_max_org_followers()
     site.count_max_org_reuses()
     site.count_max_org_datasets()
+    site.count_stock_metrics()
     # Sending signal
     on_site_metrics_computed.send(site)

udata/core/organization/activities.py

@@ -32,6 +32,7 @@ def on_user_created_organization(organization):
 
 
 @Organization.on_update.connect
-def on_user_updated_organization(organization):
+def on_user_updated_organization(organization, **kwargs):
+    changed_fields = kwargs.get("changed_fields", [])
     if current_user and current_user.is_authenticated:
-        UserUpdatedOrganization.emit(organization, organization)
+        UserUpdatedOrganization.emit(organization, organization, changed_fields)

udata/core/organization/api.py

@@ -12,6 +12,7 @@ from udata.core.badges import api as badges_api
 from udata.core.badges.fields import badge_fields
 from udata.core.contact_point.api import ContactPointApiParser
 from udata.core.contact_point.api_fields import contact_point_page_fields
+from udata.core.dataservices.csv import DataserviceCsvAdapter
 from udata.core.dataservices.models import Dataservice
 from udata.core.dataset.api import DatasetApiParser
 from udata.core.dataset.api_fields import dataset_page_fields
@@ -178,6 +179,16 @@ class DatasetsCsvAPI(API):
         return csv.stream(adapter, "{0}-datasets".format(org.slug))
 
 
+@ns.route("/<org:org>/dataservices.csv", endpoint="organization_dataservices_csv")
+@api.response(404, "Organization not found")
+@api.response(410, "Organization has been deleted")
+class DataservicesCsv(API):
+    def get(self, org):
+        dataservices = Dataservice.objects(organization=str(org.id)).visible()
+        adapter = DataserviceCsvAdapter(dataservices)
+        return csv.stream(adapter, "{0}-dataservices".format(org.slug))
+
+
 @ns.route("/<org:org>/discussions.csv", endpoint="organization_discussions_csv", doc=common_doc)
 @api.response(404, "Organization not found")
 @api.response(410, "Organization has been deleted")

udata/core/organization/api_fields.py

@@ -42,9 +42,6 @@ org_ref_fields = api.inherit(
     },
 )
 
-# This import is not at the top of the file to avoid circular imports
-from udata.core.user.api_fields import user_ref_fields  # noqa
-
 
 def check_can_access_user_private_info():
     # This endpoint is secure, only organization member has access.
@@ -64,14 +61,18 @@ def check_can_access_user_private_info():
 def member_email_with_visibility_check(email):
     if current_user_is_admin_or_self():
         return email
+    name, domain = email.split("@")
     if check_can_access_user_private_info():
         # Obfuscate email partially for other members
-        name, domain = email.split("@")
         name = name[:2] + "*" * (len(name) - 2)
         return f"{name}@{domain}"
-    return None
+    # Return only domain for other users
+    return f"***@{domain}"
 
 
+# This import is not at the top of the file to avoid circular imports
+from udata.core.user.api_fields import user_ref_fields  # noqa
+
 member_user_with_email_fields = api.inherit(
     "MemberUserWithEmail",
     user_ref_fields,

udata/core/organization/models.py

@@ -6,6 +6,7 @@ from mongoengine.signals import post_save, pre_save
 from werkzeug.utils import cached_property
 
 from udata.api_fields import field
+from udata.core.activity.models import Auditable
 from udata.core.badges.models import Badge, BadgeMixin, BadgesList
 from udata.core.metrics.models import WithMetrics
 from udata.core.storages import avatars, default_image_basename
@@ -110,29 +111,35 @@ class OrganizationBadgeMixin(BadgeMixin):
     __badges__ = BADGES
 
 
-class Organization(WithMetrics, OrganizationBadgeMixin, db.Datetimed, db.Document):
-    name = db.StringField(required=True)
-    acronym = db.StringField(max_length=128)
-    slug = db.SlugField(
-        max_length=255, required=True, populate_from="name", update=True, follow=True
+class Organization(Auditable, WithMetrics, OrganizationBadgeMixin, db.Datetimed, db.Document):
+    name = field(db.StringField(required=True))
+    acronym = field(db.StringField(max_length=128))
+    slug = field(
+        db.SlugField(max_length=255, required=True, populate_from="name", update=True, follow=True),
+        auditable=False,
     )
-    description = db.StringField(required=True)
-    url = db.URLField()
-    image_url = db.StringField()
-    logo = db.ImageField(
-        fs=avatars, basename=default_image_basename, max_size=LOGO_MAX_SIZE, thumbnails=LOGO_SIZES
+    description = field(db.StringField(required=True))
+    url = field(db.URLField())
+    image_url = field(db.StringField())
+    logo = field(
+        db.ImageField(
+            fs=avatars,
+            basename=default_image_basename,
+            max_size=LOGO_MAX_SIZE,
+            thumbnails=LOGO_SIZES,
+        )
     )
-    business_number_id = db.StringField(max_length=ORG_BID_SIZE_LIMIT)
+    business_number_id = field(db.StringField(max_length=ORG_BID_SIZE_LIMIT))
 
-    members = db.ListField(db.EmbeddedDocumentField(Member))
-    teams = db.ListField(db.EmbeddedDocumentField(Team))
-    requests = db.ListField(db.EmbeddedDocumentField(MembershipRequest))
+    members = field(db.ListField(db.EmbeddedDocumentField(Member)))
+    teams = field(db.ListField(db.EmbeddedDocumentField(Team)))
+    requests = field(db.ListField(db.EmbeddedDocumentField(MembershipRequest)))
 
-    ext = db.MapField(db.GenericEmbeddedDocumentField())
-    zone = db.StringField()
-    extras = db.OrganizationExtrasField()
+    ext = field(db.MapField(db.GenericEmbeddedDocumentField()))
+    zone = field(db.StringField())
+    extras = field(db.OrganizationExtrasField(), auditable=False)
 
-    deleted = db.DateTimeField()
+    deleted = field(db.DateTimeField())
 
     meta = {
         "indexes": [
@@ -168,19 +175,12 @@ class Organization(WithMetrics, OrganizationBadgeMixin, db.Datetimed, db.Documen
     on_update = Signal()
     before_delete = Signal()
     after_delete = Signal()
+    on_delete = Signal()
 
     @classmethod
     def pre_save(cls, sender, document, **kwargs):
         cls.before_save.send(document)
 
-    @classmethod
-    def post_save(cls, sender, document, **kwargs):
-        cls.after_save.send(document)
-        if kwargs.get("created"):
-            cls.on_create.send(document)
-        else:
-            cls.on_update.send(document)
-
     def url_for(self, *args, **kwargs):
         return endpoint_for("organizations.show", "api.organization", org=self, *args, **kwargs)
 
@@ -296,31 +296,31 @@ class Organization(WithMetrics, OrganizationBadgeMixin, db.Datetimed, db.Documen
 
     def count_members(self):
         self.metrics["members"] = len(self.members)
-        self.save()
+        self.save(signal_kwargs={"ignores": ["post_save"]})
 
     def count_datasets(self):
         from udata.models import Dataset
 
         self.metrics["datasets"] = Dataset.objects(organization=self).visible().count()
-        self.save()
+        self.save(signal_kwargs={"ignores": ["post_save"]})
 
     def count_reuses(self):
         from udata.models import Reuse
 
         self.metrics["reuses"] = Reuse.objects(organization=self).visible().count()
-        self.save()
+        self.save(signal_kwargs={"ignores": ["post_save"]})
 
     def count_dataservices(self):
         from udata.models import Dataservice
 
         self.metrics["dataservices"] = Dataservice.objects(organization=self).visible().count()
-        self.save()
+        self.save(signal_kwargs={"ignores": ["post_save"]})
 
     def count_followers(self):
         from udata.models import Follow
 
         self.metrics["followers"] = Follow.objects(until=None).followers(self).count()
-        self.save()
+        self.save(signal_kwargs={"ignores": ["post_save"]})
 
 
 pre_save.connect(Organization.pre_save, sender=Organization)

udata/core/owned.py

@@ -80,7 +80,7 @@ def check_organization_is_valid_for_current_user(organization, **_kwargs):
 
 class Owned(object):
     """
-    A mixin to factorize owning behvaior between users and organizations.
+    A mixin to factorize owning behavior between users and organizations.
     """
 
     owner = field(

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/activities.py

@@ -33,17 +33,18 @@ class UserDeletedReuse(ReuseRelatedActivity, Activity):
 
 @Reuse.on_create.connect
 def on_user_created_reuse(reuse):
-    if not reuse.private and current_user and current_user.is_authenticated:
+    if current_user and current_user.is_authenticated:
         UserCreatedReuse.emit(reuse, reuse.organization)
 
 
 @Reuse.on_update.connect
-def on_user_updated_reuse(reuse):
-    if not reuse.private and current_user and current_user.is_authenticated:
-        UserUpdatedReuse.emit(reuse, reuse.organization)
+def on_user_updated_reuse(reuse, **kwargs):
+    changed_fields = kwargs.get("changed_fields", [])
+    if current_user and current_user.is_authenticated:
+        UserUpdatedReuse.emit(reuse, reuse.organization, changed_fields)
 
 
 @Reuse.on_delete.connect
 def on_user_deleted_reuse(reuse):
-    if not reuse.private and current_user and current_user.is_authenticated:
+    if current_user and current_user.is_authenticated:
         UserDeletedReuse.emit(reuse, reuse.organization)

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/reuse/models.py

@@ -3,6 +3,7 @@ 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.activity.models import Auditable
 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
@@ -60,7 +61,7 @@ class ReuseBadgeMixin(BadgeMixin):
     additional_filters={"organization_badge": "organization.badges"},
     mask="*,datasets{id,title,uri,page}",
 )
-class Reuse(db.Datetimed, WithMetrics, ReuseBadgeMixin, Owned, db.Document):
+class Reuse(db.Datetimed, Auditable, WithMetrics, ReuseBadgeMixin, Owned, db.Document):
     title = field(
         db.StringField(required=True),
         sortable=True,
@@ -71,6 +72,7 @@ class Reuse(db.Datetimed, WithMetrics, ReuseBadgeMixin, Owned, db.Document):
             max_length=255, required=True, populate_from="title", update=True, follow=True
         ),
         readonly=True,
+        auditable=False,
     )
     description = field(
         db.StringField(required=True),
@@ -126,15 +128,17 @@ class Reuse(db.Datetimed, WithMetrics, ReuseBadgeMixin, Owned, db.Document):
     private = field(db.BooleanField(default=False), filterable={})
 
     ext = db.MapField(db.GenericEmbeddedDocumentField())
-    extras = field(db.ExtrasField())
+    extras = field(db.ExtrasField(), auditable=False)
 
     featured = field(
         db.BooleanField(),
         filterable={},
         readonly=True,
+        auditable=False,
     )
     deleted = field(
         db.DateTimeField(),
+        auditable=False,
     )
     archived = field(
         db.DateTimeField(),
@@ -181,18 +185,6 @@ class Reuse(db.Datetimed, WithMetrics, ReuseBadgeMixin, Owned, db.Document):
         # Emit before_save
         cls.before_save.send(document)
 
-    @classmethod
-    def post_save(cls, sender, document, **kwargs):
-        if "post_save" in kwargs.get("ignores", []):
-            return
-        cls.after_save.send(document)
-        if kwargs.get("created"):
-            cls.on_create.send(document)
-        else:
-            cls.on_update.send(document)
-        if document.deleted:
-            cls.on_delete.send(document)
-
     def url_for(self, *args, **kwargs):
         return endpoint_for("reuses.show", "api.reuse", reuse=self, *args, **kwargs)
 
@@ -289,13 +281,13 @@ class Reuse(db.Datetimed, WithMetrics, ReuseBadgeMixin, Owned, db.Document):
         from udata.models import Discussion
 
         self.metrics["discussions"] = Discussion.objects(subject=self, closed=None).count()
-        self.save()
+        self.save(signal_kwargs={"ignores": ["post_save"]})
 
     def count_followers(self):
         from udata.models import Follow
 
         self.metrics["followers"] = Follow.objects(until=None).followers(self).count()
-        self.save()
+        self.save(signal_kwargs={"ignores": ["post_save"]})
 
 
 pre_save.connect(Reuse.pre_save, sender=Reuse)

udata/core/site/models.py

@@ -3,6 +3,7 @@ from werkzeug.local import LocalProxy
 
 from udata.core.dataservices.models import Dataservice
 from udata.core.dataset.models import Dataset
+from udata.core.metrics.helpers import get_metrics_for_model, get_stock_metrics
 from udata.core.organization.models import Organization
 from udata.core.reuse.models import Reuse
 from udata.models import WithMetrics, db
@@ -36,15 +37,23 @@ class Site(WithMetrics, db.Document):
         "max_org_reuses",
         "max_org_datasets",
         "datasets",
+        "datasets_visits_by_months",
         "discussions",
         "followers",
         "organizations",
         "public-service",
         "resources",
+        "resources_downloads_by_months",
         "reuses",
         "dataservices",
         "users",
         "harvesters",
+        "users_by_months",
+        "datasets_by_months",
+        "harvesters_by_months",
+        "reuses_by_months",
+        "organizations_by_months",
+        "discussions_by_months",
     ]
 
     def __str__(self):
@@ -72,6 +81,9 @@ class Site(WithMetrics, db.Document):
         from udata.models import Dataset
 
         self.metrics["datasets"] = Dataset.objects.visible().count()
+        self.metrics["datasets_visits_by_months"] = get_metrics_for_model(
+            "site", None, ["visit_dataset"]
+        )[0]
         self.save()
 
     def count_resources(self):
@@ -83,6 +95,9 @@ class Site(WithMetrics, db.Document):
             ),
             {},
         ).get("count", 0)
+        self.metrics["resources_downloads_by_months"] = get_metrics_for_model(
+            "site", None, ["download_resource"]
+        )[0]
         self.save()
 
     def count_reuses(self):
@@ -172,6 +187,24 @@ class Site(WithMetrics, db.Document):
         self.metrics["max_org_datasets"] = org.metrics["datasets"] if org else 0
         self.save()
 
+    def count_stock_metrics(self):
+        from udata.harvest.models import HarvestSource
+        from udata.models import Discussion, User
+
+        self.metrics["users_by_months"] = get_stock_metrics(User.objects())
+        self.metrics["datasets_by_months"] = get_stock_metrics(
+            Dataset.objects().visible(), date_label="created_at_internal"
+        )
+        self.metrics["harvesters_by_months"] = get_stock_metrics(HarvestSource.objects())
+        self.metrics["reuses_by_months"] = get_stock_metrics(Reuse.objects().visible())
+        self.metrics["organizations_by_months"] = get_stock_metrics(
+            Organization.objects().visible()
+        )
+        self.metrics["discussions_by_months"] = get_stock_metrics(
+            Discussion.objects(), date_label="created"
+        )
+        self.save()
+
 
 def get_current_site():
     if getattr(g, "site", None) is None:

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)