Python utils.create_comment函数代码示例

    def test_profile_likes_dont_show_removed_or_private(self):
        """
        dont show private topics or removed
        """
        category = utils.create_category()
        category_removed = utils.create_category(is_removed=True)
        subcategory = utils.create_category(parent=category_removed)
        subcategory_removed = utils.create_category(parent=category, is_removed=True)
        topic_a = utils.create_private_topic(user=self.user2)
        topic_b = utils.create_topic(category=category, is_removed=True)
        topic_c = utils.create_topic(category=category_removed)
        topic_d = utils.create_topic(category=subcategory)
        topic_e = utils.create_topic(category=subcategory_removed)
        comment_a = utils.create_comment(user=self.user2, topic=topic_a.topic)
        comment_b = utils.create_comment(user=self.user, topic=topic_b)
        comment_c = utils.create_comment(user=self.user, topic=topic_c)
        comment_d = utils.create_comment(user=self.user, topic=topic_d)
        comment_e = utils.create_comment(user=self.user, topic=topic_e)
        like_a = CommentLike.objects.create(user=self.user2, comment=comment_a)
        like_b = CommentLike.objects.create(user=self.user2, comment=comment_b)
        like_c = CommentLike.objects.create(user=self.user2, comment=comment_c)
        like_d = CommentLike.objects.create(user=self.user2, comment=comment_d)
        like_e = CommentLike.objects.create(user=self.user2, comment=comment_e)

        utils.login(self)
        response = self.client.get(reverse("spirit:profile-likes", kwargs={'pk': self.user2.pk,
                                                                            'slug': self.user2.slug}))
        self.assertQuerysetEqual(response.context['comments'], [])

    def test_comment_move_signal(self):
        """
        move comments, emit signal
        """
        self._comments = []

        def comment_posted_handler(sender, comment, **kwargs):
            self._comments.append(comment)
        comment_posted.connect(comment_posted_handler)

        def comment_moved_handler(sender, comments, topic_from, **kwargs):
            self._comment_count = len(comments)
            self._topic_from = topic_from
        comment_moved.connect(comment_moved_handler)

        utils.login(self)
        self.user.is_moderator = True
        self.user.save()

        comment = utils.create_comment(user=self.user, topic=self.topic)
        comment2 = utils.create_comment(user=self.user, topic=self.topic)
        to_topic = utils.create_topic(self.category)

        form_data = {'topic': to_topic.pk,
                     'comments': [comment.pk, comment2.pk], }
        response = self.client.post(reverse('spirit:comment-move', kwargs={'topic_id': self.topic.pk, }),
                                    form_data)
        self.assertEqual(response.status_code, 302)
        self.assertListEqual(self._comments, [comment2, comment])
        self.assertEqual(self._comment_count, 2)
        self.assertEqual(repr(self._topic_from), repr(self.topic))

    def setUp(self):
        cache.clear()
        self.user = utils.create_user()
        self.category = utils.create_category()
        self.topic = utils.create_topic(category=self.category, user=self.user)

        for _ in xrange(settings.ST_COMMENTS_PER_PAGE * 4):  # 4 pages
            utils.create_comment(user=self.user, topic=self.topic)

    def setUp(self):
        cache.clear()
        self.user = utils.create_user()
        self.topic = utils.create_topic(utils.create_category())

        for _ in xrange(300):
            utils.create_comment(user=self.user, topic=self.topic)

        self.queryset = Comment.objects.all()

 def test_topic_comment_moved_handler(self):
     """
     comment_moved_handler signal
     """
     comment = utils.create_comment(topic=self.topic)
     comment2 = utils.create_comment(topic=self.topic)
     Topic.objects.filter(pk=self.topic.pk).update(comment_count=10)
     comment_moved.send(sender=comment.__class__, comments=[comment, comment2], topic_from=self.topic)
     self.assertEqual(Topic.objects.get(pk=self.topic.pk).comment_count, 8)

 def test_comments_move(self):
     comment = utils.create_comment(user=self.user, topic=self.topic)
     comment2 = utils.create_comment(user=self.user, topic=self.topic)
     to_topic = utils.create_topic(category=self.category)
     form_data = {'topic': to_topic.pk,
                  'comments': [comment.pk, comment2.pk], }
     form = CommentMoveForm(topic=self.topic, data=form_data)
     self.assertEqual(form.is_valid(), True)
     self.assertEqual(form.save(), list(Comment.objects.filter(topic=to_topic)))

    def get(self, request, *args, **kwargs):
        try:
            self.object = self.get_object()
        except Http404:
            messages.error(self.request, "That issue was not found.")
            return redirect("/")

        if self.request.GET.get("paymentId"):
            import paypalrestsdk

            paypalrestsdk.configure(
                {"mode": settings.MODE, "client_id": settings.CLIENT_ID, "client_secret": settings.CLIENT_SECRET}
            )

            payment = paypalrestsdk.Payment.find(self.request.GET.get("paymentId"))

            custom = payment.transactions[0].custom

            if payment.execute({"payer_id": self.request.GET.get("PayerID")}):
                send_mail(
                    "Processed Payment PayerID"
                    + self.request.GET.get("PayerID")
                    + " paymentID"
                    + self.request.GET.get("paymentId"),
                    "payment occured",
                    "[email protected]",
                    ["[email protected]"],
                    html_message="payment occured",
                )
                for obj in serializers.deserialize("json", custom, ignorenonexistent=True):
                    obj.object.created = datetime.datetime.now()
                    obj.object.checkout_id = self.request.GET.get("checkout_id")
                    obj.save()
                    action.send(
                        self.request.user,
                        verb="placed a $" + str(obj.object.price) + " bounty on ",
                        target=obj.object.issue,
                    )
                    post_to_slack(obj.object)
                    if not settings.DEBUG:
                        create_comment(obj.object.issue)
            else:
                messages.error(request, payment.error)
                send_mail(
                    "Payment error: PayerID"
                    + self.request.GET.get("PayerID")
                    + " paymentID"
                    + self.request.GET.get("paymentId"),
                    "payment error",
                    "[email protected]",
                    ["[email protected]"],
                    html_message="payment error",
                )

        return super(IssueDetailView, self).get(request, *args, **kwargs)

    def test_flag_closed(self):
        """
        Open flags
        """
        comment = utils.create_comment(topic=self.topic)
        comment2 = utils.create_comment(topic=self.topic)
        flag_closed = CommentFlag.objects.create(comment=comment2, is_closed=True)
        flag_ = CommentFlag.objects.create(comment=comment)

        utils.login(self)
        response = self.client.get(reverse('spirit:admin-flag-closed'))
        self.assertQuerysetEqual(response.context['flags'], map(repr, [flag_closed, ]))

 def test_profile_comments(self):
     """
     profile user's comments
     """
     utils.login(self)
     comment = utils.create_comment(user=self.user2, topic=self.topic)
     comment2 = utils.create_comment(user=self.user, topic=self.topic)
     response = self.client.get(reverse("spirit:profile-detail", kwargs={'pk': self.user2.pk,
                                                                         'slug': self.user2.slug}))
     self.assertEqual(response.status_code, 200)
     self.assertQuerysetEqual(response.context['comments'], [repr(comment), ])
     self.assertEqual(repr(response.context['p_user']), repr(self.user2))

    def test_profile_comments_order(self):
        """
        comments ordered by date
        """
        comment_a = utils.create_comment(user=self.user2, topic=self.topic)
        comment_b = utils.create_comment(user=self.user2, topic=self.topic)
        comment_c = utils.create_comment(user=self.user2, topic=self.topic)

        Comment.objects.filter(pk=comment_a.pk).update(date=timezone.now() - datetime.timedelta(days=10))
        Comment.objects.filter(pk=comment_c.pk).update(date=timezone.now() - datetime.timedelta(days=5))

        utils.login(self)
        response = self.client.get(reverse("spirit:profile-detail", kwargs={'pk': self.user2.pk,
                                                                            'slug': self.user2.slug}))
        self.assertQuerysetEqual(response.context['comments'], map(repr, [comment_b, comment_c, comment_a]))

    def get(self, request, *args, **kwargs):
        try:
            self.object = self.get_object()
        except Http404:
            messages.error(self.request, 'That issue was not found.')
            return redirect("/")
        context = self.get_context_data(object=self.object)
        return self.render_to_response(context)
        if self.request.GET.get('paymentId'):
            import paypalrestsdk
            paypalrestsdk.configure({
                'mode': settings.MODE,
                'client_id': settings.CLIENT_ID,
                'client_secret': settings.CLIENT_SECRET
            })

            payment = paypalrestsdk.Payment.find(self.request.GET.get('paymentId'))

            custom = payment.transactions[0].custom

            if payment.execute({"payer_id": self.request.GET.get('PayerID')}):
                for obj in serializers.deserialize("json", custom, ignorenonexistent=True):
                    obj.object.created = datetime.datetime.now()
                    obj.object.checkout_id = self.request.GET.get('checkout_id')
                    obj.save()
                    action.send(self.request.user, verb='placed a $' + str(obj.object.price) + ' bounty on ', target=obj.object.issue)
                    post_to_slack(obj.object)
                    if not settings.DEBUG:
                        create_comment(obj.object.issue)
            else:
                messages.error(request, payment.error)

        if self.request.GET.get('checkout_id'):
            wepay = WePay(settings.WEPAY_IN_PRODUCTION, settings.WEPAY_ACCESS_TOKEN)
            wepay_data = wepay.call('/checkout/', {
                'checkout_id': self.request.GET.get('checkout_id'),
            })

            for obj in serializers.deserialize("xml", wepay_data['long_description'], ignorenonexistent=True):
                obj.object.created = datetime.datetime.now()
                obj.object.checkout_id = self.request.GET.get('checkout_id')
                obj.save()
                action.send(self.request.user, verb='placed a $' + str(obj.object.price) + ' bounty on ', target=obj.object.issue)
                post_to_slack(obj.object)
                if not settings.DEBUG:
                    create_comment(obj.object.issue)

        return super(IssueDetailView, self).get(request, *args, **kwargs)

 def test_comment_comment_post_update_handler(self):
     """
     Increase modified_count on updated comment
     """
     comment = utils.create_comment(topic=self.topic)
     comment_post_update.send(sender=comment.__class__, comment=comment)
     self.assertEqual(Comment.objects.get(pk=comment.pk).modified_count, 1)

 def test_comment_comment_like_post_create_handler(self):
     """
     Increase like_count on comment like
     """
     comment = utils.create_comment(topic=self.topic)
     comment_like_post_create.send(sender=comment.__class__, comment=comment)
     self.assertEqual(Comment.objects.get(pk=comment.pk).likes_count, 1)

 def test_topic_notification_comment_handler(self):
     """
     set is_read=False when a comment is posted
     """
     comment = utils.create_comment(topic=self.topic)
     comment_posted.send(sender=self.topic.__class__, comment=comment, mentions=None)
     self.assertFalse(TopicNotification.objects.get(pk=self.topic_notification.pk).is_read)

 def test_topic_notification_comment_handler_unactive(self):
     """
     do nothing if notification is_active=False
     """
     TopicNotification.objects.filter(pk=self.topic_notification.pk).update(is_active=False)
     comment = utils.create_comment(topic=self.topic_notification.topic)
     comment_posted.send(sender=self.topic.__class__, comment=comment, mentions=None)
     self.assertTrue(TopicNotification.objects.get(pk=self.topic_notification.pk).is_read)