QWeb sablonok

A QWeb az Odoo által használt elsődleges sablonmotor2. Ez egy XML sablonmotor1, és főként HTML töredékek és oldalak generálására használják.

A sablon direktívák XML attribútumokként vannak megadva, amelyek t- előtaggal rendelkeznek, például t-if a Feltételes utasítások esetében, az elemek és más attribútumok pedig közvetlenül kerülnek megjelenítésre.

Az elem megjelenítésének elkerülése érdekében egy <t> helyőrző elem is elérhető, amely végrehajtja az utasítását, de önmagában nem generál semmilyen kimenetet:

<t t-if="condition">
    <p>Test</p>
</t>

az eredmény:

<p>Test</p>

ha a feltétel igaz, de:

<div t-if="condition">
    <p>Test</p>
</div>

az eredmény:

<div>
    <p>Test</p>
</div>

Adatkimenet

A QWeb kimeneti utasítása, az out, automatikusan HTML-eszképeli a bemenetét, csökkentve az XSS kockázatokat, amikor felhasználó által megadott tartalmat jelenít meg.

Az out egy kifejezést vesz, kiértékeli azt, és a dokumentumba injektálja az eredményt:

<p><t t-out="value"/></p>

a value érték 42-re állítva így jelenik meg:

<p>42</p>

További fejlett témákért (pl. nyers HTML injektálása stb.) lásd Haladó kimenet.

Feltételes utasítások

A QWeb rendelkezik egy feltételes utasítással, az if-fel, amely egy kifejezést értékel ki, amelyet attribútumértékként adnak meg:

<div>
    <t t-if="condition">
        <p>ok</p>
    </t>
</div>

Az elem megjelenik, ha a feltétel igaz:

<div>
    <p>ok</p>
</div>

de ha a feltétel hamis, akkor eltávolításra kerül az eredményből:

<div>
</div>

A feltételes megjelenítés az irányelv hordozójára vonatkozik, amely nem feltétlenül <t>:

<div>
    <p t-if="condition">ok</p>
</div>

ugyanazt az eredményt adja, mint az előző példa.

További feltételes elágazási irányelvek, mint a t-elif és t-else is elérhetők:

<div>
    <p t-if="user.birthday == today()">Happy birthday!</p>
    <p t-elif="user.login == 'root'">Welcome master!</p>
    <p t-else="">Welcome!</p>
</div>

Ciklusok

QWeb has an iteration directive foreach which take an expression returning the collection to iterate on, and a second parameter t-as providing the name to use for the „current item” of the iteration:

<t t-foreach="[1, 2, 3]" t-as="i">
    <p><t t-out="i"/></p>
</t>

úgy lesz megjelenítve, mint:

<p>1</p>
<p>2</p>
<p>3</p>

A feltételekhez hasonlóan a foreach az elemre vonatkozik, amely az irányelv attribútumát hordozza, és

<p t-foreach="[1, 2, 3]" t-as="i">
    <t t-out="i"/>
</p>

egyenértékű az előző példával.

A foreach iterálhat egy tömbön (az aktuális elem az aktuális érték lesz) vagy egy leképezésen (az aktuális elem az aktuális kulcs lesz). Egy egész szám feletti iterálás (ami egyenértékű egy 0-tól kezdődő és a megadott egész számig tartó tömbön való iterálással) továbbra is támogatott, de elavult.

A t-as által átadott név mellett a foreach néhány más változót is biztosít különböző adatpontokhoz:

Figyelem

$as helyére a t-as-nek átadott név kerül

$as_all (elavult)

az objektum, amelyen iterálunk

Megjegyzés

Ez a változó csak JavaScript QWeb-ben érhető el, Python-ban nem.

$as_érték

az aktuális iterációs érték, amely listák és egész számok esetén azonos $as-sel, de leképezéseknél az értéket adja meg (ahol $as a kulcsot adja meg)

$as_index

az aktuális iterációs index (az iteráció első elemének indexe 0)

$as_méret

a gyűjtemény mérete, ha elérhető

$as_első

hogy az aktuális elem az iteráció első eleme-e (egyenértékű a következővel: $as_index == 0)

$as_utolsó

hogy az aktuális elem az iteráció utolsó eleme-e (egyenértékű a következővel: $as_index + 1 == $as_size), megköveteli az iterált elem méretének elérhetőségét

$as_parity (elavult)

either "even" or "odd", the parity of the current iteration round

$as_even (elavult)

egy logikai jelző, amely jelzi, hogy az aktuális iterációs kör páros indexen van

$as_odd (elavult)

egy logikai jelző, amely jelzi, hogy az aktuális iterációs kör páratlan indexen van

Ezek a kiegészítő változók és minden új változó, amely a foreach-ben jön létre, csak a foreach hatókörében érhetők el. Ha a változó létezik a foreach kontextusán kívül, az értéket a foreach végén átmásolják a globális kontextusba.

<t t-set="existing_variable" t-value="False"/>
<!-- existing_variable now False -->

<p t-foreach="[1, 2, 3]" t-as="i">
    <t t-set="existing_variable" t-value="True"/>
    <t t-set="new_variable" t-value="True"/>
    <!-- existing_variable and new_variable now True -->
</p>

<!-- existing_variable always True -->
<!-- new_variable undefined -->

attribútumok

A QWeb képes a tulajdonságokat menet közben kiszámítani, és a számítás eredményét az output csomóponton beállítani. Ezt a t-att (tulajdonság) direktíva segítségével lehet megtenni, amely 3 különböző formában létezik:

t-att-$name

egy $name nevű tulajdonság jön létre, a tulajdonság értéke kiértékelésre kerül, és az eredmény a tulajdonság értékeként kerül beállításra:

<div t-att-a="42"/>

úgy lesz megjelenítve, mint:

<div a="42"></div>

t-attf-$name

ugyanaz, mint az előző, de a paraméter egy formátum string, nem csak egy kifejezés, gyakran hasznos a literál és nem literál stringek keverésére (pl. osztályok):

<t t-foreach="[1, 2, 3]" t-as="item">
    <li t-attf-class="row {{ (item_index % 2 === 0) ? 'even' : 'odd' }}">
        <t t-out="item"/>
    </li>
</t>

úgy lesz megjelenítve, mint:

<li class="row even">1</li>
<li class="row odd">2</li>
<li class="row even">3</li>

Javaslat

There are two equivalent syntaxes for format strings: "plain_text {{code}}" (aka jinja-style) and "plain_text #{code}" (aka ruby-style).

t-att=leképezés

ha a paraméter egy mapping, minden (kulcs, érték) pár új tulajdonságot és annak értékét generálja:

<div t-att="{'a': 1, 'b': 2}"/>

úgy lesz megjelenítve, mint:

<div a="1" b="2"></div>

t-att=pár

ha a paraméter egy pár (tuple vagy 2 elemű tömb), a pár első eleme a tulajdonság neve, a második eleme pedig az érték:

<div t-att="['a', 'b']"/>

úgy lesz megjelenítve, mint:

<div a="b"></div>

változók beállítása

A QWeb lehetővé teszi változók létrehozását a sablonon belül, hogy egy számítást memorizáljunk (többször is felhasználhassuk), egy adatdarabnak világosabb nevet adjunk, …

Ezt a set direktíva segítségével lehet megtenni, amely megadja a létrehozandó változó nevét. Az érték beállítása két módon történhet:

• egy t-value attribútum, amely egy kifejezést tartalmaz, és az értékelésének eredménye lesz beállítva:

  <t t-set="foo" t-value="2 + 1"/>
  <t t-out="foo"/>
  

  ki fogja nyomtatni a 3-at

• ha nincs t-value attribútum, a csomópont törzse kerül renderelésre és beállításra a változó értékeként:

  <t t-set="foo">
      <li>ok</li>
  </t>
  <t t-out="foo"/>
  

al-sablonok hívása

A QWeb sablonok használhatók felső szintű renderelésre, de használhatók egy másik sablonon belül is (az ismétlés elkerülése vagy a sablonok részeinek elnevezése érdekében) a t-call direktíva segítségével:

<t t-call="other-template"/>

Ez meghívja a megnevezett sablont a szülő végrehajtási kontextusával, ha az other_template így van definiálva:

<p><t t-value="var"/></p>

a fenti hívás <p/>-ként lesz renderelve (nincs tartalom), de:

<t t-set="var" t-value="1"/>
<t t-call="other-template"/>

<p>1</p>-ként lesz renderelve.

Ez azonban azzal a problémával jár, hogy kívülről is látható a t-call. Alternatív megoldásként a call direktíva törzsében beállított tartalom mielőtt a szub-sablon meghívásra kerülne, kiértékelésre kerül, és módosíthatja a helyi kontextust:

<t t-call="other-template">
    <t t-set="var" t-value="1"/>
</t>
<!-- "var" does not exist here -->

A call direktíva törzse tetszőlegesen összetett lehet (nem csak set direktívák), és annak renderelt formája elérhető lesz a meghívott sablonon belül egy mágikus 0 változóként:

<div>
    This template was called with content:
    <t t-out="0"/>
</div>

így hívva:

<t t-call="other-template">
    <em>content</em>
</t>

az eredmény:

<div>
    This template was called with content:
    <em>content</em>
</div>

Haladó kimenet

Alapértelmezés szerint az out HTML-eszképeli a tartalmat, amelyet eszképelni kell, védve a rendszert az XSS ellen

A tartalom, amelyet nem kell eszképelni, változatlanul kerül beillesztésre a dokumentumba, és a dokumentum tényleges jelölésének részévé válhat.

The only cross-platform „safe” content is the output of t-call or a t-set used with a „body” (as opposed to t-value or t-valuef).

Python

Usually you should not have to care too much: APIs for which it makes sense should generate „safe” content automatically, and things should work transparently.

Azokban az esetekben, amikor a dolgoknak világosabbnak kell lenniük, a következő API-k biztonságos tartalmat adnak ki, amely alapértelmezés szerint nem lesz (újra) eszképelve, amikor sablonokba kerül beillesztésre:

• HTML mezők.

• html_escape() és markupsafe.escape() (ezek aliasok, és nincs kockázata a dupla eszképelésnek).

• html_sanitize().

• markupsafe.Markup.

  Figyelem

  markupsafe.Markup egy nem biztonságos API, ez egy állítás, hogy a tartalom markup-biztonságos, de szükségszerűen nem ellenőrizhető, ezért óvatosan kell használni.

• to_text() nem jelöli a tartalmat biztonságosnak, de nem is távolítja el ezt az információt a biztonságos tartalomból.

kettős escape kényszerítése

If content is marked as safe but for some reason needs to be escaped anyway (e.g. printing the markup of an HTML fields), it can just be converted back to a normal string to „strip” the safety flag e.g. str(content) in Python and String(content) in Javascript.

Megjegyzés

Mivel a Markup sokkal gazdagabb típus, mint a Markup(), néhány művelet eltávolítja a biztonsági információt a Markup()-ból, de nem a Markup-ból, például a karakterlánc összefűzése ('' + content) Pythonban egy Markup-ot eredményez, ahol a másik operandus megfelelően escape-elve lett, míg Javascriptben egy String()-et ad, ahol a másik operandus nem lett escape-elve az összefűzés előtt.

Elavult kimeneti direktívák

esc

Egy alias az out-hoz, eredetileg HTML-escape-elte a bemenetét. Még nem hivatalosan elavult, mivel az egyetlen különbség az out és az esc között az, hogy az utóbbi kissé homályos / helytelen.

raw

Az out egy olyan változata, amely soha nem escape-eli a tartalmát. A tartalom változatlanul kerül kibocsátásra, függetlenül attól, hogy biztonságos-e vagy sem.

Elavult a(z) 15.0 verzió óta: Használja az out-ot egy markupsafe.Markup értékkel helyette.

A t-raw elavulttá vált, mert ahogy a tartalmat előállító kód fejlődik, nehéz lehet nyomon követni, hogy azt jelöléshez fogják használni, ami bonyolultabb felülvizsgálatokhoz és veszélyesebb mulasztásokhoz vezethet.

Python

Exkluzív direktívák

Eszközkötegek

„smart records” fields formatting

The t-field directive can only be used when performing field access (a.b) on a „smart” record (result of the browse method). It is able to automatically format based on field type, and is integrated in the website’s rich text editing.

A t-options használható a mezők testreszabására, a leggyakoribb opció a widget, más opciók mező- vagy widget-függőek.

Hibakeresés

t-debug

üres értékkel meghívja a breakpoint() beépített függvényt, amely általában egy hibakeresőt hív meg (pdb alapértelmezés szerint).

A viselkedés konfigurálható a PYTHONBREAKPOINT vagy a sys.breakpointhook() segítségével.

Renderelési gyorsítótár:

t-cache="key_cache" tags part of template to be cached at rendering time. Every sub-directives will be call only during the first rendering. It means that the sql queries excecuted during the rendering of those sub-directives are also done only once.

t-nocache="documentation" tags part of template to be render every time. The content can only use the root values.

Miért és mikor használjuk a t-cache-t?

Ez az utasítás a renderelés felgyorsítására szolgál, azáltal, hogy a végső dokumentum részeit gyorsítótárazza, ami adatbázis-lekérdezéseket takaríthat meg. Azonban takarékosan kell használni, mivel a t-cache elkerülhetetlenül bonyolítja a sablonokat (és például a t-set megértését).

Azonban ahhoz, hogy valóban megtakarítsuk az adatbázis-lekérdezéseket, szükséges lehet a sablont olyan értékekkel renderelni, amelyek késleltetve kerülnek kiértékelésre. Ha ezek a késleltetett értékek egy gyorsítótárazott részben vannak, akkor nem kerülnek kiértékelésre, ha a rész elérhető a gyorsítótárban.

The t-cache directive is useful for template parts using values that depend on a limited amount of data. We recommend to analyze the rendering of the template with the profiler (by activating the „Add qweb directive context” option). Passing lazy values to the rendering in controllers allow you to display the directives using these values and triggering the queries.

Az ilyen gyorsítótár használatának egyik aggálya, hogy elérhetővé tegyük különböző felhasználók számára (különböző felhasználóknak ugyanúgy kell renderelniük a gyorsítótárazott részeket). Egy másik potenciális probléma a bejegyzések érvénytelenítése szükség esetén. Az utóbbi esetben a kulcs kifejezést bölcsen kell megválasztani. Például egy rekordkészlet write_date-jének használata elavulttá teheti a gyorsítótár kulcsát anélkül, hogy kifejezetten ki kellene dobni a gyorsítótárból.

Figyelmet kell fordítani arra is, hogy a t-cache részekben lévő értékek hatókörrel rendelkeznek. Ez azt jelenti, hogy ha ebben a sablonrészben vannak t-set utasítások, akkor az utána következő rész renderelése eltérő lehet, mintha nem lenne t-cache utasítás.

Mi van, ha van egy t-cache egy másik t-cache-ben?

A részek gyorsítótárazva vannak. Mindegyik csak a renderelésének megfelelő karakterláncot tartalmazza. Így a belső t-cache valószínűleg ritkábban lesz olvasva, a gyorsítótár kulcsa nem feltétlenül lesz használva. Ha ennek így kell lennie, akkor szükség lehet egy t-nocache hozzáadására (ugyanarra a csomópontra vagy egy szülőre).

Mire használják a t-nocache-t?

Ha egy sablon részét szeretné gyorsítótárazni t-cache-sel, de egy kis résznek dinamikusnak kell maradnia és a gyorsítótárazás idején kiértékelésre kell kerülnie. Azonban a t-nocache rész nem fér hozzá a sablon t-set értékéhez. Csak a vezérlő által biztosított értékek érhetők el ott. Például a menü gyorsítótárazva van, mert mindig ugyanaz és időbe telik a renderelése (a teljesítmény fejlesztői eszközök használatával a qweb kontextusban lehet vizsgálódni). Azonban a menüben azt szeretnénk, hogy az e-kereskedelmi kosár mindig naprakész legyen. Ezért van egy t-nocache, hogy ezt a részt dinamikusan tartsuk.

A t-cache alapja

The t-cache directive allows you to store the rendered result of a template. The key expression (eg 42: t-cache="42") will be evaluated as a python expression. This will be used to generate the cache key. So there can be different cache values (cached render part) for the same template part. If the key expression is a tuple or a list, it will be searched when generating the cache key. If one or more recordsets are returned by the key expression, then the model, ids and their corresponding write_date will be used to generate the cache key. Special case: If the key expression returns a Falsy value, then the content will not be cached.

Példa:

<div t-cache="record,bool(condition)">
    <span t-if="condition" t-field="record.partner_id.name">
    <span t-else="" t-field="record.partner_id" t-options-widget="contact">
</div>

Ebben az esetben a gyorsítótárban lehetnek értékek (karakterlánc) minden olyan rekordhoz, amely már vissza lett adva igaz feltétellel, valamint a hamis feltétellel is. És ha egy modul módosítja a rekordot, a write_date módosul, a gyorsítótárazott érték elvetésre kerül.

t-cache és hatókörrel rendelkező értékek (t-set, t-foreach…)

A t-cache-ben lévő értékek hatókörrel rendelkeznek, ami viselkedésbeli változást jelent, attól függően, hogy van-e vagy nincs t-cache az egyik szülő csomóponton. Ne feledje, hogy az Odoo sok sablont, t-call-t és nézetöröklést használ. Egy t-cache hozzáadása ezért módosíthatja egy olyan sablon megjelenítését, amelyet nem lát szerkesztéskor. (A t-foreach olyan, mint egy t-set minden iterációhoz)

Példa:

<div>
    <t t-set="a" t-value="1"/>
    <inside>
        <t t-set="a" t-value="2"/>
        <t t-out="a"/>
    </inside>
    <outside t-out="a"/>

    <t t-set="b" t-value="1"/>
    <inside t-cache="True">
        <t t-set="b" t-value="2"/>
        <t t-out="b"/>
    </inside>
    <outside t-out="b"/>
</div>

Megjelenik:

<div>
    <inside>2</inside>
    <outside>2</inside>

    <inside>2</inside>
    <outside>1</inside>
</div>

A t-nocache alapja

A t-nocache attribútummal rendelkező csomópontban található sablonrész nem kerül gyorsítótárazásra. Ez a tartalom tehát dinamikus, és rendszeresen megjelenik. Az elérhető értékek azonban azok, amelyeket a vezérlő biztosít (amikor a _render metódust hívják).

Példa:

<section>
    <article t-cache="record">
        <title><t t-out="record.name"/> <i t-nocache="">(views: <t t-out="counter"/>)</i></titlle>
        <content t-out="record.description"/>
    </article>
</section>

Megjelenik (számláló = 1):

<section>
    <article>
        <title>The record name <i>(views: 1)</i></titlle>
        <content>Record description</content>
    </article>
</section>

Itt a <i> tag, amely a tárolót tartalmazza, mindig megjelenik. Míg a többi egyetlen karakterláncként van a gyorsítótárban.

t-nocache és hatókörrel rendelkező gyökérértékek (t-set, t-foreach…)

A t-nocache címke tartalma használható dokumentáció céljára és annak magyarázatára, hogy miért került hozzáadásra az utasítás. Az értékek a t-nocache hatókörébe tartoznak, ezek az értékek csak gyökérértékek (az irányító által biztosított értékek és/vagy amikor az ir.qweb _render metódusát hívják). A t-set elvégezhető a sablon részében, de máshol nem lesz elérhető.

Példa:

<section>
    <t t-set="counter" t-value="counter * 10"/>
    <header t-nocache="">
        <t t-set="counter" t-value="counter + 5"/>
        (views: <t t-out="counter"/>)
    </header>
    <article t-cache="record">
        <title><t t-out="record.name"/> <i t-nocache="">(views: <t t-out="counter"/>)</i></titlle>
        <content t-out="record.description"/>
    </article>
    <footer>(views: <t t-out="counter"/>)</footer>
</section>

Megjelenik (számláló = 1):

<section>
    <header>
        (views: 6)
    </header>
    <article>
        <title>The record name <i>(views: 1)</i></titlle>
        <content>Record description</content>
    </article>
    <footer>(views: 10)</footer>
</section>

Itt a tartalmazó <i> címke mindig megjelenítésre kerül. Míg a többi egyetlen karakterláncként van a gyorsítótárban. A számláló nem frissül a t-set által a t-nocache-en kívül.

A t-nocache-* néhány primitív értéket ad hozzá a gyorsítótárhoz.

In order to be able to use values generated in the template, it is possible to cache them. The directive is used as t-nocache-*="expr" where * is the name of the chosen value and expr the python expression so the result will be cached. The cached value must be primitive type.

Példa:

<section t-cache="records">
    <article t-foreach="records" t-as="record">
        <header>
            <title t-field="record.get_method_title()"/>
        </header>
        <footer t-nocache="This part has a dynamic counter and must be rendered all the time."
                t-nocache-cached_value="record.get_base_counter()">
            <span t-out="counter + cached_value"/>
        </footer>
    </article>
</section>

The value cached_value is cached with the cached template part of t-cache="records" and add to the scoped root values each time.

Segédeszközök

Kérés alapú

A QWeb Python-oldali használata leginkább az irányítókban (és HTTP kérések során) történik, ebben az esetben az adatbázisban tárolt sablonok (views) egyszerűen megjeleníthetők az odoo.http.HttpRequest.render() hívásával:

response = http.request.render('my-template', {
    'context_value': 42
})

Ez automatikusan létrehoz egy Response objektumot, amely visszaadható az irányítóból (vagy tovább testreszabható az igényeknek megfelelően).

Nézet alapú

A korábbi segédeszköznél mélyebb szinten található az ir.qweb _render metódusa (használja az adatbázist) és a nyilvános modul metódus render (ne használja az adatbázist):

_render(id[, values])

Egy QWeb nézet/sablon megjelenítése adatbázis azonosító vagy külső azonosító alapján. A sablonok automatikusan betöltődnek az ir.qweb rekordokból.

A _prepare_environment metódus számos alapértelmezett értéket állít be a renderelési környezetben. Az http_routing és website modulok szintén alapértelmezett értékeket igényelnek. Használhatja a minimal_qcontext=False opciót, hogy elkerülje ezt az alapértelmezett értéket, mint a nyilvános render metódus:

request

az aktuális Request objektum, ha van

debug

hogy az aktuális kérés (ha van) debug módban van-e

quote_plus

url-kódolási segédfüggvény

json

a megfelelő standard könyvtári modul

time

a megfelelő standard könyvtári modul

datetime

a megfelelő standard könyvtári modul

relativedelta

lásd a modult

keep_query

a keep_query segédfüggvény

Paraméterek

• values – kontekstuális értékek átadása QWeb-nek megjelenítéshez

• engine (str) – name of the Odoo model to use for rendering, can be used to expand or customize QWeb locally (by creating a „new” qweb based on ir.qweb with alterations)

render(template_name, values, load, **options)

load(ref)()

etree objektumot ad vissza, ref

Javascript

Exkluzív direktívák

Sablonok meghatározása

A t-name direktíva csak a sablonfájl legfelső szintjén helyezhető el (közvetlen gyermekeként a dokumentum gyökérnek):

<templates>
    <t t-name="template-name">
        <!-- template code -->
    </t>
</templates>

Nem vesz fel más paramétert, de használható egy <t> elemmel vagy bármely más elemmel. Egy <t> elemmel a <t>-nek egyetlen gyermeke kell, hogy legyen.

A sablon neve egy tetszőleges karakterlánc, bár amikor több sablon kapcsolódik egymáshoz (pl. al-sablonoknak nevezik), szokás ponttal elválasztott neveket használni a hierarchikus kapcsolatok jelzésére.

Sablon öröklés

A sablon öröklést az alábbi célokra használják:

• Meglévő sablonok helyben történő módosítása, pl. információ hozzáadása a sablonokhoz

más modulok által létrehozott sablonokhoz.

• Új sablon létrehozása egy adott szülő sablonból

A sablon öröklés két direktíva használatával történik:

• t-inherit, amely az örökölt sablon neve,

• t-inherit-mode, amely az öröklés viselkedését határozza meg: beállítható primary értékre, hogy új gyermek sablont hozzon létre a szülő sablonból, vagy extension értékre, hogy a szülő sablont helyben módosítsa.

Egy opcionális t-name direktíva is megadható. Ez lesz az újonnan létrehozott sablon neve, ha elsődleges módban használják, ellenkező esetben megjegyzésként kerül hozzáadásra az átalakított sablonhoz, hogy segítse az öröklések visszakövetését.

Maga az öröklés esetében a módosítások xpaths direktívák segítségével történnek. Lásd az XPATH dokumentációt a rendelkezésre álló utasítások teljes készletéért.

Elsődleges öröklés (gyermek sablon):

<t t-name="child.template" t-inherit="base.template" t-inherit-mode="primary">
    <xpath expr="//ul" position="inside">
        <li>new element</li>
    </xpath>
</t>

Kiterjesztéses öröklés (helyben történő átalakítás):

<t t-inherit="base.template" t-inherit-mode="extension">
    <xpath expr="//tr[1]" position="after">
        <tr><td>new cell</td></tr>
    </xpath>
</t>

Régi öröklési mechanizmus (elavult)

A sablon öröklése a t-extend direktíva segítségével történik, amely a módosítandó sablon nevét veszi paraméterként.

A t-extend direktíva elsődleges öröklésként működik, ha t-name-mel kombinálják, és kiterjesztésként, ha önmagában használják.

Mindkét esetben a módosítás tetszőleges számú t-jquery al-direktívával történik:

<t t-extend="base.template">
    <t t-jquery="ul" t-operation="append">
        <li>new element</li>
    </t>
</t>

A t-jquery direktívák egy CSS selector-t vesznek fel. Ez a szelekció az kiterjesztett sablonon kerül alkalmazásra, hogy kiválassza azokat a kontekstszeleteket, amelyekre az adott t-operation alkalmazásra kerül:

append

a csomópont törzse a kontextus csomópont végéhez van hozzáfűzve (a kontextus csomópont utolsó gyermekét követően)

prepend

a csomópont törzse a kontextus csomóponthoz van hozzáadva (a kontextus csomópont első gyermeke elé beszúrva)

before

a csomópont törzse közvetlenül a kontextus csomópont elé van beszúrva

after

a csomópont törzse közvetlenül a kontextus csomópont után van beszúrva

inner

a csomópont törzse helyettesíti a kontextus csomópont gyermekeit

replace

a csomópont törzse a kontextus csomópont helyettesítésére szolgál

attributes

a csomópont törzsének bármennyi attribute elemet kell tartalmaznia, mindegyiknek name attribútummal és valamilyen szöveges tartalommal, a kontextus csomópont megnevezett attribútuma a megadott értékre lesz beállítva (vagy lecserélve, ha már létezett, vagy hozzáadva, ha nem)

Nincs művelet

ha nincs megadva t-operation, a sablon törzse javascript kódként értelmeződik, és a kontextus csomóponttal this-ként hajtódik végre

Figyelem

bár sokkal erősebb, mint más műveletek, ez a mód sokkal nehezebben hibakereshető és karbantartható, ajánlott elkerülni

hibakeresés

A javascript QWeb implementáció néhány hibakeresési horgot biztosít:

t-log

kifejezés paramétert vesz, a kifejezést a renderelés során értékeli ki, és az eredményét a console.log-gal naplózza:

<t t-set="foo" t-value="42"/>
<t t-log="foo"/>

a konzolra kiírja a 42-t

t-debug

sablon renderelése közben egy debugger töréspontot vált ki:

<t t-if="a_test">
    <t t-debug=""/>
</t>

megállítja a végrehajtást, ha a hibakeresés aktív (a pontos feltétel a böngészőtől és annak fejlesztői eszközeitől függ)

t-js

a node törzse javascript kód, amely a sablon renderelése során kerül végrehajtásra. Egy context paramétert vesz, amely az a név, amely alatt a renderelési kontextus elérhető lesz a t-js törzsében:

<t t-set="foo" t-value="42"/>
<t t-js="ctx">
    console.log("Foo is", ctx.foo);
</t>

Segédeszközök

core.qweb

(a core a web.core modul) Egy QWeb2.Engine() példány, amelybe az összes modul által definiált sablonfájl betöltésre került, és hivatkozások a standard segédobjektumokra _ (underscore), _t (fordítási függvény) és JSON.

core.qweb.render használható az alapvető modul sablonok egyszerű renderelésére

API

class QWeb2.Engine()

The QWeb „renderer”, handles most of QWeb’s logic (loading, parsing, compiling and rendering templates).

Az Odoo Web létrehoz egyet a felhasználó számára a core modulban, és exportálja azt a core.qweb-be. Emellett betölti a különböző modulok összes sablonfájlját abba a QWeb példányba.

A QWeb2.Engine() also serves as a „template namespace”.

QWeb2.Engine.QWeb2.Engine.render(template[, context])

Egy korábban betöltött sablont renderel Stringgé, a context (ha meg van adva) használatával, hogy megtalálja a sablon renderelése során elérhető változókat (pl. megjelenítendő szövegeket).

Argumentum

• template (String()) – a renderelendő sablon neve

• context (Object()) – az alap névtér, amelyet a sablon rendereléséhez használunk

Visszatérési érték

Szöveg

The engine exposes an other method which may be useful in some cases (e.g. if you need a separate template namespace with, in Odoo Web, Kanban views get their own QWeb2.Engine() instance so their templates don’t collide with more general „module” templates):

QWeb2.Engine.QWeb2.Engine.add_template(templates)

Betölt egy sablonfájlt (sablonok gyűjteményét) a QWeb példányban. A sablonok az alábbiak szerint adhatók meg:

Egy XML szöveg

A QWeb megpróbálja XML dokumentummá elemezni, majd betölti.

Egy URL

A QWeb megpróbálja letölteni az URL tartalmát, majd betölti az eredményül kapott XML szöveget.

Egy Document vagy Node

A QWeb bejárja a dokumentum első szintjét (a megadott gyökér gyermekcsomópontjait), és betölti bármelyik elnevezett sablont vagy sablon felülírást.

A QWeb2.Engine() különféle attribútumokat is biztosít a viselkedés testreszabásához:

QWeb2.Engine.QWeb2.Engine.prefix

Előtag, amelyet az irányelvek felismerésére használnak az elemzés során. Egy karakterlánc. Alapértelmezés szerint t.

QWeb2.Engine.QWeb2.Engine.debug

Boolean flag putting the engine in „debug mode”. Normally, QWeb intercepts any error raised during template execution. In debug mode, it leaves all exceptions go through without intercepting them.

QWeb2.Engine.QWeb2.Engine.jQuery

A jQuery példány, amelyet a sablon öröklési folyamat során használnak. Alapértelmezés szerint window.jQuery.

QWeb2.Engine.QWeb2.Engine.preprocess_node

Egy Function. Ha jelen van, minden DOM csomópont sablonkóddá fordítása előtt hívódik meg. Az Odoo Web-ben ezt a szövegtartalom és néhány attribútum automatikus fordítására használják a sablonokban. Alapértelmezés szerint null.

1

hasonló ebben a Genshi-hez, bár nem használ (és nem is támogatja) az XML névtereket

2

bár néhány másikat is használ, akár történelmi okokból, akár azért, mert jobban illeszkednek a használati esethez. Az Odoo 9.0 még mindig függ a Jinja és Mako könyvtáraktól.