~launchpad-pqm/launchpad/devel

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

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

"""IBugTarget-related browser views."""

__metaclass__ = type

__all__ = [

    "BugsVHostBreadcrumb",

    "BugsPatchesView",

    "BugTargetBugListingView",

    "BugTargetBugTagsView",

    "BugTargetBugsView",

    "FileBugAdvancedView",

    "FileBugGuidedView",

    "FileBugViewBase",

    "IProductBugConfiguration",

    "OfficialBugTagsManageView",

    "ProductConfigureBugTrackerView",

    "ProjectFileBugGuidedView",

    "product_to_productbugconfiguration",

    ]

import cgi

from cStringIO import StringIO

from datetime import datetime

from operator import itemgetter

import urllib

from lazr.restful.interface import copy_field

from pytz import timezone

from simplejson import dumps

from sqlobject import SQLObjectNotFound

from z3c.ptcompat import ViewPageTemplateFile

from zope import formlib

from zope.app.form.browser import TextWidget

from zope.app.form.interfaces import InputErrors

from zope.component import getUtility

from zope.interface import (

    alsoProvides,

    implements,

    Interface,

    )

from zope.publisher.interfaces import NotFound

from zope.publisher.interfaces.browser import IBrowserPublisher

from zope.schema import (

    Bool,

    Choice,

    )

from zope.schema.interfaces import TooLong

from zope.schema.vocabulary import SimpleVocabulary

from zope.security.proxy import removeSecurityProxy

from canonical.config import config

from canonical.launchpad import _

from canonical.launchpad.browser.feeds import (

    BugFeedLink,

    BugTargetLatestBugsFeedLink,

    FeedsMixin,

    )

from canonical.launchpad.browser.librarian import ProxiedLibraryFileAlias

from canonical.launchpad.interfaces.launchpad import ILaunchpadCelebrities

from canonical.launchpad.searchbuilder import any

from canonical.launchpad.webapp import (

    canonical_url,

    LaunchpadView,

    urlappend,

    )

from canonical.launchpad.webapp.authorization import check_permission

from canonical.launchpad.webapp.batching import BatchNavigator

from canonical.launchpad.webapp.breadcrumb import Breadcrumb

from canonical.launchpad.webapp.interfaces import ILaunchBag

from canonical.launchpad.webapp.menu import structured

from canonical.launchpad.webapp.publisher import HTTP_MOVED_PERMANENTLY

from lp.app.browser.launchpadform import (

    action,

    custom_widget,

    LaunchpadEditFormView,

    LaunchpadFormView,

    safe_action,

    )

from lp.app.browser.stringformatter import FormattersAPI

from lp.app.browser.tales import BugTrackerFormatterAPI

from lp.app.enums import ServiceUsage

from lp.app.errors import (

    NotFoundError,

    UnexpectedFormData,

    )

from lp.app.interfaces.launchpad import (

    ILaunchpadUsage,

    IServiceUsage,

    )

from lp.app.validators.name import valid_name_pattern

from lp.app.widgets.product import (

    GhostCheckBoxWidget,

    GhostWidget,

    ProductBugTrackerWidget,

    )

from lp.bugs.browser.bugrole import BugRoleMixin

from lp.bugs.browser.bugtask import BugTaskSearchListingView

from lp.bugs.browser.structuralsubscription import (

    expose_structural_subscription_data_to_js,

    )

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

    BugTagsWidget,

    LargeBugTagsWidget,

    )

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

from lp.bugs.interfaces.apportjob import IProcessApportBlobJobSource

from lp.bugs.interfaces.bug import (

    CreateBugParams,

    IBug,

    IBugAddForm,

    IBugSet,

    IProjectGroupBugAddForm,

    )

from lp.bugs.interfaces.bugsupervisor import IHasBugSupervisor

from lp.bugs.interfaces.bugtarget import (

    IBugTarget,

    IOfficialBugTagTargetPublic,

    IOfficialBugTagTargetRestricted,

    )

from lp.bugs.interfaces.bugtask import (

    BugTaskSearchParams,

    BugTaskStatus,

    IBugTaskSet,

    UNRESOLVED_BUGTASK_STATUSES,

    )

from lp.bugs.interfaces.bugtracker import IBugTracker

from lp.bugs.interfaces.malone import IMaloneApplication

from lp.bugs.interfaces.securitycontact import IHasSecurityContact

from lp.bugs.model.bugtask import BugTask

from lp.bugs.model.structuralsubscription import (

    get_structural_subscriptions_for_target,

    )

from lp.bugs.utilities.filebugdataparser import FileBugData

from lp.hardwaredb.interfaces.hwdb import IHWSubmissionSet

from lp.registry.browser.product import ProductConfigureBase

from lp.registry.interfaces.distribution import IDistribution

from lp.registry.interfaces.distributionsourcepackage import (

    IDistributionSourcePackage,

    )

from lp.registry.interfaces.distroseries import IDistroSeries

from lp.registry.interfaces.person import IPerson

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.vocabularies import ValidPersonOrTeamVocabulary

from lp.services.job.interfaces.job import JobStatus

from lp.services.propertycache import cachedproperty

# A simple vocabulary for the subscribe_to_existing_bug form field.

SUBSCRIBE_TO_BUG_VOCABULARY = SimpleVocabulary.fromItems(

    [('yes', True), ('no', False)])

class IProductBugConfiguration(Interface):

    """A composite schema for editing bug app configuration."""

    bug_supervisor = copy_field(

        IHasBugSupervisor['bug_supervisor'], readonly=False)

    security_contact = copy_field(IHasSecurityContact['security_contact'])

    official_malone = copy_field(ILaunchpadUsage['official_malone'])

    enable_bug_expiration = copy_field(

        ILaunchpadUsage['enable_bug_expiration'])

    bugtracker = copy_field(IProduct['bugtracker'])

    remote_product = copy_field(IProduct['remote_product'])

    bug_reporting_guidelines = copy_field(

        IBugTarget['bug_reporting_guidelines'])

    bug_reported_acknowledgement = copy_field(

        IBugTarget['bug_reported_acknowledgement'])

    enable_bugfiling_duplicate_search = copy_field(

        IBugTarget['enable_bugfiling_duplicate_search'])

def product_to_productbugconfiguration(product):

    """Adapts an `IProduct` into an `IProductBugConfiguration`."""

    alsoProvides(

        removeSecurityProxy(product), IProductBugConfiguration)

    return product

class ProductConfigureBugTrackerView(BugRoleMixin, ProductConfigureBase):

    """View class to configure the bug tracker for a project."""

    label = "Configure bug tracker"

    schema = IProductBugConfiguration

    # This ProductBugTrackerWidget renders enable_bug_expiration and

    # remote_product as subordinate fields, so this view suppresses them.

    custom_widget('bugtracker', ProductBugTrackerWidget)

    custom_widget('enable_bug_expiration', GhostCheckBoxWidget)

    custom_widget('remote_product', GhostWidget)

    @property

    def field_names(self):

        """Return the list of field names to display."""

        field_names = [

            "bugtracker",

            "enable_bug_expiration",

            "remote_product",

            "bug_reporting_guidelines",

            "bug_reported_acknowledgement",

            "enable_bugfiling_duplicate_search",

            ]

        if check_permission("launchpad.Edit", self.context):

            field_names.extend(["bug_supervisor", "security_contact"])

        return field_names

    def validate(self, data):

        """Constrain bug expiration to Launchpad Bugs tracker."""

        if check_permission("launchpad.Edit", self.context):

            self.validateBugSupervisor(data)

            self.validateSecurityContact(data)

        # enable_bug_expiration is disabled by JavaScript when bugtracker

        # is not 'In Launchpad'. The constraint is enforced here in case the

        # JavaScript fails to activate or run. Note that the bugtracker

        # name : values are {'In Launchpad' : object, 'Somewhere else' : None

        # 'In a registered bug tracker' : IBugTracker}.

        bugtracker = data.get('bugtracker', None)

        if bugtracker is None or IBugTracker.providedBy(bugtracker):

            data['enable_bug_expiration'] = False

    @action("Change", name='change')

    def change_action(self, action, data):

        # bug_supervisor and security_contactrequires a transition method,

        # so it must be handled separately and removed for the

        # updateContextFromData to work as expected.

        if check_permission("launchpad.Edit", self.context):

            self.changeBugSupervisor(data['bug_supervisor'])

            del data['bug_supervisor']

            self.changeSecurityContact(data['security_contact'])

            del data['security_contact']

        self.updateContextFromData(data)

class FileBugReportingGuidelines(LaunchpadFormView):

    """Provides access to common bug reporting attributes.

    Attributes provided are: security_related and bug_reporting_guidelines.

    This view is a superclass of `FileBugViewBase` so that non-ajax browsers

    can load the file bug form, and it is also invoked directly via an XHR

    request to provide an HTML snippet for Javascript enabled browsers.

    """

    schema = IBug

    @property

    def field_names(self):

        """Return the list of field names to display."""

        return ['security_related']

    def setUpFields(self):

        """Set up the form fields. See `LaunchpadFormView`."""

        super(FileBugReportingGuidelines, self).setUpFields()

        security_related_field = Bool(

            __name__='security_related',

            title=_("This bug is a security vulnerability"),

            required=False, default=False)

        self.form_fields = self.form_fields.omit('security_related')

        self.form_fields += formlib.form.Fields(security_related_field)

    @property

    def bug_reporting_guidelines(self):

        """Guidelines for filing bugs in the current context.

        Returns a list of dicts, with each dict containing values for

        "preamble" and "content".

        """

        def target_name(target):

            # IProjectGroup can be considered the target of a bug during

            # the bug filing process, but does not extend IBugTarget

            # and ultimately cannot actually be the target of a

            # bug. Hence this function to determine a suitable

            # name/title to display. Hurrumph.

            if IBugTarget.providedBy(target):

                return target.bugtargetdisplayname

            else:

                return target.displayname

        guidelines = []

        bugtarget = self.context

        if bugtarget is not None:

            content = bugtarget.bug_reporting_guidelines

            if content is not None and len(content) > 0:

                guidelines.append({

                        "source": target_name(bugtarget),

                        "content": content,

                        })

            # Distribution source packages are shown with both their

            # own reporting guidelines and those of their

            # distribution.

            if IDistributionSourcePackage.providedBy(bugtarget):

                distribution = bugtarget.distribution

                content = distribution.bug_reporting_guidelines

                if content is not None and len(content) > 0:

                    guidelines.append({

                            "source": target_name(distribution),

                            "content": content,

                            })

        return guidelines

    def getMainContext(self):

        if IDistributionSourcePackage.providedBy(self.context):

            return self.context.distribution

        else:

            return self.context

class FileBugViewBase(FileBugReportingGuidelines, LaunchpadFormView):

    """Base class for views related to filing a bug."""

    implements(IBrowserPublisher)

    extra_data_token = None

    advanced_form = False

    frontpage_form = False

    data_parser = None

    def __init__(self, context, request):

        LaunchpadFormView.__init__(self, context, request)

        self.extra_data = FileBugData()

    def initialize(self):

        LaunchpadFormView.initialize(self)

        if (not self.redirect_ubuntu_filebug and

            self.extra_data_token is not None and

            not self.extra_data_to_process):

            # self.extra_data has been initialized in publishTraverse().

            if self.extra_data.initial_summary:

                self.widgets['title'].setRenderedValue(

                    self.extra_data.initial_summary)

            if self.extra_data.initial_tags:

                self.widgets['tags'].setRenderedValue(

                    self.extra_data.initial_tags)

            # XXX: Bjorn Tillenius 2006-01-15:

            #      We should include more details of what will be added

            #      to the bug report.

            self.request.response.addNotification(

                'Extra debug information will be added to the bug report'

                ' automatically.')

    @cachedproperty

    def redirect_ubuntu_filebug(self):

        if IDistribution.providedBy(self.context):

            bug_supervisor = self.context.bug_supervisor

        elif (IDistributionSourcePackage.providedBy(self.context) or

              ISourcePackage.providedBy(self.context)):

            bug_supervisor = self.context.distribution.bug_supervisor

        else:

            bug_supervisor = None

        # Work out whether the redirect should be overidden.

        do_not_redirect = (

            self.request.form.get('no-redirect') is not None or

            [key for key in self.request.form.keys()

            if 'field.actions' in key] != [] or

            self.user.inTeam(bug_supervisor))

        return (

            config.malone.ubuntu_disable_filebug and

            self.targetIsUbuntu() and

            self.extra_data_token is None and

            not do_not_redirect)

    @property

    def field_names(self):

        """Return the list of field names to display."""

        context = self.context

        field_names = ['title', 'comment', 'tags', 'security_related',

                       'bug_already_reported_as', 'filecontent', 'patch',

                       'attachment_description', 'subscribe_to_existing_bug']

        if (IDistribution.providedBy(context) or

            IDistributionSourcePackage.providedBy(context)):

            field_names.append('packagename')

        elif IMaloneApplication.providedBy(context):

            field_names.append('bugtarget')

        elif IProjectGroup.providedBy(context):

            field_names.append('product')

        elif not IProduct.providedBy(context):

            raise AssertionError('Unknown context: %r' % context)

        # If the context is a project group we want to render the optional

        # fields since they will initially be hidden and later exposed if the

        # selected project supports them.

        include_extra_fields = IProjectGroup.providedBy(context)

        if not include_extra_fields and IHasBugSupervisor.providedBy(context):

            include_extra_fields = self.user.inTeam(context.bug_supervisor)

        if include_extra_fields:

            field_names.extend(

                ['assignee', 'importance', 'milestone', 'status'])

        return field_names

    @property

    def initial_values(self):

        """Give packagename a default value, if applicable."""

        if not IDistributionSourcePackage.providedBy(self.context):

            return {}

        return {'packagename': self.context.name}

    def isPrivate(self):

        """Whether bug reports on this target are private by default."""

        return IProduct.providedBy(self.context) and self.context.private_bugs

    def contextIsProduct(self):

        return IProduct.providedBy(self.context)

    def contextIsProject(self):

        return IProjectGroup.providedBy(self.context)

    def targetIsUbuntu(self):

        ubuntu = getUtility(ILaunchpadCelebrities).ubuntu

        return (self.context == ubuntu or

                (IMaloneApplication.providedBy(self.context) and

                 self.request.form.get('field.bugtarget.distribution') ==

                 ubuntu.name))

    def getPackageNameFieldCSSClass(self):

        """Return the CSS class for the packagename field."""

        if self.widget_errors.get("packagename"):

            return 'error'

        else:

            return ''

    def validate(self, data):

        """Make sure the package name, if provided, exists in the distro."""

        # The comment field is only required if filing a new bug.

        if self.submit_bug_action.submitted():

            comment = data.get('comment')

            # The widget only exposes the error message. The private

            # attr contains the real error.

            widget_error = self.widgets.get('comment')._error

            if widget_error and isinstance(widget_error.errors, TooLong):

                self.setFieldError('comment',

                    'The description is too long. If you have lots '

                    'text to add, attach a file to the bug instead.')

            elif not comment or widget_error is not None:

                self.setFieldError(

                    'comment', "Provide details about the issue.")

        # Check a bug has been selected when the user wants to

        # subscribe to an existing bug.

        elif self.this_is_my_bug_action.submitted():

            if not data.get('bug_already_reported_as'):

                self.setFieldError('bug_already_reported_as',

                                   "Please choose a bug.")

        else:

            # We only care about those two actions.

            pass

        # We have to poke at the packagename value directly in the

        # request, because if validation failed while getting the

        # widget's data, it won't appear in the data dict.

        form = self.request.form

        if form.get("packagename_option") == "choose":

            packagename = form.get("field.packagename")

            if packagename:

                if IDistribution.providedBy(self.context):

                    distribution = self.context

                elif 'distribution' in data:

                    distribution = data['distribution']

                else:

                    assert IDistributionSourcePackage.providedBy(self.context)

                    distribution = self.context.distribution

                try:

                    distribution.guessPackageNames(packagename)

                except NotFoundError:

                    if distribution.series:

                        # If a distribution doesn't have any series,

                        # it won't have any source packages published at

                        # all, so we set the error only if there are

                        # series.

                        packagename_error = (

                            '"%s" does not exist in %s. Please choose a '

                            "different package. If you're unsure, please "

                            'select "I don\'t know"' % (

                                packagename, distribution.displayname))

                        self.setFieldError("packagename", packagename_error)

            else:

                self.setFieldError("packagename",

                                   "Please enter a package name")

        # If we've been called from the frontpage filebug forms we must check

        # that whatever product or distro is having a bug filed against it

        # actually uses Malone for its bug tracking.

        product_or_distro = self.getProductOrDistroFromContext()

        if (product_or_distro is not None and

            product_or_distro.bug_tracking_usage != ServiceUsage.LAUNCHPAD):

            self.setFieldError(

                'bugtarget',

                "%s does not use Launchpad as its bug tracker " %

                product_or_distro.displayname)

    def setUpWidgets(self):

        """Customize the onKeyPress event of the package name chooser."""

        LaunchpadFormView.setUpWidgets(self)

        if "packagename" in self.field_names:

            self.widgets["packagename"].onKeyPress = (

                "selectWidget('choose', event)")

    def setUpFields(self):

        """Set up the form fields. See `LaunchpadFormView`."""

        super(FileBugViewBase, self).setUpFields()

        # Override the vocabulary for the subscribe_to_existing_bug

        # field.

        subscribe_field = Choice(

            __name__='subscribe_to_existing_bug',

            title=u'Subscribe to this bug',

            vocabulary=SUBSCRIBE_TO_BUG_VOCABULARY,

            required=True, default=False)

        self.form_fields = self.form_fields.omit('subscribe_to_existing_bug')

        self.form_fields += formlib.form.Fields(subscribe_field)

    def contextUsesMalone(self):

        """Does the context use Malone as its official bugtracker?"""

        if IProjectGroup.providedBy(self.context):

            products_using_malone = [

                product for product in self.context.products

                if product.bug_tracking_usage == ServiceUsage.LAUNCHPAD]

            return len(products_using_malone) > 0

        else:

            bug_tracking_usage = self.getMainContext().bug_tracking_usage

            return bug_tracking_usage == ServiceUsage.LAUNCHPAD

    def shouldSelectPackageName(self):

        """Should the radio button to select a package be selected?"""

        return (

            self.request.form.get("field.packagename") or

            self.initial_values.get("packagename"))

    def handleSubmitBugFailure(self, action, data, errors):

        return self.showFileBugForm()

    @action("Submit Bug Report", name="submit_bug",

            failure=handleSubmitBugFailure)

    def submit_bug_action(self, action, data):

        """Add a bug to this IBugTarget."""

        title = data["title"]

        comment = data["comment"].rstrip()

        packagename = data.get("packagename")

        security_related = data.get("security_related", False)

        distribution = data.get(

            "distribution", getUtility(ILaunchBag).distribution)

        context = self.context

        if distribution is not None:

            # We're being called from the generic bug filing form, so

            # manually set the chosen distribution as the context.

            context = distribution

        elif IProjectGroup.providedBy(context):

            context = data['product']

        elif IMaloneApplication.providedBy(context):

            context = data['bugtarget']

        # Ensure that no package information is used, if the user

        # enters a package name but then selects "I don't know".

        if self.request.form.get("packagename_option") == "none":

            packagename = None

        # Security bugs are always private when filed, but can be disclosed

        # after they've been reported.

        if security_related:

            private = True

        else:

            private = False

        linkified_ack = structured(FormattersAPI(

            self.getAcknowledgementMessage(self.context)).text_to_html(

                last_paragraph_class="last"))

        notifications = [linkified_ack]

        params = CreateBugParams(

            title=title, comment=comment, owner=self.user,

            security_related=security_related, private=private,

            tags=data.get('tags'))

        if IDistribution.providedBy(context) and packagename:

            # We don't know if the package name we got was a source or binary

            # package name, so let the Soyuz API figure it out for us.

            packagename = str(packagename.name)

            try:

                sourcepackagename, binarypackagename = (

                    context.guessPackageNames(packagename))

            except NotFoundError:

                # guessPackageNames may raise NotFoundError. It would be

                # nicer to allow people to indicate a package even if

                # never published, but the quick fix for now is to note

                # the issue and move on.

                notifications.append(

                    "The package %s is not published in %s; the "

                    "bug was targeted only to the distribution."

                    % (packagename, context.displayname))

                params.comment += (

                    "\r\n\r\nNote: the original reporter indicated "

                    "the bug was in package %r; however, that package "

                    "was not published in %s." % (

                        packagename, context.displayname))

            else:

                context = context.getSourcePackage(sourcepackagename.name)

                params.binarypackagename = binarypackagename

        extra_data = self.extra_data

        if extra_data.extra_description:

            params.comment = "%s\n\n%s" % (

                params.comment, extra_data.extra_description)

            notifications.append(

                'Additional information was added to the bug description.')

        if extra_data.private:

            params.private = extra_data.private

        self.added_bug = bug = context.createBug(params)

        # Apply any extra options given by a bug supervisor.

        bugtask = self.added_bug.default_bugtask

        if IHasBugSupervisor.providedBy(context):

            if self.user.inTeam(context.bug_supervisor):

                if 'assignee' in data:

                    bugtask.transitionToAssignee(data['assignee'])

                if 'status' in data:

                    bugtask.transitionToStatus(data['status'], self.user)

                if 'importance' in data:

                    bugtask.transitionToImportance(

                        data['importance'], self.user)

                if 'milestone' in data:

                    bugtask.milestone = data['milestone']

        for comment in extra_data.comments:

            bug.newMessage(self.user, bug.followup_subject(), comment)

            notifications.append(

                'A comment with additional information was added to the'

                ' bug report.')

        # XXX 2007-01-19 gmb:

        #     We need to have a proper FileUpload widget rather than

        #     this rather hackish solution.

        attachment = self.request.form.get(self.widgets['filecontent'].name)

        if attachment or extra_data.attachments:

            # Attach all the comments to a single empty comment.

            attachment_comment = bug.newMessage(

                owner=self.user, subject=bug.followup_subject(), content=None)

            # Deal with attachments added in the filebug form.

            if attachment:

                # We convert slashes in filenames to hyphens to avoid

                # problems.

                filename = attachment.filename.replace('/', '-')

                # If the user hasn't entered a description for the

                # attachment we use its name.

                file_description = None

                if 'attachment_description' in data:

                    file_description = data['attachment_description']

                if file_description is None:

                    file_description = filename

                bug.addAttachment(

                    owner=self.user, data=StringIO(data['filecontent']),

                    filename=filename, description=file_description,