Python Comment.get_content_type方法代码示例

# 需要导入模块: from comments.models import Comment [as 别名]
# 或者: from comments.models.Comment import get_content_type [as 别名]
    def testReportComment(self):
        # Try to view form anonymously
        # (but get redirected because not authenticated)
        url = reverse('report_comment', args=[self.comment.id])
        response = self.client.get(url)
        self.assertEqual(response.status_code, 302)

        # Log in
        self.client.login(username=self.eusa_staff.username, password="")

        # View form
        url = reverse('report_comment', args=[self.comment.id])
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)
        self.assertIn('form', response.context)
        self.assertIn('comment', response.context)
        self.assertEqual(self.comment, response.context['comment'])

        # Report
        post = {'reason': 'Unacceptable'}
        response = self.client.post(url, post)
        self.assertEqual(response.status_code, 302)
        self.assertTrue(Report.objects.filter(
            content_type=Comment.get_content_type(),
            object_id=self.comment.id))

# 需要导入模块: from comments.models import Comment [as 别名]
# 或者: from comments.models.Comment import get_content_type [as 别名]
def moderator_panel(request):
    if not request.user.is_authenticated():
        return request_login(request)
    if not request.user.isModerator:
        messages.add_message(request, messages.ERROR,
                             "Only moderators may access the moderator panel.")
        if request.is_ajax():
            return HttpResponseForbidden("")
        else:
            return HttpResponseRedirect(reverse('frontpage'))

    if request.method == "POST":
        report_id = request.POST.get("report")
        report = Report.objects.get(id=report_id)
        action = request.POST.get("action")
        ajax_response_type = HttpResponse
        if action == "Hide":
            try:
                hide_action = HideAction()
                hide_action.moderator = request.user
                hide_action.reason = report.reason
                hide_action.content = report.content
                hide_action.save()
                report.delete()
                messages.add_message(request, messages.INFO, "Content hidden")
            except Report.DoesNotExist:
                messages.add_message(request, messages.ERROR,
                                     "Report not found")
                ajax_response_type = HttpResponseNotFound
        elif action == "Ignore":
            try:
                report.delete()
                messages.add_message(request, messages.INFO,
                                     "Report ignored")
            except Report.DoesNotExist:
                messages.add_message(request, messages.ERROR,
                                     "Report not found")
                ajax_response_type = HttpResponseNotFound
        else:
            messages.add_message(request, messages.ERROR,
                                 "Moderation action type not found")
            ajax_response_type = HttpResponseNotFound
        if request.is_ajax():
            return ajax_response_type("")

    comment_reports = Report.objects.filter(
        content_type=Comment.get_content_type())
    proposal_reports = Report.objects.filter(
        content_type=Proposal.get_content_type())
    return render(request, "moderator_panel.html",
                  {"comment_reports": comment_reports,
                   "proposal_reports": proposal_reports})

# 需要导入模块: from comments.models import Comment [as 别名]
# 或者: from comments.models.Comment import get_content_type [as 别名]
def notify_submitter_if_content_hidden(created, **kwargs):
    hide_action = kwargs.get("instance")
    if created:
        # Don't notify submitter if they hide their own content
        if hide_action.moderator != hide_action.content.user:
            recipient = hide_action.content.user
            if hide_action.content_type == Proposal.get_content_type():
                type = "proposal_hidden"
            elif hide_action.content_type == Comment.get_content_type():
                type = "comment_hidden"
            Notification.objects.create(recipient=recipient,
                                        type=type,
                                        content=hide_action.content)

# 需要导入模块: from comments.models import Comment [as 别名]
# 或者: from comments.models.Comment import get_content_type [as 别名]
def delete_notify_of_vote(**kwargs):
    # TODO: are all these conditions necessary? would it not be enough to just
    # delete any notifications where object_id=vote.id and
    # content_type=vote.content_type?
    vote = kwargs.get("instance")
    recipient = vote.content.user
    # Votes on proposals
    if vote.content_type == Proposal.get_content_type():
        if vote.isVoteUp:
            type = "proposal_vote_up"
        else:
            type = "proposal_vote_down"
    # Votes on comments
    elif vote.content_type == Comment.get_content_type():
        if vote.isVoteUp:
            type = "comment_vote_up"
        else:
            type = "comment_vote_down"
    Notification.objects.filter(recipient=recipient,
                                type=type,
                                content_type=vote.get_content_type(),
                                object_id=vote._id).delete()

# 需要导入模块: from comments.models import Comment [as 别名]
# 或者: from comments.models.Comment import get_content_type [as 别名]
def notify_of_vote(created, **kwargs):
    vote = kwargs.get("instance")
    recipient = vote.content.user
    if created and vote.user != recipient:
        # Votes on proposals
        if vote.content_type == Proposal.get_content_type():
            if vote.isVoteUp:
                type = "proposal_vote_up"
            else:
                type = "proposal_vote_down"

        # Votes on comments
        elif vote.content_type == Comment.get_content_type():
            if vote.isVoteUp:
                type = "comment_vote_up"
            else:
                type = "comment_vote_down"

        Notification.objects.create(recipient=recipient,
                                    type=type,
                                    content_type=Vote.get_content_type(),
                                    object_id=vote.id)

# 需要导入模块: from comments.models import Comment [as 别名]
# 或者: from comments.models.Comment import get_content_type [as 别名]
    def testModeratorPanel(self):
        url = reverse('moderator_panel')

        # View moderator panel anonymously
        response = self.client.get(url)
        self.assertEqual(response.status_code, 302)

        # Hide from comment report anonymously
        post = {'action': 'Hide', 'report': self.comment_report.id}
        response = self.client.post(url, post)
        self.assertEqual(response.status_code, 302)
        self.assertRaises(HideAction.DoesNotExist, HideAction.objects.get,
                          object_id=self.reported_comment.id,
                          content_type=Comment.get_content_type())
        self.assertTrue(Report.objects.get(id=self.comment_report.id))

        # Hide from proposal report anonymously
        post = {'action': 'Hide', 'report': self.proposal_report.id}
        response = self.client.post(url, post)
        self.assertEqual(response.status_code, 302)
        self.assertRaises(HideAction.DoesNotExist, HideAction.objects.get,
                          object_id=self.reported_proposal.id,
                          content_type=Proposal.get_content_type())
        self.assertTrue(Report.objects.get(id=self.proposal_report.id))

        # Login as non-moderator
        self.assertTrue(self.client.login(username=self.user.username,
                                          password=''))

        # View moderator panel as non-moderator
        response = self.client.get(url)
        self.assertEqual(response.status_code, 302)

        # Hide from comment report as non-moderator
        post = {'action': 'Hide', 'report': self.comment_report.id}
        response = self.client.post(url, post)
        self.assertEqual(response.status_code, 302)
        self.assertRaises(HideAction.DoesNotExist, HideAction.objects.get,
                          object_id=self.reported_comment.id,
                          content_type=Comment.get_content_type())
        self.assertTrue(Report.objects.get(id=self.comment_report.id))

        # Hide from proposal report as non-moderator
        post = {'action': 'Hide', 'report': self.proposal_report.id}
        response = self.client.post(url, post)
        self.assertEqual(response.status_code, 302)
        self.assertRaises(HideAction.DoesNotExist, HideAction.objects.get,
                          object_id=self.reported_proposal.id,
                          content_type=Proposal.get_content_type())
        self.assertTrue(Report.objects.get(id=self.proposal_report.id))

        # Login as moderator
        self.assertTrue(self.client.login(username=self.eusa_staff.username,
                                          password=''))

        # View moderator panel as moderator
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)

        # Hide from comment report as moderator
        post = {'action': 'Hide', 'report': self.comment_report.id}
        response = self.client.post(url, post)
        self.assertEqual(response.status_code, 200)
        self.assertTrue(HideAction.objects.get(
            object_id=self.reported_comment.id,
            content_type=Comment.get_content_type()))
        self.assertRaises(Report.DoesNotExist, Report.objects.get,
                          id=self.comment_report.id)

        # Hide from proposal report as moderator
        post = {'action': 'Hide', 'report': self.proposal_report.id}
        response = self.client.post(url, post)
        self.assertEqual(response.status_code, 200)
        self.assertTrue(HideAction.objects.get(
            object_id=self.reported_proposal.id,
            content_type=Proposal.get_content_type()))
        self.assertRaises(Report.DoesNotExist, Report.objects.get,
                          id=self.proposal_report.id)

# 需要导入模块: from comments.models import Comment [as 别名]
# 或者: from comments.models.Comment import get_content_type [as 别名]
def comment_hides(request):
    hiddens = HideAction.objects.all()\
                                .filter(
                                    content_type=Comment.get_content_type())
    return render(request, "hidden_comment_list.html", {"hiddens": hiddens})