~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).

"""Browser views for `ITranslationImportQueue`."""

__metaclass__ = type

__all__ = [
    'escape_js_string',
    'TranslationImportQueueEntryNavigation',
    'TranslationImportQueueEntryView',
    'TranslationImportQueueNavigation',
    'TranslationImportQueueView',
    ]

import os

from zope.app.form.interfaces import ConversionError
from zope.component import getUtility
from zope.interface import implements
from zope.schema.interfaces import IContextSourceBinder
from zope.schema.vocabulary import (
    SimpleTerm,
    SimpleVocabulary,
    )

from lp.app.browser.launchpadform import (
    action,
    LaunchpadFormView,
    )
from lp.app.browser.tales import DateTimeFormatterAPI
from lp.app.errors import (
    NotFoundError,
    UnexpectedFormData,
    )
from lp.app.validators.name import valid_name
from lp.registry.interfaces.distroseries import IDistroSeries
from lp.registry.interfaces.sourcepackage import ISourcePackageFactory
from lp.services.database.constants import UTC_NOW
from lp.services.webapp import (
    canonical_url,
    GetitemNavigation,
    )
from lp.services.worlddata.interfaces.language import ILanguageSet
from lp.translations.browser.hastranslationimports import (
    HasTranslationImportsView,
    )
from lp.translations.enums import RosettaImportStatus
from lp.translations.interfaces.pofile import IPOFileSet
from lp.translations.interfaces.potemplate import IPOTemplateSet
from lp.translations.interfaces.translationimporter import (
    ITranslationImporter,
    )
from lp.translations.interfaces.translationimportqueue import (
    IEditTranslationImportQueueEntry,
    ITranslationImportQueue,
    ITranslationImportQueueEntry,
    SpecialTranslationImportTargetFilter,
    TranslationFileType,
    )
from lp.translations.utilities.template import (
    make_domain,
    make_name,
    )


def replace(string, replacement):
    """In `string,` replace `replacement`[0] with `replacement`[1]."""
    return string.replace(*replacement)


def escape_js_string(string):
    """Escape `string` for use as a string in a JS <script> tag."""
    replacements = [
        ('\\', '\\\\'),
        ('"', '\\"'),
        ("'", "\\'"),
        ('\n', '\\n'),
        ]
    return reduce(replace, replacements, string)


class TranslationImportQueueEntryNavigation(GetitemNavigation):

    usedfor = ITranslationImportQueueEntry


class TranslationImportQueueEntryView(LaunchpadFormView):
    """The view part of admin interface for the translation import queue."""
    label = "Review import queue entry"
    schema = IEditTranslationImportQueueEntry

    max_series_to_display = 3

    page_title = 'Translation import queue entry'

    @property
    def initial_values(self):
        """Initialize some values on the form, when it's possible."""
        field_values = {}
        if self.request.method == 'POST':
            # We got a form post, we don't need to do any initialization.
            return field_values
        # Fill the know values.
        field_values['path'] = self.context.path

        importer = getUtility(ITranslationImporter)
        if importer.isTemplateName(self.context.path):
            file_type = TranslationFileType.POT
        elif importer.isTranslationName(self.context.path):
            file_type = TranslationFileType.PO
        else:
            file_type = TranslationFileType.UNSPEC
        field_values['file_type'] = file_type

        if self.context.sourcepackagename is not None:
            field_values['sourcepackagename'] = self.context.sourcepackagename
        if self.context.is_targeted_to_ubuntu:
            if self.context.potemplate is None:
                # Default for Ubuntu templates is to
                # include them in languagepacks.
                field_values['languagepack'] = True
            else:
                field_values['languagepack'] = (
                    self.context.potemplate.languagepack)
        if (file_type in (TranslationFileType.POT,
                          TranslationFileType.UNSPEC)):
            potemplate = self.context.potemplate
            if potemplate is None:
                domain = make_domain(self.context.path)
                field_values['name'] = make_name(domain)
                field_values['translation_domain'] = domain
            else:
                field_values['name'] = potemplate.name
                field_values['translation_domain'] = (
                    potemplate.translation_domain)
        if file_type in (TranslationFileType.PO, TranslationFileType.UNSPEC):
            field_values['potemplate'] = self.context.potemplate
            if self.context.pofile is not None:
                field_values['language'] = self.context.pofile.language
            else:
                # The entries that are translations usually have the language
                # code
                # as its filename. We try to get it to use as a suggestion.
                language_set = getUtility(ILanguageSet)
                filename = os.path.basename(self.context.path)
                guessed_language, file_ext = filename.split(u'.', 1)
                language = language_set.getLanguageByCode(guessed_language)
                if language is not None:
                    field_values['language'] = language
                    # Need to warn the user that we guessed the language
                    # information.
                    self.request.response.addWarningNotification(
                        "Review the language selection as we guessed it and"
                        " could not be accurate.")

        return field_values

    @property
    def cancel_url(self):
        """See `LaunchpadFormView`."""
        referrer = self.referrer_url
        if referrer is None:
            translationimportqueue_set = getUtility(ITranslationImportQueue)
            return canonical_url(translationimportqueue_set)
        else:
            return referrer

    @property
    def referrer_url(self):
        referrer = self.request.getHeader('referer')
        if referrer != canonical_url(self.context):
            return referrer
        else:
            return None

    @property
    def import_target(self):
        """The entry's `ProductSeries` or `SourcePackage`."""
        productseries = self.context.productseries
        distroseries = self.context.distroseries
        sourcepackagename = self.context.sourcepackagename
        if distroseries is None:
            return productseries
        else:
            factory = getUtility(ISourcePackageFactory)
            return factory.new(sourcepackagename, distroseries)

    @property
    def productseries_templates_link(self):
        """Return link to `ProductSeries`' templates.

        Use this only if the entry is attached to a `ProductSeries`.
        """
        assert self.context.productseries is not None, (
            "Entry is not attached to a ProductSeries.")

        template_count = self.context.productseries.potemplate_count
        if template_count == 0:
            return "no templates"
        else:
            link = "%s/+templates" % canonical_url(
                self.context.productseries, rootsite='translations')
            if template_count == 1:
                word = "template"
            else:
                word = "templates"
            return '<a href="%s">%d %s</a>' % (link, template_count, word)

    def _composeProductSeriesLink(self, productseries):
        """Produce HTML to link to `productseries`."""
        return '<a href="%s">%s</a>' % (
            canonical_url(productseries, rootsite='translations'),
            productseries.name)

    @property
    def product_translatable_series(self):
        """Summarize whether `Product` has translatable series.

        Use this only if the entry is attached to a `ProductSeries`.
        """
        assert self.context.productseries is not None, (
            "Entry is not attached to a ProductSeries.")

        product = self.context.productseries.product
        translatable_series = list(product.translatable_series)
        if len(translatable_series) == 0:
            return "Project has no translatable series."
        else:
            max_series_to_display = self.max_series_to_display
            links = [
                self._composeProductSeriesLink(series)
                for series in translatable_series[:max_series_to_display]]
            links_text = ', '.join(links)
            if len(translatable_series) > max_series_to_display:
                tail = ", ..."
            else:
                tail = "."
            return "Project has translatable series: " + links_text + tail

    @property
    def status_change_date(self):
        """Show date of last status change.

        Says nothing at all if the entry's status has not changed since
        upload.
        """
        change_date = self.context.date_status_changed
        if change_date == self.context.dateimported:
            return ""
        else:
            formatter = DateTimeFormatterAPI(change_date)
            return "Last changed %s." % formatter.displaydate()

    @property
    def next_url(self):
        """See `LaunchpadFormView`."""
        # The referer header we want is only available before the view's
        # form submits to itself. This field is a hidden input in the form.
        referrer = self.request.form.get('next_url')

        if (referrer is not None
            and referrer.startswith(self.request.getApplicationURL())):
            return referrer
        else:
            translationimportqueue_set = getUtility(ITranslationImportQueue)
            return canonical_url(translationimportqueue_set)

    def initialize(self):
        """Remove some fields based on the entry handled."""
        self.field_names = ['file_type', 'path', 'sourcepackagename',
                            'potemplate', 'potemplate_name',
                            'name', 'translation_domain', 'languagepack',
                            'language']

        if self.context.productseries is not None:
            # We are handling an entry for a productseries, this field is not
            # useful here.
            self.field_names.remove('sourcepackagename')

        if not self.context.is_targeted_to_ubuntu:
            # Only show languagepack for Ubuntu packages.
            self.field_names.remove('languagepack')

        # Execute default initialization.
        LaunchpadFormView.initialize(self)

# XXX: HenningEggers 2008-11-21 bug=300608: This code is too generic to be in
#      the view and should be factored out.
    def _checkProductOrPackage(self, obj):
        """Check if the given object is linked to the same productseries
        or sourcepackage as the context.

        :param obj: The object to check, must have productseries,
            distroseries and sourcepackagename attributes.
        :return: true if object and context match.
        """
        try:
            if self.context.productseries != None:
                return obj.productseries == self.context.productseries
            if self.context.distroseries != None:
                return (
                    obj.distroseries == self.context.distroseries and
                    obj.sourcepackagename == self.context.sourcepackagename)
        except AttributeError:
            pass  # return False
        return False

    def _getPOTemplateSubset(self, sourcepackagename):
        potemplate_set = getUtility(IPOTemplateSet)
        if self.context.productseries is None:
            if (sourcepackagename is not None and
                self.context.sourcepackagename is not None and
                sourcepackagename.id != self.context.sourcepackagename.id):
                # Got another sourcepackagename from the form, we will use it.
                potemplate_subset = potemplate_set.getSubset(
                    distroseries=self.context.distroseries,
                    sourcepackagename=sourcepackagename)
            else:
                potemplate_subset = potemplate_set.getSubset(
                    distroseries=self.context.distroseries,
                    sourcepackagename=self.context.sourcepackagename)
        else:
            potemplate_subset = potemplate_set.getSubset(
                productseries=self.context.productseries)
        return potemplate_subset

    def _findObjectionToFilePath(self, file_type, path):
        """Return textual objection, if any, to setting this file path."""
        importer = getUtility(ITranslationImporter)
        if file_type == TranslationFileType.POT:
            if not importer.isTemplateName(path):
                return "This filename is not appropriate for a template."
        else:
            if not importer.isTranslationName(path):
                return "This filename is not appropriate for a translation."

        if path == self.context.path:
            # No change, so no objections.
            return None

        # The Rosetta Expert decided to change the path of the file.
        # Before accepting such change, we should check first whether
        # there is already another entry with that path in the same
        # context (sourcepackagename/distroseries or productseries).
        # A duplicate name will confuse the auto-approval
        # process.
        if file_type == TranslationFileType.POT:
            potemplate_set = getUtility(IPOTemplateSet)
            existing_file = potemplate_set.getPOTemplateByPathAndOrigin(
                path, self.context.productseries, self.context.distroseries,
                self.context.sourcepackagename)
            already_exists = existing_file is not None
        else:
            pofile_set = getUtility(IPOFileSet)
            existing_files = pofile_set.getPOFilesByPathAndOrigin(
                path, self.context.productseries,
                self.context.distroseries,
                self.context.sourcepackagename)
            already_exists = not existing_files.is_empty()

        if already_exists:
            # We already have an IPOFile in this path, let's notify
            # the user about that so they choose another path.
            return "There is already a file in the given path."

        return None

    def _validatePath(self, file_type, path):
        """Should the entry's path be updated?"""
        if path is None or path.strip() == "":
            self.setFieldError('path', "The file name is missing.")
            return False

        objection = self._findObjectionToFilePath(file_type, path)
        if objection is None:
            return True
        else:
            self.setFieldError('path', objection)
            return False

    def _validatePOT(self, data):
        name = data.get('name')
        translation_domain = data.get('translation_domain')
        if name is None:
            self.setFieldError('name', 'Please specify a name for '
                               'the template.')
        elif not valid_name(name):
            self.setFieldError('name', 'Please specify a valid name for '
                               'the template. Names must be all lower '
                               'case and start with a letter or number.')
        if translation_domain is None:
            self.setFieldError('translation_domain', 'Please specify a '
                               'translation domain for the template.')

    def _validatePO(self, data):
        potemplate_name = data.get('potemplate_name')
        man_potemplate = None
        if potemplate_name == None:
            potemplate = data.get('potemplate')
            if not self._checkProductOrPackage(potemplate):
                self.setFieldError(
                    'potemplate', 'Please choose a template.')
        else:
            sourcepackagename = data.get('sourcepackagename')
            potemplate_subset = (
                self._getPOTemplateSubset(sourcepackagename))
            try:
                man_potemplate = potemplate_subset[potemplate_name]
            except NotFoundError:
                self.setFieldError('potemplate_name',
                    'Please enter a valid template name '
                    'or choose from the list above.')
        return man_potemplate

    def validate(self, data):
        """Extra validations for the given fields."""
        # Without a file type we cannot do anything
        file_type = data.get('file_type')
        if file_type not in (TranslationFileType.PO,
                             TranslationFileType.POT):
            self.setFieldError('file_type', 'Please specify the file type')
            return

        self.path_changed = self._validatePath(file_type, data.get('path'))

        self.man_potemplate = None
        if file_type == TranslationFileType.POT:
            self._validatePOT(data)
        if file_type == TranslationFileType.PO:
            self.man_potemplate = self._validatePO(data)

    def _changeActionPOT(self, data):
        """Process form for PO template files.

        PO template specific processing. Creates a new potemplate entry
        in the db if none exists with the given name. Updates the queue
        entry's path if it was changed.

        :param data: The form data.
        :returns: The potemplate instance."""
        path = data.get('path')
        name = data.get('name')
        sourcepackagename = data.get('sourcepackagename')
        translation_domain = data.get('translation_domain')
        languagepack = data.get('languagepack')

        if self.path_changed:
            self.context.path = path
        # We are importing an IPOTemplate file.

        # Create a new potemplate if this template name
        # does not yet appear in this subset.
        potemplate_subset = self._getPOTemplateSubset(sourcepackagename)
        try:
            potemplate = potemplate_subset[name]
        except NotFoundError:
            potemplate = potemplate_subset.new(
                name,
                translation_domain,
                self.context.path,
                self.context.importer)

        if (self.context.sourcepackagename is not None and
            potemplate.sourcepackagename is not None and
            self.context.sourcepackagename != potemplate.sourcepackagename):
            # We got the template from a different package than the one
            # selected by the user where the import should done, so we
            # note it here.
            potemplate.from_sourcepackagename = (
                self.context.sourcepackagename)

        if self.context.is_targeted_to_ubuntu:
            potemplate.languagepack = languagepack

        return potemplate

    def _changeActionPO(self, data):
        """Process form for PO data files.

        PO file specific processing. Creates a new pofile entry in the db
        if no matching one exists. Updates the queue entry's path if it was
        changed.

        :param data: The form data.
        :returns: The potemplate instance."""

        path = data.get('path')
        language = data.get('language')

        # Use manual potemplate, if given.
        # man_potemplate is set in validate().
        if self.man_potemplate != None:
            potemplate = self.man_potemplate
        else:
            potemplate = data.get('potemplate')

        pofile = potemplate.getPOFileByLang(language.code)
        if pofile is None:
            # We don't have such IPOFile, we need to create it.
            pofile = potemplate.newPOFile(
                language.code, self.context.importer)
        self.context.pofile = pofile
        if (self.context.sourcepackagename is not None and
            potemplate.sourcepackagename is not None and
            self.context.sourcepackagename.id !=
            pofile.potemplate.sourcepackagename.id):
            # We got the template from a different package than the one
            # selected by the user where the import should done, so we
            # note it here.
            pofile.from_sourcepackagename = self.context.sourcepackagename

        if self.path_changed:
            self.context.path = path
            # We got a path to store as the new one for the POFile.
            pofile.setPathIfUnique(path)
        elif self.context.by_maintainer:
            # This entry was uploaded by the maintainer, which means that the
            # path we got is exactly the right one. If it's different from
            # what pofile has, that would mean that either the entry changed
            # its path since previous upload or that we had to guess it
            # and now that we got the right path, we should fix it.
            pofile.setPathIfUnique(self.context.path)
        else:
            # Leave path unchanged.
            pass
        return potemplate

    @action("Approve")
    def change_action(self, action, data):
        """Process the form we got from the submission."""
        self._change_action(data)

    def _change_action(self, data):
        """Private function to be called by the doctest."""
        file_type = data.get('file_type')

        if file_type == TranslationFileType.PO:
            potemplate = self._changeActionPO(data)
        if file_type == TranslationFileType.POT:
            potemplate = self._changeActionPOT(data)

        # Store the associated IPOTemplate.
        self.context.potemplate = potemplate

        self.context.setStatus(RosettaImportStatus.APPROVED, self.user)
        self.context.date_status_changed = UTC_NOW

    @property
    def js_domain_mapping(self):
        """Return JS code mapping templates' names to translation domains."""
        target = self.import_target
        if target is None:
            contents = ""
        else:
            contents = ", \n".join([
                "'%s': '%s'" % (
                    escape_js_string(template.name),
                    escape_js_string(template.translation_domain))
                for template in target.getCurrentTranslationTemplates()])
        return "var template_domains = {%s};" % contents


class TranslationImportQueueNavigation(GetitemNavigation):
    usedfor = ITranslationImportQueue


class TranslationImportQueueView(HasTranslationImportsView):
    """The global Translation Import Queue."""

    label = "Translation import queue"

    def initialize(self):
        """Useful initialization for this view class."""
        super(TranslationImportQueueView, self).initialize()
        target_filter = self.widgets['filter_target']
        if target_filter.hasInput() and not target_filter.hasValidInput():
            raise UnexpectedFormData("Unknown target.")

    @property
    def entries(self):
        """Return the entries in the queue for this context."""
        target, file_extension, import_status = (
            self.getEntriesFilteringOptions())
        if file_extension is None:
            extensions = None
        else:
            extensions = [file_extension]

        return self.context.getAllEntries(
                target=target, import_status=import_status,
                file_extensions=extensions)

    def createFilterTargetField(self):
        """Create a field with a vocabulary to filter by target.

        :return: A form.Fields instance containing the target field.
        """
        return self.createFilterFieldHelper(
            name='filter_target',
            source=TranslationImportTargetVocabularyFactory(self),
            title='Choose which target to show')


class TranslationImportTargetVocabularyFactory:
    """Factory for a vocabulary containing a list of targets."""

    implements(IContextSourceBinder)

    def __init__(self, view):
        """Create a `TranslationImportTargetVocabularyFactory`.

        :param view: The view that called this factory.  We access its
            filter_status widget later to see which status it filters for.
        """
        self.view = view

    def __call__(self, context):
        import_queue = getUtility(ITranslationImportQueue)
        targets = import_queue.getRequestTargets()
        filtered_targets = set()

        # Read filter_status, in order to mark targets that have requests with
        # that status pending.  This works because we set up the filter_status
        # widget before the filter_target one, which uses this vocabulary
        # factory.
        status_widget = self.view.widgets['filter_status']
        if status_widget.hasInput():
            try:
                status_filter = status_widget.getInputValue()
            except ConversionError:
                raise UnexpectedFormData("Invalid status parameter.")
            if status_filter != 'all':
                try:
                    status = RosettaImportStatus.items[status_filter]
                    filtered_targets = set(
                        import_queue.getRequestTargets(status))
                except LookupError:
                    # Unknown status.  Ignore.
                    pass

        terms = [SimpleTerm('all', 'all', 'All targets')]

        for item in SpecialTranslationImportTargetFilter.items:
            term_name = '[%s]' % item.name
            terms.append(SimpleTerm(term_name, term_name, item.title))

        for target in targets:
            if IDistroSeries.providedBy(target):
                # Distroseries are not pillar names, we need to note
                # distribution.name/distroseries.name
                term_name = '%s/%s' % (target.distribution.name, target.name)
            else:
                term_name = target.name

            displayname = target.displayname
            if target in filtered_targets:
                displayname += '*'

            terms.append(SimpleTerm(term_name, term_name, displayname))
        return SimpleVocabulary(terms)