def test_zinnia_trackback(self):
setup_test_template_loader({"404.html": ""})
response = self.client.post("/trackback/404/")
self.assertEquals(response.status_code, 404)
restore_template_loaders()
self.assertEquals(self.client.post("/trackback/1/").status_code, 301)
self.assertEquals(self.client.get("/trackback/1/").status_code, 301)
entry = Entry.objects.get(slug="test-1")
self.assertEquals(entry.trackback_count, 0)
entry.trackback_enabled = False
entry.save()
self.assertEquals(
self.client.post("/trackback/1/", {"url": "http://example.com"}).content,
'<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n '
"<error>1</error>\n <message>Trackback is not enabled for "
"Test 1</message>\n \n</response>\n",
)
entry.trackback_enabled = True
entry.save()
connect_discussion_signals()
get_user_flagger() # Memoize user flagger for stable query number
with self.assertNumQueries(6):
self.assertEquals(
self.client.post("/trackback/1/", {"url": "http://example.com"}).content,
'<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n ' "<error>0</error>\n \n</response>\n",
)
disconnect_discussion_signals()
entry = Entry.objects.get(pk=entry.pk)
self.assertEquals(entry.trackback_count, 1)
self.assertEquals(
self.client.post("/trackback/1/", {"url": "http://example.com"}).content,
'<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n '
"<error>1</error>\n <message>Trackback is already registered"
"</message>\n \n</response>\n",
)
def test_get_user_flagged_does_not_exist_twice_issue_245(self):
original_user_id = flags.COMMENT_FLAG_USER_ID
flags.COMMENT_FLAG_USER_ID = None
flagger = get_user_flagger()
self.assertEqual(flagger.username, 'Zinnia-Flagger')
self.clear_user_flagger_cache()
flagger = get_user_flagger()
self.assertEqual(flagger.username, 'Zinnia-Flagger')
flags.COMMENT_FLAG_USER_ID = original_user_id
def test_get_user_flagged_does_not_exist_twice_issue_245(self):
original_user_id = flags.COMMENT_FLAG_USER_ID
flags.COMMENT_FLAG_USER_ID = None
flagger = get_user_flagger()
self.assertEquals(flagger.username, 'Zinnia-Flagger')
self.clear_user_flagger_cache()
flagger = get_user_flagger()
self.assertEquals(flagger.username, 'Zinnia-Flagger')
flags.COMMENT_FLAG_USER_ID = original_user_id
def import_comments(self, entry, comment_nodes):
"""Loops over comments nodes and import then
in django.contrib.comments"""
for comment_node in comment_nodes:
is_pingback = comment_node.find("{%s}comment_type" % WP_NS).text == PINGBACK
is_trackback = comment_node.find("{%s}comment_type" % WP_NS).text == TRACKBACK
title = "Comment #%s" % (comment_node.find("{%s}comment_id" % WP_NS).text)
self.write_out(" > %s... " % title)
content = comment_node.find("{%s}comment_content" % WP_NS).text
if not content:
self.write_out(self.style.NOTICE("SKIPPED (unfilled)\n"))
return
submit_date = datetime.strptime(comment_node.find("{%s}comment_date" % WP_NS).text, "%Y-%m-%d %H:%M:%S")
if settings.USE_TZ:
submit_date = timezone.make_aware(submit_date, timezone.utc)
approvation = comment_node.find("{%s}comment_approved" % WP_NS).text
is_public = True
is_removed = False
if approvation != "1":
is_removed = True
if approvation == "spam":
is_public = False
comment_dict = {
"content_object": entry,
"site": self.SITE,
"user_name": comment_node.find("{%s}comment_author" % WP_NS).text[:50],
"user_email": comment_node.find("{%s}comment_author_email" % WP_NS).text or "",
"user_url": comment_node.find("{%s}comment_author_url" % WP_NS).text or "",
"comment": content,
"submit_date": submit_date,
"ip_address": comment_node.find("{%s}comment_author_IP" % WP_NS).text or "",
"is_public": is_public,
"is_removed": is_removed,
}
comment = comments.get_model()(**comment_dict)
comment.save()
if is_pingback:
comment.flags.create(user=get_user_flagger(), flag=PINGBACK)
if is_trackback:
comment.flags.create(user=get_user_flagger(), flag=TRACKBACK)
self.write_out(self.style.ITEM("OK\n"))
entry.comment_count = entry.comments.count()
entry.pingback_count = entry.pingbacks.count()
entry.trackback_count = entry.trackbacks.count()
entry.save(force_update=True)
def test_zinnia_trackback(self):
setup_test_template_loader({'404.html': ''})
response = self.client.post('/trackback/404/')
self.assertEquals(response.status_code, 404)
restore_template_loaders()
self.assertEquals(self.client.post('/trackback/1/').status_code, 301)
self.assertEquals(self.client.get('/trackback/1/').status_code, 301)
entry = Entry.objects.get(slug='test-1')
self.assertEquals(entry.trackback_count, 0)
entry.trackback_enabled = False
entry.save()
self.assertEquals(
self.client.post('/trackback/1/', {
'url': 'http://example.com'
}).content,
'<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n '
'<error>1</error>\n <message>Trackback is not enabled for '
'Test 1</message>\n \n</response>\n')
entry.trackback_enabled = True
entry.save()
connect_discussion_signals()
get_user_flagger() # Memoize user flagger for stable query number
if comments.get_comment_app_name() == comments.DEFAULT_COMMENTS_APP:
# If we are not using the default comment app,
# we can count the database queries executed.
with self.assertNumQueries(6):
self.assertEquals(
self.client.post('/trackback/1/', {
'url': 'http://example.com'
}).content,
'<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n '
'<error>0</error>\n \n</response>\n')
else:
self.assertEquals(
self.client.post('/trackback/1/', {
'url': 'http://example.com'
}).content,
'<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n '
'<error>0</error>\n \n</response>\n')
disconnect_discussion_signals()
entry = Entry.objects.get(pk=entry.pk)
self.assertEquals(entry.trackback_count, 1)
self.assertEquals(
self.client.post('/trackback/1/', {
'url': 'http://example.com'
}).content,
'<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n '
'<error>1</error>\n <message>Trackback is already registered'
'</message>\n \n</response>\n')
def test_zinnia_trackback(self):
setup_test_template_loader(
{'404.html': ''})
response = self.client.post('/trackback/404/')
self.assertEquals(response.status_code, 404)
restore_template_loaders()
self.assertEquals(
self.client.post('/trackback/1/').status_code, 301)
self.assertEquals(
self.client.get('/trackback/1/').status_code, 301)
entry = Entry.objects.get(slug='test-1')
self.assertEquals(entry.trackback_count, 0)
entry.trackback_enabled = False
entry.save()
self.assertEquals(
self.client.post('/trackback/1/',
{'url': 'http://example.com'}).content,
'<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n '
'<error>1</error>\n <message>Trackback is not enabled for '
'Test 1</message>\n \n</response>\n')
entry.trackback_enabled = True
entry.save()
connect_discussion_signals()
get_user_flagger() # Memoize user flagger for stable query number
if comments.get_comment_app_name() == comments.DEFAULT_COMMENTS_APP:
# If we are not using the default comment app,
# we can count the database queries executed.
with self.assertNumQueries(6):
self.assertEquals(
self.client.post('/trackback/1/',
{'url': 'http://example.com'}).content,
'<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n'
' <error>0</error>\n \n</response>\n')
else:
self.assertEquals(
self.client.post('/trackback/1/',
{'url': 'http://example.com'}).content,
'<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n '
'<error>0</error>\n \n</response>\n')
disconnect_discussion_signals()
entry = Entry.objects.get(pk=entry.pk)
self.assertEquals(entry.trackback_count, 1)
self.assertEquals(
self.client.post('/trackback/1/',
{'url': 'http://example.com'}).content,
'<?xml version="1.0" encoding="utf-8"?>\n<response>\n \n '
'<error>1</error>\n <message>Trackback is already registered'
'</message>\n \n</response>\n')
def pingback_ping(source, target):
"""pingback.ping(sourceURI, targetURI) => 'Pingback message'
Notifies the server that a link has been added to sourceURI,
pointing to targetURI.
See: http://hixie.ch/specs/pingback/pingback-1.0"""
try:
if source == target:
return UNDEFINED_ERROR
site = Site.objects.get_current()
try:
document = ''.join(urlopen(source).readlines())
except (HTTPError, URLError):
return SOURCE_DOES_NOT_EXIST
if not target in document:
return SOURCE_DOES_NOT_LINK
scheme, netloc, path, query, fragment = urlsplit(target)
if netloc != site.domain:
return TARGET_DOES_NOT_EXIST
try:
view, args, kwargs = resolve(path)
except Resolver404:
return TARGET_DOES_NOT_EXIST
try:
entry = Entry.published.get(
slug=kwargs['slug'],
creation_date__year=kwargs['year'],
creation_date__month=kwargs['month'],
creation_date__day=kwargs['day'])
if not entry.pingbacks_are_open:
return TARGET_IS_NOT_PINGABLE
except (KeyError, Entry.DoesNotExist):
return TARGET_IS_NOT_PINGABLE
soup = BeautifulSoup(document)
title = soup.find('title')
title = title and strip_tags(title) or _('No title')
description = generate_pingback_content(soup, target,
PINGBACK_CONTENT_LENGTH)
pingback, created = comments.get_model().objects.get_or_create(
content_type=ContentType.objects.get_for_model(Entry),
object_pk=entry.pk, user_url=source, site=site,
defaults={'comment': description, 'user_name': title,
'submit_date': timezone.now()})
if created:
pingback.flags.create(user=get_user_flagger(), flag=PINGBACK)
pingback_was_posted.send(pingback.__class__,
pingback=pingback,
entry=entry)
return 'Pingback from %s to %s registered.' % (source, target)
return PINGBACK_ALREADY_REGISTERED
except:
return UNDEFINED_ERROR
def post(self, request, *args, **kwargs):
"""Check if an URL is provided and if trackbacks
are enabled on the Entry. If so the URL is registered
one time as a trackback"""
url = request.POST.get('url')
if not url:
return self.get(request, *args, **kwargs)
entry = self.get_object()
site = Site.objects.get_current()
if not entry.trackbacks_are_open:
return self.render_to_response(
{'error': u'Trackback is not enabled for %s' % entry.title})
title = request.POST.get('title') or url
excerpt = request.POST.get('excerpt') or title
blog_name = request.POST.get('blog_name') or title
trackback, created = comments.get_model().objects.get_or_create(
content_type=ContentType.objects.get_for_model(Entry),
object_pk=entry.pk, site=site, user_url=url,
user_name=blog_name, defaults={'comment': excerpt})
if created:
trackback.flags.create(user=get_user_flagger(), flag=TRACKBACK)
trackback_was_posted.send(trackback.__class__,
trackback=trackback,
entry=entry)
else:
return self.render_to_response(
{'error': u'Trackback is already registered'})
return self.render_to_response({})
def post(self, request, *args, **kwargs):
"""Check if an URL is provided and if trackbacks
are enabled on the Entry. If so the URL is registered
one time as a trackback"""
url = request.POST.get('url')
if not url:
return self.get(request, *args, **kwargs)
entry = self.get_object()
site = Site.objects.get_current()
if not entry.pingback_enabled:
return self.render_to_response(
{'error': u'Trackback is not enabled for %s' % entry.title})
title = request.POST.get('title') or url
excerpt = request.POST.get('excerpt') or title
blog_name = request.POST.get('blog_name') or title
comment, created = comments.get_model().objects.get_or_create(
content_type=ContentType.objects.get_for_model(Entry),
object_pk=entry.pk, site=site, user_url=url,
user_name=blog_name, defaults={'comment': excerpt})
if created:
comment.flags.create(user=get_user_flagger(), flag=TRACKBACK)
else:
return self.render_to_response(
{'error': u'Trackback is already registered'})
return self.render_to_response({})
def pingback_ping(source, target):
"""pingback.ping(sourceURI, targetURI) => 'Pingback message'
Notifies the server that a link has been added to sourceURI,
pointing to targetURI.
See: http://hixie.ch/specs/pingback/pingback-1.0"""
try:
if source == target:
return UNDEFINED_ERROR
site = Site.objects.get_current()
try:
document = ''.join(urlopen(source).readlines())
except (HTTPError, URLError):
return SOURCE_DOES_NOT_EXIST
if not target in document:
return SOURCE_DOES_NOT_LINK
scheme, netloc, path, query, fragment = urlsplit(target)
if netloc != site.domain:
return TARGET_DOES_NOT_EXIST
try:
view, args, kwargs = resolve(path)
except Resolver404:
return TARGET_DOES_NOT_EXIST
try:
entry = Entry.published.get(slug=kwargs['slug'],
creation_date__year=kwargs['year'],
creation_date__month=kwargs['month'],
creation_date__day=kwargs['day'])
if not entry.pingback_enabled:
return TARGET_IS_NOT_PINGABLE
except (KeyError, Entry.DoesNotExist):
return TARGET_IS_NOT_PINGABLE
soup = BeautifulSoup(document)
title = soup.find('title')
title = title and strip_tags(title) or _('No title')
description = generate_pingback_content(soup, target,
PINGBACK_CONTENT_LENGTH)
comment, created = comments.get_model().objects.get_or_create(
content_type=ContentType.objects.get_for_model(Entry),
object_pk=entry.pk,
user_url=source,
site=site,
defaults={
'comment': description,
'user_name': title
})
if created:
comment.flags.create(user=get_user_flagger(), flag=PINGBACK)
return 'Pingback from %s to %s registered.' % (source, target)
return PINGBACK_ALREADY_REGISTERED
except:
return UNDEFINED_ERROR
def test_zinnia_trackback(self):
# Clear the cache of user flagger to avoid error on MySQL
get_user_flagger.cache_clear()
# Disable spam-checkers
import zinnia.spam_checker
original_scb = zinnia.spam_checker.SPAM_CHECKER_BACKENDS
zinnia.spam_checker.SPAM_CHECKER_BACKENDS = []
response = self.client.post('/trackback/404/')
trackback_url = '/trackback/%s/' % self.first_entry.pk
self.assertEqual(response.status_code, 404)
self.assertEqual(self.client.post(trackback_url).status_code, 301)
self.first_entry.trackback_enabled = False
self.first_entry.save()
self.assertEqual(self.first_entry.trackback_count, 0)
response = self.client.post(trackback_url,
{'url': 'http://example.com'})
self.assertEqual(response['Content-Type'], 'text/xml')
self.assertEqual(response.context['error'],
'Trackback is not enabled for Test 1')
self.first_entry.trackback_enabled = True
self.first_entry.save()
connect_discussion_signals()
get_user_flagger() # Memoize user flagger for stable query number
if comments.get_comment_app_name() == comments.DEFAULT_COMMENTS_APP:
# If we are using the default comment app,
# we can count the database queries executed.
with self.assertNumQueries(8):
response = self.client.post(trackback_url,
{'url': 'http://example.com'})
else:
response = self.client.post(trackback_url,
{'url': 'http://example.com'})
self.assertEqual(response['Content-Type'], 'text/xml')
self.assertEqual('error' in response.context, False)
disconnect_discussion_signals()
entry = Entry.objects.get(pk=self.first_entry.pk)
self.assertEqual(entry.trackback_count, 1)
response = self.client.post(trackback_url,
{'url': 'http://example.com'})
self.assertEqual(response.context['error'],
'Trackback is already registered')
zinnia.spam_checker.SPAM_CHECKER_BACKENDS = original_scb
def test_zinnia_trackback(self):
# Clear the cache of user flagger to avoid error on MySQL
get_user_flagger.cache_clear()
# Disable spam-checkers
import zinnia.spam_checker
original_scb = zinnia.spam_checker.SPAM_CHECKER_BACKENDS
zinnia.spam_checker.SPAM_CHECKER_BACKENDS = []
response = self.client.post('/trackback/404/')
trackback_url = '/trackback/%s/' % self.first_entry.pk
self.assertEqual(response.status_code, 404)
self.assertEqual(self.client.post(trackback_url).status_code, 301)
self.first_entry.trackback_enabled = False
self.first_entry.save()
self.assertEqual(self.first_entry.trackback_count, 0)
response = self.client.post(trackback_url,
{'url': 'http://example.com'})
self.assertEqual(response['Content-Type'], 'text/xml')
self.assertEqual(response.context['error'],
'Trackback is not enabled for Test 1')
self.first_entry.trackback_enabled = True
self.first_entry.save()
connect_discussion_signals()
get_user_flagger() # Memoize user flagger for stable query number
if comments.get_comment_app_name() == comments.DEFAULT_COMMENTS_APP:
# If we are using the default comment app,
# we can count the database queries executed.
with self.assertNumQueries(8):
response = self.client.post(trackback_url,
{'url': 'http://example.com'})
else:
response = self.client.post(trackback_url,
{'url': 'http://example.com'})
self.assertEqual(response['Content-Type'], 'text/xml')
self.assertEqual('error' in response.context, False)
disconnect_discussion_signals()
entry = Entry.objects.get(pk=self.first_entry.pk)
self.assertEqual(entry.trackback_count, 1)
response = self.client.post(trackback_url,
{'url': 'http://example.com'})
self.assertEqual(response.context['error'],
'Trackback is already registered')
zinnia.spam_checker.SPAM_CHECKER_BACKENDS = original_scb
def test_zinnia_trackback(self):
# Clean the memoization of user flagger to avoid error on MySQL
try:
del user_flagger_[()]
except KeyError:
pass
self.inhibit_templates('zinnia/entry_trackback.xml', '404.html')
response = self.client.post('/trackback/404/')
trackback_url = '/trackback/%s/' % self.first_entry.pk
self.assertEqual(response.status_code, 404)
self.assertEqual(self.client.post(trackback_url).status_code, 301)
self.first_entry.trackback_enabled = False
self.first_entry.save()
self.assertEqual(self.first_entry.trackback_count, 0)
response = self.client.post(trackback_url,
{'url': 'http://example.com'})
self.assertEqual(response['Content-Type'], 'text/xml')
self.assertEqual(response.context['error'],
'Trackback is not enabled for Test 1')
self.first_entry.trackback_enabled = True
self.first_entry.save()
connect_discussion_signals()
get_user_flagger() # Memoize user flagger for stable query number
if comments.get_comment_app_name() == comments.DEFAULT_COMMENTS_APP:
# If we are using the default comment app,
# we can count the database queries executed.
with self.assertNumQueries(8):
response = self.client.post(trackback_url,
{'url': 'http://example.com'})
else:
response = self.client.post(trackback_url,
{'url': 'http://example.com'})
self.assertEqual(response['Content-Type'], 'text/xml')
self.assertEqual('error' in response.context, False)
disconnect_discussion_signals()
entry = Entry.objects.get(pk=self.first_entry.pk)
self.assertEqual(entry.trackback_count, 1)
response = self.client.post(trackback_url,
{'url': 'http://example.com'})
self.assertEqual(response.context['error'],
'Trackback is already registered')
def test_zinnia_trackback(self):
# Clean the memoization of user flagger to avoid error on MySQL
try:
del user_flagger_[()]
except KeyError:
pass
self.inhibit_templates('zinnia/entry_trackback.xml', '404.html')
response = self.client.post('/trackback/404/')
trackback_url = '/trackback/%s/' % self.first_entry.pk
self.assertEqual(response.status_code, 404)
self.assertEqual(self.client.post(trackback_url).status_code, 301)
self.first_entry.trackback_enabled = False
self.first_entry.save()
self.assertEqual(self.first_entry.trackback_count, 0)
response = self.client.post(trackback_url,
{'url': 'http://example.com'})
self.assertEqual(response['Content-Type'], 'text/xml')
self.assertEqual(response.context['error'],
'Trackback is not enabled for Test 1')
self.first_entry.trackback_enabled = True
self.first_entry.save()
connect_discussion_signals()
get_user_flagger() # Memoize user flagger for stable query number
if comments.get_comment_app_name() == comments.DEFAULT_COMMENTS_APP:
# If we are using the default comment app,
# we can count the database queries executed.
with self.assertNumQueries(8):
response = self.client.post(trackback_url,
{'url': 'http://example.com'})
else:
response = self.client.post(trackback_url,
{'url': 'http://example.com'})
self.assertEqual(response['Content-Type'], 'text/xml')
self.assertEqual('error' in response.context, False)
disconnect_discussion_signals()
entry = Entry.objects.get(pk=self.first_entry.pk)
self.assertEqual(entry.trackback_count, 1)
response = self.client.post(trackback_url,
{'url': 'http://example.com'})
self.assertEqual(response.context['error'],
'Trackback is already registered')
def post(self, request, *args, **kwargs):
"""
Check if an URL is provided and if trackbacks
are enabled on the Entry.
If so the URL is registered one time as a trackback.
"""
url = request.POST.get('url')
if not url:
return self.get(request, *args, **kwargs)
entry = self.get_object()
site = Site.objects.get_current()
if not entry.trackbacks_are_open:
return self.render_to_response(
{'error': 'Trackback is not enabled for %s' % entry.title})
title = request.POST.get('title') or url
excerpt = request.POST.get('excerpt') or title
blog_name = request.POST.get('blog_name') or title
ip_address = request.META.get('REMOTE_ADDR', None)
trackback_klass = comments.get_model()
trackback_datas = {
'content_type': ContentType.objects.get_for_model(Entry),
'object_pk': entry.pk,
'site': site,
'user_url': url,
'user_name': blog_name,
'ip_address': ip_address,
'comment': excerpt
}
trackback = trackback_klass(**trackback_datas)
if check_is_spam(trackback, entry, request):
return self.render_to_response(
{'error': 'Trackback considered like spam'})
trackback_defaults = {'comment': trackback_datas.pop('comment')}
trackback, created = trackback_klass.objects.get_or_create(
defaults=trackback_defaults,
**trackback_datas)
if created:
trackback.flags.create(user=get_user_flagger(), flag=TRACKBACK)
trackback_was_posted.send(trackback.__class__,
trackback=trackback,
entry=entry)
else:
return self.render_to_response(
{'error': 'Trackback is already registered'})
return self.render_to_response({})
def post(self, request, *args, **kwargs):
"""
Check if an URL is provided and if trackbacks
are enabled on the Entry.
If so the URL is registered one time as a trackback.
"""
url = request.POST.get('url')
if not url:
return self.get(request, *args, **kwargs)
entry = self.get_object()
site = Site.objects.get_current()
if not entry.trackbacks_are_open:
return self.render_to_response(
{'error': 'Trackback is not enabled for %s' % entry.title})
title = request.POST.get('title') or url
excerpt = request.POST.get('excerpt') or title
blog_name = request.POST.get('blog_name') or title
ip_address = request.META.get('REMOTE_ADDR', None)
trackback_klass = comments.get_model()
trackback_datas = {
'content_type': ContentType.objects.get_for_model(Entry),
'object_pk': entry.pk,
'site': site,
'user_url': url,
'user_name': blog_name,
'ip_address': ip_address,
'comment': excerpt
}
trackback = trackback_klass(**trackback_datas)
if check_is_spam(trackback, entry, request):
return self.render_to_response(
{'error': 'Trackback considered like spam'})
trackback_defaults = {'comment': trackback_datas.pop('comment')}
trackback, created = trackback_klass.objects.get_or_create(
defaults=trackback_defaults, **trackback_datas)
if created:
trackback.flags.create(user=get_user_flagger(), flag=TRACKBACK)
trackback_was_posted.send(trackback.__class__,
trackback=trackback,
entry=entry)
else:
return self.render_to_response(
{'error': 'Trackback is already registered'})
return self.render_to_response({})
def test_zinnia_trackback(self):
self.inhibit_templates('zinnia/entry_trackback.xml', '404.html')
response = self.client.post('/trackback/404/')
self.assertEquals(response.status_code, 404)
self.assertEquals(
self.client.post('/trackback/1/').status_code, 301)
entry = Entry.objects.get(slug='test-1')
entry.trackback_enabled = False
entry.save()
self.assertEquals(entry.trackback_count, 0)
response = self.client.post('/trackback/1/',
{'url': 'http://example.com'})
self.assertEquals(response['Content-Type'], 'text/xml')
self.assertEquals(response.context['error'],
'Trackback is not enabled for Test 1')
entry.trackback_enabled = True
entry.save()
connect_discussion_signals()
get_user_flagger() # Memoize user flagger for stable query number
if comments.get_comment_app_name() == comments.DEFAULT_COMMENTS_APP:
# If we are using the default comment app,
# we can count the database queries executed.
with self.assertNumQueries(6):
response = self.client.post('/trackback/1/',
{'url': 'http://example.com'})
else:
response = self.client.post('/trackback/1/',
{'url': 'http://example.com'})
self.assertEquals(response['Content-Type'], 'text/xml')
self.assertEquals('error' in response.context, False)
disconnect_discussion_signals()
entry = Entry.objects.get(pk=entry.pk)
self.assertEquals(entry.trackback_count, 1)
response = self.client.post('/trackback/1/',
{'url': 'http://example.com'})
self.assertEquals(response.context['error'],
'Trackback is already registered')
def test_zinnia_trackback(self):
self.inhibit_templates('zinnia/entry_trackback.xml', '404.html')
response = self.client.post('/trackback/404/')
self.assertEquals(response.status_code, 404)
self.assertEquals(
self.client.post('/trackback/1/').status_code, 301)
entry = Entry.objects.get(slug='test-1')
entry.trackback_enabled = False
entry.save()
self.assertEquals(entry.trackback_count, 0)
response = self.client.post('/trackback/1/',
{'url': 'http://example.com'})
self.assertEquals(response['Content-Type'], 'text/xml')
self.assertEquals(response.context['error'],
'Trackback is not enabled for Test 1')
entry.trackback_enabled = True
entry.save()
connect_discussion_signals()
get_user_flagger() # Memoize user flagger for stable query number
if comments.get_comment_app_name() == comments.DEFAULT_COMMENTS_APP:
# If we are using the default comment app,
# we can count the database queries executed.
with self.assertNumQueries(6):
response = self.client.post('/trackback/1/',
{'url': 'http://example.com'})
else:
response = self.client.post('/trackback/1/',
{'url': 'http://example.com'})
self.assertEquals(response['Content-Type'], 'text/xml')
self.assertEquals('error' in response.context, False)
disconnect_discussion_signals()
entry = Entry.objects.get(pk=entry.pk)
self.assertEquals(entry.trackback_count, 1)
response = self.client.post('/trackback/1/',
{'url': 'http://example.com'})
self.assertEquals(response.context['error'],
'Trackback is already registered')
def moderate(self, comment, content_object, request):
"""Determine whether a given comment on a given object should be
allowed to show up immediately, or should be marked non-public
and await approval."""
if self.auto_moderate_comments:
return True
if check_is_spam(comment, content_object, request,
self.spam_checker_backends):
comment.save()
flag, created = CommentFlag.objects.get_or_create(
comment=comment, user=get_user_flagger(), flag=SPAM)
signals.comment_was_flagged.send(
sender=comment.__class__, comment=comment,
flag=flag, created=created, request=request)
return True
return False
def post(self, request, *args, **kwargs):
"""
Check if an URL is provided and if trackbacks
are enabled on the Entry.
If so the URL is registered one time as a trackback.
"""
url = request.POST.get('url')
if not url:
return self.get(request, *args, **kwargs)
entry = self.get_object()
site = Site.objects.get_current()
if not entry.trackbacks_are_open:
return self.render_to_response(
{'error': 'Trackback is not enabled for %s' % entry.title})
title = request.POST.get('title') or url
excerpt = request.POST.get('excerpt') or title
blog_name = request.POST.get('blog_name') or title
ip_address = request.META.get( 'REMOTE_ADDR', None )
if len(url) > 199:
return self.render_to_response(
{'error': u'Spam Filtered'})
# what is this even used for?
blog_name = blog_name[:50]
trackback, created = comments.get_model().objects.get_or_create(
content_type=ContentType.objects.get_for_model(Entry),
object_pk=entry.pk, site=site, user_url=url,
user_name=blog_name, ip_address=ip_address,
defaults={'comment': excerpt,
'submit_date': timezone.now()})
if created:
trackback.flags.create(user=get_user_flagger(), flag=TRACKBACK)
trackback_was_posted.send(trackback.__class__,
trackback=trackback,
entry=entry)
else:
return self.render_to_response(
{'error': 'Trackback is already registered'})
return self.render_to_response({})
def post(self, request, *args, **kwargs):
"""
Check if an URL is provided and if trackbacks
are enabled on the Entry.
If so the URL is registered one time as a trackback.
"""
url = request.POST.get('url')
if not url:
return self.get(request, *args, **kwargs)
entry = self.get_object()
site = Site.objects.get_current()
if not entry.trackbacks_are_open:
return self.render_to_response(
{'error': 'Trackback is not enabled for %s' % entry.title})
title = request.POST.get('title') or url
excerpt = request.POST.get('excerpt') or title
blog_name = request.POST.get('blog_name') or title
ip_address = request.META.get('REMOTE_ADDR', None)
trackback, created = comments.get_model().objects.get_or_create(
content_type=ContentType.objects.get_for_model(Entry),
object_pk=entry.pk,
site=site,
user_url=url,
user_name=blog_name,
ip_address=ip_address,
defaults={
'comment': excerpt,
'submit_date': timezone.now()
})
if created:
trackback.flags.create(user=get_user_flagger(), flag=TRACKBACK)
trackback_was_posted.send(trackback.__class__,
trackback=trackback,
entry=entry)
else:
return self.render_to_response(
{'error': 'Trackback is already registered'})
return self.render_to_response({})
def moderate(self, comment, content_object, request):
"""Determine whether a given comment on a given object should be
allowed to show up immediately, or should be marked non-public
and await approval."""
if self.auto_moderate_comments:
return True
if check_is_spam(comment, content_object, request,
self.spam_checker_backends):
comment.save()
flag, created = CommentFlag.objects.get_or_create(
comment=comment, user=get_user_flagger(), flag=SPAM)
signals.comment_was_flagged.send(sender=comment.__class__,
comment=comment,
flag=flag,
created=created,
request=request)
return True
return False
def test_get_user_flagger_cache(self):
get_user_flagger()
with self.assertNumQueries(0):
get_user_flagger()
def test_get_user_flagger_does_not_exist(self):
original_user_id = flags.COMMENT_FLAG_USER_ID
flags.COMMENT_FLAG_USER_ID = 4242
flagger = get_user_flagger()
self.assertEqual(flagger.username, 'Zinnia-Flagger')
flags.COMMENT_FLAG_USER_ID = original_user_id
def import_comments(self, entry, comment_nodes):
"""Loops over comments nodes and import then
in django.contrib.comments"""
for comment_node in comment_nodes:
is_pingback = comment_node.find(
'{%s}comment_type' % WP_NS).text == PINGBACK
is_trackback = comment_node.find(
'{%s}comment_type' % WP_NS).text == TRACKBACK
title = 'Comment #%s' % (comment_node.find(
'{%s}comment_id/' % WP_NS).text)
self.write_out(' > %s... ' % title)
content = comment_node.find(
'{%s}comment_content/' % WP_NS).text
if not content:
self.write_out(self.style.NOTICE('SKIPPED (unfilled)\n'))
return
submit_date = datetime.strptime(
comment_node.find('{%s}comment_date' % WP_NS).text,
'%Y-%m-%d %H:%M:%S')
if settings.USE_TZ:
submit_date = timezone.make_aware(submit_date, timezone.utc)
approvation = comment_node.find(
'{%s}comment_approved' % WP_NS).text
is_public = True
is_removed = False
if approvation != '1':
is_removed = True
if approvation == 'spam':
is_public = False
comment_dict = {
'content_object': entry,
'site': self.SITE,
'user_name': comment_node.find(
'{%s}comment_author/' % WP_NS).text[:50],
'user_email': comment_node.find(
'{%s}comment_author_email/' % WP_NS).text or '',
'user_url': comment_node.find(
'{%s}comment_author_url/' % WP_NS).text or '',
'comment': content,
'submit_date': submit_date,
'ip_address': comment_node.find(
'{%s}comment_author_IP/' % WP_NS).text or '',
'is_public': is_public,
'is_removed': is_removed, }
comment = comments.get_model()(**comment_dict)
comment.save()
if is_pingback:
comment.flags.create(
user=get_user_flagger(), flag=PINGBACK)
if is_trackback:
comment.flags.create(
user=get_user_flagger(), flag=TRACKBACK)
self.write_out(self.style.ITEM('OK\n'))
entry.comment_count = entry.comments.count()
entry.pingback_count = entry.pingbacks.count()
entry.trackback_count = entry.trackbacks.count()
entry.save(force_update=True)
def pingback_ping(source, target):
"""
pingback.ping(sourceURI, targetURI) => 'Pingback message'
Notifies the server that a link has been added to sourceURI,
pointing to targetURI.
See: http://hixie.ch/specs/pingback/pingback-1.0
"""
try:
if source == target:
return UNDEFINED_ERROR
site = Site.objects.get_current()
try:
document = ''.join(map(
lambda byte_line: byte_line.decode('utf-8'),
urlopen(source).readlines()))
except (HTTPError, URLError):
return SOURCE_DOES_NOT_EXIST
if target not in document:
return SOURCE_DOES_NOT_LINK
target_splitted = urlsplit(target)
if target_splitted.netloc != site.domain:
return TARGET_DOES_NOT_EXIST
try:
view, args, kwargs = resolve(target_splitted.path)
except Resolver404:
return TARGET_DOES_NOT_EXIST
try:
entry = Entry.published.get(
slug=kwargs['slug'],
publication_date__year=kwargs['year'],
publication_date__month=kwargs['month'],
publication_date__day=kwargs['day'])
if not entry.pingbacks_are_open:
return TARGET_IS_NOT_PINGABLE
except (KeyError, Entry.DoesNotExist):
return TARGET_IS_NOT_PINGABLE
soup = BeautifulSoup(document, 'html.parser')
title = str(soup.find('title'))
title = title and strip_tags(title) or _('No title')
description = generate_pingback_content(soup, target,
PINGBACK_CONTENT_LENGTH)
pingback_klass = comments.get_model()
pingback_datas = {
'content_type': ContentType.objects.get_for_model(Entry),
'object_pk': entry.pk,
'site': site,
'user_url': source,
'user_name': title,
'comment': description
}
pingback = pingback_klass(**pingback_datas)
if check_is_spam(pingback, entry, FakeRequest()):
return PINGBACK_IS_SPAM
pingback_defaults = {'comment': pingback_datas.pop('comment'),
'user_name': pingback_datas.pop('user_name')}
pingback, created = pingback_klass.objects.get_or_create(
defaults=pingback_defaults,
**pingback_datas)
if created:
pingback.flags.create(user=get_user_flagger(), flag=PINGBACK)
pingback_was_posted.send(pingback.__class__,
pingback=pingback,
entry=entry)
return 'Pingback from %s to %s registered.' % (source, target)
return PINGBACK_ALREADY_REGISTERED
except Exception:
return UNDEFINED_ERROR
def test_get_user_flagger_does_not_exist(self):
original_user_id = flags.COMMENT_FLAG_USER_ID
flags.COMMENT_FLAG_USER_ID = 4242
flagger = get_user_flagger()
self.assertEquals(flagger.username, 'Zinnia-Flagger')
flags.COMMENT_FLAG_USER_ID = original_user_id
def test_get_user_flagger_cache(self):
get_user_flagger()
with self.assertNumQueries(0):
get_user_flagger()
def pingback_ping(source, target):
"""
pingback.ping(sourceURI, targetURI) => 'Pingback message'
Notifies the server that a link has been added to sourceURI,
pointing to targetURI.
See: http://hixie.ch/specs/pingback/pingback-1.0
"""
try:
if source == target:
return UNDEFINED_ERROR
site = Site.objects.get_current()
try:
document = ''.join(map(
lambda byte_line: byte_line.decode('utf-8'),
urlopen(source).readlines()))
except (HTTPError, URLError):
return SOURCE_DOES_NOT_EXIST
if target not in document:
return SOURCE_DOES_NOT_LINK
target_splitted = urlsplit(target)
if target_splitted.netloc != site.domain:
return TARGET_DOES_NOT_EXIST
try:
view, args, kwargs = resolve(target_splitted.path)
except Resolver404:
return TARGET_DOES_NOT_EXIST
try:
entry = Entry.published.get(
slug=kwargs['slug'],
publication_date__year=kwargs['year'],
publication_date__month=kwargs['month'],
publication_date__day=kwargs['day'])
if not entry.pingbacks_are_open:
return TARGET_IS_NOT_PINGABLE
except (KeyError, Entry.DoesNotExist):
return TARGET_IS_NOT_PINGABLE
soup = BeautifulSoup(document, 'html.parser')
title = six.text_type(soup.find('title'))
title = title and strip_tags(title) or _('No title')
description = generate_pingback_content(soup, target,
PINGBACK_CONTENT_LENGTH)
pingback_klass = comments.get_model()
pingback_datas = {
'content_type': ContentType.objects.get_for_model(Entry),
'object_pk': entry.pk,
'site': site,
'user_url': source,
'user_name': title,
'comment': description
}
pingback = pingback_klass(**pingback_datas)
if check_is_spam(pingback, entry, FakeRequest()):
return PINGBACK_IS_SPAM
pingback_defaults = {'comment': pingback_datas.pop('comment'),
'user_name': pingback_datas.pop('user_name')}
pingback, created = pingback_klass.objects.get_or_create(
defaults=pingback_defaults,
**pingback_datas)
if created:
pingback.flags.create(user=get_user_flagger(), flag=PINGBACK)
pingback_was_posted.send(pingback.__class__,
pingback=pingback,
entry=entry)
return 'Pingback from %s to %s registered.' % (source, target)
return PINGBACK_ALREADY_REGISTERED
except Exception:
return UNDEFINED_ERROR
def import_comments(self, entry, comment_nodes):
"""Loops over comments nodes and import then
in django.contrib.comments"""
for comment_node in comment_nodes:
is_pingback = comment_node.find(
'{%s}comment_type' % WP_NS).text == PINGBACK
is_trackback = comment_node.find(
'{%s}comment_type' % WP_NS).text == TRACKBACK
title = 'Comment #%s' % (comment_node.find(
'{%s}comment_id' % WP_NS).text)
self.write_out(' > %s... ' % title)
content = comment_node.find(
'{%s}comment_content' % WP_NS).text
if not content:
self.write_out(self.style.NOTICE('SKIPPED (unfilled)\n'))
return
submit_date = datetime.strptime(
comment_node.find('{%s}comment_date' % WP_NS).text,
'%Y-%m-%d %H:%M:%S')
if settings.USE_TZ:
submit_date = timezone.make_aware(submit_date, timezone.utc)
approvation = comment_node.find(
'{%s}comment_approved' % WP_NS).text
is_public = True
is_removed = False
if approvation != '1':
is_removed = True
if approvation == 'spam':
is_public = False
comment_dict = {
'content_object': entry,
'site': self.SITE,
'user_name': comment_node.find(
'{%s}comment_author' % WP_NS).text[:50],
'user_email': comment_node.find(
'{%s}comment_author_email' % WP_NS).text or '',
'user_url': comment_node.find(
'{%s}comment_author_url' % WP_NS).text or '',
'comment': content,
'submit_date': submit_date,
'ip_address': comment_node.find(
'{%s}comment_author_IP' % WP_NS).text or '',
'is_public': is_public,
'is_removed': is_removed, }
comment = comments.get_model()(**comment_dict)
comment.save()
if is_pingback:
comment.flags.create(
user=get_user_flagger(), flag=PINGBACK)
if is_trackback:
comment.flags.create(
user=get_user_flagger(), flag=TRACKBACK)
self.write_out(self.style.ITEM('OK\n'))
entry.comment_count = entry.comments.count()
entry.pingback_count = entry.pingbacks.count()
entry.trackback_count = entry.trackbacks.count()
entry.save(force_update=True)
