~launchpad-pqm/launchpad/devel

# Copyright 2009-2011 Canonical Ltd.  This software is licensed under the

# GNU Affero General Public License version 3 (see the file LICENSE).

"""IBugTask-related browser views."""

__metaclass__ = type

__all__ = [

    'BugListingBatchNavigator',

    'BugListingPortletInfoView',

    'BugListingPortletStatsView',

    'BugNominationsView',

    'BugsBugTaskSearchListingView',

    'bugtarget_renderer',

    'BugTargetTraversalMixin',

    'BugTargetView',

    'bugtask_heat_html',

    'BugTaskBreadcrumb',

    'BugTaskContextMenu',

    'BugTaskCreateQuestionView',

    'BugTaskEditView',

    'BugTaskExpirableListingView',

    'BugTaskListingItem',

    'BugTaskListingView',

    'BugTaskNavigation',

    'BugTaskPortletView',

    'BugTaskPrivacyAdapter',

    'BugTaskRemoveQuestionView',

    'BugTasksAndNominationsView',

    'BugTaskSearchListingView',

    'BugTaskSetNavigation',

    'BugTaskStatusView',

    'BugTaskTableRowView',

    'BugTaskTextView',

    'BugTaskView',

    'calculate_heat_display',

    'get_buglisting_search_filter_url',

    'get_comments_for_bugtask',

    'get_sortorder_from_request',

    'get_visible_comments',

    'NominationsReviewTableBatchNavigatorView',

    'TextualBugTaskSearchListingView',

    ]

import cgi

from collections import defaultdict

from datetime import (

    datetime,

    timedelta,

    )

from itertools import groupby

from math import (

    floor,

    log,

    )

from operator import attrgetter

import re

import transaction

import urllib

from lazr.delegates import delegates

from lazr.enum import (

    EnumeratedType,

    Item,

    )

from lazr.lifecycle.event import ObjectModifiedEvent

from lazr.lifecycle.snapshot import Snapshot

from lazr.restful.interface import copy_field

from lazr.restful.interfaces import (

    IFieldHTMLRenderer,

    IJSONRequestCache,

    IReference,

    IWebServiceClientRequest,

    )

from lazr.uri import URI

from pytz import utc

from simplejson import dumps

from z3c.ptcompat import ViewPageTemplateFile

from zope import (

    component,

    formlib,

    )

from zope.app.form import CustomWidgetFactory

from zope.app.form.browser.itemswidgets import RadioWidget

from zope.app.form.interfaces import (

    IDisplayWidget,

    IInputWidget,

    InputErrors,

    WidgetsError,

    )

from zope.app.form.utility import (

    setUpWidget,

    setUpWidgets,

    )

from zope.component import (

    ComponentLookupError,

    getAdapter,

    getMultiAdapter,

    getUtility,

    queryMultiAdapter,

    )

from zope.event import notify

from zope.interface import (

    implementer,

    implements,

    Interface,

    providedBy,

    )

from zope.schema import Choice

from zope.schema.interfaces import (

    IContextSourceBinder,

    IList,

    )

from zope.schema.vocabulary import (

    getVocabularyRegistry,

    SimpleVocabulary,

    )

from zope.security.interfaces import Unauthorized

from zope.security.proxy import (

    isinstance as zope_isinstance,

    removeSecurityProxy,

    )

from zope.traversing.interfaces import IPathAdapter

from canonical.config import config

from canonical.launchpad import (

    _,

    helpers,

    )

from canonical.launchpad.browser.feeds import (

    BugTargetLatestBugsFeedLink,

    FeedsMixin,

    )

from canonical.launchpad.interfaces.launchpad import IHasExternalBugTracker

from canonical.launchpad.mailnotification import get_unified_diff

from canonical.launchpad.searchbuilder import (

    all,

    any,

    NULL,

    )

from canonical.launchpad.webapp import (

    canonical_url,

    enabled_with_permission,

    GetitemNavigation,

    LaunchpadView,

    Link,

    Navigation,

    NavigationMenu,

    redirection,

    stepthrough,

    )

from canonical.launchpad.webapp.authorization import check_permission

from canonical.launchpad.webapp.batching import TableBatchNavigator

from canonical.launchpad.webapp.breadcrumb import Breadcrumb

from canonical.launchpad.webapp.interfaces import ILaunchBag

from canonical.launchpad.webapp.menu import structured

from canonical.lazr.interfaces import IObjectPrivacy

from canonical.lazr.utils import smartquote

from lp.answers.interfaces.questiontarget import IQuestionTarget

from lp.app.browser.launchpadform import (

    action,

    custom_widget,

    LaunchpadEditFormView,

    LaunchpadFormView,

    )

from lp.app.browser.lazrjs import (

    TextAreaEditorWidget,

    TextLineEditorWidget,

    vocabulary_to_choice_edit_items,

    )

from lp.app.browser.stringformatter import FormattersAPI

from lp.app.browser.tales import (

    ObjectImageDisplayAPI,

    PersonFormatterAPI,

    )

from lp.app.enums import ServiceUsage

from lp.app.errors import (

    NotFoundError,

    UnexpectedFormData,

    )

from lp.app.interfaces.launchpad import (

    ILaunchpadCelebrities,

    IServiceUsage,

    )

from lp.app.validators import LaunchpadValidationError

from lp.app.widgets.itemswidgets import LabeledMultiCheckBoxWidget

from lp.app.widgets.project import ProjectScopeWidget

from lp.bugs.browser.bug import (

    BugContextMenu,

    BugTextView,

    BugViewMixin,

    )

from lp.bugs.browser.bugcomment import (

    build_comments_from_chunks,

    group_comments_with_activity,

    )

from lp.bugs.browser.structuralsubscription import (

    expose_structural_subscription_data_to_js,

    )

from lp.bugs.browser.widgets.bug import BugTagsWidget

from lp.bugs.browser.widgets.bugtask import (

    AssigneeDisplayWidget,

    BugTaskAssigneeWidget,

    BugTaskBugWatchWidget,

    BugTaskSourcePackageNameWidget,

    DBItemDisplayWidget,

    NewLineToSpacesWidget,

    NominationReviewActionWidget,

    )

from lp.bugs.interfaces.bug import (

    IBug,

    IBugSet,

    )

from lp.bugs.interfaces.bugactivity import IBugActivity

from lp.bugs.interfaces.bugattachment import (

    BugAttachmentType,

    IBugAttachmentSet,

    )

from lp.bugs.interfaces.bugnomination import (

    BugNominationStatus,

    IBugNominationSet,

    )

from lp.bugs.interfaces.bugtask import (

    BugBlueprintSearch,

    BugBranchSearch,

    BugTagsSearchCombinator,

    BugTaskImportance,

    BugTaskSearchParams,

    BugTaskStatus,

    BugTaskStatusSearchDisplay,

    DEFAULT_SEARCH_BUGTASK_STATUSES_FOR_DISPLAY,

    IBugTask,

    IBugTaskSearch,

    IBugTaskSet,

    ICreateQuestionFromBugTaskForm,

    IFrontPageBugTaskSearch,

    IllegalTarget,

    INominationsReviewTableBatchNavigator,

    IPersonBugTaskSearch,

    IRemoveQuestionFromBugTaskForm,

    IUpstreamProductBugTaskSearch,

    UNRESOLVED_BUGTASK_STATUSES,

    UserCannotEditBugTaskStatus,

    )

from lp.bugs.interfaces.bugtracker import BugTrackerType

from lp.bugs.interfaces.bugwatch import BugWatchActivityStatus

from lp.bugs.interfaces.cve import ICveSet

from lp.bugs.interfaces.malone import IMaloneApplication

from lp.bugs.model.bugtask import validate_target

from lp.registry.interfaces.distribution import (

    IDistribution,

    IDistributionSet,

    )

from lp.registry.interfaces.distributionsourcepackage import (

    IDistributionSourcePackage,

    )

from lp.registry.interfaces.distroseries import (

    IDistroSeries,

    IDistroSeriesSet,

    )

from lp.registry.interfaces.person import (

    IPerson,

    IPersonSet,

    )

from lp.registry.interfaces.product import IProduct

from lp.registry.interfaces.productseries import IProductSeries

from lp.registry.interfaces.projectgroup import IProjectGroup

from lp.registry.interfaces.sourcepackage import ISourcePackage

from lp.registry.model.personroles import PersonRoles

from lp.registry.vocabularies import MilestoneVocabulary

from lp.services.fields import PersonChoice

from lp.services.propertycache import cachedproperty

DISPLAY_BUG_STATUS_FOR_PATCHES = {

    BugTaskStatus.NEW: True,

    BugTaskStatus.INCOMPLETE: True,

    BugTaskStatus.INVALID: False,

    BugTaskStatus.WONTFIX: False,

    BugTaskStatus.CONFIRMED: True,

    BugTaskStatus.TRIAGED: True,

    BugTaskStatus.INPROGRESS: True,

    BugTaskStatus.FIXCOMMITTED: True,

    BugTaskStatus.FIXRELEASED: False,

    BugTaskStatus.UNKNOWN: False,

    BugTaskStatus.EXPIRED: False,

    }

@component.adapter(IBugTask, IReference, IWebServiceClientRequest)

@implementer(IFieldHTMLRenderer)

def bugtarget_renderer(context, field, request):

    """Render a bugtarget as a link."""

    def render(value):

        html = """<span>

          <a href="%(href)s" class="%(class)s">%(displayname)s</a>

        </span>""" % {

            'href': canonical_url(context.target),

            'class': ObjectImageDisplayAPI(context.target).sprite_css(),

            'displayname': cgi.escape(context.bugtargetdisplayname)}

        return html

    return render

def unique_title(title):

    """Canonicalise a message title to help identify messages with new

    information in their titles.

    """

    if title is None:

        return None

    title = title.lower()

    if title.startswith('re:'):

        title = title[3:]

    return title.strip()

def get_comments_for_bugtask(bugtask, truncate=False, for_display=False,

    slice_info=None, show_spam_controls=False):

    """Return BugComments related to a bugtask.

    This code builds a sorted list of BugComments in one shot,

    requiring only two database queries. It removes the titles

    for those comments which do not have a "new" subject line

    :param for_display: If true, the zeroth comment is given an empty body so

        that it will be filtered by get_visible_comments.

    :param slice_info: If not None, defines a list of slices of the comments

        to retrieve.

    """

    comments = build_comments_from_chunks(bugtask, truncate=truncate,

        slice_info=slice_info, show_spam_controls=show_spam_controls)

    # TODO: further fat can be shaved off here by limiting the attachments we

    # query to those that slice_info would include.

    for attachment in bugtask.bug.attachments_unpopulated:

        message_id = attachment.message.id

        # All attachments are related to a message, so we can be

        # sure that the BugComment is already created.

        if message_id not in comments:

            # We are not showing this message.

            break

        if attachment.type == BugAttachmentType.PATCH:

            comments[message_id].patches.append(attachment)

        else:

            comments[message_id].bugattachments.append(attachment)

    comments = sorted(comments.values(), key=attrgetter("index"))

    current_title = bugtask.bug.title

    for comment in comments:

        if not ((unique_title(comment.title) == \

                 unique_title(current_title)) or \

                (unique_title(comment.title) == \

                 unique_title(bugtask.bug.title))):

            # this comment has a new title, so make that the rolling focus

            current_title = comment.title

            comment.display_title = True

    if for_display and comments and comments[0].index == 0:

        # We show the text of the first comment as the bug description,

        # or via the special link "View original description", but we want

        # to display attachments filed together with the bug in the

        # comment list.

        comments[0].text_for_display = ''

    return comments

def get_visible_comments(comments, user=None):

    """Return comments, filtering out empty or duplicated ones."""

    visible_comments = []

    previous_comment = None

    for comment in comments:

        # Omit comments that are identical to their previous

        # comment, which were probably produced by

        # double-submissions or user errors, and which don't add

        # anything useful to the bug itself.

        # Also omit comments with no body text or attachments to display.

        if (comment.isEmpty() or

            previous_comment and

            previous_comment.isIdenticalTo(comment)):

            continue

        visible_comments.append(comment)

        previous_comment = comment

    # These two lines are here to fill the ValidPersonOrTeamCache cache,

    # so that checking owner.is_valid_person, when rendering the link,

    # won't issue a DB query. Note that this should be obsolete now with

    # getMessagesForView improvements.

    commenters = set(comment.owner for comment in visible_comments)

    getUtility(IPersonSet).getValidPersons(commenters)

    # If a user is supplied, we can also strip out comments that the user

    # cannot see, because they have been marked invisible.

    strip_invisible = True

    if user is not None:

        role = PersonRoles(user)

        strip_invisible = not (role.in_admin or role.in_registry_experts)

    if strip_invisible:

        visible_comments = [c for c in visible_comments if c.visible]

    return visible_comments

def get_sortorder_from_request(request):

    """Get the sortorder from the request.

    >>> from canonical.launchpad.webapp.servers import LaunchpadTestRequest

    >>> get_sortorder_from_request(LaunchpadTestRequest(form={}))

    ['-importance']

    >>> get_sortorder_from_request(

    ...     LaunchpadTestRequest(form={'orderby': '-status'}))

    ['-status']

    >>> get_sortorder_from_request(LaunchpadTestRequest(

    ...     form={'orderby': 'status,-severity,importance'}))

    ['status', 'importance']

    >>> get_sortorder_from_request(

    ...     LaunchpadTestRequest(form={'orderby': 'priority,-severity'}))

    ['-importance']

    """

    order_by_string = request.get("orderby", '')

    if order_by_string:

        if not zope_isinstance(order_by_string, list):

            order_by = order_by_string.split(',')

        else:

            order_by = order_by_string

    else:

        order_by = []

    # Remove old order_by values that people might have in bookmarks.

    for old_order_by_column in ['priority', 'severity']:

        if old_order_by_column in order_by:

            order_by.remove(old_order_by_column)

        if '-' + old_order_by_column in order_by:

            order_by.remove('-' + old_order_by_column)

    if order_by:

        return order_by

    else:

        # No sort ordering specified, so use a reasonable default.

        return ["-importance"]

def get_default_search_params(user):

    """Return a BugTaskSearchParams instance with default values.

    By default, a search includes any bug that is unresolved and not a

    duplicate of another bug.

    If this search will be used to display a list of bugs to the user

    it may be a good idea to set the orderby attribute using

    get_sortorder_from_request():

      params = get_default_search_params(user)

      params.orderby = get_sortorder_from_request(request)

    """

    return BugTaskSearchParams(

        user=user, status=any(*UNRESOLVED_BUGTASK_STATUSES), omit_dupes=True)

OLD_BUGTASK_STATUS_MAP = {

    'Unconfirmed': 'New',

    'Needs Info': 'Incomplete',

    'Rejected': 'Invalid',

    }

def rewrite_old_bugtask_status_query_string(query_string):

    """Return a query string with old status names replaced with new.

    If an old status string has been used in the query, construct a

    corrected query string for the search, else return the original

    query string.

    """

    query_elements = cgi.parse_qsl(

        query_string, keep_blank_values=True, strict_parsing=False)

    query_elements_mapped = []

    for name, value in query_elements:

        if name == 'field.status:list':

            value = OLD_BUGTASK_STATUS_MAP.get(value, value)

        query_elements_mapped.append((name, value))

    if query_elements == query_elements_mapped:

        return query_string

    else:

        return urllib.urlencode(query_elements_mapped, doseq=True)

def target_has_expirable_bugs_listing(target):

    """Return True or False if the target has the expirable-bugs listing.

    The target must be a Distribution, DistroSeries, Product, or

    ProductSeries, and the pillar must have enabled bug expiration.

    """

    if IDistribution.providedBy(target) or IProduct.providedBy(target):

        return target.enable_bug_expiration

    elif IProductSeries.providedBy(target):

        return target.product.enable_bug_expiration

    elif IDistroSeries.providedBy(target):

        return target.distribution.enable_bug_expiration

    else:

        # This context is not a supported bugtarget.

        return False

class BugTargetTraversalMixin:

    """Mix-in in class that provides .../+bug/NNN traversal."""

    redirection('+bug', '+bugs')

    @stepthrough('+bug')

    def traverse_bug(self, name):

        """Traverses +bug portions of URLs"""

        return self._get_task_for_context(name)

    def _get_task_for_context(self, name):

        """Return the IBugTask for this name in this context.

        If the bug has been reported, but not in this specific context, a

        redirect to the default context will be returned.

        Returns None if no bug with the given name is found, or the

        bug is not accessible to the current user.

        """

        context = self.context

        # Raises NotFoundError if no bug is found

        bug = getUtility(IBugSet).getByNameOrID(name)

        # Get out now if the user cannot view the bug. Continuing may

        # reveal information about its context

        if not check_permission('launchpad.View', bug):

            return None

        # Loop through this bug's tasks to try and find the appropriate task

        # for this context. We always want to return a task, whether or not

        # the user has the permission to see it so that, for example, an

        # anonymous user is presented with a login screen at the correct URL,

        # rather than making it look as though this task was "not found",

        # because it was filtered out by privacy-aware code.

        for bugtask in bug.bugtasks:

            if bugtask.target == context:

                # Security proxy this object on the way out.

                return getUtility(IBugTaskSet).get(bugtask.id)

        # If we've come this far, there's no task for the requested

        # context. Redirect to one that exists.

        return self.redirectSubTree(canonical_url(bug.default_bugtask))

class BugTaskNavigation(Navigation):

    """Navigation for the `IBugTask`."""

    usedfor = IBugTask

    @stepthrough('attachments')

    def traverse_attachments(self, name):

        """traverse to an attachment by id."""

        if name.isdigit():

            attachment = getUtility(IBugAttachmentSet)[name]

            if attachment is not None and attachment.bug == self.context.bug:

                return self.redirectSubTree(

                    canonical_url(attachment), status=301)

    @stepthrough('+attachment')

    def traverse_attachment(self, name):

        """traverse to an attachment by id."""

        if name.isdigit():

            attachment = getUtility(IBugAttachmentSet)[name]

            if attachment is not None and attachment.bug == self.context.bug:

                return attachment

    @stepthrough('comments')

    def traverse_comments(self, name):

        """Traverse to a comment by id."""

        if not name.isdigit():

            return None

        index = int(name)

        comments = get_comments_for_bugtask(self.context)

        # I couldn't find a way of using index to restrict the queries

        # in get_comments_for_bugtask in a way that wasn't horrible, and

        # it wouldn't really save us a lot in terms of database time, so

        # I have chosed to use this simple solution for now.

        #   -- kiko, 2006-07-11

        try:

            comment = comments[index]

            if (comment.visible

                or check_permission('launchpad.Admin', self.context)):

                return comment

            else:

                return None

        except IndexError:

            return None

    @stepthrough('nominations')

    def traverse_nominations(self, nomination_id):

        """Traverse to a nomination by id."""

        if not nomination_id.isdigit():

            return None

        return getUtility(IBugNominationSet).get(nomination_id)

    redirection('references', '..')

class BugTaskSetNavigation(GetitemNavigation):

    """Navigation for the `IbugTaskSet`."""

    usedfor = IBugTaskSet

class BugTaskContextMenu(BugContextMenu):

    """Context menu of actions that can be performed upon an `IBugTask`."""

    usedfor = IBugTask

class BugTaskTextView(LaunchpadView):

    """View for a simple text page displaying information about a bug task."""

    def render(self):

        """Return a text representation of the parent bug."""

        view = BugTextView(self.context.bug, self.request)

        view.initialize()

        return view.render()

class BugTaskView(LaunchpadView, BugViewMixin, FeedsMixin):

    """View class for presenting information about an `IBugTask`."""

    override_title_breadcrumbs = True

    def __init__(self, context, request):

        LaunchpadView.__init__(self, context, request)

        self.notices = []

        # Make sure we always have the current bugtask.

        if not IBugTask.providedBy(context):

            self.context = getUtility(ILaunchBag).bugtask

        else:

            self.context = context

        list(getUtility(IPersonSet).getPrecachedPersonsFromIDs(

            [self.context.bug.ownerID], need_validity=True))

    @property

    def page_title(self):

        heading = 'Bug #%s in %s' % (

            self.context.bug.id, self.context.bugtargetdisplayname)

        title = FormattersAPI(self.context.bug.title).obfuscate_email()

        return smartquote('%s: "%s"') % (heading, title)

    @property

    def next_url(self):

        """Provided so returning to the page they came from works."""

        referer = self.request.getHeader('referer')

        # XXX bdmurray 2010-09-30 bug=98437: work around zope's test

        # browser setting referer to localhost.

        if referer and referer != 'localhost':

            next_url = referer

        else:

            next_url = canonical_url(self.context)

        return next_url

    @property

    def cancel_url(self):

        """Provided so returning to the page they came from works."""

        referer = self.request.getHeader('referer')

        # XXX bdmurray 2010-09-30 bug=98437: work around zope's test

        # browser setting referer to localhost.

        if referer and referer != 'localhost':

            cancel_url = referer

        else:

            cancel_url = canonical_url(self.context)

        return cancel_url

    def initialize(self):

        """Set up the needed widgets."""

        bug = self.context.bug

        IJSONRequestCache(self.request).objects['bug'] = bug

        # See render() for how this flag is used.

        self._redirecting_to_bug_list = False

        self.bug_title_edit_widget = TextLineEditorWidget(

            bug, IBug['title'], "Edit this summary", 'h1',

            edit_url=canonical_url(self.context, view_name='+edit'))

        # XXX 2010-10-05 gmb bug=655597:

        # This line of code keeps the view's query count down,

        # possibly using witchcraft. It should be rewritten to be

        # useful or removed in favour of making other queries more

        # efficient. The witchcraft is because the subscribers are accessed

        # in the initial page load, so the data is actually used.

        if self.user is not None:

            list(bug.getSubscribersForPerson(self.user))

    def userIsSubscribed(self):

        """Is the user subscribed to this bug?"""

        return (

            self.context.bug.isSubscribed(self.user) or

            self.context.bug.isSubscribedToDupes(self.user))

    def render(self):

        """Render the bug list if the user has permission to see the bug."""

        # Prevent normal rendering when redirecting to the bug list

        # after unsubscribing from a private bug, because rendering the

        # bug page would raise Unauthorized errors!

        if self._redirecting_to_bug_list:

            return u''

        else:

            return LaunchpadView.render(self)