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.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 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 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 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 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_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