~launchpad-pqm/launchpad/devel

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

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

"""Translations vocabularies."""

__metaclass__ = type

__all__ = [

    'FilteredDeltaLanguagePackVocabulary',

    'FilteredFullLanguagePackVocabulary',

    'FilteredLanguagePackVocabulary',

    'TranslatableLanguageVocabulary',

    'TranslationGroupVocabulary',

    'TranslationMessageVocabulary',

    'TranslationTemplateVocabulary',

    ]

from sqlobject import AND

from zope.schema.vocabulary import SimpleTerm

from lp.registry.interfaces.distroseries import IDistroSeries

from lp.services.database.sqlbase import sqlvalues

from lp.services.webapp.vocabulary import (

    NamedSQLObjectVocabulary,

    SQLObjectVocabularyBase,

    )

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

from lp.services.worlddata.vocabularies import LanguageVocabulary

from lp.translations.enums import LanguagePackType

from lp.translations.model.languagepack import LanguagePack

from lp.translations.model.potemplate import POTemplate

from lp.translations.model.translationgroup import TranslationGroup

from lp.translations.model.translationmessage import TranslationMessage

class TranslatableLanguageVocabulary(LanguageVocabulary):

    """All the translatable languages known by Launchpad.

    Messages cannot be translated into English or a non-visible language.

    This vocabulary contains all the languages known to Launchpad,

    excluding English and non-visible languages.

    """

    def __contains__(self, language):

        """See `IVocabulary`.

        This vocabulary excludes English and languages that are not visible.

        """

        assert ILanguage.providedBy(language), (

            "'in TranslatableLanguageVocabulary' requires ILanguage as "

            "left operand, got %s instead." % type(language))

        if language.code == 'en':

            return False

        return language.visible == True and super(

            TranslatableLanguageVocabulary, self).__contains__(language)

    def __iter__(self):

        """See `IVocabulary`.

        Iterate languages that are visible and not English.

        """

        languages = self._table.select(

            "Language.code != 'en' AND Language.visible = True",

            orderBy=self._orderBy)

        for language in languages:

            yield self.toTerm(language)

    def getTermByToken(self, token):

        """See `IVocabulary`."""

        if token == 'en':

            raise LookupError(token)

        term = super(TranslatableLanguageVocabulary, self).getTermByToken(

            token)

        if not term.value.visible:

            raise LookupError(token)

        return term

class TranslationGroupVocabulary(NamedSQLObjectVocabulary):

    _table = TranslationGroup

class TranslationMessageVocabulary(SQLObjectVocabularyBase):

    _table = TranslationMessage

    _orderBy = 'date_created'

    def toTerm(self, obj):

        translation = ''

        if obj.msgstr0 is not None:

            translation = obj.msgstr0.translation

        return SimpleTerm(obj, obj.id, translation)

    def __iter__(self):

        for message in self.context.messages:

            yield self.toTerm(message)

class TranslationTemplateVocabulary(SQLObjectVocabularyBase):

    """The set of all POTemplates for a given product or package."""

    _table = POTemplate

    _orderBy = 'name'

    def __init__(self, context):

        if context.productseries != None:

            self._filter = AND(

                POTemplate.iscurrent == True,

                POTemplate.productseries == context.productseries)

        else:

            self._filter = AND(

                POTemplate.iscurrent == True,

                POTemplate.distroseries == context.distroseries,

                POTemplate.sourcepackagename == context.sourcepackagename)

        super(TranslationTemplateVocabulary, self).__init__(context)

    def toTerm(self, obj):

        return SimpleTerm(obj, obj.id, obj.name)

class FilteredLanguagePackVocabularyBase(SQLObjectVocabularyBase):

    """Base vocabulary class to retrieve language packs for a distroseries."""

    _table = LanguagePack

    _orderBy = '-date_exported'

    def toTerm(self, obj):

        return SimpleTerm(

            obj, obj.id, '%s' % obj.date_exported.strftime('%F %T %Z'))

    def _baseQueryList(self):

        """Return a list of sentences that defines the specific filtering.

        That list will be linked with an ' AND '.

        """

        raise NotImplementedError

    def __iter__(self):

        if not IDistroSeries.providedBy(self.context):

            # This vocabulary is only useful from a DistroSeries context.

            return

        query = self._baseQueryList()

        query.append('distroseries = %s' % sqlvalues(self.context))

        language_packs = self._table.select(

            ' AND '.join(query), orderBy=self._orderBy)

        for language_pack in language_packs:

            yield self.toTerm(language_pack)

class FilteredFullLanguagePackVocabulary(FilteredLanguagePackVocabularyBase):

    """Full export Language Pack for a distribution series."""

    displayname = 'Select a full export language pack'

    def _baseQueryList(self):

        """See `FilteredLanguagePackVocabularyBase`."""

        return ['type = %s' % sqlvalues(LanguagePackType.FULL)]

class FilteredDeltaLanguagePackVocabulary(FilteredLanguagePackVocabularyBase):

    """Delta export Language Pack for a distribution series."""

    displayname = 'Select a delta export language pack'

    def _baseQueryList(self):

        """See `FilteredLanguagePackVocabularyBase`."""

        return ['(type = %s AND updates = %s)' % sqlvalues(

            LanguagePackType.DELTA, self.context.language_pack_base)]

class FilteredLanguagePackVocabulary(FilteredLanguagePackVocabularyBase):

    displayname = 'Select a language pack'

    def toTerm(self, obj):

        return SimpleTerm(

            obj, obj.id, '%s (%s)' % (

                obj.date_exported.strftime('%F %T %Z'), obj.type.title))

    def _baseQueryList(self):

        """See `FilteredLanguagePackVocabularyBase`."""

        # We are interested on any full language pack or language pack

        # that is a delta of the current base lanuage pack type,

        # except the ones already used.

        used_lang_packs = []

        if self.context.language_pack_base is not None:

            used_lang_packs.append(self.context.language_pack_base.id)

        if self.context.language_pack_delta is not None:

            used_lang_packs.append(self.context.language_pack_delta.id)

        query = []

        if used_lang_packs:

            query.append('id NOT IN %s' % sqlvalues(used_lang_packs))

        query.append('(updates is NULL OR updates = %s)' % sqlvalues(

            self.context.language_pack_base))

        return query