udata 9.1.2.dev30355__py2.py3-none-any.whl → 9.1.2.dev30382__py2.py3-none-any.whl

udata/core/discussions/api.py

@@ -1,127 +1,130 @@
-from bson import ObjectId
 from datetime import datetime
 
-from flask_security import current_user
+from bson import ObjectId
 from flask_restx.inputs import boolean
+from flask_security import current_user
 
+from udata.api import API, api, fields
 from udata.auth import admin_permission
-from udata.api import api, API, fields
 from udata.core.spam.api import SpamAPIMixin
 from udata.core.spam.fields import spam_fields
-from udata.utils import id_or_404
 from udata.core.user.api_fields import user_ref_fields
+from udata.utils import id_or_404
 
-from .forms import DiscussionCreateForm, DiscussionCommentForm
-from .models import Message, Discussion
+from .forms import DiscussionCommentForm, DiscussionCreateForm
+from .models import Discussion, Message
 from .permissions import CloseDiscussionPermission
 from .signals import on_discussion_deleted
 
-
-ns = api.namespace('discussions', 'Discussion related operations')
-
-message_fields = api.model('DiscussionMessage', {
-    'content': fields.String(description='The message body'),
-    'posted_by': fields.Nested(user_ref_fields,
-                               description='The message author'),
-    'posted_on': fields.ISODateTime(description='The message posting date'),
-    'spam': fields.Nested(spam_fields),
-})
-
-discussion_fields = api.model('Discussion', {
-    'id': fields.String(description='The discussion identifier'),
-    'subject': fields.Nested(api.model_reference,
-                             description='The discussion target object'),
-    'class': fields.ClassName(description='The object class',
-                              discriminator=True),
-    'title': fields.String(description='The discussion title'),
-    'user': fields.Nested(
-        user_ref_fields, description='The discussion author'),
-    'created': fields.ISODateTime(description='The discussion creation date'),
-    'closed': fields.ISODateTime(description='The discussion closing date'),
-    'closed_by': fields.Nested(user_ref_fields, allow_null=True,
-                               description='The user who closed the discussion'),
-    'discussion': fields.Nested(message_fields),
-    'url': fields.UrlFor('api.discussion',
-                         description='The discussion API URI'),
-    'extras': fields.Raw(description='Extra attributes as key-value pairs'),
-    'spam': fields.Nested(spam_fields),
-})
-
-start_discussion_fields = api.model('DiscussionStart', {
-    'title': fields.String(description='The title of the discussion to open',
-                           required=True),
-    'comment': fields.String(description='The content of the initial comment',
-                             required=True),
-    'subject': fields.Nested(api.model_reference,
-                             description='The discussion target object',
-                             required=True),
-    'extras': fields.Raw(description='Extras attributes as key-value pairs'),
-})
-
-comment_discussion_fields = api.model('DiscussionResponse', {
-    'comment': fields.String(
-        description='The comment to submit', required=True),
-    'close': fields.Boolean(
-        description='Is this a closing response. Only subject owner can close')
-})
-
-discussion_page_fields = api.model('DiscussionPage',
-                                   fields.pager(discussion_fields))
+ns = api.namespace("discussions", "Discussion related operations")
+
+message_fields = api.model(
+    "DiscussionMessage",
+    {
+        "content": fields.String(description="The message body"),
+        "posted_by": fields.Nested(user_ref_fields, description="The message author"),
+        "posted_on": fields.ISODateTime(description="The message posting date"),
+        "spam": fields.Nested(spam_fields),
+    },
+)
+
+discussion_fields = api.model(
+    "Discussion",
+    {
+        "id": fields.String(description="The discussion identifier"),
+        "subject": fields.Nested(api.model_reference, description="The discussion target object"),
+        "class": fields.ClassName(description="The object class", discriminator=True),
+        "title": fields.String(description="The discussion title"),
+        "user": fields.Nested(user_ref_fields, description="The discussion author"),
+        "created": fields.ISODateTime(description="The discussion creation date"),
+        "closed": fields.ISODateTime(description="The discussion closing date"),
+        "closed_by": fields.Nested(
+            user_ref_fields, allow_null=True, description="The user who closed the discussion"
+        ),
+        "discussion": fields.Nested(message_fields),
+        "url": fields.UrlFor("api.discussion", description="The discussion API URI"),
+        "extras": fields.Raw(description="Extra attributes as key-value pairs"),
+        "spam": fields.Nested(spam_fields),
+    },
+)
+
+start_discussion_fields = api.model(
+    "DiscussionStart",
+    {
+        "title": fields.String(description="The title of the discussion to open", required=True),
+        "comment": fields.String(description="The content of the initial comment", required=True),
+        "subject": fields.Nested(
+            api.model_reference, description="The discussion target object", required=True
+        ),
+        "extras": fields.Raw(description="Extras attributes as key-value pairs"),
+    },
+)
+
+comment_discussion_fields = api.model(
+    "DiscussionResponse",
+    {
+        "comment": fields.String(description="The comment to submit", required=True),
+        "close": fields.Boolean(
+            description="Is this a closing response. Only subject owner can close"
+        ),
+    },
+)
+
+discussion_page_fields = api.model("DiscussionPage", fields.pager(discussion_fields))
 
 parser = api.parser()
 parser.add_argument(
-    'sort', type=str, default='-created', location='args',
-    help='The sorting attribute')
+    "sort", type=str, default="-created", location="args", help="The sorting attribute"
+)
 parser.add_argument(
-    'closed', type=boolean, location='args',
-    help='Filters discussions on their closed status if specified')
+    "closed",
+    type=boolean,
+    location="args",
+    help="Filters discussions on their closed status if specified",
+)
 parser.add_argument(
-    'for', type=str, location='args', action='append',
-    help='Filter discussions for a given subject')
+    "for", type=str, location="args", action="append", help="Filter discussions for a given subject"
+)
+parser.add_argument("user", type=str, location="args", help="Filter discussions created by a user")
+parser.add_argument("page", type=int, default=1, location="args", help="The page to fetch")
 parser.add_argument(
-    'user', type=str, location='args',
-    help='Filter discussions created by a user')
-parser.add_argument(
-    'page', type=int, default=1, location='args', help='The page to fetch')
-parser.add_argument(
-    'page_size', type=int, default=20, location='args',
-    help='The page size to fetch')
+    "page_size", type=int, default=20, location="args", help="The page size to fetch"
+)
 
 
-@ns.route('/<id>/spam/', endpoint='discussion_spam')
-@ns.doc(delete={'id': 'unspam'})
+@ns.route("/<id>/spam/", endpoint="discussion_spam")
+@ns.doc(delete={"id": "unspam"})
 class DiscussionSpamAPI(SpamAPIMixin):
     model = Discussion
 
 
-@ns.route('/<id>/', endpoint='discussion')
+@ns.route("/<id>/", endpoint="discussion")
 class DiscussionAPI(API):
-    '''
+    """
     Base class for a discussion thread.
-    '''
-    @api.doc('get_discussion')
+    """
+
+    @api.doc("get_discussion")
     @api.marshal_with(discussion_fields)
     def get(self, id):
-        '''Get a discussion given its ID'''
+        """Get a discussion given its ID"""
         discussion = Discussion.objects.get_or_404(id=id_or_404(id))
         return discussion
 
     @api.secure
-    @api.doc('comment_discussion')
+    @api.doc("comment_discussion")
     @api.expect(comment_discussion_fields)
-    @api.response(403, 'Not allowed to close this discussion '
-                       "OR can't add comments on a closed discussion")
+    @api.response(
+        403, "Not allowed to close this discussion " "OR can't add comments on a closed discussion"
+    )
     @api.marshal_with(discussion_fields)
     def post(self, id):
-        '''Add comment and optionally close a discussion given its ID'''
+        """Add comment and optionally close a discussion given its ID"""
         discussion = Discussion.objects.get_or_404(id=id_or_404(id))
         if discussion.closed:
             api.abort(403, "Can't add comments on a closed discussion")
         form = api.validate(DiscussionCommentForm)
-        message = Message(
-            content=form.comment.data,
-            posted_by=current_user.id
-        )
+        message = Message(content=form.comment.data, posted_by=current_user.id)
         discussion.discussion.append(message)
         message_idx = len(discussion.discussion) - 1
         close = form.close.data
@@ -137,81 +140,82 @@ class DiscussionAPI(API):
         return discussion
 
     @api.secure(admin_permission)
-    @api.doc('delete_discussion')
-    @api.response(403, 'Not allowed to delete this discussion')
+    @api.doc("delete_discussion")
+    @api.response(403, "Not allowed to delete this discussion")
     def delete(self, id):
-        '''Delete a discussion given its ID'''
+        """Delete a discussion given its ID"""
         discussion = Discussion.objects.get_or_404(id=id_or_404(id))
         discussion.delete()
         on_discussion_deleted.send(discussion)
-        return '', 204
+        return "", 204
 
 
-@ns.route('/<id>/comments/<int:cidx>/spam', endpoint='discussion_comment_spam')
-@ns.doc(delete={'id': 'unspam'})
+@ns.route("/<id>/comments/<int:cidx>/spam", endpoint="discussion_comment_spam")
+@ns.doc(delete={"id": "unspam"})
 class DiscussionSpamAPI(SpamAPIMixin):
     def get_model(self, id, cidx):
         discussion = Discussion.objects.get_or_404(id=id_or_404(id))
         if len(discussion.discussion) <= cidx:
-            api.abort(404, 'Comment does not exist')
+            api.abort(404, "Comment does not exist")
         elif cidx == 0:
-            api.abort(400, 'You cannot unspam the first comment of a discussion')
+            api.abort(400, "You cannot unspam the first comment of a discussion")
         return discussion, discussion.discussion[cidx]
 
-@ns.route('/<id>/comments/<int:cidx>', endpoint='discussion_comment')
+
+@ns.route("/<id>/comments/<int:cidx>", endpoint="discussion_comment")
 class DiscussionCommentAPI(API):
-    '''
+    """
     Base class for a comment in a discussion thread.
-    '''
+    """
+
     @api.secure(admin_permission)
-    @api.doc('delete_discussion_comment')
-    @api.response(403, 'Not allowed to delete this comment')
+    @api.doc("delete_discussion_comment")
+    @api.response(403, "Not allowed to delete this comment")
     def delete(self, id, cidx):
-        '''Delete a comment given its index'''
+        """Delete a comment given its index"""
         discussion = Discussion.objects.get_or_404(id=id_or_404(id))
         if len(discussion.discussion) <= cidx:
-            api.abort(404, 'Comment does not exist')
+            api.abort(404, "Comment does not exist")
         elif cidx == 0:
-            api.abort(400, 'You cannot delete the first comment of a discussion')
+            api.abort(400, "You cannot delete the first comment of a discussion")
         discussion.discussion.pop(cidx)
         discussion.save()
-        return '', 204
+        return "", 204
 
 
-@ns.route('/', endpoint='discussions')
+@ns.route("/", endpoint="discussions")
 class DiscussionsAPI(API):
-    '''
+    """
     Base class for a list of discussions.
-    '''
-    @api.doc('list_discussions')
+    """
+
+    @api.doc("list_discussions")
     @api.expect(parser)
     @api.marshal_with(discussion_page_fields)
     def get(self):
-        '''List all Discussions'''
+        """List all Discussions"""
         args = parser.parse_args()
         discussions = Discussion.objects
-        if args['for']:
-            discussions = discussions.generic_in(subject=args['for'])
-        if args['user']:
-            discussions = discussions(discussion__posted_by=ObjectId(args['user']))
-        if args['closed'] is False:
+        if args["for"]:
+            discussions = discussions.generic_in(subject=args["for"])
+        if args["user"]:
+            discussions = discussions(discussion__posted_by=ObjectId(args["user"]))
+        if args["closed"] is False:
             discussions = discussions(closed=None)
-        elif args['closed'] is True:
+        elif args["closed"] is True:
             discussions = discussions(closed__ne=None)
-        discussions = discussions.order_by(args['sort'])
-        return discussions.paginate(args['page'], args['page_size'])
+        discussions = discussions.order_by(args["sort"])
+        return discussions.paginate(args["page"], args["page_size"])
 
     @api.secure
-    @api.doc('create_discussion')
+    @api.doc("create_discussion")
     @api.expect(start_discussion_fields)
     @api.marshal_with(discussion_fields)
     def post(self):
-        '''Create a new Discussion'''
+        """Create a new Discussion"""
         form = api.validate(DiscussionCreateForm)
 
-        message = Message(
-            content=form.comment.data,
-            posted_by=current_user.id)
+        message = Message(content=form.comment.data, posted_by=current_user.id)
         discussion = Discussion(user=current_user.id, discussion=[message])
         form.populate_obj(discussion)
         discussion.save()

udata/core/discussions/factories.py

@@ -9,11 +9,11 @@ class DiscussionFactory(ModelFactory):
     class Meta:
         model = Discussion
 
-    title = factory.Faker('sentence')
+    title = factory.Faker("sentence")
 
 
 class MessageDiscussionFactory(ModelFactory):
     class Meta:
         model = Message
 
-    content = factory.Faker('sentence')
+    content = factory.Faker("sentence")

udata/core/discussions/forms.py

@@ -1,23 +1,25 @@
-from udata.forms import ModelForm, Form, fields, validators
+from udata.forms import Form, ModelForm, fields, validators
 from udata.i18n import lazy_gettext as _
 
-from .models import Discussion
 from .constants import COMMENT_SIZE_LIMIT
+from .models import Discussion
 
-__all__ = ('DiscussionCreateForm', 'DiscussionCommentForm')
+__all__ = ("DiscussionCreateForm", "DiscussionCommentForm")
 
 
 class DiscussionCreateForm(ModelForm):
     model_class = Discussion
 
-    title = fields.StringField(_('Title'), [validators.DataRequired()])
+    title = fields.StringField(_("Title"), [validators.DataRequired()])
     comment = fields.StringField(
-        _('Comment'), [validators.DataRequired(), validators.Length(max=COMMENT_SIZE_LIMIT)])
-    subject = fields.ModelField(_('Subject'), [validators.DataRequired()])
+        _("Comment"), [validators.DataRequired(), validators.Length(max=COMMENT_SIZE_LIMIT)]
+    )
+    subject = fields.ModelField(_("Subject"), [validators.DataRequired()])
     extras = fields.ExtrasField()
 
 
 class DiscussionCommentForm(Form):
     comment = fields.StringField(
-        _('Comment'), [validators.DataRequired(), validators.Length(max=COMMENT_SIZE_LIMIT)])
+        _("Comment"), [validators.DataRequired(), validators.Length(max=COMMENT_SIZE_LIMIT)]
+    )
     close = fields.BooleanField(default=False)

udata/core/discussions/metrics.py

@@ -1,6 +1,4 @@
-from .signals import (
-    on_new_discussion, on_discussion_closed, on_discussion_deleted
-)
+from .signals import on_discussion_closed, on_discussion_deleted, on_new_discussion
 
 
 @on_new_discussion.connect

udata/core/discussions/models.py

@@ -3,9 +3,10 @@ from datetime import datetime
 
 from flask_login import current_user
 
-from udata.mongo import db
 from udata.core.spam.models import SpamMixin, spam_protected
-from .signals import (on_new_discussion, on_discussion_closed, on_new_discussion_comment)
+from udata.mongo import db
+
+from .signals import on_discussion_closed, on_new_discussion, on_new_discussion_comment
 
 log = logging.getLogger(__name__)
 
@@ -13,23 +14,29 @@ log = logging.getLogger(__name__)
 class Message(SpamMixin, db.EmbeddedDocument):
     content = db.StringField(required=True)
     posted_on = db.DateTimeField(default=datetime.utcnow, required=True)
-    posted_by = db.ReferenceField('User')
+    posted_by = db.ReferenceField("User")
 
     def texts_to_check_for_spam(self):
         return [self.content]
-    
+
     def spam_report_message(self, breadcrumb):
-        message =  f"Spam potentiel dans le message"
+        message = f"Spam potentiel dans le message"
         if self.posted_by:
             message += f" de [{self.posted_by.fullname}]({self.posted_by.external_url})"
 
         if len(breadcrumb) != 2:
-            log.warning(f"`spam_report_message` called on message with a breadcrumb of {len(breadcrumb)} elements.", extra={ 'breadcrumb': breadcrumb})
+            log.warning(
+                f"`spam_report_message` called on message with a breadcrumb of {len(breadcrumb)} elements.",
+                extra={"breadcrumb": breadcrumb},
+            )
             return message
-        
+
         discussion = breadcrumb[0]
         if not isinstance(discussion, Discussion):
-            log.warning(f"`spam_report_message` called on message with a breadcrumb not containing a Discussion at index 0.", extra={ 'breadcrumb': breadcrumb})
+            log.warning(
+                f"`spam_report_message` called on message with a breadcrumb not containing a Discussion at index 0.",
+                extra={"breadcrumb": breadcrumb},
+            )
             return message
 
         message += f" sur la discussion « [{discussion.title}]({discussion.external_url}) »"
@@ -37,22 +44,18 @@ class Message(SpamMixin, db.EmbeddedDocument):
 
 
 class Discussion(SpamMixin, db.Document):
-    user = db.ReferenceField('User')
+    user = db.ReferenceField("User")
     subject = db.GenericReferenceField()
     title = db.StringField(required=True)
     discussion = db.ListField(db.EmbeddedDocumentField(Message))
     created = db.DateTimeField(default=datetime.utcnow, required=True)
     closed = db.DateTimeField()
-    closed_by = db.ReferenceField('User')
+    closed_by = db.ReferenceField("User")
     extras = db.ExtrasField()
 
     meta = {
-        'indexes': [
-            'user',
-            'subject',
-            '-created'
-        ],
-        'ordering': ['-created'],
+        "indexes": ["user", "subject", "-created"],
+        "ordering": ["-created"],
     }
 
     def person_involved(self, person):
@@ -64,8 +67,8 @@ class Discussion(SpamMixin, db.Document):
 
     def texts_to_check_for_spam(self):
         # Discussion should always have a first message but it's not the case in some tests…
-        return [self.title, self.discussion[0].content if len(self.discussion) else '']
-    
+        return [self.title, self.discussion[0].content if len(self.discussion) else ""]
+
     def embeds_to_check_for_spam(self):
         return self.discussion[1:]
 
@@ -89,17 +92,15 @@ class Discussion(SpamMixin, db.Document):
 
     @property
     def external_url(self):
-        return self.subject.url_for(
-            _anchor='discussion-{id}'.format(id=self.id),
-            _external=True)
-    
+        return self.subject.url_for(_anchor="discussion-{id}".format(id=self.id), _external=True)
+
     def spam_report_message(self, breadcrumb):
-        message =  f"Spam potentiel sur la discussion « [{self.title}]({self.external_url}) »"
+        message = f"Spam potentiel sur la discussion « [{self.title}]({self.external_url}) »"
         if self.user:
             message += f" de [{self.user.fullname}]({self.user.external_url})"
 
         return message
-    
+
     @spam_protected()
     def signal_new(self):
         on_new_discussion.send(self)

udata/core/discussions/notifications.py

@@ -1,32 +1,36 @@
+import logging
+
 from udata.features.notifications.actions import notifier
 
 from .actions import discussions_for
 
-
-import logging
-
 log = logging.getLogger(__name__)
 
 
-@notifier('discussion')
+@notifier("discussion")
 def discussions_notifications(user):
-    '''Notify user about open discussions'''
+    """Notify user about open discussions"""
     notifications = []
 
     # Only fetch required fields for notification serialization
     # Greatly improve performances and memory usage
-    qs = discussions_for(user).only('id', 'created', 'title', 'subject')
+    qs = discussions_for(user).only("id", "created", "title", "subject")
 
     # Do not dereference subject (so it's a DBRef)
     # Also improve performances and memory usage
     for discussion in qs.no_dereference():
-        notifications.append((discussion.created, {
-            'id': discussion.id,
-            'title': discussion.title,
-            'subject': {
-                'id': discussion.subject['_ref'].id,
-                'type': discussion.subject['_cls'].lower(),
-            }
-        }))
+        notifications.append(
+            (
+                discussion.created,
+                {
+                    "id": discussion.id,
+                    "title": discussion.title,
+                    "subject": {
+                        "id": discussion.subject["_ref"].id,
+                        "type": discussion.subject["_cls"].lower(),
+                    },
+                },
+            )
+        )
 
     return notifications

udata/core/discussions/permissions.py

@@ -1,7 +1,7 @@
 from udata.auth import Permission, UserNeed
-
 from udata.core.organization.permissions import (
-    OrganizationAdminNeed, OrganizationEditorNeed
+    OrganizationAdminNeed,
+    OrganizationEditorNeed,
 )
 
 
@@ -10,7 +10,7 @@ class CloseDiscussionPermission(Permission):
         needs = []
         subject = discussion.subject
 
-        if getattr(subject, 'organization'):
+        if getattr(subject, "organization"):
             needs.append(OrganizationAdminNeed(subject.organization.id))
             needs.append(OrganizationEditorNeed(subject.organization.id))
         elif subject.owner:

udata/core/discussions/signals.py

@@ -3,14 +3,14 @@ from blinker import Namespace
 namespace = Namespace()
 
 #: Trigerred when an discussion is created
-on_new_discussion = namespace.signal('on-new-discussion')
+on_new_discussion = namespace.signal("on-new-discussion")
 
 #: Trigerred when a new comment is posted on an discussion
 # (excluding creation and closing)
-on_new_discussion_comment = namespace.signal('on-new-discussion-comment')
+on_new_discussion_comment = namespace.signal("on-new-discussion-comment")
 
 #: Trigerred when an discussion is closed
-on_discussion_closed = namespace.signal('on-discussion-closed')
+on_discussion_closed = namespace.signal("on-discussion-closed")
 
 #: Trigerred when an discussion is deleted
-on_discussion_deleted = namespace.signal('on-discussion-deleted')
+on_discussion_deleted = namespace.signal("on-discussion-deleted")