~launchpad-pqm/launchpad/devel

# Copyright 2009 Canonical Ltd.  This software is licensed under the
# GNU Affero General Public License version 3 (see the file LICENSE).

"""Bug comment browser view classes."""

__metaclass__ = type
__all__ = [
    'BugComment',
    'BugCommentBoxExpandedReplyView',
    'BugCommentBoxView',
    'BugCommentBreadcrumb',
    'BugCommentView',
    'BugCommentXHTMLRepresentation',
    'build_comments_from_chunks',
    'group_comments_with_activity',
    ]

from datetime import (
    datetime,
    timedelta,
    )
from itertools import (
    chain,
    groupby,
    )
from operator import itemgetter

from lazr.restful.interfaces import IWebServiceClientRequest
from pytz import utc
from zope.component import (
    adapts,
    getMultiAdapter,
    getUtility,
    )
from zope.interface import (
    implements,
    Interface,
    )

from lp.bugs.interfaces.bugmessage import IBugComment
from lp.services.config import config
from lp.services.features import getFeatureFlag
from lp.services.librarian.browser import ProxiedLibraryFileAlias
from lp.services.webapp import (
    canonical_url,
    LaunchpadView,
    )
from lp.services.webapp.breadcrumb import Breadcrumb
from lp.services.webapp.interfaces import ILaunchBag


COMMENT_ACTIVITY_GROUPING_WINDOW = timedelta(minutes=5)


def build_comments_from_chunks(
        bugtask, truncate=False, slice_info=None, show_spam_controls=False,
        user=None):
    """Build BugComments from MessageChunks.

    :param truncate: Perform truncation of large messages.
    :param slice_info: If not None, an iterable of slices to retrieve.
    """
    chunks = bugtask.bug.getMessagesForView(slice_info=slice_info)
    # This would be better as part of indexed_messages eager loading.
    comments = {}
    for bugmessage, message, chunk in chunks:
        bug_comment = comments.get(message.id)
        if bug_comment is None:
            bug_comment = BugComment(
                bugmessage.index, message, bugtask, visible=message.visible,
                show_spam_controls=show_spam_controls, user=user)
            comments[message.id] = bug_comment
            # This code path is currently only used from a BugTask view which
            # has already loaded all the bug watches. If we start lazy loading
            # those, or not needing them we will need to batch lookup watches
            # here.
            if bugmessage.bugwatchID is not None:
                bug_comment.bugwatch = bugmessage.bugwatch
                bug_comment.synchronized = (
                    bugmessage.remote_comment_id is not None)
        bug_comment.chunks.append(chunk)

    for comment in comments.values():
        # Once we have all the chunks related to a comment populated,
        # we get the text set up for display.
        comment.setupText(truncate=truncate)
    return comments


def group_comments_with_activity(comments, activities):
    """Group comments and activity together for human consumption.

    Generates a stream of comment instances (with the activity grouped within)
    or `list`s of grouped activities.

    :param comments: An iterable of `BugComment` instances, which should be
        sorted by index already.
    :param activities: An iterable of `BugActivity` instances.
    """
    window = COMMENT_ACTIVITY_GROUPING_WINDOW

    comment_kind = "comment"
    if comments:
        max_index = comments[-1].index + 1
    else:
        max_index = 0
    comments = (
        (comment.datecreated, comment.index,
            comment.owner, comment_kind, comment)
        for comment in comments)
    activity_kind = "activity"
    activity = (
        (activity.datechanged, max_index,
            activity.person, activity_kind, activity)
        for activity in activities)
    # when an action and a comment happen at the same time, the action comes
    # second, when two events are tied the comment index is used to
    # disambiguate.
    events = sorted(chain(comments, activity), key=itemgetter(0, 1, 2))

    def gen_event_windows(events):
        """Generate event windows.

        Yields `(window_index, kind, event)` tuples, where `window_index` is
        an integer, and is incremented each time the windowing conditions are
        triggered.

        :param events: An iterable of `(date, ignored, actor, kind, event)`
            tuples in order.
        """
        window_comment, window_actor = None, None
        window_index, window_end = 0, None
        for date, _, actor, kind, event in events:
            window_ended = (
                # A window may contain only one comment.
                (window_comment is not None and kind is comment_kind) or
                # All events must have happened within a given timeframe.
                (window_end is None or date >= window_end) or
                # All events within the window must belong to the same actor.
                (window_actor is None or actor != window_actor))
            if window_ended:
                window_comment, window_actor = None, actor
                window_index, window_end = window_index + 1, date + window
            if kind is comment_kind:
                window_comment = event
            yield window_index, kind, event

    event_windows = gen_event_windows(events)
    event_windows_grouper = groupby(event_windows, itemgetter(0))
    for window_index, window_group in event_windows_grouper:
        window_group = [
            (kind, event) for (index, kind, event) in window_group]
        for kind, event in window_group:
            if kind is comment_kind:
                window_comment = event
                window_comment.activity.extend(
                    event for (kind, event) in window_group
                    if kind is activity_kind)
                yield window_comment
                # There's only one comment per window.
                break
        else:
            yield [event for (kind, event) in window_group]


class BugComment:
    """Data structure that holds all data pertaining to a bug comment.

    It keeps track of which index it has in the bug comment list and
    also provides functionality to truncate the comment.

    Note that although this class is called BugComment it really takes
    as an argument a bugtask. The reason for this is to allow
    canonical_url()s of BugComments to take you to the correct
    (task-specific) location.
    """
    implements(IBugComment)

    def __init__(
            self, index, message, bugtask, activity=None,
            visible=True, show_spam_controls=False, user=None):

        self.index = index
        self.bugtask = bugtask
        self.bugwatch = None

        self.title = message.title
        self.display_title = False
        self.datecreated = message.datecreated
        self.owner = message.owner
        self.rfc822msgid = message.rfc822msgid

        self.chunks = []
        self.bugattachments = []
        self.patches = []

        if activity is None:
            activity = []

        self.activity = activity

        self.synchronized = False
        self.visible = visible
        # We use a feature flag to control users deleting their own comments.
        user_owns_comment = False
        flag = 'disclosure.users_hide_own_bug_comments.enabled'
        if bool(getFeatureFlag(flag)):
            user_owns_comment = user is not None and user == self.owner
        self.show_spam_controls = show_spam_controls or user_owns_comment

    @property
    def show_for_admin(self):
        """Show hidden comments for Launchpad admins.

        This is used in templates to add a class to hidden
        comments to enable display for admins, so the admin
        can see the comment even after it is hidden. Since comments
        aren't published unless the user is registry or admin, this
        can just check if the comment is visible.
        """
        return not self.visible

    def setupText(self, truncate=False):
        """Set the text for display and truncate it if necessary.

        Note that this method must be called before either isIdenticalTo() or
        isEmpty() are called, since to do otherwise would mean that they could
        return false positives and negatives respectively.
        """
        comment_limit = config.malone.max_comment_size

        bits = [unicode(chunk.content)
                for chunk in self.chunks
                if chunk.content is not None and len(chunk.content) > 0]
        text = self.text_contents = '\n\n'.join(bits)

        if truncate and comment_limit and len(text) > comment_limit:
            # Note here that we truncate at comment_limit, and not
            # comment_limit - 3; while it would be nice to account for
            # the ellipsis, this breaks down when the comment limit is
            # less than 3 (which can happen in a testcase) and it makes
            # counting the strings harder.
            self.text_for_display = "%s..." % text[:comment_limit]
            self.was_truncated = True
        else:
            self.text_for_display = text
            self.was_truncated = False

    def isIdenticalTo(self, other):
        """Compare this BugComment to another and return True if they are
        identical.
        """
        if self.owner != other.owner:
            return False
        if self.text_for_display != other.text_for_display:
            return False
        if self.title != other.title:
            return False
        if (self.bugattachments or self.patches or other.bugattachments or
            other.patches):
            # We shouldn't collapse comments which have attachments;
            # there's really no possible identity in that case.
            return False
        return True

    def isEmpty(self):
        """Return True if text_for_display is empty."""

        return (len(self.text_for_display) == 0 and
            len(self.bugattachments) == 0 and len(self.patches) == 0)

    @property
    def add_comment_url(self):
        return canonical_url(self.bugtask, view_name='+addcomment')

    @property
    def show_footer(self):
        """Return True if the footer should be shown for this comment."""
        return bool(
            len(self.activity) > 0 or
            self.bugwatch or
            self.show_spam_controls)

    @property
    def rendered_cache_time(self):
        """The number of seconds we can cache the rendered comment for.

        Bug comments are cached with 'authenticated' visibility, so
        should contain no information hidden from some users. We use
        'authenticated' rather than 'public' as email addresses are
        obfuscated for unauthenticated users.
        """
        now = datetime.now(tz=utc)

        # The major factor in how long we can cache a bug comment is the
        # timestamp. For up to 5 minutes comments and activity can be grouped
        # together as related, so do not cache.
        if self.datecreated > now - COMMENT_ACTIVITY_GROUPING_WINDOW:
            # Don't return 0 because that indicates no time limit.
            return -1

        # The rendering of the timestamp changes every minute for the first
        # hour because we say '7 minutes ago'.
        elif self.datecreated > now - timedelta(hours=1):
            return 60

        # Don't cache for long if we are waiting for synchronization.
        elif self.bugwatch and not self.synchronized:
            return 5 * 60

        # For the rest of the first day, the rendering changes every
        # hour. '4 hours ago'. Expire in 15 minutes so the timestamp
        # is at most 15 minutes out of date.
        elif self.datecreated > now - timedelta(days=1):
            return 15 * 60

        # Otherwise, cache away. Lets cache for 6 hours. We don't want
        # to cache for too long as there are still things that can
        # become stale - eg. if a bug attachment has been deleted we
        # should stop rendering the link.
        else:
            return 6 * 60 * 60


class BugCommentView(LaunchpadView):
    """View for a single bug comment."""

    def __init__(self, context, request):
        # We use the current bug task as the context in order to get the
        # menu and portlets working.
        bugtask = getUtility(ILaunchBag).bugtask
        LaunchpadView.__init__(self, bugtask, request)
        self.comment = context

    @property
    def show_spam_controls(self):
        return self.comment.show_spam_controls

    def page_title(self):
        return 'Comment %d for bug %d' % (
            self.comment.index, self.context.bug.id)

    @property
    def page_description(self):
        return self.comment.text_contents

    @property
    def privacy_notice_classes(self):
        if not self.context.bug.private:
            return 'hidden'
        else:
            return ''


class BugCommentBoxViewMixin:
    """A class which provides proxied Librarian URLs for bug attachments."""

    @property
    def show_spam_controls(self):
        if hasattr(self.context, 'show_spam_controls'):
            return self.context.show_spam_controls
        elif (hasattr(self, 'comment') and
            hasattr(self.comment, 'show_spam_controls')):
            return self.comment.show_spam_controls
        else:
            return False

    def proxiedUrlOfLibraryFileAlias(self, attachment):
        """Return the proxied URL for the Librarian file of the attachment."""
        return ProxiedLibraryFileAlias(
            attachment.libraryfile, attachment).http_url


class BugCommentBoxView(LaunchpadView, BugCommentBoxViewMixin):
    """Render a comment box with reply field collapsed."""

    expand_reply_box = False


class BugCommentBoxExpandedReplyView(LaunchpadView, BugCommentBoxViewMixin):
    """Render a comment box with reply field expanded."""

    expand_reply_box = True


class BugCommentXHTMLRepresentation:
    adapts(IBugComment, IWebServiceClientRequest)
    implements(Interface)

    def __init__(self, comment, request):
        self.comment = comment
        self.request = request

    def __call__(self):
        """Render `BugComment` as XHTML using the webservice."""
        comment_view = getMultiAdapter(
            (self.comment, self.request), name="+box")
        return comment_view()


class BugCommentBreadcrumb(Breadcrumb):
    """Breadcrumb for an `IBugComment`."""

    def __init__(self, context):
        super(BugCommentBreadcrumb, self).__init__(context)

    @property
    def text(self):
        return "Comment #%d" % self.context.index