Module

Modulele aduc claritate aplicațiilor Nette, facilitând divizarea ușoară în unități logice.

Similar cu organizarea fișierelor în foldere pe un hard disk, în Nette putem împărți în module prezentatorii, șabloanele și alte clase auxiliare. Cum funcționează acest lucru în practică? Pur și simplu prin încorporarea de noi subdirectoare în structură. Iată un exemplu de structură cu două module, Front și Admin:

app/
├── UI/
│   ├── Admin/            ← Admin module
│   │   ├── @layout.latte
│   │   ├── Dashboard/
│   │   │   ├── DashboardPresenter.php
│   │   │   └── default.latte
│   │   └── ...
│   ├── Front/            ← Front module
│   │   ├── @layout.latte
│   │   ├── Home/
│   │   │   ├── HomePresenter.php
│   │   │   └── default.latte
│   │   └── ...

Această structură de directoare se reflectă în spațiile de nume ale claselor, astfel încât, de exemplu, DashboardPresenter se află în spațiul de nume App\UI\Admin\Dashboard:

namespace App\UI\Admin\Dashboard;

class DashboardPresenter extends Nette\Application\UI\Presenter
{
	// ...
}

În aplicație, ne referim la prezentatorul Dashboard din cadrul modulului Admin folosind notația două puncte ca Admin:Dashboard. Pentru acțiunea default, ne referim la acesta ca Admin:Dashboard:default.

Structura prezentată nu este rigidă; o puteți personaliza complet în funcție de nevoile dumneavoastră în cadrul configurației.

Modulele pot include toate celelalte fișiere, cum ar fi componentele și clasele auxiliare, pe lângă prezentatori și șabloane. Dacă vă gândiți unde să le plasați pe acestea, luați în considerare utilizarea unui dosar Accessory:

app/
├── UI/
│   ├── Admin/
│   │   ├── Accessory/
│   │   │   ├── FormFactory.php
│   │   │   └── AdminLayout.php
│   │   ├── Dashboard/
│   │   └── ...

Module imbricate

Modulele pot avea mai multe niveluri de anvelopare, similar cu o structură de directoare pe un disc:

app/
├── UI/
│   ├── Blog/             ← Blog module
│   │   ├── Admin/        ← Admin submodule
│   │   │   ├── Dashboard/
│   │   │   └── ...
│   │   ├── Front/        ← Front submodule
│   │   │   ├── @layout.latte
│   │   │   ├── Home/
│   │   │   └── ...
│   ├── Forum/            ← Forum module
│   │   └── ...

Modulul Blog este împărțit în submodulele Admin și Front. Acest lucru se reflectă și în spațiile de nume, care apar apoi ca App\UI\Blog\Admin și similar. Pentru a ne referi la prezentatorul Dashboard din cadrul submodulului Admin, ne referim la acesta ca Blog:Admin:Dashboard.

Nesting-ul poate fi atât de adânc cât este necesar, permițând crearea de sub-submodule.

De exemplu, dacă în administrație aveți mulți prezentatori legați de gestionarea comenzilor, cum ar fi OrderDetail, OrderEdit, , OrderDispatch, etc., puteți crea un modul Order în care vor fi organizați prezentatori precum Detail, Edit, Dispatch, și alții.

Crearea de legături

Legăturile din șabloanele de prezentator sunt relative la modulul curent. Astfel, legătura Foo:default duce la prezentatorul Foo din același modul ca și prezentatorul curent. Dacă modulul curent este Front, de exemplu, atunci legătura se prezintă astfel:

<a n:href="Product:show">link to Front:Product:show</a>

O legătură este relativă chiar dacă include numele unui modul, care este considerat atunci un submodul:

<a n:href="Shop:Product:show">link to Front:Shop:Product:show</a>

Legăturile absolute sunt scrise în mod analog cu căile absolute de acces de pe disc, dar cu două puncte în loc de bară oblică. Astfel, o legătură absolută începe cu două puncte:

<a n:href=":Admin:Product:show">link to Admin:Product:show</a>

Pentru a afla dacă ne aflăm într-un anumit modul sau într-un submodul al acestuia, putem utiliza funcția isModuleCurrent(moduleName).

<li n:class="isModuleCurrent('MyEshop:Users') ? active">
	<a n:href="Product:">...</a>
</li>

Rutarea

A se vedea capitolul privind rutarea.

Cartografiere

Cartografierea definește regulile de derivare a numelui clasei din numele prezentatorului. Aceste reguli sunt specificate în configurație la cheia application › mapping.

Structurile de directoare menționate anterior pe această pagină se bazează pe următoarea cartografiere:

application:
	mapping: App\UI\*\**Presenter

Cum funcționează cartografierea? Pentru o mai bună înțelegere, să ne imaginăm mai întâi o aplicație fără module. Dorim ca clasele de prezentatori să se încadreze în spațiul de nume App\UI, astfel încât prezentatorul Home să fie asociat cu clasa App\UI\HomePresenter. Acest lucru poate fi realizat cu această configurație:

application:
	mapping: App\UI\*Presenter

Această cartografiere funcționează prin înlocuirea asteriscului din masca App\UI\*Presenter cu numele prezentatorului Home, rezultând numele final al clasei App\UI\HomePresenter. Simplu!

Cu toate acestea, după cum puteți vedea în exemplele din acest capitol și din alte capitole, plasăm clasele de prezentatori în subdirectoare eponime, de exemplu, prezentatorul Home este mapat în clasa App\UI\Home\HomePresenter. Acest lucru se realizează prin dublarea asteriscului (necesită Nette Application 3.2):

application:
	mapping: App\UI\**Presenter

Acum, să trecem la maparea prezentatorilor în module. Putem defini mape specifice pentru fiecare modul:

application:
	mapping:
		Front: App\UI\Front\**Presenter
		Admin: App\UI\Admin\**Presenter
		Api: App\Api\*Presenter

În conformitate cu această configurație, prezentatorul Front:Home se mapează la clasa App\UI\Front\Home\HomePresenter, în timp ce prezentatorul Api:OAuth se mapează la clasa App\Api\OAuthPresenter.

Deoarece modulele Front și Admin au o abordare similară de cartografiere și este posibil să existe mai multe astfel de module, este posibil să se creeze o regulă generală care să le înlocuiască. Un nou asterisc pentru modul este adăugat la masca clasei:

application:
	mapping:
		*: App\UI\*\**Presenter
		Api: App\Api\*Presenter

Pentru modulele imbricate pe mai multe niveluri, cum ar fi prezentatorul Admin:User:Edit, segmentul de asterisc se repetă pentru fiecare nivel, rezultând clasa App\UI\Admin\User\Edit\EditPresenter.

O notație alternativă constă în utilizarea unei matrice compuse din trei segmente în locul unui șir de caractere. Această notație este echivalentă cu cea anterioară:

application:
	mapping:
		*: [App\UI, *, **Presenter]
		Api: [App\Api, '', *Presenter]

Dacă avem doar o singură regulă în configurație, cea generală, putem scrie pe scurt:

application:
	mapping: App\UI\*\**Presenter