def post(self, request, *args, **kwargs): try: comment = comments.get_model().objects.get(pk=kwargs['id']) except comments.get_model().DoesNotExist: content = { 'state': 'error', 'rating': 0 } else: responses = signals.comment_was_rated.send( sender = comment.__class__, comment = comment, request = self.request, rate = self.rate ) rating = 0 for (receiver, response) in responses: if response: rating += response comment.rating = rating comment.save() content = { 'state': 'success', 'rating': rating } return http.HttpResponse(simplejson.dumps(content), content_type='application/json')
def connect(self): """ Hook up the moderation methods to pre- and post-save signals from the comment models. """ signals.comment_will_be_posted.connect(self.pre_save_moderation, sender=comments.get_model()) signals.comment_was_posted.connect(self.post_save_moderation, sender=comments.get_model())
def items(self): qs = comments.get_model().objects.filter( site__pk = self.site.pk, is_public = True, is_removed = False, ) return qs.order_by('-submit_date')[:40]
def flag(request, comment_id, next=None): """ Flags a comment. Confirmation on GET, action on POST. Templates: :template:`comments/flag.html`, Context: comment the flagged `comments.comment` object """ comment = get_object_or_404(comments.get_model(), pk=comment_id, site__pk=settings.SITE_ID) # Flag on POST if request.method == 'POST': if next is None: next = utils.get_comment_url(comment=comment, request=request) perform_flag(request, comment) return next_redirect(request, fallback=next) # Render a form on GET else: if next is None: next = utils.get_comment_url(comment=comment, request=request) return render_to_response('comments/flag.html', {'comment': comment, "next": next}, template.RequestContext(request) )
def delete(request, comment_id, next=None): """ Deletes a comment. Confirmation on GET, action on POST. Requires the "can moderate comments" permission. Templates: :template:`comments/delete.html`, Context: comment the flagged `comments.comment` object """ comment = get_object_or_404(comments.get_model(), pk=comment_id, site__pk=get_current_site(request).pk) # Delete on POST if request.method == 'POST': # Flag the comment as deleted instead of actually deleting it. perform_delete(request, comment) return next_redirect(request, fallback=next or 'comments-delete-done', c=comment.pk) # Render a form on GET else: return render(request, 'comments/delete.html', { 'comment': comment, "next": next })
def flag(request, comment_id, next=None): """ Flags a comment. Confirmation on GET, action on POST. Templates: :template:`comments/flag.html`, Context: comment the flagged `comments.comment` object """ comment = get_object_or_404(comments.get_model(), pk=comment_id, site__pk=get_current_site(request).pk) # Flag on POST if request.method == 'POST': perform_flag(request, comment) return next_redirect(request, fallback=next or 'comments-flag-done', c=comment.pk) # Render a form on GET else: return render(request, 'comments/flag.html', { 'comment': comment, "next": next })
def approve(request, comment_id, next=None): """ Approve a comment (that is, mark it as public and non-removed). Confirmation on GET, action on POST. Requires the "can moderate comments" permission. Templates: :template:`comments/approve.html`, Context: comment the `comments.comment` object for approval """ comment = get_object_or_404(comments.get_model(), pk=comment_id, site__pk=get_current_site(request).pk) # Delete on POST if request.method == 'POST': # Flag the comment as approved. perform_approve(request, comment) return next_redirect(request, fallback=next or 'comments-approve-done', c=comment.pk) # Render a form on GET else: return render(request, 'comments/approve.html', { 'comment': comment, "next": next })
def get_comment_url(comment_pk=None, comment=None, request=None, include_anchor=True): if comment_pk: import comments comment = get_object_or_404(comments.get_model(), pk=comment_pk, site__pk=settings.SITE_ID) if comment is None: raise Exception('No comment supplied') top_level = get_top_level_comment(comment) target = top_level.content_object page = get_comment_page(target=target, comment=top_level, request=request) if target and isinstance(page, int): url = UrlHelper(target.get_absolute_url()) if page <= 1: # Remove pager parameter as we want to go to the first page. url.del_params('page') else: # Update pager parameter url.update_query_data(page=page) full_url = url.get_full_path() if include_anchor: full_url += '#comment-%s' % comment._get_pk_val() return full_url
def delete(request, comment_id, next=None): """ Deletes a comment. Confirmation on GET, action on POST. Requires the "can moderate comments" permission. Templates: :template:`comments/delete.html`, Context: comment the flagged `comments.comment` object """ comment = get_object_or_404(comments.get_model(), pk=comment_id, site__pk=settings.SITE_ID) # Delete on POST if request.method == 'POST': # Flag the comment as deleted instead of actually deleting it. perform_delete(request, comment) return next_redirect(request, fallback=next or 'comments-delete-done', c=comment.pk) # Render a form on GET else: return render_to_response('comments/delete.html', {'comment': comment, "next": next}, template.RequestContext(request) )
def approve(request, comment_id, next=None): """ Approve a comment (that is, mark it as public and non-removed). Confirmation on GET, action on POST. Requires the "can moderate comments" permission. Templates: :template:`comments/approve.html`, Context: comment the `comments.comment` object for approval """ comment = get_object_or_404(comments.get_model(), pk=comment_id, site__pk=settings.SITE_ID) # Delete on POST if request.method == 'POST': # Flag the comment as approved. perform_approve(request, comment) return next_redirect(request, fallback=next or 'comments-approve-done', c=comment.pk) # Render a form on GET else: return render_to_response('comments/approve.html', {'comment': comment, "next": next}, template.RequestContext(request) )
def confirmed(request): comment = None if 'c' in request.GET: try: comment = comments.get_model().objects.get(pk=request.GET['c']) except (ObjectDoesNotExist, ValueError): pass return render(request, template, {'comment': comment})
def __init__(self, ctype=None, object_pk_expr=None, object_expr=None, as_varname=None, comment=None): if ctype is None and object_expr is None: raise template.TemplateSyntaxError("Comment nodes must be given either a literal object or a ctype and object pk.") self.comment_model = comments.get_model() self.as_varname = as_varname self.ctype = ctype self.object_pk_expr = object_pk_expr self.object_expr = object_expr self.comment = comment
def post(self, request, *args, **kwargs): try: comment = comments.get_model().objects.get(pk=kwargs['id']) except comments.get_model().DoesNotExist: content = { 'state': 'error', } else: signals.comment_was_hidden.send( sender = comment.__class__, comment = comment, request = self.request, ) perform_hide(request, comment) content = { 'state': 'success', } return http.HttpResponse(simplejson.dumps(content), content_type='application/json')
def confirmed(request): comment = None if 'c' in request.GET: try: comment = comments.get_model().objects.get(pk=request.GET['c']) except (ObjectDoesNotExist, ValueError): pass return render_to_response(template, {'comment': comment}, context_instance=RequestContext(request) )
def mark_as_spam(request, comment_id, next=None): comment = get_object_or_404(comments.get_model(), pk=comment_id, site__pk=settings.SITE_ID) if request.method == 'POST': perform_mark_as_spam(request, comment) return next_redirect(request, next, mark_as_spam_done, c=comment.pk) else: return render_to_response('comments/mark_spam.html', {'comment': comment, "next": next}, template.RequestContext(request) )
def get_parent_url(comment=None, comment_pk=None, request=None): if comment_pk: import comments comment = get_object_or_404(comments.get_model(), pk=comment_pk, site__pk=settings.SITE_ID) if comment is None: raise Exception('No comment supplied') if comment.parent: return get_comment_url(comment=comment.parent, request=request) elif comment: url = get_comment_url(comment=comment, request=request, include_anchor=False) return url + '#comments'
def get_query_set(ctype=None, object_pk=None, target=None, root_only=False, except_root=False, tree_ids=None): if target: ctype = ContentType.objects.get_for_model(target) object_pk = force_text(target._get_pk_val()) if ctype is None or object_pk is None: raise Exception('No ctype or object_pk supplied') import comments COMMENT_MODEL = comments.get_model() qs = COMMENT_MODEL.objects.filter( content_type=ctype, object_pk=smart_text(object_pk), site__pk=settings.SITE_ID, ) # Only return the root level items? if root_only: qs = qs.exclude(parent__isnull=False) if except_root: qs = qs.exclude(parent__isnull=True) # Get tree ids. if tree_ids: qs = qs.filter(tree_id__in = tree_ids) # The is_public and is_removed fields are implementation details of the # built-in comment model's spam filtering system, so they might not # be present on a custom comment model subclass. If they exist, we # should filter on them. field_names = [f.name for f in COMMENT_MODEL._meta.fields] if 'is_public' in field_names: qs = qs.filter(is_public=True) if getattr(settings, 'COMMENTS_HIDE_REMOVED', True) and 'is_removed' in field_names: qs = qs.filter(is_removed=False) return qs
def get_comment_model(self): return comments.get_model()
def get_comments_for_obj(obj): content_type = ContentType.objects.get_for_model(obj) return (get_model().objects .filter(content_type=content_type, object_pk=obj.id) .select_related('user__profile'))
@classmethod def on_comment_post(cls, comment, request, **kwargs): if comment.content_object.__class__ == cls: view_time, created = BlogPostView.objects.get_or_create(user=request.user, post=comment.content_object) view_time.timestamp = datetime.now() view_time.save() def last_view(self, user): views = self.last_view_objs.filter(user=user).order_by('-timestamp') if len(views) > 0: return views[0].timestamp else: return datetime.now() post_save.connect(BlogPost.on_comment_create, sender=get_model()) pre_delete.connect(BlogPost.on_comment_delete, sender=get_model()) comment_was_posted.connect(BlogPost.on_comment_post, sender=get_model()) class BlogSubscription(models.Model): user = models.ForeignKey(User) blog = models.ForeignKey(Blog) created = models.DateTimeField(auto_now_add=True) def __unicode__(self): return "{0}: {1}".format(self.blog, self.user.username) class Meta: verbose_name = _(u'подписка') verbose_name_plural = _(u'подписки')
from django.utils.html import escape from django.utils.encoding import smart_text from django.utils.safestring import mark_safe from django.utils.translation import ugettext as _ from django.views.decorators.csrf import csrf_protect from django.views.decorators.http import require_POST from django.http import HttpResponse, Http404 from pure_pagination.paginator import Paginator, EmptyPage, PageNotAnInteger import comments from comments import signals from comments.sorters import CommentSorter from comments.views.utils import next_redirect, confirmation_view from comments import utils COMMENT_MODEL = comments.get_model() COMMENTS_PER_PAGE = getattr(settings, 'COMMENTS_PER_PAGE', 10) COMMENTS_ANCHOR = getattr(settings, 'COMMENTS_ANCHOR', 'comments') def _lookup_content_type(token): try: app, model = token.split('.') return ContentType.objects.get_by_natural_key(app, model) except ValueError: raise Exception("Third argument in must be in the format 'app.model'") except ContentType.DoesNotExist: raise Exception("non-existant content-type: '%s.%s'" % (app, model)) #def get_root_comments(ctype=None, object_pk=None, order_by='submit_date'):
self._bulk_flag(request, queryset, perform_delete, lambda n: ungettext('removed', 'removed', n)) remove_comments.short_description = _("Remove selected comments") def _bulk_flag(self, request, queryset, action, done_message): """ Flag, approve, or remove some comments from an admin action. Actually calls the `action` argument to perform the heavy lifting. """ n_comments = 0 for comment in queryset: action(request, comment) n_comments += 1 msg = ungettext('%(count)s comment was successfully %(action)s.', '%(count)s comments were successfully %(action)s.', n_comments) self.message_user( request, msg % { 'count': n_comments, 'action': done_message(n_comments) }) # Only register the default admin if the model is the built-in comment model # (this won't be true if there's a custom comment app). Klass = get_model() if Klass._meta.app_label == "django_comments": admin.site.register(Klass, CommentsAdmin)
Flag, approve, or remove some comments from an admin action. Actually calls the `action` argument to perform the heavy lifting. """ n_comments = 0 for comment in queryset: action(request, comment) n_comments += 1 msg = ungettext(u'1 comment was successfully %(action)s.', u'%(count)s comments were successfully %(action)s.', n_comments) self.message_user(request, msg % {'count': n_comments, 'action': done_message(n_comments)}) def save_model(self, request, obj, form, change): """ Custom handling for the admin 'action' buttons I manually added to the model change_form view. Hopefully hacks like this won't be necessary in future versions of django: https://code.djangoproject.com/ticket/12090 """ super(CommentsAdmin, self).save_model(request, obj, form, change) if 'approve' in form.data: perform_approve(request, obj) elif 'spam' in form.data: perform_mark_as_spam(request, obj) # Only register the default admin if the model is the built-in comment model # (this won't be true if there's a custom comment app). if get_model() is MPTTComment: admin.site.register(MPTTComment, CommentsAdmin)
(None, {'fields': ('content_type', 'object_pk', 'site')} ), (_('Content'), {'fields': ('user', 'user_name', 'user_email', 'user_url', 'title', 'comment')} ), (_('Hierarchy'), {'fields': ('parent',)} ), (_('Metadata'), {'fields': ('ip_address', 'is_public', 'is_removed')} ), ) list_display = ('name', 'title', 'content_type', 'object_pk', 'parent', 'ip_address', 'submit_date', 'is_public', 'is_removed') search_fields = ('title', 'comment', 'user__username', 'user_name', 'user_email', 'user_url', 'ip_address') raw_id_fields = ("parent",) # Only register the default admin if the model is the built-in comment model # (this won't be true if there's a custom comment app). if get_model() is Comment: admin.site.register(Comment, CommentsAdmin) admin.site.register(ThreadedComment, ThreadedCommentsAdmin)
def testGetModel(self): from custom_comments.models import CustomComment self.assertEqual(comments.get_model(), CustomComment)