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 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)
