def get_comment(self, check_permissions=True):
        pk = self.kwargs[self.comment_lookup_url_kwarg]
        try:
            comment = Comment.find_one(Q('_id', 'eq', pk) & Q('root_target', 'ne', None))
        except NoResultsFound:
            raise NotFound

        # Deleted root targets still appear as tuples in the database and are included in
        # the above query, requiring an additional check
        if isinstance(comment.root_target.referent, TrashedFileNode):
            comment.root_target = None
            comment.save()

        if comment.root_target is None:
            raise NotFound

        if isinstance(comment.root_target.referent, StoredFileNode):
            root_target = comment.root_target
            referent = root_target.referent

            if referent.provider == 'osfstorage':
                try:
                    StoredFileNode.find(
                        Q('node', 'eq', comment.node._id) &
                        Q('_id', 'eq', referent._id) &
                        Q('is_file', 'eq', True)
                    )
                except NoResultsFound:
                    Comment.update(Q('root_target', 'eq', root_target), data={'root_target': None})
                    raise NotFound
            else:
                if referent.provider == 'dropbox':
                    # referent.path is the absolute path for the db file, but wb requires the relative path
                    referent = DropboxFile.load(referent._id)
                url = waterbutler_api_url_for(comment.node._id, referent.provider, referent.path, meta=True)
                waterbutler_request = requests.get(
                    url,
                    cookies=self.request.COOKIES,
                    headers={'Authorization': self.request.META.get('HTTP_AUTHORIZATION')},
                )

                if waterbutler_request.status_code == 401:
                    raise PermissionDenied

                if waterbutler_request.status_code == 404:
                    Comment.update(Q('root_target', 'eq', root_target), data={'root_target': None})
                    raise NotFound

                if is_server_error(waterbutler_request.status_code):
                    raise ServiceUnavailableError(detail='Could not retrieve files information at this time.')

                try:
                    waterbutler_request.json()['data']
                except KeyError:
                    raise ServiceUnavailableError(detail='Could not retrieve files information at this time.')

        if check_permissions:
            # May raise a permission denied
            self.check_object_permissions(self.request, comment)
        return comment

 def setUp(self):
     super(TestMigrateSpam, self).setUp()
     self.generic_report = {
         'category': 'spam',
         'text': 'spammer spam',
         'date': datetime.utcnow(),
         'retracted': False
     }
     Comment.remove()
     self.user = AuthUserFactory()
     self.comment_1 = CommentFactory()
     self.comment_1.spam_status = 0
     self.comment_1.reports[self.user._id] = self.generic_report
     self.comment_1.save()
     self.comment_2 = CommentFactory()
     self.comment_2.spam_status = 0
     self.comment_2.reports[self.user._id] = self.generic_report
     self.comment_2.save()
     self.comment_3 = CommentFactory()
     self.comment_3.spam_status = 0
     self.comment_3.save()
     self.comment_4 = CommentFactory()
     self.comment_4.date_last_reported = None
     self.comment_4.spam_status = Comment.FLAGGED
     self.comment_4.reports[self.user._id] = self.generic_report
     self.comment_4.save()
     self.comment_5 = CommentFactory()
     self.comment_5.date_last_reported = None
     self.comment_5.spam_status = Comment.UNKNOWN
     self.comment_5.save()
     self.comment_6 = CommentFactory()
     self.comment_6.date_last_reported = None
     self.comment_6.spam_status = Comment.SPAM
     self.comment_6.reports[self.user._id] = self.generic_report
     self.comment_6.save()

    def get_paginated_response(self, data):
        """Add number of unread comments to links.meta when viewing list of comments filtered by
        a target node, file or wiki page."""
        response = super(CommentPagination, self).get_paginated_response(data)
        response_dict = response.data
        kwargs = self.request.parser_context['kwargs'].copy()

        if self.request.query_params.get('related_counts', False):
            target_id = self.request.query_params.get('filter[target]', None)
            node_id = kwargs.get('node_id', None)
            node = Node.load(node_id)
            user = self.request.user
            if target_id and not user.is_anonymous() and node.is_contributor(user):
                root_target = Guid.load(target_id)
                if root_target:
                    page = getattr(root_target.referent, 'root_target_page', None)
                    if page:
                        if not len(data):
                            unread = 0
                        else:
                            unread = Comment.find_n_unread(user=user, node=node, page=page, root_id=target_id)
                        if self.request.version < '2.1':
                            response_dict['links']['meta']['unread'] = unread
                        else:
                            response_dict['meta']['unread'] = unread
        return Response(response_dict)

    def test_comments_move_when_folder_moved_to_different_provider(self, destination_provider, destination_path):
        if self.provider == destination_provider:
            return True

        self.project.add_addon(destination_provider, auth=Auth(self.user))
        self.project.save()
        self.addon_settings = self.project.get_addon(destination_provider)
        self.addon_settings.folder = "/AddonFolder"
        self.addon_settings.save()

        source = {"path": "/subfolder/", "node": self.project, "provider": self.provider}
        destination = {
            "path": "/subfolder/",
            "node": self.project,
            "provider": destination_provider,
            "children": [{"path": "/subfolder/file.txt", "node": self.project, "provider": destination_provider}],
        }
        file_name = "file.txt"
        self._create_file_with_comment(node=source["node"], path="{}{}".format(source["path"], file_name))
        payload = self._create_payload("move", self.user, source, destination, self.file._id)
        update_file_guid_referent(self=None, node=destination["node"], event_type="addon_file_moved", payload=payload)
        self.guid.reload()

        file_node = FileNode.resolve_class(destination_provider, FileNode.FILE).get_or_create(
            destination["node"], destination_path
        )
        assert_equal(self.guid._id, file_node.get_guid()._id)
        file_comments = Comment.find(Q("root_target", "eq", self.guid._id))
        assert_equal(file_comments.count(), 1)

    def test_comments_move_when_folder_moved_to_different_provider(self, destination_provider, destination_path):
        if self.provider == destination_provider:
            return True

        self.project.add_addon(destination_provider, auth=Auth(self.user))
        self.project.save()
        self.addon_settings = self.project.get_addon(destination_provider)
        self.addon_settings.folder = '/AddonFolder'
        self.addon_settings.save()

        source = {
            'path': '/subfolder/',
            'node': self.project,
            'provider': self.provider
        }
        destination = {
            'path': '/subfolder/',
            'node': self.project,
            'provider': destination_provider,
            'children': [{
                    'path': '/subfolder/file.txt',
                    'node': self.project,
                    'provider': destination_provider
            }]
        }
        file_name = 'file.txt'
        self._create_file_with_comment(node=source['node'], path='{}{}'.format(source['path'], file_name))
        payload = self._create_payload('move', self.user, source, destination, self.file._id)
        update_file_guid_referent(self=None, node=destination['node'], event_type='addon_file_moved', payload=payload)
        self.guid.reload()

        file_node = FileNode.resolve_class(destination_provider, FileNode.FILE).get_or_create(destination['node'], destination_path)
        assert_equal(self.guid._id, file_node.get_guid()._id)
        file_comments = Comment.find(Q('root_target', 'eq', self.guid._id))
        assert_equal(file_comments.count(), 1)

    def test_comments_move_when_file_moved_to_osfstorage(self):
        osfstorage = self.project.get_addon('osfstorage')
        root_node = osfstorage.get_root()
        osf_file = root_node.append_file('file.txt')
        osf_file.create_version(self.user, {
            'object': '06d80e',
            'service': 'cloud',
            osfstorage_settings.WATERBUTLER_RESOURCE: 'osf',
        }, {
            'size': 1337,
            'contentType': 'img/png',
            'etag': 'abcdefghijklmnop'
        }).save()

        source = {
            'path': '/file.txt',
            'node': self.project,
            'provider': self.provider
        }
        destination = {
            'path': osf_file.path,
            'node': self.project,
            'provider': 'osfstorage'
        }
        self._create_file_with_comment(node=source['node'], path=source['path'])
        payload = self._create_payload('move', self.user, source, destination, self.file._id, destination_file_id=destination['path'].strip('/'))
        update_file_guid_referent(self=None, node=destination['node'], event_type='addon_file_moved', payload=payload)
        self.guid.reload()

        file_node = FileNode.resolve_class('osfstorage', FileNode.FILE).get_or_create(destination['node'], destination['path'])
        assert_equal(self.guid._id, file_node.get_guid()._id)
        file_comments = Comment.find(Q('root_target', 'eq', self.guid._id))
        assert_equal(file_comments.count(), 1)

 def get_context_data(self, **kwargs):
     item = Comment.load(self.kwargs.get('spam_id'))
     kwargs = super(SpamDetail, self).get_context_data(**kwargs)
     kwargs.setdefault('page_number', self.request.GET.get('page', 1))
     kwargs.setdefault('comment', serialize_comment(item))
     kwargs.setdefault('status', self.request.GET.get('status', u'1'))
     return kwargs

 def get_queryset(self):
     query = (
         Q("reports", "ne", {})
         & Q("reports", "ne", None)
         & Q("spam_status", "eq", int(self.request.GET.get("status", "1")))
     )
     return Comment.find(query).sort(self.ordering)

    def test_comments_move_when_folder_moved_to_osfstorage(self):
        osfstorage = self.project.get_addon("osfstorage")
        root_node = osfstorage.get_root()
        osf_folder = root_node.append_folder("subfolder")
        osf_file = osf_folder.append_file("file.txt")
        osf_file.create_version(
            self.user,
            {"object": "06d80e", "service": "cloud", osfstorage_settings.WATERBUTLER_RESOURCE: "osf"},
            {"size": 1337, "contentType": "img/png", "etag": "1234567890abcde"},
        ).save()

        source = {"path": "/subfolder/", "node": self.project, "provider": self.provider}
        destination = {
            "path": "/subfolder/",
            "node": self.project,
            "provider": "osfstorage",
            "children": [{"path": "/subfolder/file.txt", "node": self.project, "provider": "osfstorage"}],
        }
        file_name = "file.txt"
        self._create_file_with_comment(node=source["node"], path="{}{}".format(source["path"], file_name))
        payload = self._create_payload(
            "move", self.user, source, destination, self.file._id, destination_file_id=osf_file._id
        )
        update_file_guid_referent(self=None, node=destination["node"], event_type="addon_file_moved", payload=payload)
        self.guid.reload()

        file_node = FileNode.resolve_class("osfstorage", FileNode.FILE).get_or_create(destination["node"], osf_file._id)
        assert_equal(self.guid._id, file_node.get_guid()._id)
        file_comments = Comment.find(Q("root_target", "eq", self.guid._id))
        assert_equal(file_comments.count(), 1)

 def get_queryset(self):
     query = (
         Q('reports', 'ne', {}) &
         Q('reports', 'ne', None) &
         Q('spam_status', 'eq', int(self.request.GET.get('status', '1')))
     )
     return Comment.find(query).sort(self.ordering)

 def form_valid(self, form):
     spam_id = self.kwargs.get('spam_id')
     item = Comment.load(spam_id)
     try:
         if int(form.cleaned_data.get('confirm')) == Comment.SPAM:
             item.confirm_spam()
             item.is_deleted = True
             log_message = 'Confirmed SPAM: {}'.format(spam_id)
             log_action = CONFIRM_SPAM
         else:
             item.confirm_ham()
             item.is_deleted = False
             log_message = 'Confirmed HAM: {}'.format(spam_id)
             log_action = CONFIRM_HAM
         item.save()
     except AttributeError:
         raise Http404('Spam with id "{}" not found.'.format(spam_id))
     update_admin_log(
         user_id=self.request.user.id,
         object_id=spam_id,
         object_repr='Comment',
         message=log_message,
         action_flag=log_action
     )
     return super(SpamDetail, self).form_valid(form)

 def test_find_unread_new_comments(self):
     project = ProjectFactory()
     user = UserFactory()
     project.add_contributor(user)
     project.save()
     comment = CommentFactory(node=project, user=project.creator)
     n_unread = Comment.find_n_unread(user=user, node=project)
     assert_equal(n_unread, 1)

 def test_find_unread_does_not_include_deleted_comments(self):
     project = ProjectFactory()
     user = AuthUserFactory()
     project.add_contributor(user)
     project.save()
     comment = CommentFactory(node=project, user=project.creator, is_deleted=True)
     n_unread = Comment.find_n_unread(user=user, node=project)
     assert_equal(n_unread, 0)

 def get_context_data(self, **kwargs):
     spam_id = self.kwargs.get("spam_id")
     try:
         kwargs.setdefault("comment", serialize_comment(Comment.load(spam_id)))
     except AttributeError:
         raise Http404("Spam with id {} not found.".format(spam_id))
     kwargs.setdefault("page_number", self.request.GET.get("page", "1"))
     kwargs.setdefault("status", self.request.GET.get("status", "1"))
     return super(EmailFormView, self).get_context_data(**kwargs)

    def test_find_unread_includes_edited_comments(self):
        project = ProjectFactory()
        user = AuthUserFactory()
        project.add_contributor(user)
        project.save()
        comment = CommentFactory(node=project, user=project.creator)

        url = project.api_url_for("update_comments_timestamp")
        payload = {"page": "node", "rootId": project._id}
        res = self.app.put_json(url, payload, auth=user.auth)
        user.reload()
        n_unread = Comment.find_n_unread(user=user, node=project, page="node")
        assert_equal(n_unread, 0)

        # Edit previously read comment
        comment.edit(auth=Auth(project.creator), content="edited", save=True)
        n_unread = Comment.find_n_unread(user=user, node=project, page="node")
        assert_equal(n_unread, 1)

 def test_find_unread_includes_comment_replies(self):
     project = ProjectFactory()
     user = UserFactory()
     project.add_contributor(user)
     project.save()
     comment = CommentFactory(node=project, user=user)
     reply = CommentFactory(node=project, target=comment, user=project.creator)
     n_unread = Comment.find_n_unread(user=user, node=project)
     assert_equal(n_unread, 1)

 def get_context_data(self, **kwargs):
     spam_id = self.kwargs.get('spam_id')
     try:
         kwargs.setdefault('comment',
                           serialize_comment(Comment.load(spam_id)))
     except AttributeError:
         raise Http404('Spam with id {} not found.'.format(spam_id))
     kwargs.setdefault('page_number', self.request.GET.get('page', '1'))
     kwargs.setdefault('status', self.request.GET.get('status', '1'))
     return super(EmailFormView, self).get_context_data(**kwargs)

 def test_create_comment_content_cannot_exceed_max_length(self):
     with assert_raises(ValidationValueError):
         comment = Comment.create(
             auth=self.auth,
             user=self.comment.user,
             node=self.comment.node,
             target=self.comment.target,
             is_public=True,
             content=''.join(['c' for c in range(settings.COMMENT_MAXLENGTH + 1)])
         )

    def get_comment(self, check_permissions=True):
        pk = self.kwargs[self.comment_lookup_url_kwarg]
        try:
            comment = Comment.find_one(Q('_id', 'eq', pk))
        except NoResultsFound:
            raise NotFound

        if check_permissions:
            # May raise a permission denied
            self.check_object_permissions(self.request, comment)
        return comment

 def test_create_sends_comment_added_signal(self):
     with capture_signals() as mock_signals:
         comment = Comment.create(
             auth=self.auth,
             user=self.comment.user,
             node=self.comment.node,
             target=self.comment.target,
             is_public=True,
             content='This is a comment.'
         )
     assert_equal(mock_signals.signals_sent(), set([comment_added]))