udata 10.4.2.dev35274__py2.py3-none-any.whl → 10.4.2.dev35386__py2.py3-none-any.whl

udata/core/activity/__init__.py

@@ -6,6 +6,7 @@ log = logging.getLogger(__name__)
 def init_app(app):
     # Load all core actvitiess
     import udata.core.user.activities  # noqa
+    import udata.core.dataservices.activities  # noqa
     import udata.core.dataset.activities  # noqa
     import udata.core.reuse.activities  # noqa
     import udata.core.organization.activities  # noqa

udata/core/activity/api.py

@@ -4,6 +4,7 @@ from bson import ObjectId
 from mongoengine.errors import DoesNotExist
 
 from udata.api import API, api, fields
+from udata.auth import current_user
 from udata.core.organization.api_fields import org_ref_fields
 from udata.core.user.api_fields import user_ref_fields
 from udata.models import Activity, db
@@ -46,6 +47,7 @@ activity_fields = api.model(
         "label": fields.String(description="The label of the activity", required=True),
         "key": fields.String(description="The key of the activity", required=True),
         "icon": fields.String(description="The icon of the activity", required=True),
+        "changes": fields.List(fields.String, description="Changed attributes as list"),
         "extras": fields.Raw(description="Extras attributes as key-value pairs"),
     },
 )
@@ -76,7 +78,7 @@ class SiteActivityAPI(API):
     @api.expect(activity_parser)
     @api.marshal_with(activity_page_fields)
     def get(self):
-        """Fetch site activity, optionally filtered by user of org."""
+        """Fetch site activity, optionally filtered by user or org."""
         args = activity_parser.parse_args()
         qs = Activity.objects
 
@@ -95,10 +97,11 @@ class SiteActivityAPI(API):
         qs = qs.order_by("-created_at")
         qs = qs.paginate(args["page"], args["page_size"])
 
-        # Filter out DBRefs
+        # - Filter out DBRefs
         # Always return a result even not complete
         # But log the error (ie. visible in sentry, silent for user)
         # Can happen when someone manually delete an object in DB (ie. without proper purge)
+        # - Filter out private items (except for sysadmin users)
         safe_items = []
         for item in qs.queryset.items:
             try:
@@ -106,6 +109,11 @@ class SiteActivityAPI(API):
             except DoesNotExist as e:
                 log.error(e, exc_info=True)
             else:
+                if hasattr(item.related_to, "private") and (
+                    current_user.is_anonymous or not current_user.sysadmin
+                ):
+                    if item.related_to.private:
+                        continue
                 safe_items.append(item)
         qs.queryset.items = safe_items
 

udata/core/activity/models.py

@@ -3,6 +3,7 @@ from datetime import datetime
 from blinker import Signal
 from mongoengine.signals import post_save
 
+from udata.api_fields import get_fields
 from udata.auth import current_user
 from udata.mongo import db
 
@@ -36,6 +37,7 @@ class Activity(db.Document, metaclass=EmitNewActivityMetaClass):
     organization = db.ReferenceField("Organization")
     related_to = db.ReferenceField(db.DomainModel, required=True)
     created_at = db.DateTimeField(default=datetime.utcnow, required=True)
+    changes = db.ListField(db.StringField())
 
     extras = db.ExtrasField()
 
@@ -65,11 +67,36 @@ class Activity(db.Document, metaclass=EmitNewActivityMetaClass):
         return cls.on_new.connect(func, sender=cls)
 
     @classmethod
-    def emit(cls, related_to, organization=None, extras=None):
+    def emit(cls, related_to, organization=None, changed_fields=None, extras=None):
         new_activity.send(
             cls,
             related_to=related_to,
             actor=current_user._get_current_object(),
             organization=organization,
+            changes=changed_fields,
             extras=extras,
         )
+
+
+class Auditable(object):
+    @classmethod
+    def post_save(cls, sender, document, **kwargs):
+        try:
+            auditable_fields = [
+                key for key, field, info in get_fields(cls) if info.get("auditable", True)
+            ]
+        except Exception:
+            # for backward compatibility, all fields are treated as auditable for classes not using field() function
+            auditable_fields = document._get_changed_fields()
+        changed_fields = [
+            field for field in document._get_changed_fields() if field in auditable_fields
+        ]
+        if "post_save" in kwargs.get("ignores", []):
+            return
+        cls.after_save.send(document)
+        if kwargs.get("created"):
+            cls.on_create.send(document)
+        elif len(changed_fields):
+            cls.on_update.send(document, changed_fields=changed_fields)
+        if getattr(document, "deleted_at", None) or getattr(document, "deleted", None):
+            cls.on_delete.send(document)

udata/core/activity/tasks.py

@@ -1,4 +1,5 @@
 import logging
+from collections.abc import Iterable
 
 from udata.models import Organization, User, db
 from udata.tasks import task
@@ -9,28 +10,36 @@ log = logging.getLogger(__name__)
 
 
 @new_activity.connect
-def delay_activity(cls, related_to, actor, organization=None, extras=None):
+def delay_activity(cls, related_to, actor, organization=None, changes=None, extras=None):
     emit_activity.delay(
         cls.__name__,
         str(actor.id),
         related_to_cls=related_to.__class__.__name__,
         related_to_id=str(related_to.id),
         organization_id=str(organization.id) if organization else None,
+        changes=changes,
         extras=extras,
     )
 
 
 @task
 def emit_activity(
-    classname, actor_id, related_to_cls, related_to_id, organization_id=None, extras=None
+    classname,
+    actor_id,
+    related_to_cls,
+    related_to_id,
+    organization_id=None,
+    changes=None,
+    extras=None,
 ):
     log.debug(
-        "Emit new activity: %s %s %s %s %s %s",
+        "Emit new activity: %s %s %s %s %s %s %s",
         classname,
         actor_id,
         related_to_cls,
         related_to_id,
         organization_id,
+        ", ".join(changes) if changes and isinstance(changes, Iterable) else "",
         extras,
     )
     cls = db.resolve_model(classname)
@@ -40,4 +49,10 @@ def emit_activity(
         organization = Organization.objects.get(pk=organization_id)
     else:
         organization = None
-    cls.objects.create(actor=actor, related_to=related_to, organization=organization, extras=extras)
+    cls.objects.create(
+        actor=actor,
+        related_to=related_to,
+        organization=organization,
+        changes=changes,
+        extras=extras,
+    )

udata/core/dataservices/activities.py

@@ -0,0 +1,53 @@
+from udata.auth import current_user
+from udata.i18n import lazy_gettext as _
+from udata.models import Activity, Dataservice, db
+
+__all__ = (
+    "UserCreatedDataservice",
+    "UserUpdatedDataservice",
+    "UserDeletedDataservice",
+    "DataserviceRelatedActivity",
+)
+
+
+class DataserviceRelatedActivity(object):
+    related_to = db.ReferenceField("Dataservice")
+
+
+class UserCreatedDataservice(DataserviceRelatedActivity, Activity):
+    key = "dataservice:created"
+    icon = "fa fa-plus"
+    badge_type = "success"
+    label = _("created a dataservice")
+
+
+class UserUpdatedDataservice(DataserviceRelatedActivity, Activity):
+    key = "dataservice:updated"
+    icon = "fa fa-pencil"
+    label = _("updated a dataservice")
+
+
+class UserDeletedDataservice(DataserviceRelatedActivity, Activity):
+    key = "dataservice:deleted"
+    icon = "fa fa-remove"
+    badge_type = "error"
+    label = _("deleted a dataservice")
+
+
+@Dataservice.on_create.connect
+def on_user_created_dataservice(dataservice):
+    if current_user and current_user.is_authenticated:
+        UserCreatedDataservice.emit(dataservice, dataservice.organization)
+
+
+@Dataservice.on_update.connect
+def on_user_updated_dataservice(dataservice, **kwargs):
+    changed_fields = kwargs.get("changed_fields", [])
+    if current_user and current_user.is_authenticated:
+        UserUpdatedDataservice.emit(dataservice, dataservice.organization, changed_fields)
+
+
+@Dataservice.on_delete.connect
+def on_user_deleted_dataservice(dataservice):
+    if current_user and current_user.is_authenticated:
+        UserDeletedDataservice.emit(dataservice, dataservice.organization)

udata/core/dataservices/models.py

@@ -8,6 +8,7 @@ from mongoengine.signals import post_save
 import udata.core.contact_point.api_fields as contact_api_fields
 import udata.core.dataset.api_fields as datasets_api_fields
 from udata.api_fields import field, function_field, generate_fields
+from udata.core.activity.models import Auditable
 from udata.core.dataservices.constants import DATASERVICE_ACCESS_TYPES, DATASERVICE_FORMATS
 from udata.core.dataset.models import Dataset
 from udata.core.metrics.models import WithMetrics
@@ -105,7 +106,7 @@ class HarvestMetadata(db.EmbeddedDocument):
         {"key": "views", "value": "metrics.views"},
     ],
 )
-class Dataservice(WithMetrics, Owned, db.Document):
+class Dataservice(Auditable, WithMetrics, Owned, db.Document):
     meta = {
         "indexes": [
             "$title",
@@ -117,6 +118,11 @@ class Dataservice(WithMetrics, Owned, db.Document):
         "auto_create_index_on_save": True,
     }
 
+    after_save = Signal()
+    on_create = Signal()
+    on_update = Signal()
+    on_delete = Signal()
+
     verbose_name = _("dataservice")
 
     def __str__(self):
@@ -175,7 +181,10 @@ class Dataservice(WithMetrics, Owned, db.Document):
         description="Is the dataservice private to the owner or the organization",
     )
 
-    extras = field(db.ExtrasField())
+    extras = field(
+        db.ExtrasField(),
+        auditable=False,
+    )
 
     contact_points = field(
         db.ListField(
@@ -201,8 +210,9 @@ class Dataservice(WithMetrics, Owned, db.Document):
         ),
         readonly=True,
         sortable="last_modified",
+        auditable=False,
     )
-    deleted_at = field(db.DateTimeField())
+    deleted_at = field(db.DateTimeField(), auditable=False)
     archived_at = field(db.DateTimeField())
 
     datasets = field(
@@ -223,6 +233,7 @@ class Dataservice(WithMetrics, Owned, db.Document):
     harvest = field(
         db.EmbeddedDocumentField(HarvestMetadata),
         readonly=True,
+        auditable=False,
     )
 
     def url_for(self, *args, **kwargs):
@@ -250,26 +261,11 @@ class Dataservice(WithMetrics, Owned, db.Document):
 
     def count_discussions(self):
         self.metrics["discussions"] = Discussion.objects(subject=self, closed=None).count()
-        self.save()
+        self.save(signal_kwargs={"ignores": ["post_save"]})
 
     def count_followers(self):
         self.metrics["followers"] = Follow.objects(until=None).followers(self).count()
-        self.save()
-
-    on_create = Signal()
-    on_update = Signal()
-    on_delete = Signal()
-
-    @classmethod
-    def post_save(cls, sender, document, **kwargs):
-        if "post_save" in kwargs.get("ignores", []):
-            return
-        if kwargs.get("created"):
-            cls.on_create.send(document)
-        else:
-            cls.on_update.send(document)
-        if document.deleted_at:
-            cls.on_delete.send(document)
+        self.save(signal_kwargs={"ignores": ["post_save"]})
 
 
 post_save.connect(Dataservice.post_save, sender=Dataservice)

udata/core/dataset/activities.py

@@ -35,19 +35,66 @@ class UserDeletedDataset(DatasetRelatedActivity, Activity):
     label = _("deleted a dataset")
 
 
+class UserAddedResourceToDataset(DatasetRelatedActivity, Activity):
+    key = "dataset:resource:added"
+    icon = "fa fa-plus"
+    label = _("added a resource to a dataset")
+
+
+class UserUpdatedResource(DatasetRelatedActivity, Activity):
+    key = "dataset:resource:updated"
+    icon = "fa fa-pencil"
+    label = _("updated a resource")
+
+
+class UserRemovedResourceFromDataset(DatasetRelatedActivity, Activity):
+    key = "dataset:resource:deleted"
+    icon = "fa fa-remove"
+    label = _("removed a resource from a dataset")
+
+
+@Dataset.on_resource_added.connect
+def on_user_added_resource_to_dataset(sender, document, **kwargs):
+    if current_user and current_user.is_authenticated:
+        UserAddedResourceToDataset.emit(
+            document, document.organization, None, {"resource_id": str(kwargs["resource_id"])}
+        )
+
+
+@Dataset.on_resource_updated.connect
+def on_user_updated_resource(sender, document, **kwargs):
+    changed_fields = kwargs.get("changed_fields", [])
+    if current_user and current_user.is_authenticated:
+        UserUpdatedResource.emit(
+            document,
+            document.organization,
+            changed_fields,
+            {"resource_id": str(kwargs["resource_id"])},
+        )
+
+
+@Dataset.on_resource_removed.connect
+def on_user_removed_resource_from_dataset(sender, document, **kwargs):
+    if current_user and current_user.is_authenticated:
+        UserRemovedResourceFromDataset.emit(
+            document, document.organization, None, {"resource_id": str(kwargs["resource_id"])}
+        )
+
+
 @Dataset.on_create.connect
 def on_user_created_dataset(dataset):
-    if not dataset.private and current_user and current_user.is_authenticated:
+    if current_user and current_user.is_authenticated:
         UserCreatedDataset.emit(dataset, dataset.organization)
 
 
 @Dataset.on_update.connect
-def on_user_updated_dataset(dataset):
-    if not dataset.private and current_user and current_user.is_authenticated:
-        UserUpdatedDataset.emit(dataset, dataset.organization)
+def on_user_updated_dataset(dataset, **kwargs):
+    changed_fields = kwargs.get("changed_fields", [])
+    if current_user and current_user.is_authenticated:
+        UserUpdatedDataset.emit(dataset, dataset.organization, changed_fields)
 
 
 @Dataset.on_delete.connect
 def on_user_deleted_dataset(dataset):
-    if not dataset.private and current_user and current_user.is_authenticated:
+    if current_user and current_user.is_authenticated:
         UserDeletedDataset.emit(dataset, dataset.organization)

udata/core/dataset/models.py

@@ -19,6 +19,7 @@ from werkzeug.utils import cached_property
 from udata.api_fields import field
 from udata.app import cache
 from udata.core import storages
+from udata.core.activity.models import Auditable
 from udata.core.owned import Owned, OwnedQuerySet
 from udata.frontend.markdown import mdstrip
 from udata.i18n import lazy_gettext as _
@@ -540,45 +541,57 @@ class DatasetBadgeMixin(BadgeMixin):
     __badges__ = BADGES
 
 
-class Dataset(WithMetrics, DatasetBadgeMixin, Owned, db.Document):
-    title = db.StringField(required=True)
-    acronym = db.StringField(max_length=128)
+class Dataset(Auditable, WithMetrics, DatasetBadgeMixin, Owned, db.Document):
+    title = field(db.StringField(required=True))
+    acronym = field(db.StringField(max_length=128))
     # /!\ do not set directly the slug when creating or updating a dataset
     # this will break the search indexation
-    slug = db.SlugField(
-        max_length=255, required=True, populate_from="title", update=True, follow=True
+    slug = field(
+        db.SlugField(
+            max_length=255, required=True, populate_from="title", update=True, follow=True
+        ),
+        auditable=False,
     )
-    description = db.StringField(required=True, default="")
-    license = db.ReferenceField("License")
+    description = field(db.StringField(required=True, default=""))
+    license = field(db.ReferenceField("License"))
 
-    tags = db.TagListField()
-    resources = db.ListField(db.EmbeddedDocumentField(Resource))
+    tags = field(db.TagListField())
+    resources = field(db.ListField(db.EmbeddedDocumentField(Resource)), auditable=False)
 
-    private = db.BooleanField(default=False)
-    frequency = db.StringField(choices=list(UPDATE_FREQUENCIES.keys()))
-    frequency_date = db.DateTimeField(verbose_name=_("Future date of update"))
-    temporal_coverage = db.EmbeddedDocumentField(db.DateRange)
-    spatial = db.EmbeddedDocumentField(SpatialCoverage)
-    schema = db.EmbeddedDocumentField(Schema)
+    private = field(db.BooleanField(default=False))
+    frequency = field(db.StringField(choices=list(UPDATE_FREQUENCIES.keys())))
+    frequency_date = field(db.DateTimeField(verbose_name=_("Future date of update")))
+    temporal_coverage = field(db.EmbeddedDocumentField(db.DateRange))
+    spatial = field(db.EmbeddedDocumentField(SpatialCoverage))
+    schema = field(db.EmbeddedDocumentField(Schema))
 
-    ext = db.MapField(db.GenericEmbeddedDocumentField())
-    extras = db.ExtrasField()
-    harvest = db.EmbeddedDocumentField(HarvestDatasetMetadata)
+    ext = field(db.MapField(db.GenericEmbeddedDocumentField()), auditable=False)
+    extras = field(db.ExtrasField(), auditable=False)
+    harvest = field(db.EmbeddedDocumentField(HarvestDatasetMetadata), auditable=False)
 
-    quality_cached = db.DictField()
+    quality_cached = field(db.DictField(), auditable=False)
 
-    featured = db.BooleanField(required=True, default=False)
+    featured = field(
+        db.BooleanField(required=True, default=False),
+        auditable=False,
+    )
 
-    contact_points = db.ListField(db.ReferenceField("ContactPoint", reverse_delete_rule=db.PULL))
+    contact_points = field(
+        db.ListField(db.ReferenceField("ContactPoint", reverse_delete_rule=db.PULL))
+    )
 
-    created_at_internal = DateTimeField(
-        verbose_name=_("Creation date"), default=datetime.utcnow, required=True
+    created_at_internal = field(
+        DateTimeField(verbose_name=_("Creation date"), default=datetime.utcnow, required=True),
+        auditable=False,
     )
-    last_modified_internal = DateTimeField(
-        verbose_name=_("Last modification date"), default=datetime.utcnow, required=True
+    last_modified_internal = field(
+        DateTimeField(
+            verbose_name=_("Last modification date"), default=datetime.utcnow, required=True
+        ),
+        auditable=False,
     )
-    deleted = db.DateTimeField()
-    archived = db.DateTimeField()
+    deleted = field(db.DateTimeField(), auditable=False)
+    archived = field(db.DateTimeField())
 
     def __str__(self):
         return self.title or ""
@@ -654,18 +667,6 @@ class Dataset(WithMetrics, DatasetBadgeMixin, Owned, db.Document):
     def pre_save(cls, sender, document, **kwargs):
         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 clean(self):
         super(Dataset, self).clean()
         if self.frequency in LEGACY_FREQUENCIES:
@@ -1046,19 +1047,19 @@ class Dataset(WithMetrics, DatasetBadgeMixin, 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_reuses(self):
         from udata.models import Reuse
 
         self.metrics["reuses"] = Reuse.objects(datasets=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_init.connect(Dataset.pre_init, sender=Dataset)

udata/core/metrics/models.py

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

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/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(