~launchpad-pqm/launchpad/devel

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

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

# pylint: disable-msg=F0401

"""Browser code for PO templates."""

__metaclass__ = type

__all__ = [

    'POTemplateAdminView',

    'POTemplateBreadcrumb',

    'POTemplateEditView',

    'POTemplateFacets',

    'POTemplateExportView',

    'POTemplateMenu',

    'POTemplateNavigation',

    'POTemplateSetNavigation',

    'POTemplateSubsetNavigation',

    'POTemplateSubsetURL',

    'POTemplateSubsetView',

    'POTemplateURL',

    'POTemplateUploadView',

    'POTemplateView',

    'POTemplateViewPreferred',

    'BaseSeriesTemplatesView',

    ]

import cgi

import datetime

import operator

import os.path

from lazr.restful.utils import smartquote

import pytz

from storm.expr import (

    And,

    Or,

    )

from storm.info import ClassAlias

from zope.component import getUtility

from zope.interface import implements

from zope.publisher.browser import FileUpload

from zope.security.proxy import removeSecurityProxy

from lp import _

from lp.app.browser.launchpadform import ReturnToReferrerMixin

from lp.app.browser.tales import DateTimeFormatterAPI

from lp.app.enums import (

    service_uses_launchpad,

    ServiceUsage,

    )

from lp.app.errors import NotFoundError

from lp.app.validators.name import valid_name

from lp.registry.browser.productseries import ProductSeriesFacets

from lp.registry.browser.sourcepackage import SourcePackageFacets

from lp.registry.interfaces.productseries import IProductSeries

from lp.registry.interfaces.role import IPersonRoles

from lp.registry.interfaces.sourcepackage import ISourcePackage

from lp.registry.model.packaging import Packaging

from lp.registry.model.product import Product

from lp.registry.model.productseries import ProductSeries

from lp.registry.model.sourcepackagename import SourcePackageName

from lp.services.helpers import is_tar_filename

from lp.services.webapp import (

    action,

    canonical_url,

    enabled_with_permission,

    GetitemNavigation,

    LaunchpadEditFormView,

    LaunchpadView,

    Link,

    Navigation,

    NavigationMenu,

    StandardLaunchpadFacets,

    )

from lp.services.webapp.authorization import check_permission

from lp.services.webapp.breadcrumb import Breadcrumb

from lp.services.webapp.interfaces import (

    ICanonicalUrlData,

    ILaunchBag,

    )

from lp.services.webapp.menu import structured

from lp.services.worlddata.interfaces.language import ILanguageSet

from lp.translations.browser.poexportrequest import BaseExportView

from lp.translations.browser.translations import TranslationsMixin

from lp.translations.browser.translationsharing import (

    TranslationSharingDetailsMixin,

    )

from lp.translations.interfaces.pofile import IPOFileSet

from lp.translations.interfaces.potemplate import (

    IPOTemplate,

    IPOTemplateSet,

    IPOTemplateSubset,

    )

from lp.translations.interfaces.side import TranslationSide

from lp.translations.interfaces.translationimporter import (

    ITranslationImporter,

    )

from lp.translations.interfaces.translationimportqueue import (

    ITranslationImportQueue,

    )

from lp.translations.model.potemplate import POTemplate

class POTemplateNavigation(Navigation):

    usedfor = IPOTemplate

    def traverse(self, name):

        """Return the IPOFile associated with the given name."""

        assert self.request.method in ['GET', 'HEAD', 'POST'], (

            'We only know about GET, HEAD, and POST')

        user = getUtility(ILaunchBag).user

        # We do not want users to see the 'en' potemplate because

        # we store the messages we want to translate as English.

        if name == 'en':

            raise NotFoundError(name)

        pofile = self.context.getPOFileByLang(name)

        if pofile is not None:

            # Already have a valid POFile entry, just return it.

            return pofile

        elif self.request.method in ['GET', 'HEAD']:

            # It's just a query, get a fake one so we don't create new

            # POFiles just because someone is browsing the web.

            language = getUtility(ILanguageSet).getLanguageByCode(name)

            if language is None:

                raise NotFoundError(name)

            return self.context.getDummyPOFile(

                language, requester=user, check_for_existing=False)

        else:

            # It's a POST.

            # XXX CarlosPerelloMarin 2006-04-20 bug=40275: We should

            # check the kind of POST we got.  A logout will also be a

            # POST and we should not create a POFile in that case.

            return self.context.newPOFile(name, owner=user)

class POTemplateFacets(StandardLaunchpadFacets):

    usedfor = IPOTemplate

    def __init__(self, context):

        StandardLaunchpadFacets.__init__(self, context)

        target = context.translationtarget

        if IProductSeries.providedBy(target):

            self._is_product_series = True

            self.target_facets = ProductSeriesFacets(target)

        elif ISourcePackage.providedBy(target):

            self._is_product_series = False

            self.target_facets = SourcePackageFacets(target)

        else:

            # We don't know yet how to handle this target.

            raise NotImplementedError

        # Enable only the menus that the translation target uses.

        self.enable_only = self.target_facets.enable_only

        # From an IPOTemplate URL, we reach its translationtarget (either

        # ISourcePackage or IProductSeries using self.target.

        self.target = '../../'

    def overview(self):

        overview_link = self.target_facets.overview()

        overview_link.target = self.target

        return overview_link

    def translations(self):

        translations_link = self.target_facets.translations()

        translations_link.target = self.target

        return translations_link

    def bugs(self):

        bugs_link = self.target_facets.bugs()

        bugs_link.target = self.target

        return bugs_link

    def answers(self):

        answers_link = self.target_facets.answers()

        answers_link.target = self.target

        return answers_link

    def specifications(self):

        specifications_link = self.target_facets.specifications()

        specifications_link.target = self.target

        return specifications_link

    def branches(self):

        branches_link = self.target_facets.branches()

        if not self._is_product_series:

            branches_link.target = self.target

        return branches_link

class POTemplateMenu(NavigationMenu):

    """Navigation menus for `IPOTemplate` objects."""

    usedfor = IPOTemplate

    facet = 'translations'

    # XXX: henninge 2009-04-22 bug=365112: The order in this list was

    # rearranged so that the last item is public. The desired order is:

    # links = ['overview', 'upload', 'download', 'edit', 'administer']

    links = ['overview', 'edit', 'administer', 'upload', 'download']

    def overview(self):

        text = 'Overview'

        return Link('', text)

    @enabled_with_permission('launchpad.Edit')

    def upload(self):

        text = 'Upload'

        return Link('+upload', text, icon='add')

    def download(self):

        text = 'Download'

        return Link('+export', text, icon='download')

    @enabled_with_permission('launchpad.Edit')

    def edit(self):

        text = 'Edit'

        return Link('+edit', text, icon='edit')

    @enabled_with_permission('launchpad.TranslationsAdmin')

    def administer(self):

        text = 'Administer'

        return Link('+admin', text, icon='edit')

class POTemplateSubsetView:

    def __init__(self, context, request):

        self.context = context

        self.request = request

    def __call__(self):

        # We are not using this context directly, only for traversals.

        self.request.response.redirect('../+translations')

class POTemplateView(LaunchpadView,

                     TranslationsMixin, TranslationSharingDetailsMixin):

    SHOW_RELATED_TEMPLATES = 4

    label = "Translation status"

    def initialize(self):

        """Get the requested languages and submit the form."""

        self.description = self.context.description

    def requestPoFiles(self):

        """Yield a POFile or DummyPOFile for each of the languages in the

        request, which includes country languages from the request IP,

        browser preferences, and/or personal Launchpad language prefs.

        """

        for language in self._sortLanguages(self.translatable_languages):

            yield self._getPOFileOrDummy(language)

    def num_messages(self):

        N = self.context.messageCount()

        if N == 0:

            return "no messages at all"

        elif N == 1:

            return "1 message"

        else:

            return "%s messages" % N

    def pofiles(self, preferred_only=False):

        """Iterate languages shown when viewing this PO template.

        Yields a POFileView object for each language this template has

        been translated into, and for each of the user's languages.

        Where the template has no POFile for that language, we use

        a DummyPOFile.

        """

        # This inline import is needed to workaround a circular import problem

        # because lp.translations.browser.pofile imports

        # lp.translations.browser.potemplate.

        from lp.translations.browser.pofile import POFileView

        languages = self.translatable_languages

        if not preferred_only:

            # Union the languages the template has been translated into with

            # the user's selected languages.

            languages = set(self.context.languages()) | set(languages)

        for language in self._sortLanguages(languages):

            pofile = self._getPOFileOrDummy(language)

            pofileview = POFileView(pofile, self.request)

            # Initialize the view.

            pofileview.initialize()

            yield pofileview

    @property

    def group_parent(self):

        """Return a parent object implementing `ITranslationPolicy`."""

        if self.context.productseries is not None:

            return self.context.productseries.product

        else:

            return self.context.distroseries.distribution

    @property

    def has_translation_documentation(self):

        """Are there translation instructions for this project."""

        translation_group = self.group_parent.translationgroup

        return (translation_group is not None and

                translation_group.translation_guide_url is not None)

    @property

    def related_templates_by_source(self):

        by_source = list(

            self.context.relatives_by_source[:self.SHOW_RELATED_TEMPLATES])

        return by_source

    @property

    def more_templates_by_source_link(self):

        by_source_count = self.context.relatives_by_source.count()

        if (by_source_count > self.SHOW_RELATED_TEMPLATES):

            other = by_source_count - self.SHOW_RELATED_TEMPLATES

            if (self.context.distroseries):

                sourcepackage = self.context.distroseries.getSourcePackage(

                    self.context.sourcepackagename)

                url = canonical_url(

                    sourcepackage, rootsite="translations",

                    view_name='+translations')

            else:

                url = canonical_url(

                    self.context.productseries,

                    rootsite="translations",

                    view_name="+templates")

            if other == 1:

                return " and <a href=\"%s\">one other template</a>" % url

            else:

                return " and <a href=\"%s\">%d other templates</a>" % (

                    url, other)

        else:

            return ""

    @property

    def has_pofiles(self):

        languages = set(

            self.context.languages()).union(self.translatable_languages)

        return len(languages) > 0

    def _sortLanguages(self, languages):

        return sorted(languages, key=operator.attrgetter('englishname'))

    def _getPOFileOrDummy(self, language):

        pofile = self.context.getPOFileByLang(language.code)

        if pofile is None:

            pofileset = getUtility(IPOFileSet)

            pofile = pofileset.getDummy(self.context, language)

        return pofile

    @property

    def is_upstream_template(self):

        return self.context.translation_side == TranslationSide.UPSTREAM

    def is_sharing(self):

        potemplate = self.context.getOtherSidePOTemplate()

        return potemplate is not None

    @property

    def sharing_template(self):

        return self.context.getOtherSidePOTemplate()

    def getTranslationSourcePackage(self):

        """See `TranslationSharingDetailsMixin`."""

        if self.is_upstream_template:

            productseries = self.context.productseries

            return productseries.getUbuntuTranslationFocusPackage()

        else:

            return self.context.sourcepackage

class POTemplateUploadView(LaunchpadView, TranslationsMixin):

    """Upload translations and updated template."""

    label = "Upload translations"

    page_title = "Upload translations"

    @property

    def cancel_url(self):

        return canonical_url(self.context)

    def initialize(self):

        """Get the requested languages and submit the form."""

        self.submitForm()

    def submitForm(self):

        """Process any uploaded files."""

        if self.request.method == 'POST':

            if 'UPLOAD' in self.request.form:

                self.upload()

    def upload(self):

        """Handle a form submission to change the contents of the template.

        Uploads may fail if there are already entries with the same path name

        and uploader (importer) in the queue and the new upload cannot be

        safely matched to any of them.  The user will be informed about the

        failure with a warning message."""

        # XXX henninge 20008-12-03 bug=192925: This code is duplicated for

        # productseries and pofile and should be unified.

        file = self.request.form.get('file')

        if not isinstance(file, FileUpload):

            if not file:

                self.request.response.addErrorNotification(

                    "Your upload was ignored because you didn't select a "

                    "file. Please select a file and try again.")

            else:

                # XXX: Carlos Perello Marin 2004-12-30 bug=116:

                # Epiphany seems to have an unpredictable bug with upload

                # forms (or perhaps it's launchpad because I never had

                # problems with bugzilla). The fact is that some uploads don't

                # work and we get a unicode object instead of a file-like

                # object in "file". We show an error if we see that behaviour.

                self.request.response.addErrorNotification(

                    "Your upload failed because there was a problem receiving"

                    " data. Please try again.")

            return

        filename = file.filename

        content = file.read()

        if len(content) == 0:

            self.request.response.addWarningNotification(

                "Ignored your upload because the uploaded file is empty.")

            return

        translation_import_queue = getUtility(ITranslationImportQueue)

        root, ext = os.path.splitext(filename)

        translation_importer = getUtility(ITranslationImporter)

        if ext in translation_importer.supported_file_extensions:

            # Add it to the queue.

            entry = translation_import_queue.addOrUpdateEntry(

                filename, content, True, self.user,

                sourcepackagename=self.context.sourcepackagename,

                distroseries=self.context.distroseries,

                productseries=self.context.productseries,

                potemplate=self.context)

            if entry is None:

                self.request.response.addWarningNotification(

                    "Upload failed.  The name of the file you "

                    "uploaded matched multiple existing "

                    "uploads, for different templates.  This makes it "

                    "impossible to determine which template the new "

                    "upload was for.  Try uploading to a specific "

                    "template: visit the page for the template that you "

                    "want to upload to, and select the upload option "

                    "from there.")

            else:

                self.request.response.addInfoNotification(

                    structured(

                    'Thank you for your upload.  It will be automatically '

                    'reviewed in the next few hours.  If that is not '

                    'enough to determine whether and where your file '

                    'should be imported, it will be reviewed manually by an '

                    'administrator in the coming few days.  You can track '

                    'your upload\'s status in the '

                    '<a href="%s/+imports">Translation Import Queue</a>',

                        canonical_url(self.context.translationtarget)))

        elif is_tar_filename(filename):

            # Add the whole tarball to the import queue.

            (num, conflicts) = (

                translation_import_queue.addOrUpdateEntriesFromTarball(

                    content, True, self.user,

                    sourcepackagename=self.context.sourcepackagename,

                    distroseries=self.context.distroseries,

                    productseries=self.context.productseries,

                    potemplate=self.context))

            if num > 0:

                if num == 1:

                    plural_s = ''

                    itthey = 'it'

                else:

                    plural_s = 's'

                    itthey = 'they'

                self.request.response.addInfoNotification(

                    structured(

                    'Thank you for your upload. %s file%s from the tarball '

                    'will be automatically '

                    'reviewed in the next few hours.  If that is not enough '

                    'to determine whether and where your file%s should '

                    'be imported, %s will be reviewed manually by an '

                    'administrator in the coming few days.  You can track '

                    'your upload\'s status in the '

                    '<a href="%s/+imports">Translation Import Queue</a>' % (

                        num, plural_s, plural_s, itthey,

                        canonical_url(self.context.translationtarget))))

                if len(conflicts) > 0:

                    if len(conflicts) == 1:

                        warning = (

                            "A file could not be uploaded because its "

                            "name matched multiple existing uploads, for "

                            "different templates.")

                        ul_conflicts = structured(

                            "The conflicting file name was:<br /> "

                            "<ul><li>%s</li></ul>", conflicts[0])

                    else:

                        warning = structured(

                            "%s files could not be uploaded because their "

                            "names matched multiple existing uploads, for "

                            "different templates.", len(conflicts))

                        ul_conflicts = structured(

                            "The conflicting file names were:<br /> "

                            "<ul><li>%s</li></ul>" % (

                            "</li><li>".join(map(cgi.escape, conflicts))))

                    self.request.response.addWarningNotification(

                        structured(

                        "%s  This makes it "

                        "impossible to determine which template the new "

                        "upload was for.  Try uploading to a specific "

                        "template: visit the page for the template that you "

                        "want to upload to, and select the upload option "

                        "from there.<br />%s", warning, ul_conflicts))

            else:

                if len(conflicts) == 0:

                    self.request.response.addWarningNotification(

                        "Upload ignored.  The tarball you uploaded did not "

                        "contain any files that the system recognized as "

                        "translation files.")

                else:

                    self.request.response.addWarningNotification(

                        "Upload failed.  One or more of the files you "

                        "uploaded had names that matched multiple existing "

                        "uploads, for different templates.  This makes it "

                        "impossible to determine which template the new "

                        "upload was for.  Try uploading to a specific "

                        "template: visit the page for the template that you "

                        "want to upload to, and select the upload option "

                        "from there.")

        else:

            self.request.response.addWarningNotification(

                "Upload failed because the file you uploaded was not"

                " recognised as a file that can be imported.")

class POTemplateViewPreferred(POTemplateView):

    """View class that shows only users preferred templates."""

    def pofiles(self):

        return POTemplateView.pofiles(self, preferred_only=True)

class POTemplateEditView(ReturnToReferrerMixin, LaunchpadEditFormView):

    """View class that lets you edit a POTemplate object."""

    schema = IPOTemplate

    label = 'Edit translation template details'

    page_title = 'Edit details'

    PRIORITY_MIN_VALUE = 0

    PRIORITY_MAX_VALUE = 100000

    @property

    def field_names(self):

        field_names = [

            'name', 'translation_domain', 'description', 'priority',

            'path', 'iscurrent']

        if self.context.distroseries:

            field_names.extend([

                'sourcepackagename',

                'languagepack',

                ])

        else:

            field_names.append('owner')

        return field_names

    @property

    def _return_url(self):

        # We override the ReturnToReferrerMixin _return_url because it might

        # change when any of the productseries, distroseries,

        # sourcepackagename or name attributes change, and the basic version

        # only supports watching changes to a single attribute.

        # The referer header is a hidden input in the form.

        referrer = self.request.form.get('_return_url')

        returnChanged = False

        if referrer is None:

            # "referer" is misspelled in the HTTP specification.

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

            # If we were looking at the actual template, we want a new

            # URL constructed.

            if referrer is not None and '/+pots/' in referrer:

                returnChanged = True

        if (referrer is not None

            and not returnChanged

            and referrer.startswith(self.request.getApplicationURL())

            and referrer != self.request.getHeader('location')):

            return referrer

        else:

            return canonical_url(self.context)

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

    def change_action(self, action, data):

        context = self.context

        iscurrent = data.get('iscurrent', context.iscurrent)

        context.setActive(iscurrent)

        old_description = context.description

        old_translation_domain = context.translation_domain

        self.updateContextFromData(data)

        if old_description != context.description:

            self.user.assignKarma(

                'translationtemplatedescriptionchanged',

                product=context.product, distribution=context.distribution,

                sourcepackagename=context.sourcepackagename)

        if old_translation_domain != context.translation_domain:

            # We only change date_last_updated when the translation_domain

            # field is changed because it is the only relevant field we

            # care about regarding the date of last update.

            naked_context = removeSecurityProxy(context)

            naked_context.date_last_updated = datetime.datetime.now(pytz.UTC)

    def _validateTargetAndGetTemplates(self, data):

        """Return a POTemplateSubset corresponding to the chosen target."""

        sourcepackagename = data.get('sourcepackagename',

                                     self.context.sourcepackagename)

        return getUtility(IPOTemplateSet).getSubset(

            distroseries=self.context.distroseries,

            sourcepackagename=sourcepackagename,

            productseries=self.context.productseries)

    def validate(self, data):

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

        if name is None or not valid_name(name):

            self.setFieldError(

                'name',

                'Template name can only start with lowercase letters a-z '

                'or digits 0-9, and other than those characters, can only '

                'contain "-", "+" and "." characters.')

        distroseries = data.get('distroseries', self.context.distroseries)

        sourcepackagename = data.get(

            'sourcepackagename', self.context.sourcepackagename)

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

        sourcepackage_changed = (

            distroseries is not None and

            (distroseries != self.context.distroseries or

             sourcepackagename != self.context.sourcepackagename))

        productseries_changed = (productseries is not None and

                                 productseries != self.context.productseries)

        similar_templates = self._validateTargetAndGetTemplates(data)

        if similar_templates is not None:

            self.validateName(

                name, similar_templates, sourcepackage_changed,

                productseries_changed)

            self.validateDomain(

                data.get('translation_domain'), similar_templates,

                sourcepackage_changed, productseries_changed)

        priority = data.get('priority')