comment.py

import pytz
from django.db import models
from django.db.models import Q
from django.utils import timezone
from .node import Node
from .nodelog import NodeLog
from .base import GuidMixin, Guid, BaseModel
from .mixins import CommentableMixin
from .spam import SpamMixin
from .validators import CommentMaxLength, string_required
from osf.utils.fields import NonNaiveDateTimeField

from framework.exceptions import PermissionsError
from website import settings
from website.util import api_v2_url
from website.project import signals as project_signals
from website.project.model import get_valid_mentioned_users_guids


class Comment(GuidMixin, SpamMixin, CommentableMixin, BaseModel):
    __guid_min_length__ = 12
    OVERVIEW = 'node'
    FILES = 'files'
    WIKI = 'wiki'
    SPAM_CHECK_FIELDS = {'content'}

    user = models.ForeignKey('OSFUser', null=True, on_delete=models.CASCADE)
    # the node that the comment belongs to
    node = models.ForeignKey('AbstractNode', null=True, on_delete=models.CASCADE)

    # The file or project overview page that the comment is for
    root_target = models.ForeignKey(Guid, on_delete=models.SET_NULL,
                                    related_name='comments',
                                    null=True, blank=True)

    # the direct 'parent' of the comment (e.g. the target of a comment reply is another comment)
    target = models.ForeignKey(Guid, on_delete=models.SET_NULL,
                                    related_name='child_comments',
                                    null=True, blank=True)

    edited = models.BooleanField(default=False)
    is_deleted = models.BooleanField(default=False)
    deleted = NonNaiveDateTimeField(blank=True, null=True)
    # The type of root_target: node/files
    page = models.CharField(max_length=255, blank=True)
    content = models.TextField(
        validators=[
            CommentMaxLength(settings.COMMENT_MAXLENGTH),
            string_required,
        ]
    )

    # The mentioned users
    ever_mentioned = models.ManyToManyField(blank=True, related_name='mentioned_in', to='OSFUser')

    @property
    def url(self):
        return f'/{self._id}/'

    @property
    def absolute_api_v2_url(self):
        path = f'/comments/{self._id}/'
        return api_v2_url(path)

    @property
    def target_type(self):
        """The object "type" used in the OSF v2 API."""
        return 'comments'

    @property
    def root_target_page(self):
        """The page type associated with the object/Comment.root_target."""
        return None

    def belongs_to_node(self, node_id):
        """Check whether the comment is attached to the specified node."""
        return self.node._id == node_id

    # used by django and DRF
    def get_absolute_url(self):
        return self.absolute_api_v2_url

    def get_comment_page_url(self):
        if isinstance(self.root_target.referent, Node):
            return self.node.absolute_url
        return settings.DOMAIN + str(self.root_target._id) + '/'

    def get_content(self, auth):
        """ Returns the comment content if the user is allowed to see it. Deleted comments
        can only be viewed by the user who created the comment."""
        if not auth and not self.node.is_public:
            raise PermissionsError

        if self.is_deleted and ((not auth or auth.user.is_anonymous) or
                                (auth and not auth.user.is_anonymous and self.user._id != auth.user._id)):
            return None

        return self.content

    def get_comment_page_title(self):
        if self.page == Comment.FILES:
            return self.root_target.referent.name
        elif self.page == Comment.WIKI:
            return self.root_target.referent.page_name
        return ''

    def get_comment_page_type(self):
        if self.page == Comment.FILES:
            return 'file'
        elif self.page == Comment.WIKI:
            return 'wiki'
        return self.node.project_or_component

    @classmethod
    def find_n_unread(cls, user, node, page, root_id=None):
        if node.is_contributor_or_group_member(user):
            if page == Comment.OVERVIEW:
                view_timestamp = user.get_node_comment_timestamps(target_id=node._id)
                root_target = Guid.load(node._id)
            elif page == Comment.FILES or page == Comment.WIKI:
                view_timestamp = user.get_node_comment_timestamps(target_id=root_id)
                root_target = Guid.load(root_id)
            else:
                raise ValueError('Invalid page')

            if not view_timestamp.tzinfo:
                view_timestamp = view_timestamp.replace(tzinfo=pytz.utc)

            return cls.objects.filter(
                Q(node=node) & ~Q(user=user) & Q(is_deleted=False) &
                (Q(created__gt=view_timestamp) | Q(modified__gt=view_timestamp)) &
                Q(root_target=root_target)
            ).count()

        return 0

    @classmethod
    def find_count(cls, node, page, root_id=None):
        if page == Comment.OVERVIEW:
            root_target = Guid.load(node._id)
        elif page == Comment.FILES or page == Comment.WIKI:
            root_target = Guid.load(root_id)
        else:
            raise ValueError('Invalid page')

        return cls.objects.filter(
            Q(node=node) & 
            Q(is_deleted=False) &
            Q(root_target=root_target)
        ).count()

    @classmethod
    def create(cls, auth, **kwargs):
        comment = cls(**kwargs)
        if not comment.node.can_comment(auth):
            raise PermissionsError(f'{auth.user!r} does not have permission to comment on this node')
        log_dict = {
            'project': comment.node.parent_id,
            'node': comment.node._id,
            'user': comment.user._id,
            'comment': comment._id,
        }
        if isinstance(comment.target.referent, Comment):
            comment.root_target = comment.target.referent.root_target
        else:
            comment.root_target = comment.target

        page = getattr(comment.root_target.referent, 'root_target_page', None)
        if not page:
            raise ValueError('Invalid root target.')
        comment.page = page

        log_dict.update(comment.root_target.referent.get_extra_log_params(comment))

        new_mentions = []
        if comment.content:
            if not comment.id:
                # must have id before accessing M2M
                comment.save()
            new_mentions = get_valid_mentioned_users_guids(comment, comment.node.contributors_and_group_members)
            if new_mentions:
                project_signals.mention_added.send(comment, new_mentions=new_mentions, auth=auth)
                comment.ever_mentioned.add(*comment.node.contributors.filter(guids___id__in=new_mentions))

        comment.save()

        comment.node.add_log(
            NodeLog.COMMENT_ADDED,
            log_dict,
            auth=auth,
            save=False,
        )

        comment.node.save()
        project_signals.comment_added.send(comment, auth=auth, new_mentions=new_mentions)

        return comment

    def edit(self, content, auth, save=False):
        if not self.node.can_comment(auth) or self.user._id != auth.user._id:
            raise PermissionsError(f'{auth.user!r} does not have permission to edit this comment')
        log_dict = {
            'project': self.node.parent_id,
            'node': self.node._id,
            'user': self.user._id,
            'comment': self._id,
        }
        log_dict.update(self.root_target.referent.get_extra_log_params(self))
        self.content = content
        self.edited = True
        self.modified = timezone.now()
        new_mentions = get_valid_mentioned_users_guids(self, self.node.contributors_and_group_members)

        if save:
            if new_mentions:
                project_signals.mention_added.send(self, new_mentions=new_mentions, auth=auth)
                self.ever_mentioned.add(*self.node.contributors.filter(guids___id__in=new_mentions))
            self.save()
            self.node.add_log(
                NodeLog.COMMENT_UPDATED,
                log_dict,
                auth=auth,
                save=False,
            )
            self.node.save()

    def delete(self, auth, save=False):
        if not self.node.can_comment(auth) or self.user._id != auth.user._id:
            raise PermissionsError(f'{auth.user!r} does not have permission to comment on this node')
        log_dict = {
            'project': self.node.parent_id,
            'node': self.node._id,
            'user': self.user._id,
            'comment': self._id,
        }
        self.is_deleted = True
        current_time = timezone.now()
        self.deleted = current_time
        log_dict.update(self.root_target.referent.get_extra_log_params(self))
        self.modified = current_time
        if save:
            self.save()
            self.node.add_log(
                NodeLog.COMMENT_REMOVED,
                log_dict,
                auth=auth,
                save=False,
            )
            self.node.save()

    def undelete(self, auth, save=False):
        if not self.node.can_comment(auth) or self.user._id != auth.user._id:
            raise PermissionsError(f'{auth.user!r} does not have permission to comment on this node')
        self.is_deleted = False
        self.deleted = None
        log_dict = {
            'project': self.node.parent_id,
            'node': self.node._id,
            'user': self.user._id,
            'comment': self._id,
        }
        log_dict.update(self.root_target.referent.get_extra_log_params(self))
        self.modified = timezone.now()
        if save:
            self.save()
            self.node.add_log(
                NodeLog.COMMENT_RESTORED,
                log_dict,
                auth=auth,
                save=False,
            )
            self.node.save()

    def _get_spam_content(self, *unused_args, **unused_kwargs):
        '''For compatibility with the domain extraction management command.'''
        content = [getattr(self, field, []) for field in self.SPAM_CHECK_FIELDS]
        if not content:
            return None
        return ' '.join(content)