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