~launchpad-pqm/launchpad/devel

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

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

__metaclass__ = type

__all__ = [

    'DistributionSourcePackageAnswersMenu',

    'DistributionSourcePackageBreadcrumb',

    'DistributionSourcePackageChangelogView',

    'DistributionSourcePackageEditView',

    'DistributionSourcePackageFacets',

    'DistributionSourcePackageHelpView',

    'DistributionSourcePackageNavigation',

    'DistributionSourcePackageOverviewMenu',

    'DistributionSourcePackagePublishingHistoryView',

    'DistributionSourcePackageView',

    ]

from datetime import datetime

import itertools

import operator

from lazr.delegates import delegates

from lazr.restful.interfaces import IJSONRequestCache

from lazr.restful.utils import smartquote

import pytz

from zope.component import (

    adapter,

    getUtility,

    )

from zope.interface import (

    implements,

    Interface,

    )

from lp.answers.browser.questiontarget import (

    QuestionTargetAnswersMenu,

    QuestionTargetFacetMixin,

    QuestionTargetTraversalMixin,

    )

from lp.answers.enums import QuestionStatus

from lp.app.browser.launchpadform import (

    action,

    LaunchpadEditFormView,

    )

from lp.app.browser.stringformatter import (

    extract_bug_numbers,

    extract_email_addresses,

    )

from lp.app.browser.tales import CustomizableFormatter

from lp.app.enums import ServiceUsage

from lp.app.interfaces.launchpad import IServiceUsage

from lp.bugs.browser.bugtask import BugTargetTraversalMixin

from lp.bugs.browser.structuralsubscription import (

    expose_structural_subscription_data_to_js,

    StructuralSubscriptionMenuMixin,

    StructuralSubscriptionTargetTraversalMixin,

    )

from lp.bugs.interfaces.bug import IBugSet

from lp.registry.browser import add_subscribe_link

from lp.registry.browser.pillar import PillarBugsMenu

from lp.registry.interfaces.distributionsourcepackage import (

    IDistributionSourcePackage,

    )

from lp.registry.interfaces.person import IPersonSet

from lp.registry.interfaces.pocket import pocketsuffix

from lp.registry.interfaces.series import SeriesStatus

from lp.services.helpers import shortlist

from lp.services.propertycache import cachedproperty

from lp.services.webapp import (

    canonical_url,

    Navigation,

    redirection,

    StandardLaunchpadFacets,

    )

from lp.services.webapp.breadcrumb import Breadcrumb

from lp.services.webapp.interfaces import IBreadcrumb

from lp.services.webapp.menu import (

    ApplicationMenu,

    enabled_with_permission,

    Link,

    NavigationMenu,

    )

from lp.services.webapp.publisher import LaunchpadView

from lp.services.webapp.sorting import sorted_dotted_numbers

from lp.soyuz.browser.sourcepackagerelease import linkify_changelog

from lp.soyuz.interfaces.archive import IArchiveSet

from lp.soyuz.interfaces.distributionsourcepackagerelease import (

    IDistributionSourcePackageRelease,

    )

from lp.soyuz.interfaces.packagediff import IPackageDiffSet

from lp.translations.browser.customlanguagecode import (

    HasCustomLanguageCodesTraversalMixin,

    )

class DistributionSourcePackageFormatterAPI(CustomizableFormatter):

    """Adapt IDistributionSourcePackage objects to a formatted string."""

    _link_permission = 'zope.Public'

    _link_summary_template = '%(displayname)s'

    def _link_summary_values(self):

        displayname = self._context.displayname

        return {'displayname': displayname}

@adapter(IDistributionSourcePackage)

class DistributionSourcePackageBreadcrumb(Breadcrumb):

    """Builds a breadcrumb for an `IDistributionSourcePackage`."""

    implements(IBreadcrumb)

    @property

    def text(self):

        return smartquote('"%s" package') % (

            self.context.sourcepackagename.name)

class DistributionSourcePackageFacets(QuestionTargetFacetMixin,

                                      StandardLaunchpadFacets):

    usedfor = IDistributionSourcePackage

    enable_only = ['overview', 'bugs', 'answers', 'branches']

    def overview(self):

        text = 'Overview'

        summary = 'General information about {0}'.format(

            self.context.displayname)

        return Link('', text, summary)

    def bugs(self):

        text = 'Bugs'

        summary = 'Bugs reported about {0}'.format(self.context.displayname)

        return Link('', text, summary)

    def branches(self):

        text = 'Code'

        summary = 'Branches for {0}'.format(self.context.displayname)

        return Link('', text, summary)

class DistributionSourcePackageLinksMixin:

    def publishinghistory(self):

        return Link('+publishinghistory', 'Show publishing history')

    @enabled_with_permission('launchpad.BugSupervisor')

    def edit(self):

        """Edit the details of this source package."""

        # This is titled "Edit bug reporting guidelines" because that

        # is the only editable property of a source package right now.

        return Link('+edit', 'Configure bug tracker', icon='edit')

    def new_bugs(self):

        base_path = "+bugs"

        get_data = "?field.status:list=NEW"

        return Link(base_path + get_data, "New bugs", site="bugs")

    def open_questions(self):

        base_path = "+questions"

        get_data = "?field.status=OPEN"

        return Link(base_path + get_data, "Open Questions", site="answers")

class DistributionSourcePackageOverviewMenu(

    ApplicationMenu, DistributionSourcePackageLinksMixin):

    usedfor = IDistributionSourcePackage

    facet = 'overview'

    links = ['new_bugs', 'open_questions']

class DistributionSourcePackageBugsMenu(

    PillarBugsMenu,

    StructuralSubscriptionMenuMixin,

    DistributionSourcePackageLinksMixin):

    usedfor = IDistributionSourcePackage

    facet = 'bugs'

    @cachedproperty

    def links(self):

        links = ['filebug']

        add_subscribe_link(links)

        return links

class DistributionSourcePackageAnswersMenu(QuestionTargetAnswersMenu):

    usedfor = IDistributionSourcePackage

    facet = 'answers'

    links = QuestionTargetAnswersMenu.links + ['gethelp']

    def gethelp(self):

        return Link('+gethelp', 'Help and support options', icon='info')

class DistributionSourcePackageNavigation(Navigation,

    BugTargetTraversalMixin, HasCustomLanguageCodesTraversalMixin,

    QuestionTargetTraversalMixin,

    StructuralSubscriptionTargetTraversalMixin):

    usedfor = IDistributionSourcePackage

    redirection("+editbugcontact", "+subscribe")

    def traverse(self, name):

        return self.context.getVersion(name)

class DecoratedDistributionSourcePackageRelease:

    """A decorated DistributionSourcePackageRelease.

    The publishing history and package diffs for the release are

    pre-cached.

    """

    delegates(IDistributionSourcePackageRelease, 'context')

    def __init__(

        self, distributionsourcepackagerelease, publishing_history,

        package_diffs, person_data, user):

        self.context = distributionsourcepackagerelease

        self._publishing_history = publishing_history

        self._package_diffs = package_diffs

        self._person_data = person_data

        self._user = user

    @property

    def publishing_history(self):

        """ See `IDistributionSourcePackageRelease`."""

        return self._publishing_history

    @property

    def package_diffs(self):

        """ See `ISourcePackageRelease`."""

        return self._package_diffs

    @property

    def change_summary(self):

        """ See `ISourcePackageRelease`."""

        return linkify_changelog(

            self._user, self.context.change_summary, self._person_data)

class IDistributionSourcePackageActionMenu(Interface):

    """Marker interface for the action menu."""

class DistributionSourcePackageActionMenu(

    NavigationMenu,

    StructuralSubscriptionMenuMixin,

    DistributionSourcePackageLinksMixin):

    """Action menu for distro source packages."""

    usedfor = IDistributionSourcePackageActionMenu

    facet = 'overview'

    title = 'Actions'

    @cachedproperty

    def links(self):

        links = ['publishing_history', 'change_log']

        add_subscribe_link(links)

        links.append('edit')

        return links

    def publishing_history(self):

        text = 'View full publishing history'

        return Link('+publishinghistory', text, icon="info")

    def change_log(self):

        text = 'View full change log'

        return Link('+changelog', text, icon="info")

class DistributionSourcePackageBaseView(LaunchpadView):

    """Common features to all `DistributionSourcePackage` views."""

    def releases(self):

        """All releases for this `IDistributionSourcePackage`."""

        def not_empty(text):

            return (

                text is not None and isinstance(text, basestring)

                and len(text.strip()) > 0)

        dspr_pubs = self.context.getReleasesAndPublishingHistory()

        # Return as early as possible to avoid unnecessary processing.

        if len(dspr_pubs) == 0:

            return []

        sprs = [dspr.sourcepackagerelease for (dspr, spphs) in dspr_pubs]

        # Pre-load the bugs and persons referenced by the +changelog page from

        # the database.

        # This will improve the performance of the ensuing changelog

        # linkification.

        the_changelog = '\n'.join(

            [spr.changelog_entry for spr in sprs

             if not_empty(spr.changelog_entry)])

        unique_bugs = extract_bug_numbers(the_changelog)

        self._bug_data = list(

            getUtility(IBugSet).getByNumbers(

                [int(key) for key in unique_bugs.keys()]))

        # Preload email/person data only if user is logged on. In the opposite

        # case the emails in the changelog will be obfuscated anyway and thus

        # cause no database lookups.

        if self.user:

            self._person_data = dict(

                [(email.email, person) for (email, person) in

                    getUtility(IPersonSet).getByEmails(

                        extract_email_addresses(the_changelog),

                        include_hidden=False)])

        else:

            self._person_data = None

        # Collate diffs for relevant SourcePackageReleases

        pkg_diffs = getUtility(IPackageDiffSet).getDiffsToReleases(

            sprs, preload_for_display=True)

        spr_diffs = {}

        for spr, diffs in itertools.groupby(pkg_diffs,

                                            operator.attrgetter('to_source')):

            spr_diffs[spr] = list(diffs)

        return [

            DecoratedDistributionSourcePackageRelease(

                dspr, spphs, spr_diffs.get(dspr.sourcepackagerelease, []),

                self._person_data, self.user)

            for (dspr, spphs) in dspr_pubs]

class DistributionSourcePackageView(DistributionSourcePackageBaseView,

                                    LaunchpadView):

    """View class for DistributionSourcePackage."""

    implements(IDistributionSourcePackageActionMenu)

    def initialize(self):

        super(DistributionSourcePackageView, self).initialize()

        expose_structural_subscription_data_to_js(

            self.context, self.request, self.user)

        pub = self.context.latest_overall_publication

        if pub:

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

                canonical_url(pub.archive, path_only_if_possible=True))

    @property

    def label(self):

        return self.context.title

    page_title = label

    @property

    def next_url(self):

        """See `LaunchpadFormView`."""

        return canonical_url(self.context)

    @property

    def all_published_in_active_distroseries(self):

        """Return a list of publishings in each active distroseries.

        The list contains dictionaries each with a key of "suite" and

        "description" where suite is "distroseries-pocket" and

        description is "(version): component/section".

        """

        results = []

        for pub in self.context.current_publishing_records:

            if pub.distroseries.active:

                entry = {

                    "suite": (pub.distroseries.name.capitalize() +

                               pocketsuffix[pub.pocket]),

                    "description": "(%s): %s/%s" % (

                        pub.sourcepackagerelease.version,

                        pub.component.name, pub.section.name),

                    }

                results.append(entry)

        return results

    @property

    def related_ppa_versions(self):

        """Return a list of the latest 3 ppas with related publishings.

        The list contains dictionaries each with a key of 'archive' and

        'publications'.

        """

        # Grab the related archive publications and limit the result to

        # the first 3.

        # XXX Michael Nelson 2009-06-24 bug=387020

        # Currently we need to find distinct archives here manually because,

        # without a concept of IArchive.rank or similar, the best ordering

        # that orderDistributionSourcePackage.findRelatedArchives() method

        # can provide is on a join (SourcePackageRelease.dateuploaded), but

        # this prohibits a distinct clause.

        # To ensure that we find distinct archives here with only one query,

        # we grab the first 20 results and iterate through to find three

        # distinct archives (20 is a magic number being greater than

        # 3 * number of distroseries).

        related_archives = self.context.findRelatedArchives()

        related_archives.config(limit=20)

        top_three_archives = []

        for archive in related_archives:

            if archive in top_three_archives:

                continue

            else:

                top_three_archives.append(archive)

            if len(top_three_archives) == 3:

                break

        # Now we'll find the relevant publications for the top

        # three archives.

        archive_set = getUtility(IArchiveSet)

        publications = archive_set.getPublicationsInArchives(

                self.context.sourcepackagename, top_three_archives,

                self.context.distribution)

        # Collect the publishings for each archive

        archive_publishings = {}

        for pub in publications:

            archive_publishings.setdefault(pub.archive, []).append(pub)

        # Then construct a list of dicts with the results for easy use in

        # the template, preserving the order of the archives:

        archive_versions = []

        for archive in top_three_archives:

            versions = []

            # For each publication, append something like:

            # 'Jaunty (1.0.1b)' to the versions list.

            for pub in archive_publishings[archive]:

                versions.append(

                    "%s (%s)" % (

                        pub.distroseries.displayname,

                        pub.source_package_version,

                        )

                    )

            archive_versions.append({

                'archive': archive,

                'versions': ", ".join(versions),

                })

        return archive_versions

    @property

    def further_ppa_versions_url(self):

        """Return the url used to find further PPA versions of this package.

        """

        return "%s/+ppas?name_filter=%s" % (

            canonical_url(self.context.distribution),

            self.context.name,

            )

    @cachedproperty

    def active_distroseries_packages(self):

        """Cached proxy call to context/get_distroseries_packages."""

        return self.context.get_distroseries_packages()

    @property

    def packages_by_active_distroseries(self):

        """Dict of packages keyed by distroseries."""

        packages_dict = {}

        for package in self.active_distroseries_packages:

            packages_dict[package.distroseries] = package

        return packages_dict

    @cachedproperty

    def active_series(self):

        """Return active distroseries where this package is published.

        Used in the template code that shows the table of versions.

        The returned series are sorted in reverse order of creation.

        """

        series = set()

        for package in self.active_distroseries_packages:

            series.add(package.distroseries)

        result = sorted_dotted_numbers(

            series, key=operator.attrgetter('version'))

        result.reverse()

        return result

    def published_by_version(self, sourcepackage):

        """Return a dict of publications keyed by version.

        :param sourcepackage: ISourcePackage

        """

        publications = sourcepackage.distroseries.getPublishedSources(

            sourcepackage.sourcepackagename)

        pocket_dict = {}

        for pub in shortlist(publications):

            version = pub.source_package_version

            pocket_dict.setdefault(version, []).append(pub)

        return pocket_dict

    @property

    def latest_sourcepackage(self):

        if len(self.active_series) == 0:

            return None

        return self.active_series[0].getSourcePackage(

            self.context.sourcepackagename)

    @property

    def version_table(self):

        """Rows of data for the template to render in the packaging table."""

        rows = []

        packages_by_series = self.packages_by_active_distroseries

        for distroseries in self.active_series:

            # The first row for each series is the "title" row.

            packaging = packages_by_series[distroseries].direct_packaging

            package = packages_by_series[distroseries]

            # Don't show the "Set upstream link" action for older series

            # without packaging info, so the user won't feel required to

            # fill it in.

            show_set_upstream_link = (

                packaging is None

                and distroseries.status in (

                    SeriesStatus.CURRENT,

                    SeriesStatus.DEVELOPMENT,

                    )

                )

            title_row = {

                'blank_row': False,

                'title_row': True,

                'data_row': False,

                'distroseries': distroseries,

                'series_package': package,

                'packaging': packaging,

                'show_set_upstream_link': show_set_upstream_link,

                }

            rows.append(title_row)

            # After the title row, we list each package version that's

            # currently published, and which pockets it's published in.

            pocket_dict = self.published_by_version(package)

            for version in pocket_dict:

                most_recent_publication = pocket_dict[version][0]

                date_published = most_recent_publication.datepublished

                if date_published is None:

                    published_since = None

                else:

                    now = datetime.now(tz=pytz.UTC)

                    published_since = now - date_published

                pockets = ", ".join(

                    [pub.pocket.name for pub in pocket_dict[version]])

                row = {

                    'blank_row': False,

                    'title_row': False,

                    'data_row': True,

                    'version': version,

                    'publication': most_recent_publication,

                    'pockets': pockets,

                    'component': most_recent_publication.component_name,

                    'published_since': published_since,

                    }

                rows.append(row)

            # We need a blank row after each section, so the series

            # header row doesn't appear too close to the previous

            # section.

            rows.append({

                'blank_row': True,

                'title_row': False,

                'data_row': False,

                })

        return rows

    @cachedproperty

    def open_questions(self):

        """Return result set containing open questions for this package."""

        return self.context.searchQuestions(status=QuestionStatus.OPEN)

    @cachedproperty

    def bugs_answers_usage(self):

        """Return a  dict of uses_bugs, uses_answers, uses_both, uses_either.

        """

        service_usage = IServiceUsage(self.context)

        uses_bugs = (

            service_usage.bug_tracking_usage == ServiceUsage.LAUNCHPAD)

        uses_answers = service_usage.answers_usage == ServiceUsage.LAUNCHPAD

        uses_both = uses_bugs and uses_answers

        uses_either = uses_bugs or uses_answers

        return dict(

            uses_bugs=uses_bugs, uses_answers=uses_answers,

            uses_both=uses_both, uses_either=uses_either)

class DistributionSourcePackageChangelogView(

    DistributionSourcePackageBaseView, LaunchpadView):

    """View for presenting change logs for a `DistributionSourcePackage`."""

    page_title = 'Change log'

    @property

    def label(self):

        return 'Change log for %s' % self.context.title

class DistributionSourcePackagePublishingHistoryView(LaunchpadView):

    """View for presenting `DistributionSourcePackage` publishing history."""

    page_title = 'Publishing history'

    @property

    def label(self):

        return 'Publishing history of %s' % self.context.title

class DistributionSourcePackageEditView(LaunchpadEditFormView):

    """Edit a distribution source package."""

    schema = IDistributionSourcePackage

    field_names = [

        'bug_reporting_guidelines',

        'bug_reported_acknowledgement',

        'enable_bugfiling_duplicate_search',

        ]

    @property

    def label(self):

        """The form label."""

        return 'Edit %s' % self.context.title

    @property

    def page_title(self):

        """The page title."""

        return self.label

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

    def change_action(self, action, data):

        self.updateContextFromData(data)

    @property

    def next_url(self):

        return canonical_url(self.context)

    cancel_url = next_url

class DistributionSourcePackageHelpView(LaunchpadView):

    """A View to show Answers help."""

    page_title = 'Help and support options'