def render(self, **kwargs):
parent_type = self.parent.__class__.__name__.lower()
request = kwargs.get('request')
comment_page = self.parent
if hasattr(comment_page, 'original_translation') and comment_page.original_translation:
comment_page = comment_page.original_translation
f = None
if self.comments_enabled and request.POST:
extra = request._feincms_appcontent_parameters.get('page_extra_path', ())
if len(extra) > 0 and extra[0] == u"post-comment":
from django.contrib.comments.views.comments import post_comment
r = post_comment(request)
if not isinstance(r, HttpResponseRedirect):
f = comments.get_form()(comment_page, data=request.POST)
if f is None:
f = comments.get_form()(comment_page)
return render_to_string([
'content/comments/%s.html' % parent_type,
'content/comments/default-site.html',
'content/comments/default.html',
], RequestContext(request, { 'content': self, 'feincms_page' : self.parent, 'parent': comment_page, 'form' : f }))
def post(request, username, year, month, slug,
template_name="dpress/post.html"):
post = Post.objects.filter(slug=slug, publish__year=int(year),
publish__month=int(month)).filter(author__username=username)
if not post:
raise Http404
if post[0].status == 1 and post[0].author != request.user:
raise Http404
post=post[0]
user = request.user
initial={}
if user.is_authenticated():
initial={'name': user.username, 'email': user.email}
form = comments.get_form()(post, initial=initial)
if request.method == "POST":
data = request.POST.copy()
form = comments.get_form()(post, data=data)
if form.is_valid():
comment = form.get_comment_object()
comment.ip_address = request.META.get("REMOTE_ADDR", None)
if request.user.is_authenticated():
comment.user = request.user
comment.save()
return render_to_response(template_name, {
"post": post,
"form": form,
}, context_instance=RequestContext(request))
def render(self, **kwargs):
parent_type = self.parent.__class__.__name__.lower()
request = kwargs.get('request')
comment_page = self.parent
if hasattr(comment_page, 'original_translation') and comment_page.original_translation:
comment_page = comment_page.original_translation
f = None
if self.comments_enabled and request.POST:
# I guess the drawback is that this page can't handle any other types of posts
# just the comments for right now, but if we just post to the current path
# and handle it this way .. at least it works for now.
#extra = request._feincms_appcontent_parameters.get('page_extra_path', ())
#if len(extra) > 0 and extra[0] == u"post-comment":
from django.contrib.comments.views.comments import post_comment
r = post_comment(request)
if not isinstance(r, HttpResponseRedirect):
f = comments.get_form()(comment_page, data=request.POST)
if f is None:
f = comments.get_form()(comment_page)
return render_to_string([
'content/comments/%s.html' % parent_type,
'content/comments/default-site.html',
'content/comments/default.html',
], RequestContext(request, { 'content': self, 'feincms_page' : self.parent, 'parent': comment_page, 'form' : f }))
def test_notify_followers_dupes(self):
# first of all confirm Bob's comment otherwise it doesn't reach DB
self.get_confirm_comment_url(self.key)
# then put in play pull-request-15's assert...
# https://github.com/danirus/django-comments-xtd/pull/15
diary = Diary.objects.create(body='Lorem ipsum', allow_comments=True)
self.assertEqual(diary.pk, self.article.pk)
self.form = comments.get_form()(diary)
data = {
"name": "Charlie",
"email": "*****@*****.**",
"followup": True,
"reply_to": 0,
"level": 1,
"order": 1,
"comment": "Es war einmal eine kleine..."
}
data.update(self.form.initial)
self.response = self.client.post(reverse("comments-post-comment"),
data=data)
self.key = str(
re.search(r'http://.+/confirm/(?P<key>[\S]+)',
self.mock_mailer.call_args[0][1]).group("key"))
# 1) confirmation for Bob (sent in `setUp()`)
# 2) confirmation for Charlie
self.assertEqual(self.mock_mailer.call_count, 2)
self.get_confirm_comment_url(self.key)
self.assertEqual(self.mock_mailer.call_count, 2)
self.form = comments.get_form()(self.article)
data = {
"name": "Alice",
"email": "*****@*****.**",
"followup": True,
"reply_to": 0,
"level": 1,
"order": 1,
"comment": "Es war einmal iene kleine..."
}
data.update(self.form.initial)
self.response = self.client.post(reverse("comments-post-comment"),
data=data)
self.assertEqual(self.mock_mailer.call_count, 3)
self.key = re.search(r'http://.+/confirm/(?P<key>[\S]+)',
self.mock_mailer.call_args[0][1]).group("key")
self.get_confirm_comment_url(self.key)
self.assertEqual(self.mock_mailer.call_count, 4)
self.assert_(self.mock_mailer.call_args[0][3] == ["*****@*****.**"])
self.assert_(self.mock_mailer.call_args[0][1].find(
"There is a new comment following up yours.") > -1)
def test_job_comment(self):
mail.outbox = []
self.client.login(username=self.super_username,
password=self.super_password)
form = comments.get_form()(self.job1)
url = reverse('comments-post-comment')
form_data = {
'name': 'Reviewer',
'email': self.superuser.email,
'url': 'http://example.com',
'comment': 'Lorem ispum',
'reply_to': 0,
'post': 'Post'
}
form_data.update(form.initial)
self.assertEqual(len(mail.outbox), 0)
response = self.client.post(url, form_data)
self.assertEqual(response.status_code, 302)
self.assertIn('http://testserver/comments/posted/?c=',
response['Location'])
mail_sent_queue.get(block=True)
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].to,
[self.creator.email, '*****@*****.**'])
form = comments.get_form()(self.job1)
form_data = {
'name': 'creator',
'email': self.creator.email,
'url': 'http://example.com',
'comment': 'Lorem ispum',
'reply_to': 0,
'post': 'Post'
}
form_data.update(form.initial)
response = self.client.post(url, form_data)
self.assertEqual(response.status_code, 302)
self.assertIn('http://testserver/comments/posted/?c=',
response['Location'])
mail_sent_queue.get(block=True)
self.assertEqual(len(mail.outbox), 3)
self.assertEqual(mail.outbox[1].to,
[self.creator.email, '*****@*****.**'])
self.assertEqual(mail.outbox[2].to, [self.superuser.email])
def setUp(self):
patcher = patch('django_comments_xtd.views.send_mail')
self.mock_mailer = patcher.start()
self.article = Article.objects.create(
title="September",
slug="september",
body="What I did on September...")
self.form = comments.get_form()(self.article)
data = {
"name": "Bob",
"email": "*****@*****.**",
"followup": True,
"reply_to": 0,
"level": 1,
"order": 1,
"comment": "Es war einmal iene kleine..."
}
data.update(self.form.initial)
self.response = self.client.post(reverse("comments-post-comment"),
data=data)
self.assert_(self.mock_mailer.call_count == 1)
self.key = str(
re.search(r'http://.+/confirm/(?P<key>[\S]+)',
self.mock_mailer.call_args[0][1]).group("key"))
self.addCleanup(patcher.stop)
def get_form(self, context):
ctype, object_pk = self.get_target_ctype_pk(context)
if object_pk:
return comments.get_form()(
ctype.get_object_for_this_type(pk=object_pk))
else:
return None
def test_no_notification_for_same_user_email(self):
# test that a follow-up user_email don't get a notification when
# sending another email to the thread
self.assertEqual(self.mock_mailer.call_count, 1)
self.get_confirm_comment_url(self.key) # confirm Bob's comment
# no comment followers yet:
self.assertEqual(self.mock_mailer.call_count, 1)
# send Bob's 2nd comment
self.form = comments.get_form()(self.article)
data = {
"name": "Alice",
"email": "*****@*****.**",
"followup": True,
"reply_to": 0,
"level": 1,
"order": 1,
"comment": "Bob's comment he shouldn't get notified about"
}
data.update(self.form.initial)
self.response = self.client.post(reverse("comments-post-comment"),
data=data)
self.assertEqual(self.mock_mailer.call_count, 2)
self.key = re.search(r'http://.+/confirm/(?P<key>[\S]+)',
self.mock_mailer.call_args[0][1]).group("key")
self.get_confirm_comment_url(self.key)
self.assertEqual(self.mock_mailer.call_count, 2)
def setUp(self):
super(TestCommentModeration, self).setUp()
self.opts = CommentOptionsObject.objects.create(
target_ct=self.publishable.content_type,
target_id=self.publishable.pk,
premoderated=True)
self.form = comments.get_form()(target_object=self.publishable)
def threaded_comment_json(comment, viewer):
coll = ContentType.objects.get_for_model(Collaboration)
all = ThreadedComment.objects.filter(
content_type=coll, object_pk=comment.content_object.pk, site__pk=settings.SITE_ID
)
all = fill_tree(all)
all = annotate_tree_properties(all)
return {
"type": "discussion",
"form": comments.get_form()(comment.content_object).__unicode__(),
"editing": True,
"can_edit": True,
"discussion": {
"id": comment.id,
"max_length": COMMENT_MAX_LENGTH,
"thread": [
{
"open": obj.open if hasattr(obj, "open") else None,
"close": [i for i in obj.close] if hasattr(obj, "close") else None,
"id": obj.id,
"author": obj.name,
"author_username": obj.user.username,
"submit_date": pretty_date(obj.submit_date),
"title": obj.title,
"content": obj.comment,
"can_edit": True if obj.user == viewer else False,
}
for obj in all
],
},
}
def setUp(self):
patcher = patch('django_comments_xtd.views.send_mail')
self.mock_mailer = patcher.start()
self.article = Article.objects.create(title="October",
slug="october",
body="What I did on October...")
self.form = comments.get_form()(self.article)
def test_notify_comment_followers(self):
# send a couple of comments to the article with followup=True and check
# that when the second comment is confirmed a followup notification
# email is sent to the user who sent the first comment
self.assertEqual(len(mail.outbox), 1)
self.get_confirm_comment_url(self.key)
self.assertEqual(len(mail.outbox), 1) # no comment followers yet
# send 2nd comment
self.form = comments.get_form()(self.article)
data = {
"name": "Alice",
"email": "*****@*****.**",
"followup": True,
"reply_to": 0,
"level": 1,
"order": 1,
"comment": "Es war einmal iene kleine..."
}
data.update(self.form.initial)
self.response = self.client.post(reverse("comments-post-comment"),
data=data)
if mail_sent_queue.get(block=True):
pass
self.assertEqual(len(mail.outbox), 2)
self.key = re.search(r'http://.+/confirm/(?P<key>[\S]+)',
mail.outbox[1].body).group("key")
self.get_confirm_comment_url(self.key)
if mail_sent_queue.get(block=True):
pass
self.assertEqual(len(mail.outbox), 3)
self.assert_(mail.outbox[2].to == ["*****@*****.**"])
self.assert_(mail.outbox[2].body.find(
"There is a new comment following up yours.") > -1)
def new_comment(request, comment_id=None, *args, **kwargs):
is_ajax = request.GET.get('is_ajax') and '_ajax' or ''
if not comment_id:
return CommentPostBadRequest("Missing comment id.")
parent_comment = get_model().objects.get(pk=comment_id)
target = parent_comment.content_object
model = target.__class__
# Construct the initial comment form
form = get_form()(target, parent_comment=parent_comment)
template_list = [
"comments/%s_%s_new_form%s.html" % tuple(str(model._meta).split(".") + [is_ajax]),
"comments/%s_new_form%s.html" % (model._meta.app_label, is_ajax),
"comments/new_form%s.html" % is_ajax,
]
return render_to_response(
template_list, {
"form" : form,
},
RequestContext(request, {})
)
def reply(request, cid):
try:
comment = XtdComment.objects.get(pk=cid)
except (XtdComment.DoesNotExist):
raise Http404
if comment.level == max_thread_level_for_content_type(comment.content_type):
return render_to_response(
"django_comments_xtd/max_thread_level.html",
{'max_level': settings.COMMENTS_XTD_MAX_THREAD_LEVEL},
context_instance=RequestContext(request))
form = get_form()(comment.content_object, comment=comment)
next = request.GET.get("next", reverse("comments-xtd-sent"))
template_arg = [
"django_comments_xtd/%s/%s/reply.html" % (
comment.content_type.app_label,
comment.content_type.model),
"django_comments_xtd/%s/reply.html" % (
comment.content_type.app_label,),
"django_comments_xtd/reply.html"
]
return render_to_response(template_arg,
{"comment": comment, "form": form, "next": next },
context_instance=RequestContext(request))
def new_comment(request, comment_id=None, *args, **kwargs):
is_ajax = request.GET.get('is_ajax') and '_ajax' or ''
if not comment_id:
return CommentPostBadRequest("Missing comment id.")
parent_comment = get_model().objects.get(pk=comment_id)
target = parent_comment.content_object
model = target.__class__
# Construct the initial comment form
form = get_form()(target, parent_comment=parent_comment)
template_list = [
"comments/%s_%s_new_form%s.html" % tuple(str(model._meta).split(".") + [is_ajax]),
"comments/%s_new_form%s.html" % (model._meta.app_label, is_ajax),
"comments/new_form%s.html" % is_ajax,
]
return render_to_response(
template_list, {
"form" : form,
},
RequestContext(request, {})
)
def reply(request, cid):
try:
comment = XtdComment.objects.get(pk=cid)
except (XtdComment.DoesNotExist):
raise Http404
if comment.level == max_thread_level_for_content_type(comment.content_type):
return render_to_response(
"django_comments_xtd/max_thread_level.html",
{'max_level': settings.COMMENTS_XTD_MAX_THREAD_LEVEL},
context_instance=RequestContext(request))
form = get_form()(comment.content_object, comment=comment)
next = request.GET.get("next", reverse("comments-xtd-sent"))
template_arg = [
"django_comments_xtd/%s/%s/reply.html" % (
comment.content_type.app_label,
comment.content_type.model),
"django_comments_xtd/%s/reply.html" % (
comment.content_type.app_label,),
"django_comments_xtd/reply.html"
]
return render_to_response(template_arg,
{"comment": comment, "form": form, "next": next },
context_instance=RequestContext(request))
def test_notify_comment_followers(self):
# send a couple of comments to the article with followup=True and check
# that when the second comment is confirmed a followup notification
# email is sent to the user who sent the first comment
self.assertEqual(len(mail.outbox), 1)
self.get_confirm_comment_url(self.key)
self.assertEqual(len(mail.outbox), 1) # no comment followers yet
# send 2nd comment
self.form = comments.get_form()(self.article)
data = {"name":"Alice", "email":"*****@*****.**", "followup": True,
"reply_to": 0, "level": 1, "order": 1,
"comment":"Es war einmal iene kleine..." }
data.update(self.form.initial)
self.response = self.client.post(reverse("comments-post-comment"),
data=data)
if mail_sent_queue.get(block=True):
pass
self.assertEqual(len(mail.outbox), 2)
self.key = re.search(r'http://.+/confirm/(?P<key>[\S]+)',
mail.outbox[1].body).group("key")
self.get_confirm_comment_url(self.key)
if mail_sent_queue.get(block=True):
pass
self.assertEqual(len(mail.outbox), 3)
self.assert_(mail.outbox[2].to == ["*****@*****.**"])
self.assert_(mail.outbox[2].body.find("There is a new comment following up yours.") > -1)
def get_form(self, context):
ctype, object_pk = self.get_target_ctype_pk(context)
if object_pk:
return comments.get_form()(ctype.get_object_for_this_type(pk=object_pk),
parent_comment=None)
else:
return None
def new_comment(request, parent_pk=None, content_type=None, object_pk=None, *args, **kwargs):
"""
Display the form used to post a reply.
Expects a comment_id, and an optionnal 'is_ajax' parameter in request.GET.
"""
is_ajax = request.GET.get('is_ajax') and '_ajax' or ''
data = {
'parent_pk': parent_pk,
'content_type': content_type,
'object_pk': object_pk,
}
response = _lookup_content_object(data)
if isinstance(response, HttpResponse):
return response
else:
target, parent_comment, model = response
# Construct the initial comment form
form = get_form()(target, parent_comment=parent_comment)
template_list = [
"comments/%s_%s_new_form%s.html" % tuple(str(model._meta).split(".") + [is_ajax]),
"comments/%s_new_form%s.html" % (model._meta.app_label, is_ajax),
"comments/new_form%s.html" % is_ajax,
]
return TemplateResponse(request, template_list, { "form" : form })
def threaded_comment_json(comment, viewer):
coll = ContentType.objects.get_for_model(Collaboration)
all = ThreadedComment.objects.filter(content_type=coll, object_pk=comment.content_object.pk, site__pk=settings.SITE_ID)
all = fill_tree(all)
all = annotate_tree_properties(all)
return {
'type': 'discussion',
'form': comments.get_form()(comment.content_object).__unicode__(),
'editing': True,
'can_edit': True,
'discussion': {
'id': comment.id,
'max_length': COMMENT_MAX_LENGTH,
'thread': [{ 'open': obj.open if hasattr(obj, "open") else None,
'close': [ i for i in obj.close ] if hasattr(obj, "close") else None,
'id': obj.id,
'author': obj.name,
'author_username': obj.user.username,
'submit_date': pretty_date(obj.submit_date),
'title': obj.title,
'content': obj.comment,
'can_edit': True if obj.user == viewer else False
} for obj in all]
}
}
def post(request, template_name='comments/comments.html'):
"""
Post a comment.
HTTP POST is required.
"""
# Fill out some initial data fields from an authenticated user, if present
data = request.POST.copy()
if request.user.is_authenticated():
if not data.get('name', ''):
data["name"] = request.user.get_full_name() or request.user.username
if not data.get('email', ''):
data["email"] = request.user.email
# Look up the object we're trying to comment about
ctype = data.get("content_type")
object_pk = data.get("object_pk")
try:
model = models.get_model(*ctype.split(".", 1))
target = model._default_manager.get(pk=object_pk)
except:
raise
# Construct the comment form
form = comments.get_form()(target, data=data)
if not form.is_valid():
return direct_to_template(request, template_name, {
'object': target,
'form': form,
})
# Otherwise create the comment
comment = form.get_comment_object()
comment.ip_address = request.META.get("REMOTE_ADDR", None)
if request.user.is_authenticated():
comment.user = request.user
# Signal that the comment is about to be saved
responses = signals.comment_will_be_posted.send(
sender = comment.__class__,
comment = comment,
request = request
)
# Save the comment and signal that it was saved
comment.is_removed = False
comment.save()
signals.comment_was_posted.send(
sender = comment.__class__,
comment = comment,
request = request
)
return direct_to_template(request, template_name, {
'object': target,
'form': form,
})
def add(self):
import time
from django.db import models
from django.contrib import comments
from django.contrib.comments.views.comments import CommentPostBadRequest
from django.contrib.comments import signals
comment_form = comments.get_form()
try:
model = models.get_model(*self.content_type.split('.', 1))
targets = model._default_manager.filter(pk__in = self.object_pks)
except:
raise
for target in targets:
d_form = comment_form(target)
timestamp = str(time.time()).split('.')[0]
object_pk = str(target.pk)
data = {
'content_type': self.content_type,
'object_pk': object_pk,
'timestamp': timestamp,
'comment': self.comment
}
security_hash_dict = {
'content_type': self.content_type,
'object_pk': object_pk,
'timestamp': timestamp
}
data['security_hash'] = d_form.generate_security_hash(**security_hash_dict)
form = comment_form(target, data=data)
# Response the errors if got
if not form.is_valid():
return form.errors
# Otherwise create the comment
comment = form.get_comment_object()
comment.ip_address = self.request.META.get("REMOTE_ADDR", None)
if self.request.user.is_authenticated():
comment.user = self.request.user
# Signal that the comment is about to be saved
responses = signals.comment_will_be_posted.send(
sender = comment.__class__,
comment = comment,
request = self.request
)
# Save the comment and signal that it was saved
comment.save()
signals.comment_was_posted.send(
sender = comment.__class__,
comment = comment,
request = self.request
)
return
def threaded_comment_json(request, comment):
viewer = request.user
coll = ContentType.objects.get_for_model(Collaboration)
all_comments = ThreadedComment.objects.filter(
content_type=coll,
object_pk=comment.content_object.pk,
site__pk=settings.SITE_ID)
all_comments = fill_tree(all_comments)
all_comments = list(annotate_tree_properties(all_comments))
rand = ''.join([choice(letters) for i in range(5)])
citations = threaded_comment_citations(all_comments, viewer)
asset_resource = AssetResource()
sherd_resource = SherdNoteResource()
return {
'type':
'discussion',
'form':
comments.get_form()(comment.content_object).__unicode__(),
'editing':
True,
'can_edit':
True,
'discussion': {
'id':
comment.id,
'max_length':
COMMENT_MAX_LENGTH,
'thread': [{
'open':
obj.open if hasattr(obj, "open") else None,
'close':
[i for i in obj.close] if hasattr(obj, "close") else None,
'id':
obj.id,
'author':
obj.name,
'author_username':
obj.user.username,
'submit_date':
pretty_date(obj.submit_date),
'title':
obj.title,
'content':
obj.comment,
'can_edit':
True if obj.user == viewer else False
} for obj in all_comments]
},
'assets':
dict([('%s_%s' % (rand, ann.asset.pk),
asset_resource.render_one(request, ann.asset))
for ann in citations if (ann.title != "Annotation Deleted"
and ann.title != 'Asset Deleted')]),
'annotations':
[sherd_resource.render_one(request, ann, rand) for ann in citations],
}
def test_post_works_for_correct_data_with_parent(self):
c = create_comment(self.publishable, self.publishable.content_type)
form = comments.get_form()(target_object=self.publishable, parent=c.pk)
response = self.client.post(self.get_url('new'), self.get_form_data(form))
self.assert_equals(302, response.status_code)
self.assert_equals(2, comments.get_model().objects.count())
child = comments.get_model().objects.exclude(pk=c.pk)[0]
self.assert_equals(c, child.parent)
def test_post_from_banned_ip_does_not_work(self):
template_loader.templates['page/comment_form.html'] = ''
form = comments.get_form()(target_object=self.publishable)
response = self.client.post(self.get_url('new'), self.get_form_data(form))
self.assert_equals(200, response.status_code)
self.assert_equals(0, comments.get_model().objects.count())
self.assert_true('ip_ban' in response.context)
self.assert_equals(self.ip_ban, response.context['ip_ban'])
def test_job_comment(self):
mail.outbox = []
self.client.login(username=self.super_username, password=self.super_password)
form = comments.get_form()(self.job1)
url = reverse('comments-post-comment')
form_data = {
'name': 'Reviewer',
'email': self.superuser.email,
'url': 'http://example.com',
'comment': 'Lorem ispum',
'reply_to': 0,
'post': 'Post'
}
form_data.update(form.initial)
self.assertEqual(len(mail.outbox), 0)
response = self.client.post(url, form_data)
self.assertEqual(response.status_code, 302)
self.assertIn('http://testserver/comments/posted/?c=', response['Location'])
mail_sent_queue.get(block=True)
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].to, [self.creator.email, '*****@*****.**'])
form = comments.get_form()(self.job1)
form_data = {
'name': 'creator',
'email': self.creator.email,
'url': 'http://example.com',
'comment': 'Lorem ispum',
'reply_to': 0,
'post': 'Post'
}
form_data.update(form.initial)
response = self.client.post(url, form_data)
self.assertEqual(response.status_code, 302)
self.assertIn('http://testserver/comments/posted/?c=', response['Location'])
mail_sent_queue.get(block=True)
self.assertEqual(len(mail.outbox), 3)
self.assertEqual(mail.outbox[1].to, [self.creator.email, '*****@*****.**'])
self.assertEqual(mail.outbox[2].to, [self.superuser.email])
def get_form(self, context):
ctype, object_pk = self.get_target_ctype_pk(context)
parent_id = None
if self.parent:
parent_id = self.parent.resolve(context, ignore_failures=True)
if object_pk:
return comments.get_form()(ctype.get_object_for_this_type(pk=object_pk), parent=parent_id)
else:
return None
def post_comment(request, next=None, using=None):
"""
Post a comment.
HTTP POST is required. If ``POST['submit'] == "preview"`` or if there are
errors a preview template, ``comments/preview.html``, will be rendered.
"""
# Fill out some initial data fields from an authenticated user, if present
data = request.POST.copy()
if request.user.is_authenticated():
if not data.get('name', ''):
data["name"] = request.user.get_full_name() or request.user.username
if not data.get('email', ''):
data["email"] = request.user.email
# Check to see if the POST data overrides the view's next argument.
next = data.get("next", next)
# Look up the object we're trying to comment about
ctype = data.get("content_type")
object_pk = data.get("object_pk")
model = models.get_model(*ctype.split(".", 1))
target = model._default_manager.using(using).get(pk=object_pk)
# Construct the comment form
form = comments.get_form()(target, data=data)
# Check security information
if form.security_errors():
return None
# Create the comment
comment = form.get_comment_object()
comment.ip_address = request.META.get("REMOTE_ADDR", None)
if request.user.is_authenticated():
comment.user = request.user
# Signal that the comment is about to be saved
responses = signals.comment_will_be_posted.send(
sender = comment.__class__,
comment = comment,
request = request
)
# Save the comment and signal that it was saved
comment.save()
message = get_object_or_404(Message, pk = object_pk)
message.envoyer_commentaire_notification(comment.pk, request.user.username)
signals.comment_was_posted.send(
sender = comment.__class__,
comment = comment,
request = request
)
comment_list = [comment]
return render_to_response('comments/list.html', {'comment_list': comment_list},context_instance=RequestContext(request))
def test_post_works_for_correct_data_with_parent(self):
c = create_comment(self.publishable, self.publishable.content_type)
form = comments.get_form()(target_object=self.publishable, parent=c.pk)
response = self.client.post(self.get_url('new'),
self.get_form_data(form))
self.assert_equals(302, response.status_code)
self.assert_equals(2, comments.get_model().objects.count())
child = comments.get_model().objects.exclude(pk=c.pk)[0]
self.assert_equals(c, child.parent)
def test_post_from_banned_ip_does_not_work(self):
template_loader.templates['page/comment_form.html'] = ''
form = comments.get_form()(target_object=self.publishable)
response = self.client.post(self.get_url('new'),
self.get_form_data(form))
self.assert_equals(200, response.status_code)
self.assert_equals(0, comments.get_model().objects.count())
self.assert_true('ip_ban' in response.context)
self.assert_equals(self.ip_ban, response.context['ip_ban'])
def add(self):
import time
from django.contrib import comments
from django.contrib.comments import signals
from django.db import models
comment_form = comments.get_form()
try:
model = models.get_model(*self.content_type.split('.', 1))
targets = model._default_manager.filter(pk__in=self.object_pks)
except:
raise
for target in targets.iterator():
d_form = comment_form(target)
timestamp = str(time.time()).split('.')[0]
object_pk = str(target.pk)
data = {
'content_type': self.content_type,
'object_pk': object_pk,
'timestamp': timestamp,
'comment': self.comment
}
security_hash_dict = {
'content_type': self.content_type,
'object_pk': object_pk,
'timestamp': timestamp
}
data['security_hash'] = d_form.generate_security_hash(
**security_hash_dict)
form = comment_form(target, data=data)
# Response the errors if got
if not form.is_valid():
return form.errors
# Otherwise create the comment
comment = form.get_comment_object()
comment.ip_address = self.request.META.get("REMOTE_ADDR", None)
if self.request.user.is_authenticated():
comment.user = self.request.user
# Signal that the comment is about to be saved
responses = signals.comment_will_be_posted.send(
sender=comment.__class__,
comment=comment,
request=self.request)
# Save the comment and signal that it was saved
comment.save()
signals.comment_was_posted.send(sender=comment.__class__,
comment=comment,
request=self.request)
return
def process(self, request, **kwargs):
parent_type = self.parent.__class__.__name__.lower()
comment_page = self.parent
if (hasattr(comment_page, 'original_translation')
and comment_page.original_translation):
comment_page = comment_page.original_translation
f = None
if self.comments_enabled and request.POST:
# I guess the drawback is that this page can't handle any other
# types of posts just the comments for right now, but if we just
# post to the current path and handle it this way .. at least it
# works for now.
# extra = request._feincms_extra_context.get('page_extra_path', ())
# if len(extra) > 0 and extra[0] == "post-comment":
r = post_comment(request, next=comment_page.get_absolute_url())
if isinstance(r, HttpResponseRedirect):
return r
f = comments.get_form()(comment_page, data=request.POST)
if f is None:
f = comments.get_form()(comment_page)
self.rendered_output = render_to_string(
[
'content/comments/%s.html' % parent_type,
'content/comments/default-site.html',
'content/comments/default.html',
],
RequestContext(
request, {
'content': self,
'feincms_page': self.parent,
'parent': comment_page,
'form': f,
}),
)
def get_form(self, context):
parent_id = None
if self.parent:
parent_id = self.parent.resolve(context, ignore_failures=True)
obj = self.get_object(context)
if obj:
return comments.get_form()(obj, parent=parent_id)
else:
return None
def get_form(self, context):
parent_id = None
if self.parent:
parent_id = self.parent.resolve(context, ignore_failures=True)
obj = self.get_object(context)
if obj:
return comments.get_form()(obj, parent=parent_id)
else:
return None
def get_form(self, context):
ctype, object_pk = self.get_target_ctype_pk(context)
parent_id = None
if self.parent:
parent_id = self.parent.resolve(context, ignore_failures=True)
if object_pk:
return comments.get_form()(
ctype.get_object_for_this_type(pk=object_pk), parent=parent_id)
else:
return None
def get_comment_form(request, next=None, using=None, object_pk=None, ctype=None, curcomment=None, templates=None):
"""Request the comment by a get request
This also assure that refreshing the error page or the detailcomment
won't let to an http 405 error
"""
# this is a request.GET call
ctype = request.GET.get("ctype")
object_pk = request.GET.get("object_pk")
if (ctype is None or object_pk is None) and curcomment is None:
return CommentPostBadRequest("Missing content_type, object_pk or comment_id field.")
# we got the ctype and object_pk but not comment_id
if curcomment is None:
try:
model = models.get_model(*ctype.split(".", 1))
target = model._default_manager.using(using).get(pk=object_pk)
except TypeError:
return CommentPostBadRequest(
"Invalid content_type value: %r" % escape(ctype))
except AttributeError:
return CommentPostBadRequest(
"The given content-type %r does not resolve to a valid model." % \
escape(ctype))
except ObjectDoesNotExist:
return CommentPostBadRequest(
"No object matching content-type %r and object PK %r exists." % \
(escape(ctype), escape(object_pk)))
except (ValueError, ValidationError) as e:
return CommentPostBadRequest(
"Attempting go get content-type %r and object PK %r exists raised %s" % \
(escape(ctype), escape(object_pk), e.__class__.__name__))
else :
if curcomment.is_removed or curcomment.is_moderated:
# do not display reply form in those two cases
raise Http404
target = curcomment.content_object
# we are sending a new clean comment form
form = django_comment.get_form()(target)
ctx = {
"form": form,
"comment" : curcomment,
"post": target,
"object_pk": object_pk,
"ctype": ctype,
"next": get_model_target(object_pk) if curcomment is None else None,
}
return render_to_response(
templates,
ctx,
RequestContext(request, {})
)
def setUp(self):
# Creates an article and send two comments to the article with follow-up
# notifications. First comment doesn't have to send any notification.
# Second comment has to send one notification (to Bob).
patcher = patch('django_comments_xtd.views.send_mail')
self.mock_mailer = patcher.start()
self.article = Article.objects.create(title="September",
slug="september",
body="John's September")
self.form = comments.get_form()(self.article)
# Bob sends 1st comment to the article with follow-up
data = {
"name": "Bob",
"email": "*****@*****.**",
"followup": True,
"reply_to": 0,
"level": 1,
"order": 1,
"comment": "Nice September you had..."
}
data.update(self.form.initial)
response = self.client.post(reverse("comments-post-comment"),
data=data)
self.assert_(self.mock_mailer.call_count == 1)
bobkey = str(
re.search(r'http://.+/confirm/(?P<key>[\S]+)',
self.mock_mailer.call_args[0][1]).group("key"))
self.get_confirm_comment_url(bobkey) # confirm Bob's comment
# Alice sends 2nd comment to the article with follow-up
data = {
"name": "Alice",
"email": "*****@*****.**",
"followup": True,
"reply_to": 1,
"level": 1,
"order": 1,
"comment": "Yeah, great photos"
}
data.update(self.form.initial)
response = self.client.post(reverse("comments-post-comment"),
data=data)
self.assert_(self.mock_mailer.call_count == 2)
alicekey = str(
re.search(r'http://.+/confirm/(?P<key>[\S]+)',
self.mock_mailer.call_args[0][1]).group("key"))
self.get_confirm_comment_url(alicekey) # confirm Alice's comment
# Bob receives a follow-up notification
self.assert_(self.mock_mailer.call_count == 3)
self.bobs_mutekey = str(
re.search(r'http://.+/mute/(?P<key>[\S]+)',
self.mock_mailer.call_args[0][1]).group("key"))
self.addCleanup(patcher.stop)
def process(self, request, **kwargs):
parent_type = self.parent.__class__.__name__.lower()
comment_page = self.parent
if (hasattr(comment_page, 'original_translation')
and comment_page.original_translation):
comment_page = comment_page.original_translation
f = None
if self.comments_enabled and request.POST:
# I guess the drawback is that this page can't handle any other
# types of posts just the comments for right now, but if we just
# post to the current path and handle it this way .. at least it
# works for now.
#extra = request._feincms_extra_context.get('page_extra_path', ())
#if len(extra) > 0 and extra[0] == "post-comment":
r = post_comment(request, next=comment_page.get_absolute_url())
if isinstance(r, HttpResponseRedirect):
return r
f = comments.get_form()(comment_page, data=request.POST)
if f is None:
f = comments.get_form()(comment_page)
self.rendered_output = render_to_string(
[
'content/comments/%s.html' % parent_type,
'content/comments/default-site.html',
'content/comments/default.html',
],
RequestContext(request, {
'content': self,
'feincms_page': self.parent,
'parent': comment_page,
'form': f,
}),
)
def render_review_form(request, target):
form = comments.get_form()(target)
context = {
"comment" : form.data.get("comment", ""),
"form" : form,
"item": target,
}
request_context = RequestContext(request, {})
return render_to_string(get_template_list(Item, 'form'),
context,
request_context)
def test_notify_followers_dupes(self):
# first of all confirm Bob's comment otherwise it doesn't reach DB
self.get_confirm_comment_url(self.key)
# then put in play pull-request-15's assert...
# https://github.com/danirus/django-comments-xtd/pull/15
diary = Diary.objects.create(
body='Lorem ipsum',
allow_comments=True
)
self.assertEqual(diary.pk, self.article.pk)
self.form = comments.get_form()(diary)
data = {"name": "Charlie", "email": "*****@*****.**",
"followup": True, "reply_to": 0, "level": 1, "order": 1,
"comment": "Es war einmal eine kleine..." }
data.update(self.form.initial)
self.response = self.client.post(reverse("comments-post-comment"),
data=data)
self.key = str(re.search(r'http://.+/confirm/(?P<key>[\S]+)',
self.mock_mailer.call_args[0][1]).group("key"))
# 1) confirmation for Bob (sent in `setUp()`)
# 2) confirmation for Charlie
self.assertEqual(self.mock_mailer.call_count, 2)
self.get_confirm_comment_url(self.key)
self.assertEqual(self.mock_mailer.call_count, 2)
self.form = comments.get_form()(self.article)
data = {"name":"Alice", "email":"*****@*****.**", "followup": True,
"reply_to": 0, "level": 1, "order": 1,
"comment":"Es war einmal iene kleine..." }
data.update(self.form.initial)
self.response = self.client.post(reverse("comments-post-comment"),
data=data)
self.assertEqual(self.mock_mailer.call_count, 3)
self.key = re.search(r'http://.+/confirm/(?P<key>[\S]+)',
self.mock_mailer.call_args[0][1]).group("key")
self.get_confirm_comment_url(self.key)
self.assertEqual(self.mock_mailer.call_count, 4)
self.assert_(self.mock_mailer.call_args[0][3] == ["*****@*****.**"])
self.assert_(self.mock_mailer.call_args[0][1].find("There is a new comment following up yours.") > -1)
def get_form(self, context):
ctype, object_pk = self.get_target_ctype_pk(context)
if object_pk:
initial = None
if 'user' in context and context['user'].is_authenticated():
initial = { 'name': (context['user'].get_full_name() or
context['user'].username),
'email': context['user'].email }
return comments.get_form()(
ctype.get_object_for_this_type(pk=object_pk), initial=initial)
else:
return None
def comment(request) :
if request.method == 'POST' :
prod_id = request.POST['object_pk']
prod = Product.objects.get(pk=prod_id)
post_values = request.POST.copy()
post_values['name']= request.user.first_name + request.user.last_name
post_values['email']= request.user.email
comm_form = get_form()
form = comm_form(target_object=prod, data=post_values)
if (form.is_valid()) :
form.save()
return HttpResponseRedirect(request.POST['next'])
return HttpResponseRedirect('/')
def comment(request):
if request.method == 'POST':
prod_id = request.POST['object_pk']
prod = Product.objects.get(pk=prod_id)
post_values = request.POST.copy()
post_values['name'] = request.user.first_name + request.user.last_name
post_values['email'] = request.user.email
comm_form = get_form()
form = comm_form(target_object=prod, data=post_values)
if (form.is_valid()):
form.save()
return HttpResponseRedirect(request.POST['next'])
return HttpResponseRedirect('/')
def _post_comment(self, data=None, parent=None):
Comment = comments.get_model()
body = (data or self.BASE_DATA).copy()
url = comments.get_form_target()
args = [Site.objects.all()[0]]
kwargs = {}
if parent is not None:
kwargs['parent'] = unicode(parent.pk)
body['parent'] = unicode(parent.pk)
form = comments.get_form()(*args, **kwargs)
body.update(form.generate_security_data())
self.client.post(url, body, follow=True)
return Comment.objects.order_by('-id')[0]
def __get_form(request):
"""
Validates and returns the form. Modified post_comment from
django.contrib.comments.views.comments
"""
# Fill out some initial data fields from an authenticated user, if present
data = request.POST.copy()
if request.user.is_authenticated():
if not data.get('name', ''):
data["name"] = request.user.get_full_name(
) or request.user.username
if not data.get('email', ''):
data["email"] = request.user.email
# Check to see if the POST data overrides the view's next argument.
#next = data.get("next", next) #not necessary
# Look up the object we're trying to comment about
ctype = data.get("content_type")
object_pk = data.get("object_pk")
if ctype is None or object_pk is None:
return CommentPostBadRequest(
"Missing content_type or object_pk field.")
try:
model = models.get_model(*ctype.split(".", 1))
target = model._default_manager.get(pk=object_pk)
except TypeError:
return CommentPostBadRequest("Invalid content_type value: %r" %
escape(ctype))
except AttributeError:
return CommentPostBadRequest(
"The given content-type %r does not resolve to a valid model." % \
escape(ctype))
except ObjectDoesNotExist:
return CommentPostBadRequest(
"No object matching content-type %r and object PK %r exists." % \
(escape(ctype), escape(object_pk)))
# Do we want to preview the comment?
preview = "preview" in data
# Construct the comment form
form = comments.get_form()(target, data=data)
# Check security information
if form.security_errors():
return CommentPostBadRequest(
"The comment form failed security verification: %s" % \
escape(str(form.security_errors())))
return form
def restaurant(request, slug):
restaurant = get_object_or_404(Restaurant, slug=slug)
mform = MenuItemForm(prefix="menu")
cform = comments.get_form()(restaurant)
ajax = process_ajax(request, restaurant)
if ajax:
return ajax
if request.method == "POST":
if request.GET["type"] == "menu":
mform = MenuItemForm(request.POST, prefix="menu")
if mform.is_valid():
model = mform.save(commit=False)
model.user = request.user
model.restaurant = restaurant
model.is_available = True
model.save()
mform = MenuItemForm(prefix="menu")
return HttpResponseRedirect("./")
else :
cform = comments.get_form()(restaurant, data=request.POST.copy())
if cform.is_valid():
comment = cform.get_comment_object()
comment.ip_address = request.META.get("REMOTE_ADDR", None)
if request.user.is_authenticated():
comment.user = request.user
comment.save()
cform = comments.get_form()(restaurant)
return HttpResponseRedirect("./")
del cform.fields['honeypot']
del cform.fields['url']
referer = request.environ.get("HTTP_REFERER")
if referer != None:
if referer.startswith("http://stumptownvegans.com/") or referer.startswith("http://localhost:8000/") and not ReferingSite.objects.all().filter(url=referer) and not ReferingSite.objects.all().filter(restaurant=restaurant):
try:
ReferingSite(restaurant=restaurant, url=referer).save()
except:
logging.critical(traceback.format_exc())
return render_to_response("restaurants/restaurant_detail.html", {'menu_form': mform, 'comment_form': cform, 'object': restaurant, 'menu':restaurant.menuitem_set.all().order_by("category") ,'tags':getTags(restaurant)}, context_instance=RequestContext(request))
def post_comment_as_logged_in_user(self):
c = create_comment(self.publishable, self.publishable.content_type)
boy = User.objects.create(username='******', email='*****@*****.**')
boy.set_password('boy')
boy.save()
self.client.login(username='******', password='******')
form = comments.get_form()(target_object=self.publishable, parent=c.pk)
data = { 'name': '', 'email': '', }
response = self.client.post(self.get_url('new'), self.get_form_data(form, **data))
tools.assert_equals(302, response.status_code)
tools.assert_equals(2, comments.get_model().objects.count())
child = comments.get_model().objects.exclude(pk=c.pk)[0]
tools.assert_equals(u'boy', child.user_name)
tools.assert_equals(u'*****@*****.**', child.user_email)
def setUp(self):
# Create an article and send a comment. Test method will chech headers
# to see wheter messages has multiparts or not.
patcher = patch('django_comments_xtd.views.send_mail')
self.mock_mailer = patcher.start()
self.article = Article.objects.create(
title="September", slug="september", body="John's September")
self.form = comments.get_form()(self.article)
# Bob sends 1st comment to the article with follow-up
self.data = {"name": "Bob", "email": "*****@*****.**",
"followup": True, "reply_to": 0, "level": 1, "order": 1,
"comment": "Nice September you had..." }
self.data.update(self.form.initial)
def setUp(self):
self.article = Article.objects.create(title="September",
slug="september",
body="What I did on September...")
self.form = comments.get_form()(self.article)
data = {"name":"Bob", "email":"*****@*****.**", "followup": True,
"comment":"Es war einmal iene kleine..." }
data.update(self.form.initial)
self.response = self.client.post(reverse("comments-post-comment"),
data=data)
if mail_sent_queue.get(block=True):
pass
self.key = re.search(r'http://.+/confirm/(?P<key>[\S]+)',
mail.outbox[0].body).group("key")
def process(self, request, **kwargs):
parent_type = self.parent.__class__.__name__.lower()
comment_page = self.parent
if hasattr(comment_page, "original_translation") and comment_page.original_translation:
comment_page = comment_page.original_translation
f = None
if self.comments_enabled and request.POST:
# I guess the drawback is that this page can't handle any other types of posts
# just the comments for right now, but if we just post to the current path
# and handle it this way .. at least it works for now.
# extra = request._feincms_extra_context.get('page_extra_path', ())
# if len(extra) > 0 and extra[0] == u"post-comment":
from django.contrib.comments.views.comments import post_comment
r = post_comment(request, next=comment_page.get_absolute_url())
if isinstance(r, HttpResponseRedirect):
return r
f = comments.get_form()(comment_page, data=request.POST)
if f is None:
f = comments.get_form()(comment_page)
self.rendered_output = render_to_string(
[
"content/comments/%s.html" % parent_type,
"content/comments/default-site.html",
"content/comments/default.html",
],
RequestContext(request, {"content": self, "feincms_page": self.parent, "parent": comment_page, "form": f}),
)
def reply(request, comment_id, template_name="comments/reply_form.html"):
comment = get_object_or_404(comments.get_model(), pk=comment_id)
form = comments.get_form()(comment.content_object,
initial={
"parent_id": comment.id
})
return render(
request, template_name, {
"object": comment.content_object,
"form": form,
"form_id": "{}-reply-{}".format(comment.content_object.id,
comment_id),
"form_target": reverse("comment_reply", args=[comment_id]),
})
def _post_comment(self, data=None, parent=None):
Comment = comments.get_model()
body = self.BASE_DATA.copy()
if data:
body.update(data)
url = comments.get_form_target()
args = [Site.objects.all()[0]]
kwargs = {}
if parent is not None:
kwargs['parent'] = unicode(parent.pk)
body['parent'] = unicode(parent.pk)
form = comments.get_form()(*args, **kwargs)
body.update(form.generate_security_data())
self.client.post(url, body, follow=True)
return Comment.objects.order_by('-id')[0]
def get_form(self, context):
ctype, object_pk = self.get_target_ctype_pk(context)
if object_pk:
initial = None
if 'user' in context and context['user'].is_authenticated():
initial = {
'name': (context['user'].get_full_name()
or context['user'].username),
'email':
context['user'].email
}
return comments.get_form()(
ctype.get_object_for_this_type(pk=object_pk), initial=initial)
else:
return None
def create(request,
content_type_id,
object_id,
template_name="comments/reply_form.html"):
print content_type_id, object_id
ctype = get_object_or_404(ContentType, id=content_type_id)
entity = get_object_or_404(ctype.model_class(), pk=object_id)
print ctype, entity
form = comments.get_form()(entity)
return render(
request, template_name, {
"object": entity,
"form": form,
"form_id": "{}-comment".format(entity.id),
})
def post_comment(request, next=None, using=None):
form = RecaptchaForm(request.POST)
data = request.session['data']
model = request.session['model']
target = request.session['target']
next = data.get("next", next)
if form.is_valid():
form = comments.get_form()(target, data=data)
comment = form.get_comment_object()
comment.ip_address = request.META.get("REMOTE_ADDR", None)
if request.user.is_authenticated():
comment.user = request.user
# Signal that the comment is about to be saved
responses = signals.comment_will_be_posted.send(
sender=comment.__class__, comment=comment, request=request)
for (receiver, response) in responses:
if response == False:
return CommentPostBadRequest(
"comment_will_be_posted receiver %r killed the comment" %
receiver.__name__)
# Save the comment and signal that it was saved
comment.save()
signals.comment_was_posted.send(sender=comment.__class__,
comment=comment,
request=request)
return next_redirect(data, next, comment_done, c=comment._get_pk_val())
else:
template_list = [
"comments/%s_%s_verify.html" %
(model._meta.app_label, model._meta.module_name),
"comments/%s_verify.html" % model._meta.app_label,
"comments/%s/%s/verify.html" %
(model._meta.app_label, model._meta.module_name),
"comments/%s/verify.html" % model._meta.app_label,
"comments/verify.html",
]
return render_to_response(
template_list, {
"comment": request.session['data'].get("comment", ""),
"form": form,
"next": next,
}, RequestContext(request, {}))
def test_get_comment_create_data(self):
# as it's used in django.contrib.comments.views.comments
data = {"name":"Daniel",
"email":"*****@*****.**",
"followup": True,
"comment":"Es war einmal iene kleine..." }
data.update(self.form.initial)
form = comments.get_form()(self.article, data)
self.assert_(self.form.security_errors() == {})
self.assert_(self.form.errors == {})
comment = form.get_comment_object()
# it does have the new field 'followup'
self.assert_(comment.has_key("followup"))
# and as long as settings.COMMENTS_XTD_CONFIRM_EMAIL is True
# is_public is set to False until receive the user confirmation
self.assert_(comment.is_public == False)
def lucidTag(request):
if (settings.DEBUG or request.user.is_superuser) and not settings.ADMINS:
messages.info(request, "Please fill out settings.ADMINS!")
object2comment = request.PYLUCID.object2comment
if object2comment == False:
# Don't display pylucid comments on this page
# e.g. search get view display search results
return ""
form = comments.get_form()(object2comment)
context = {
"form":form,
"object2comment": object2comment,
}
return render_to_response("pylucid_comments/comments.html",
context, context_instance=RequestContext(request)
)
def post_comment(request, next=None, using=None):
if request.is_ajax():
# Fill out some initial data fields from an authenticated user, if present
data = request.POST.copy()
if not data.get('name', ''):
data["name"] = request.user.username
if not data.get('email', ''):
data["email"] = request.user.email
print >> sys.stderr, data
# Look up the object we're trying to comment about
ctype = data.get("content_type")
object_pk = data.get("object_pk")
model = models.get_model(*ctype.split(".", 1))
target = model._default_manager.using(using).get(pk=object_pk)
# Construct the comment form
form = comments.get_form()(target, data=data)
# Otherwise create the comment
comment = form.get_comment_object()
comment.ip_address = request.META.get("REMOTE_ADDR", None)
if request.user.is_authenticated():
comment.user = request.user
# Signal that the comment is about to be saved
responses = signals.comment_will_be_posted.send(
sender=comment.__class__, comment=comment, request=request)
# Save the comment and signal that it was saved
comment.save()
signals.comment_was_posted.send(sender=comment.__class__,
comment=comment,
request=request)
return render_to_response('recipe/comment.html', {'comment': comment})
else:
raise http.Http404
