Modulok fordítása

Ez a rész bemutatja, hogyan lehet fordítási képességeket biztosítani a moduljához.

Megjegyzés

Ha szeretne hozzájárulni az Odoo fordításához, kérjük, tekintse meg az Odoo Wiki oldalt.

Fordítható kifejezés exportálása

Számos kifejezés a moduljaiban implicit módon fordítható. Ennek eredményeként, még ha nem is végzett konkrét munkát a fordítás érdekében, exportálhatja a modulja fordítható kifejezéseit, és találhat tartalmat, amivel dolgozhat.

A fordítások exportálása az adminisztrációs felületen keresztül történik, a háttérfelületre való bejelentkezéssel és a Beállítások ‣ Fordítások ‣ Import / Export ‣ Fordítások exportálása megnyitásával.

• hagyja az alapértelmezett nyelvet (új nyelv/üres sablon)

• válassza ki a PO File formátumot

• válassza ki a modulját

• kattintson a Export gombra és töltse le a fájlt

Ez egy yourmodule.pot nevű fájlt ad, amelyet át kell helyezni a yourmodule/i18n/ könyvtárba. A fájl egy PO sablon, amely egyszerűen felsorolja a fordítható szövegeket, és amelyből tényleges fordítások (PO fájlok) hozhatók létre. PO fájlok létrehozhatók msginit használatával, egy dedikált fordító eszközzel, mint például a POEdit, vagy egyszerűen a sablon új fájlba másolásával, amelynek neve language.po. A fordítási fájlokat a yourmodule/i18n/ könyvtárba kell helyezni, a yourmodule.pot mellé, és az Odoo automatikusan betölti őket, amikor a megfelelő nyelv telepítve van (Beállítások ‣ Fordítások ‣ Nyelvek)

Megjegyzés

a fordítások minden betöltött nyelvhez szintén telepítve vagy frissítve vannak, amikor egy modult telepítenek vagy frissítenek

Implicit exportok

Odoo automatically exports translatable strings from „data”-type content:

• nem-QWeb nézetekben minden szövegcsomópont exportálva van, valamint a string, help, sum, confirm és placeholder attribútumok tartalma

• QWeb templates (both server-side and client-side), all text nodes are exported except inside t-translation="off" blocks, the content of the title, alt, label and placeholder attributes are also exported

• a Field esetében, hacsak a modelljük nincs _translate = False-ként megjelölve:

  • a string és help attribútumaik exportálva vannak

  • ha a selection jelen van és lista (vagy tuple), akkor exportálódik

  • ha a translate attribútumuk True értékre van állítva, akkor az összes meglévő értékük (minden rekord esetében) exportálódik

• a _constraints és _sql_constraints súgó/hibaüzenetei exportálódnak

Explicit exportok

When it comes to more „imperative” situations in Python code or Javascript code, Odoo cannot automatically export translatable terms so they must be marked explicitly for export. This is done by wrapping a literal string in a function call.

In Python, the wrapping function is odoo.api.Environment._() and odoo.tools.translate._():

title = self.env._("Bank Accounts")

# old API for backward-compatibility
from odoo.tools import _
title = _("Bank Accounts")

JavaScriptben a csomagoló függvény általában odoo.web._t():

title = _t("Bank Accounts");

Figyelem

Csak a literál sztringek jelölhetők exportálásra, kifejezések vagy változók nem. Azokban az esetekben, amikor sztringek formázásra kerülnek, ez azt jelenti, hogy a formátum sztringet kell jelölni, nem a formázott sztringet

The lazy version of _ and _t is the odoo.tools.translate.LazyTranslate factory in python and odoo.web._lt() in javascript. The translation lookup is executed only at rendering and can be used to declare translatable properties in class methods of global variables.

from odoo.tools import LazyTranslate
_lt = LazyTranslate(__name__)
LAZY_TEXT = _lt("some text")

Megjegyzés

Egy modul fordításai alapértelmezés szerint nem érhetők el a front end számára, így JavaScriptből sem elérhetők. Ennek eléréséhez a modul nevét vagy website előtaggal kell ellátni (mint például website_sale, website_event stb.), vagy explicit módon regisztrálni kell az _get_translation_frontend_modules_name() implementálásával az ir.http modellhez.

Ez a következőképpen nézhet ki:

from odoo import models

class IrHttp(models.AbstractModel):
    _inherit = 'ir.http'

    @classmethod
    def _get_translation_frontend_modules_name(cls):
        modules = super()._get_translation_frontend_modules_name()
        return modules + ['your_module']

Környezet

To translate, the translation function needs to know the language and the module name. When using Environment._ the language is known and you may pass the module name as a parameter, otherwise it’s extracted from the caller.

In case of odoo.tools.translate._, the language and the module are extracted from the context. For this, we inspect the caller’s local variables. The drawback of this method is that it is error-prone: we try to find the context variable or self.env, however these may not exist if you use translations outside of model methods; i.e. it does not work inside regular functions or python comprehensions.

Lazy translations are bound to the module during their creation and the language is resolved when evaluating using str(). Note that you can also pass a lazy translation to Environment._ to translate it without any magic language resolution.

Változók

Ne az extract működhet, de nem fogja helyesen fordítani a szöveget:

_("Scheduled meeting with %s" % invitee.name)

Tegye a dinamikus változókat a fordítási keresés paraméterévé (ez az eredetire esik vissza, ha a fordításban hiányzik a helykitöltő):

_("Scheduled meeting with %s", invitee.name)

Blokkok

Ne ossza fel a fordítást több blokkra vagy sorra:

# bad, trailing spaces, blocks out of context
_("You have ") + len(invoices) + _(" invoices waiting")
_t("You have ") + invoices.length + _t(" invoices waiting");

# bad, multiple small translations
_("Reference of the document that generated ") + \
_("this sales order request.")

Tegye egy blokkban tartsa, teljes kontextust adva a fordítóknak:

# good, allow to change position of the number in the translation
_("You have %s invoices waiting") % len(invoices)
_.str.sprintf(_t("You have %s invoices waiting"), invoices.length);

# good, full sentence is understandable
_("Reference of the document that generated " + \
  "this sales order request.")

Többes szám

Ne többesítse a kifejezéseket angol módon:

msg = _("You have %(count)s invoice", count=invoice_count)
if invoice_count > 1:
  msg += _("s")

Tegye tartsa szem előtt, hogy minden nyelvnek más többes számú formái vannak:

if invoice_count > 1:
  msg = _("You have %(count)s invoices", count=invoice_count)
else:
  msg = _("You have one invoice")

Olvasási vs Futási idő

Ne hívja meg a fordítási keresést a szerver indításakor:

ERROR_MESSAGE = {
  # bad, evaluated at server launch with no user language
  'access_error': _('Access Error'),
  'missing_error': _('Missing Record'),
}

class Record(models.Model):

  def _raise_error(self, code):
    raise UserError(ERROR_MESSAGE[code])

Ne hívja meg a fordítási keresést, amikor a javascript fájl beolvasásra kerül:

# bad, js _t is evaluated too early
var core = require('web.core');
var _t = core._t;
var map_title = {
    access_error: _t('Access Error'),
    missing_error: _t('Missing Record'),
};

Használja a késleltetett fordítási keresési módszert:

ERROR_MESSAGE = {
  'access_error': _lt('Access Error'),
  'missing_error': _lt('Missing Record'),
}

class Record(models.Model):

  def _raise_error(self, code):
    # translation lookup executed at error rendering
    raise UserError(ERROR_MESSAGE[code])

vagy értékelje dinamikusan a fordítható tartalmat:

# good, evaluated at run time
def _get_error_message(self):
  return {
    access_error: _('Access Error'),
    missing_error: _('Missing Record'),
  }

Használja abban az esetben, amikor a fordítási keresés akkor történik, amikor a JS fájl beolvasásra kerül, az _lt-t _t helyett, hogy a kifejezést akkor fordítsa le, amikor az használva van:

# good, js _lt is evaluated lazily
var core = require('web.core');
var _lt = core._lt;
var map_title = {
    access_error: _lt('Access Error'),
    missing_error: _lt('Missing Record'),
};