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_zinnia_trackback(self):
# Clean the memoization of user flagger to avoid error on MySQL
try:
del user_flagger_[()]
except KeyError:
pass
self.inhibit_templates('events/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, 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 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
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 = 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, 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 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 test_get_user_flagger_cache(self):
get_user_flagger()
with self.assertNumQueries(0):
get_user_flagger()
def import_comments(self, entry, comment_nodes):
"""
Loops over comments nodes and import then
in django_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_gmt' % WP_NS).text,
'%Y-%m-%d %H:%M:%S')
if settings.USE_TZ:
submit_date = timezone.make_aware(submit_date,
pytz.timezone('GMT'))
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 None,
'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)