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

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

@@ -1,5 +1,7 @@
 from flask_security import current_user
 
+from udata.core.dataservices.activities import DataserviceRelatedActivity
+from udata.core.dataservices.models import Dataservice
 from udata.core.dataset.activities import DatasetRelatedActivity
 from udata.core.discussions.signals import on_new_discussion, on_new_discussion_comment
 from udata.core.followers.signals import on_follow
@@ -40,6 +42,11 @@ class UserFollowedUser(FollowActivity, Activity):
     template = "activity/user.html"
 
 
+class UserDiscussedDataservice(DiscussActivity, DataserviceRelatedActivity, Activity):
+    key = "dataservice:discussed"
+    label = _("discussed a dataservice")
+
+
 class UserDiscussedDataset(DiscussActivity, DatasetRelatedActivity, Activity):
     key = "dataset:discussed"
     label = _("discussed a dataset")
@@ -50,6 +57,11 @@ class UserDiscussedReuse(DiscussActivity, ReuseRelatedActivity, Activity):
     label = _("discussed a reuse")
 
 
+class UserFollowedDataservice(FollowActivity, DataserviceRelatedActivity, Activity):
+    key = "dataservice:followed"
+    label = _("followed a dataservice")
+
+
 class UserFollowedDataset(FollowActivity, DatasetRelatedActivity, Activity):
     key = "dataset:followed"
     label = _("followed a dataset")
@@ -68,7 +80,9 @@ class UserFollowedOrganization(FollowActivity, OrgRelatedActivity, Activity):
 @on_follow.connect
 def write_activity_on_follow(follow, **kwargs):
     if current_user.is_authenticated:
-        if isinstance(follow.following, Dataset):
+        if isinstance(follow.following, Dataservice):
+            UserFollowedDataservice.emit(follow.following)
+        elif isinstance(follow.following, Dataset):
             UserFollowedDataset.emit(follow.following)
         elif isinstance(follow.following, Reuse):
             UserFollowedReuse.emit(follow.following)
@@ -82,6 +96,8 @@ def write_activity_on_follow(follow, **kwargs):
 @on_new_discussion_comment.connect
 def write_activity_on_discuss(discussion, **kwargs):
     if current_user.is_authenticated:
+        if isinstance(discussion.subject, Dataservice):
+            UserDiscussedDataservice.emit(discussion.subject)
         if isinstance(discussion.subject, Dataset):
             UserDiscussedDataset.emit(discussion.subject)
         elif isinstance(discussion.subject, Reuse):

udata/core/user/models.py

@@ -12,6 +12,7 @@ from mongoengine.signals import post_save, pre_save
 from werkzeug.utils import cached_property
 
 from udata import mail
+from udata.api_fields import field
 from udata.core import storages
 from udata.core.discussions.models import Discussion
 from udata.core.storages import avatars, default_image_basename
@@ -42,49 +43,53 @@ class UserSettings(db.EmbeddedDocument):
 
 
 class User(WithMetrics, UserMixin, db.Document):
-    slug = db.SlugField(max_length=255, required=True, populate_from="fullname")
-    email = db.StringField(max_length=255, required=True, unique=True)
-    password = db.StringField()
-    active = db.BooleanField()
-    fs_uniquifier = db.StringField(max_length=64, unique=True, sparse=True)
-    roles = db.ListField(db.ReferenceField(Role), default=[])
+    slug = field(
+        db.SlugField(max_length=255, required=True, populate_from="fullname"), auditable=False
+    )
+    email = field(db.StringField(max_length=255, required=True, unique=True))
+    password = field(db.StringField())
+    active = field(db.BooleanField())
+    fs_uniquifier = field(db.StringField(max_length=64, unique=True, sparse=True))
+    roles = field(db.ListField(db.ReferenceField(Role), default=[]))
 
-    first_name = db.StringField(max_length=255, required=True)
-    last_name = db.StringField(max_length=255, required=True)
+    first_name = field(db.StringField(max_length=255, required=True))
+    last_name = field(db.StringField(max_length=255, required=True))
 
-    avatar_url = db.URLField()
-    avatar = db.ImageField(fs=avatars, basename=default_image_basename, thumbnails=AVATAR_SIZES)
-    website = db.URLField()
-    about = db.StringField()
+    avatar_url = field(db.URLField())
+    avatar = field(
+        db.ImageField(fs=avatars, basename=default_image_basename, thumbnails=AVATAR_SIZES)
+    )
+    website = field(db.URLField())
+    about = field(db.StringField())
 
-    prefered_language = db.StringField()
+    prefered_language = field(db.StringField())
 
-    apikey = db.StringField()
+    apikey = field(db.StringField())
 
-    created_at = db.DateTimeField(default=datetime.utcnow, required=True)
+    created_at = field(db.DateTimeField(default=datetime.utcnow, required=True), auditable=False)
 
     # The field below is required for Flask-security
     # when SECURITY_CONFIRMABLE is True
-    confirmed_at = db.DateTimeField()
+    confirmed_at = field(db.DateTimeField(), auditable=False)
 
-    password_rotation_demanded = db.DateTimeField()
-    password_rotation_performed = db.DateTimeField()
+    password_rotation_demanded = field(db.DateTimeField(), auditable=False)
+    password_rotation_performed = field(db.DateTimeField(), auditable=False)
 
     # The 5 fields below are required for Flask-security
     # when SECURITY_TRACKABLE is True
-    last_login_at = db.DateTimeField()
-    current_login_at = db.DateTimeField()
-    last_login_ip = db.StringField()
-    current_login_ip = db.StringField()
-    login_count = db.IntField()
+    last_login_at = field(db.DateTimeField(), auditable=False)
+    current_login_at = field(db.DateTimeField(), auditable=False)
+    last_login_ip = field(db.StringField(), auditable=False)
+    current_login_ip = field(db.StringField(), auditable=False)
+    login_count = field(db.IntField(), auditable=False)
 
-    deleted = db.DateTimeField()
-    ext = db.MapField(db.GenericEmbeddedDocumentField())
-    extras = db.ExtrasField()
+    deleted = field(db.DateTimeField())
+    ext = field(db.MapField(db.GenericEmbeddedDocumentField()))
+    extras = field(db.ExtrasField(), auditable=False)
 
     # Used to track notification for automatic inactive users deletion
     # when YEARS_OF_INACTIVITY_BEFORE_DELETION is set
-    inactive_deletion_notified_at = db.DateTimeField()
+    inactive_deletion_notified_at = field(db.DateTimeField(), auditable=False)
 
     before_save = Signal()
     after_save = Signal()
@@ -209,6 +214,8 @@ class User(WithMetrics, UserMixin, db.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)
@@ -294,31 +301,31 @@ class User(WithMetrics, UserMixin, db.Document):
         from udata.models import Dataset
 
         self.metrics["datasets"] = Dataset.objects(owner=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(owner=self).visible().count()
-        self.save()
+        self.save(signal_kwargs={"ignores": ["post_save"]})
 
     def count_dataservices(self):
         from udata.core.dataservices.models import Dataservice
 
         self.metrics["dataservices"] = Dataservice.objects(owner=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"]})
 
     def count_following(self):
         from udata.models import Follow
 
         self.metrics["following"] = Follow.objects.following(self).count()
-        self.save()
+        self.save(signal_kwargs={"ignores": ["post_save"]})
 
 
 datastore = MongoEngineUserDatastore(db, User, Role)

udata/mongo/datetime_fields.py

@@ -67,6 +67,7 @@ class Datetimed(object):
         ),
         sortable=True,
         readonly=True,
+        auditable=False,
     )