Proiect Symfony

Curs 1

Ce este Symfony?

Symfony este scris în PHP urmărind modelul MVC (model-view-controller), este free sub licența MIT. Acest framework este open source, apărut în varianta inițială cu mai mult de zece ani în urmă (octombrie 2005) și devenit unul dintre cele mai populare cadre de lucru PHP datorită multiplelor facilități și a bunei documentații. Facilități:

instrumentele puternice, predefinite;
viteză, flexibilitate, componente reutilizabile;
testare;

Instalare resurse necesare

1. Se descarcă și se instalează configurația XAMPP corespunzătoare PHP 5.6.12 de la adresa: https://www.apachefriends.org/download.html versiunea pe 32/64 biți.

Din directorul corespunzător instalării (C:/xampp), se rulează xampp-control și se pornește serverul Apache .

Observație: Serverul apache poate întampina probleme la pornire în situația în care pe calculatorul pe care se încearcă rularea există instalate aplicații care folosesc portul 80 (ex: Skype, Team Viewer). În această situație:

Din xampp-control, în dreptul secțiunii Apache deschidem Config -> Apache (httpd.conf). În fișierul deschis, se modifică linia Listen 80 cu înlocuirea valorii 80 corespunzătoare port-ului cu o altă valoare (ex: 81) și se salvează fișierul.
Din xampp-control, în dreptul secțiunii Apache deschidem Config -> Apache (httpd-ssl.conf). În fișierul deschis, se modifică linia Listen 443 cu înlocuirea valorii 443 cu o alta valoare (ex: 4433) și se salvează fișierul.
Se reîncearcă pornirea serverului Apache.

2. În continuare, verificăm dacă PHP este configurat la cerințele symfony. Pentru aceasta, de la adresa http://sf-to.org/1.4/check.php se descarcă scriptul și se salvează într-o locație pe hard-disk. Recomandăm a folosi ambele variante de testare indicate în continuare:

Copiem scriptul în \xampp\php și îl rulăm din linia de comandă DOS prin \xampp\php> php check_configuration.php
Copiem scriptul in \xampp\htdocs și îl accesăm dintr-un browser web la adresa http://localhost(:81)/check_configuration.php

În mod obișnuit vom avea două avertizări. Prima, cea legată de CLI, o vom ignora. Cea de-a doua este legată de necesitatea activării unui accelerator.

Ultima versiune PHP care avea inclusă extensia php_apc a fost PHP 5.3. Pentru noile versiuni, aceasta a fost inlocuită cu php_opcache.

Ultima lansare a APC a fost php_apc 3.1.14, care, deși putea fi folosita cu PHP 5.5, a fost îndepărtată (scoasa) din cauza unor probleme de memorie grave care nu au putut fi stabilite. Drept urmare, php_apc 3.1.14 nu mai este disponibil.

Pentru a lucra cu PHP ce au versiuni peste 5.3, suntem nevoiți să folosim APCu, o extensie a APC cu partea cache Opcode îndepărtată (sursa tuturor problemelor APC).

3. Pentru instalarea acceleratorului APCu, descărcăm ultimul build de la adresa http://windows.php.net/downloads/pecl/releases/apcu/4.0.7/, varianta corespunzătoare pe 32/64 de biți, Thread Safe.

Trebuie să acordăm o atenție specială părții ce conține vc11, ceea ce înseamnă că biblioteca va fi compilată cu MS Visual Studio 11. În cazul în care instalarea PHP va fi compilată cu MS Visual Studio 09, extensia nu va funcționa.
Din această arhivă, se extrag fișierele php_apcu.dll și php_apcu.pdb în folderul C:\xampp\php\ext.
În folderul C:\xampp\php, edităm fișierul php.ini adăugând următoarele rânduri la sfârșitul său:

 [APCu] 
 extension=php_apcu.dll
 apc.enabled=1 
 apc.shm_size=32M 
 apc.ttl=7200 
 apc.enable_cli=1 
 apc.serializer=php

Se salvează fișierul php.ini și se restartează serverul Apache. După ce am îndeplinit toate cerințele, eventual cu ignorarea CLI-ului, ștergem fișierul check_configuration.php din locațiile în care l-am copiat.

4. În cazul în care nu am instalat Java cu o ocazie anterioară, se accesează http://java.com/en/download și se descarcă versiunea corespunzătoare sistemului pe 32/64 de biți.

După instalare, vom seta variabile-le de mediu și sistem accesând Control Panel -> System -> Advanced -> Environment Variables.
Se crează o variabilă de sistem JAVA_HOME care primește calea către folderul de instalare (ex: C:\Program Files\Java\jdk1.8.0_25), iar apoi se editează variabila Path, adăugând la finalul string-ului ;%JAVA_HOME%\bin;

5. PHP a fost instalat odată cu XAMPP. Vom adăuga și pentru acesta calea către executabilul PHP la variabilele de sistem pentru a putea fi recunoscut drept comandă în DOS independent de locația curentă.

În cadrul Control Panel -> System -> Advanced -> Environment Variables, edităm variabila Path, adăugând la finalul string-ului ;C:\xampp\php\;

6. Folosim ca IDE Eclipse for PHP Developers care este disponibil pentru descărcare la adresa http://www.eclipse.org/downloads. Se alege versiunea pe 32/64 de biți.

Realizarea primului proiect

Observație! Toate descărcările și instalările trebuie să fie făcute pentru aceeași versiune de sistem (32 sau 64 de biți).
În urma dezarhivării fișierului descărcat, putem folosi imediat Eclipse fără să fie necesară o nouă instalare.

Pentru realizarea unui proiect cu ajutorul framework-ului Symfony, vom avea nevoie de următoarele:

1. Crearea unui proiect Symfony se poate face in două moduri: prin folosirea unui plugin sau în linie de comandă și importarea proiectului în Eclipse.

Prima metodă presupune instalarea unui plugin ce permite crearea proiectelor de tip Symfony în mod direct în cadrul Eclipse.

În Eclipse: Help -> Eclipse Marketplace
Find Symfony; Install
Versiunile mai vechi de Eclipse nu dispun de Marketplace, prin urmare se va folosi Help -> Install New Software, se va alege unul dintre site-urile disponibile și se va căuta și instala Symfony.
Pentru a putea crea proiecte Symfony, este necesară adăugarea unui executabil PHP astfel: Window -> Preferences -> PHP -> PHP Executables și se adaugă calea către php.exe din folderul C:\xampp\php\php.exe.
Dispunem acum de opțiunea creării unui proiect Symfony în cadrul Eclipse care va genera întreaga structură de fișiere și directoare corespunzătoare framework-ului.
Daca apar erori legate de fișierele .xml, se face click dreapta pe proiect -> Properties -> Validation, se bifează prima casuță și se debifează cele două din dreptul XML Validator și XML Schema Validator. Click dreapta pe proiect -> Validate.

A doua metodă presupune rularea in linie de comandă DOS a următoarei comenzi: php –r “readfile(‘http://symfony.com/installer’);” > symfony

Fișierul descărcat se mută în folderul în care se vor crea viitoarele proiecte și se va executa apoi în linie de comandă în respectivul folder: php symfony
Crearea unei aplicații se face tot în linie de comandă prin php symfony new nume_proiect. Această comandă crează un nume_proiect care conține un nou proiect bazat pe cea mai recentă versiune stabilă de Symfony disponibilă. De asemenea, installer-ul verifică dacă sistemul dispune de cerințele tehnice necesare rulării aplicațiilor Symfony.
Noul proiect se importă apoi în Eclipse, accesând tab-ul File->Import. În fereastra apărută vom selecta tipul proiectului și anume PHP->Symfony Project, pașii următori fiind completați cu datele proiectului (numele și folderul care il conține).

2. În urma generării proiectului, se va crea următoarea structură de directoare.

3. In exemplul următor, am creat un nou fisier “index.php” în folderul web. Proiectul Symfony este acum accesibil prin solicitarea scriptului web/index.php dintr-un browser.

4. De reținut este faptul că având toate fișierele în directorul rădăcină web este un lucru bun pentru testarea Symfony pe calculatorul local, dar nu ne ajută în cazul unui server de producție deoarece ar putea face ca unele componente interne ale aplicației să devină vizibile altor utilizatori.

La final, proiectul va avea următoarea structură:

Subversiuni

1. Folosirea unor diverse versiuni ale codului sursă reprezintă o practică uzuală în dezvoltarea unei aplicații.

2. Câteva avantaje:

încredere
posibilitatea de a reveni la o versiune precedentă în caz de avarie
posibilitatea ca mai mult de o persoană să lucreze eficient la proiect
acces la versiunile succesive

3. Ca și sistem de versionare, propunem TortoiseGit.

4. Înainte de a-l instala, trebuie să descărcăm și să instalăm ultima versiune de Git de la adresa: https://git-scm.com/downloads.

5. TortoiseGit va fi descărcat și instalat de la adresa: https://tortoisegit.org/download/.

6. Dupa ce acestea au fost instalate, se crează un cont pe site-ul https://github.com/. După autentificare, se crează un nou repository și se reține url-ul corespunzător (ex: https://github.com/maria-negrea/SymfonyPractice.git ).

7. Primul pas constă în crearea unei clone a repository-ului creat anterior prin click dreapta -> Git Clone.

Se introduce url-ul repository-ului și se specifică numele folder-ului ce urmează a fi creat (clona).
În cazul în care se dorește versionarea unui proiect existent, acesta este mutat in folderul nou. În cazul unui proiect nou, acesta va fi creat direct în acest folder.

8. Al doilea pas constă în salvarea în repository a modificărilor făcute în acest folder clonă prin click dreapta -> Git commit -> “master”…

În acest moment, apare o fereastră în care sunt vizibile modificările făcute (fișiere adăugate/modificate).

9. Se introduce un mesaj sugestiv pentru versiunea adaugată și se dă click pe Ok. În fereastra care apare apoi, se da click pe butonul Push și se introduc credențialele contului de GitHub.

10. Pentru a se verifica faptul că datele au fost salvate în repository, se poate accesa repository-ul direct de pe site-ul GitHub, unde sunt vizibile toate commit-urile.

11. Al doilea pas se repetă de fiecare dată când ne dorim persistarea modificărilor asupra unui proiect.

Bibliografie Curs 1

http://files.zend.com/help/Zend-Studio/content/working_with_symfony_eclipse.htm

https://www.devside.net/wamp-server/installing-apc-for-php-5-5

http://www.tinywall.info/2014/05/install-setup-getting-started-tutorial-php-symfony-hello-world-example-windows.html

http://robertgreiner.com/2010/02/getting-started-with-git-and-tortoisegit-on-windows/

Acest ghid de instalare a fost creat strict cu scop informativ.

Curs 2

ORM

1. Object / Relational Mapping (ORM) este o tehnică de programare ce face posibilă accesarea și manipularea obiectelor fără ca programatorii să fie interesați de sursa de date de unde provin aceste obiecte.

2. Efortul de a conecta atributele claselor definite prin intermediul unui limbaj orientat pe obiecte cu câmpurile tabelelor din baza de date nu poate fi ignorat, iar scopul unui ORM este acela de a crea o relație naturală, transparentă, fiabilă și de durată între cele două modele.

Doctrine

1. Doctrine este un ORM (sistem de relaționare a obiectelor) pentru PHP 5.2.3+ care folosește un DBAL ("strat" de abstractizare pentru baza de date). Una din trăsăturile sale distinctive este capacitatea de a oferi dezvoltatorilor o alternativă la SQL, permițând un grad maxim de flexibilitate fără a fi nevoie de duplicarea nejustificată a codului.

2. Proiectul Doctrine este începutul pentru diferite librării PHP focusate în primul rând pe păstrarea bazelor de date și maparea obiectelor. Acesta a beneficiat foarte mult de conceptele din Hibernate ORM și le-a adaptat pentru a se potrivi cu limbajul PHP.

Configurarea

1. Editarea fișierului app/config/parameters.yml corespunzător conexiunii cu baza de date

Crearea unei baze de date

1. Pentru utilizarea comenzilor php din mediul de dezvoltare Eclipse vom urma pașii:

Run->External Tools -> External Tools Configuration
Name: nume_comandă
Location: calea_către_php.exe
Working Directory: Browse Workspace -> Selectăm proiectul curent
Arguments: argumentele necesare comenzii
-> Apply
-> Run

Crearea unui tabel

1. Pentru a crea un tabel în baza de date este necesar să creăm o clasă .php corespuzătoare în folderul Entity (AppBundle\Entity):

CRUD pe un tabel din baza de date

1. C=Create

2. R=Read

3. U=Update

4. D=Delete

Generarea modelului utizând o bază de date existentă

1. Crearea unei tabele în baza de date

2. Verificăm dacă este corect definită configurarea bazei de date utilizată în fișierul

app/config/parameters.yml

3. Generarea fișierului ce contine metadatele corespunzătoare tabelului curent:

app/console doctrine:mapping:

convert yml ./src/Resources/config/doctrine --filter="Category" --from-database --force

4. Vizualizăm fișierul generat :

Resources/config/doctrine/Category.orm.yml

5. Putem utiliza și fișiere metadate xml înlocuind în comanda anterioară “yml” cu “xml”

6. Generarea clasei entitate corespunzătoare:

app/console doctrine:mapping:import AppBundle annotation --filter="Category"

Observație! Pentru a genera toate entitățile corespunzătoare tabelelor din baza de date se va omite utilizarea filtrului(“filter”)

7. Generarea de getteri și setteri pentru clasa mapată din baza de date:

app/console doctrine:generate:entities AppBundle:Category

Curs 3

Arhitectura MVC

1. Arhitectura MVC definește o modalitate de a organiza codul în relație cu natura sa și conține 3 nivele:

Model: conține partea de business logic care la rândul său conține interacțiunea cu baza de date.

View: care conține partea de interacțiune cu utilizatorul și care la rândul său conține template engine-ul.

Controller: reprezintă o porțiune de cod ce apeleză modelul pentru a obține date ce apoi sunt trimise view-ului pentru a fi redate clientului. La crearea unui nou proiect automat se generează două fișiere care gestionează front controalele, trimitând diversele acțiuni modulelor:

index.php

frontend_dev.php

Avantaje:

este ușor de scris;

execuție rapidă.

Dezavantaje:

nu există verificare de eroare (dacă conexiunea către baza de date se întrerupe);

codul HTML și PHP este combinat;

codul este legat la o bază de date;

Acțiuni

Conține logica aplicației ( ! arhitectura MVC)

Acțiunile folosesc modelul pentru a crea variabile pentru view

Pentru o cerere din aplicația web, URL-ul definește o acțiune și parametrii asociați cererii

Numele acțiunilor: executeActionName

Numele clasei: moduleNameActions (clasa este derivată din sfActions)

Doctrine

1. Doctrine este un set de biblioteci PHP în primul rând axat pe furnizarea de servicii de persistența și funcționalitati aferente. Proiectele sale sunt un mapper obiect relational (ORM) și stratul de bază de date de abstractizare este construit pe partea de sus.

2. Una dintre caracteristicile cheie este opțiunea de a scrie interogări de baze de date într-un obiect orientat SQL de proprietate numit Doctrina Query Language (DQL) .

3. Symfony Standard Edition are integrat Doctrine-ul, prin care putem mapa obiecte către o bază de date (de ex. MySQL, SQLite, etc). Asigură un set de tool-uri pentru interacțiunea cu baza de date.

Create

Instanțierea obiectului

Setarea proprietăților

$product se folosește ca și un obiect normal

getDoctrine()->getManager() = entity manager are rolul de a persista și de a citi/scrie obiectele din/în baza de date

persist() = Doctrine v-a administra obiectul

flush() = Doctrine caută toate obiectele care trebuie persistate, în exemplul nostru obiectul este creat acum, astfel se execută un INSERT query => este creat o linie în tabel

Read

Citirea din baza de date se face folosind ID-ul

Update

1. Pași:

Preluarea obiectului de la Doctrine

Modificarea obiectului

flush() pe Entity Manager

2. Pentru crearea și updatarea obiectelor se parcurg aceleași pași, Doctrine este optimizat astfel încât execută un UPDATE query automat dacă entitatea există deja în baza de date.

3. Nu e nevoie de apelarea metodei persist(), deoarece obiectul a fost cerut de la Doctrine, deci este deja administrat.

Delete

1. Apelarea metodei remove().

2. Queryul DELETE se execută doar după ce se apeleaza metoda flush()

Generarea codului

$php console generate:doctrine:crud --entity=AppBundle:Product --format=annotation --with-write --no-interaction

Relații

Tipuri:

1:1 , one-to-one

1:n, one-to-many

m:1, many-to-one

m:n, many-to-many

(Unidirecțional, Bidirecțional, Self-referencing)

CRUD Tutorial

1. Creare proiect nou

2. Se deschide un cmd, calea spre folderul proiectului: C:\xampp\htdocs\Demo

3. Introducem: php app/console generate:bundle

4. Introducem: Bundle/TutorialBundle

5. Introducem la bundle name: TutorialBundle

6. La target directory apăsăm: Enter

7. Introducem: Annotation

8. Introducem: Yes

9. Introducem: Yes

10. Introducem: Yes (kernel)

11. Introducem: Yes (routing)

//dacă afișează: "You can now start using the generated code!" => ok

12. Introducem: php app/console doctrine:generate:entity

13. Setăm: app\config\parameters.yml

------------------------------------

parameters:

database_driver: pdo_mysql

database_host: localhost

database_name: test_project

database_user: root

database_password: password

------------------------------------

//creăm o conexiune in mysql workbench

//creăm o baza de date: php app/console doctrine:database:create

La shortcut name introducem: TutorialBundle:Employee

14.La configuration format introducem: annotation

15.Introducem coloanele:

Prima coloană:

- la new field name introducem: Name

- la field type introducem: string

- la field length introducem: 30

A doua coloană:

- la new field name introducem: Salary

- la field type introducem: integer

//când am terminat de introdus, apăsăm enter

Introducem: yes La final introducem: yes (pentru confirmare)

16. Repetăm procedeul de la pct.12 pentru a crea o nouă entitate. -La shortcut name introducem: TutorialBundle:Department

-La configuration format introducem: annotation

-Introducem coloanele: Name:string,30

Introducem: yes, apoi iar yes pentru confirmare

17. Introducem: php app/console doctrine:generate:entities Acme

- adică generam tabelele pentru baza de date

18. Introducem: php app/console doctrine:schema:update --force

19. Mergem în proiect: src\Acme\TutorialBundle\Entity\Employee

20. Copiem acesta în locația de mai sus: //la sfârșit după getSalary

/*

*@ORM\ManyToOne|targetEntity="Department", inversedBy="employees")

*ORM\JoinColumn(name="department_id",referencedColumnName="id")

*/

protected $department;

21. Mergem în proiect: src\Acme\TutorialBundle\Entity\Department

22. Copiem:

/*

*ORM\OneToMany(targetEntity="Employee", mappedBy="department")

*/

protected $employees;

public function _construct(){

$this->employees = new ArrayCollection();

}

23. Introducem: php app/console doctrine:schema:update --force

24. Introducem: php app/console doctrine:generate:entities Acme

25. Introducem: php app/console generate:doctrine:crud

26. La shortcut name introducem: TutorialBundle:Department

27. Introdcem: yes

28. Introducem: annotation

29. Apăsăm: enter

30. Confirmăm(introducem: yes)

Dacă este ok atunci apare: You can now start using the generated code!

31. Introducem: php app/console generate:doctrine:crud

32. La shortcut name introducem: TutorialBundle:Employee

33. Introdcem: yes

34. Introducem: annotation

35. Apăsăm: enter

36. Confirmăm (adică introducem: yes)

37. Facem un test : Navigăm pe: http://localhost:81/Demo/web/app_dev.php/department/

Introducem Department1 și Department2

Create, Read, Update, Delete

Bibliografie Curs 3

http://symfony.com/doc/current/book/doctrine.html

http://georgehk.blogspot.ro/2014/04/crud-operation-in-symfony-with-mysql.html

http://symfony.com/legacy/doc/book/1_0/en/06-Inside-the-Controller-Layer

https://en.wikipedia.org/wiki/Doctrine_(PHP)

Curs 4

Relația 1:1 Exemplu

Exemplu : product -> order - 1:1 se traduce prin : fiecare produs se poate regăsi pe o singură comandă la un moment dat, iar o comandă conține un singur produs .

- 2 modalități de specificare :

Relație de tipul OneToOne

Relație de tipul 1 : m, cu m=1 (obținem m=1 setând ca valoarea câmpului referit să fie unică)

Relația 1:1 Pași

1. Pentru acest exemplu, vom crea mai întâi structura bazei de date în MySQL Workbrench, după care vom genera entitățile php corespunzătoare în cadrul unui proiect Symfony.

2. În Workbrench, vom crea o nouă bază de date :

3. În Eclipse, se creează un nou proiect Symfony. Dacă apar erori:

Click dreapta pe proiect->Properties->Validation; Bifăm primul checkbox și le de debifăm pe ultimile două(debifăm ambele checkbox-uri aferente fiecărei opțiuni); Apply, Ok; Click dreapta pe proiect->Validate

4. În app/config/parameters.yml setăm valoarea parametrului database_name cu numele bazei de date create la pasul anterior.

5. Revenind în Workbrench la baza de date creată anterior, vom crea două tabele care vor avea următoarele structuri :

6. În continuare, vom stabili relația dintre tabele. Pentru aceasta, vom crea în Workbrench o nouă diagramă.

7. La “Stored Connection” alegem conexiunea în care lucrăm, selectăm baza de date, Next, Next ... .

8. Adăugăm relația între tabele.

9. De menționat este faptul că există un BUG în MySQL Workbrench care împiedică recunoașterea relațiilor one-to-one, transformându-le în one-to-many.

10. Pentru ca această relație să devină one-to-one, vom efectua următoarele: Click dreapta pe relație-Edit Relationship-Alegem tabul Foreign Key și apăsăm Edit Table.

11. Setăm ca valoarea noii coloane create in tabelul orders să fie unică.

12. După aceasta, vom sincroniza modelul cu baza de date existentă.

13. Un ultim pas presupune setarea operațiilor de Update și Delete ca fiind cascadate.

14. Click dreapta pe tabelul orders-> Alter Table-> alegem Foreign Keys-> setăm On Delete și On Update->Apply.

15. În continuare, vom genera fișierul ce conține metadatele corespunzătoare celor două tabele din baza de date, entitățile php aferente, metode get si set pentru atributele claselor și, în final, operațiile CRUD.

- php app/console doctrine:mapping:convert yml ./src/Resources/config/doctrine --from-database --force

- php app/console doctrine:mapping:import AppBundle annotation

- php app/console doctrine:generate:entities AppBundle:Product

php app/console doctrine:generate:entities AppBundle:Orders

- php app/console generate:doctrine:crud

La shortcut name introducem: AppBundle:Product

Introdcem: yes

Introducem: annotation

Apăsăm: enter

Confirmăm (adică introducem: yes)

Repetăm comanda și pentru Orders.

16. Deoarece coloana idproduct este referențiată în tabela orders, form-ul corespunzător adăugării unei noi comenzi va conține un combobox în care vor fi stocate denumirile produselor. Pentru a putea fi încărcate denumirile produselor, în clasa php Product (src/AppBundle/Entity/Product.php) trebuie adăugată o metodă __toString() după cum urmează :

17. Testăm

http://localhost:81/testOnetoOne/web/app_dev.php/orders/

Relația m:n Exemplu

Exemplu : product order

- m:n se traduce prin : un produs poate fi adăugat pe mai multe comenzi la un moment dat, iar o comandă conține unul sau mai multe produse.

Modalitate de specificare :

- Se utilizează un tabel de asociere pentru care nu va fi generată o entitate in proiectul Symfony.

Relația m:n Pași

1. Repetăm pașii 1-7 de la relația one-to-one.

2. După ce am adăugam o relație de tipul m:n dinspre tabelul orders spre product obținem :

3. Efectuăm pașii 12-14, cu mențiunea că vom setaoperațiile cascadate în tabelul orders_has_product, pentru ambele chei străine.

4. Se efectuează pasul 15.

5. Deoarece tipul relației este de mai mulți la mai mulți și fiecare entitate conține o listă de alte obiecte, în ambele clase vom adăuga câte o metodă __toString() pentru a putea fi posibilă listarea si alegerea multiplă a obiectelor în cadrul unei liste, vizibilă în form-urile aferente fiecărei entități.

În clasa Product

public function __toString(){

return $this->getProductName();

}

În clasa Orders

public function __toString(){

return $this->getCustomerName();

}

6. Testăm

http://localhost:81/testManytoMany/web/app_dev.php/orders/

Curs 5

Slot-uri

<?php

require '../vendor/autoload.php';

use Symfony\Component\Templating\PhpEngine;

use Symfony\Component\Templating\TemplateNameParser;

use Symfony\Component\Templating\Loader\FilesystemLoader;

use Symfony\Component\Templating\Helper\SlotsHelper;

$loader = new FilesystemLoader(__DIR__.'/%name%');

$templating = new PhpEngine(new TemplateNameParser(), $loader);

$templating->set(new SlotsHelper());

$name = 'Bogdan Musat';

$templating['slots']->set('body','< h1 >'.$name.'< /h1 >');

echo $templating->render('hello.php');

?>

<!doctype html>

<html>

<head>

<title>

<?php $view['slots']->output('title', 'Default title') ?>

</title>

</head>

<body>

<?php $view['slots']->output('body') ?>

</body>

</html>

Further documentation:

http://symfony.com/doc/current/components/templating/helpers/slotshelper.html

Symfony Request and Response

Varianta PHP

$uri = $_SERVER['REQUEST_URI'];

$foo = $_GET['foo'];

header('Content-Type: text/html');

echo 'The URI requested is: '.$uri;

echo 'The value of the "foo" parameter is:'.$foo;

Request-uri

use Symfony\Component\HttpFoundation\Request;

$request = Request::createFromGlobals();

// retrieve GET and POST variables respectively

$request->query->get('foo');

$request->request->get('bar', 'default value if bar does not exist');

// retrieve a COOKIE value

$request->cookies->get('PHPSESSID');

Response-uri

use Symfony\Component\HttpFoundation\Response;

$response = new Response();

$response->setContent('<html><body>< h1 >Hello world!< /h1 ></body></html>');

$response->setStatusCode(Response::HTTP_OK);

$response->headers->set('Content-Type', 'text/html');

// prints the HTTP headers followed by the content

$response->send();

Further documentation:

http://symfony.com/doc/current/book/http_fundamentals.html

Routing

Rutare fara parametri

/**

*@Route("/lucky/number", name="lucky-number")

*/

public function numberAction()

{

$number = rand(0, 100);

return new Response(

'<html><body>Lucky number: '.$number.'</body></html>'

);

}

Rutare cu parametri

/**

* @Route("/message/{slug}", name="message_show")

*/

public function showAction($slug)

{

return new Response(

'<html><body>< h1 >'.$slug.'< /h1 ></body></html>'

);

}

Pentru apelarea rutelor definite, apelam: localhost:port/NumeAplicatie/web/app_dev.php/ruta

Remark !!! Este necesara includerea lui app_dev.php in URL, deoarece rutele nu vor fi vizibile in modul de productie, ci doar in cel de development

Ex:

localhost:81/Routing/web/app_dev.php/lucky/number

localhost:81/Routing/web/app_dev.php/message/Hello World!

Debugarea rutelor

- Pentru debugare, ne ducem in folder-ul proiectului si apelam urmatoarea linie de comanda: php app/console debug:router

- In unele cazuri app/console trebuie inlocuit cu bin/console, depinzand unde se afla fisierul „console”

Comanda va afisa toate rutele implicite si cele definite de programator:

homepage              ANY       /
contact               GET       /contact
contact_process       POST      /contact
article_show          ANY       /articles/{_locale}/{year}/{title}.{_format}
blog                  ANY       /blog/{page}
blog_show             ANY       /blog/{slug}

Further documentation:

http://symfony.com/doc/current/book/routing.html

Fixture dinamice

Sunt utile pentru popularea rapidă în mod dinamic a bazei de date.

Datele inserate sunt utilizate fie pentru testare, fie reprezintă datele inițiale necesare pentru ca aplicația să ruleze fară probleme.

DoctrineFixturesBundle este folosit pentru încarcarea datelor de testare cu doctrina ORM, care este un ORM implicit în Symfony.

Taskul doctrine:data-load va determina încărcarea dinamică a datelor în baza de date.

1. În cmd/xampp/htdocs/:

php -r "file_put_contents('symfony', file_get_contents('http://symfony.com/installer'));"

php symfony new TestareUser

2. În Eclipse:

Import→PHP → Existing Composer Project → TestareUser → Browse

3. Instalăm Global Composer.

4. In cmd/xampp/htdocs/TestareUser se va da comanda:

composer require --dev doctrine/doctrine-fixtures-bundle

5. Se va construi baza de date: TestUser

6. Se va construi tabela: User

7. Baza de date va avea următoarele câmpuri:

8. În clasa AppKernel adăugăm la sfârșitul funcției registerBundles():

if (in_array($this->getEnvironment(), array('dev', 'test'))) {

$bundles[] = new Doctrine\Bundle\FixturesBundle\DoctrineFixturesBundle(); }

9. În app/config/parameters.yml se modifică numele bazei de date.

10. În cmd/xampp/htdocs/TestareUser vom da următoarele comenzi:

php app/console doctrine:mapping:convert yml ./src/Resources/config/doctrine --from-database --force

php app/console doctrine:mapping:import AppBundle annotation

php app/console doctrine:generate:entities AppBundle:User

php app/console generate:doctrine:crud

11. La shortcut name tastăm: AppBundle:User

Tastăm: yes

Tastăm :annotation

Apăsăm: enter

Tastăm: yes

12. În src/AppBundle se copiaza folderul DataFixtures

Best practice: cand se crează un fixture, este bine să îl denumim LoadNumeFixtureData!

13. În cmd/xampp/htdocs/TestareUser tastăm comanda :

php app/console doctrine:fixtures:load

14. Apare întrebarea: Careful, database will be purged. Do you want to continue y/N? Se tastează “y” , pentru a se suprascrie tabela.

15. localhost:/TestareUser/web/app_dev.php/user

Probleme de Securitate

1. Modificăm indexAction, din UserController, adaugând un query care va aduce din tabela User doar înregistrarile care au data expirării mai mare decât data curentă.

2. Modificăm showAction după cum urmează:

Conceptul DRY

Conceptul DRY(don’t repeat yourself)

Def: Este un principiu fundamental al programării, ce propune ca blocurile comune, repetitive, să fie reprezentate printr-o singură entitate(model). Orice modificare a „modelului” se va propaga automat tuturor blocurilor aferente.

- Practic, duplicarea în logică trebuie eliminată prin abstractizare, iar duplicarea în proces trebuie eliminată prin automatizare.

- Prin folosirea corespunzătoare a principiului se elimină:

Codul duplicat;

Munca manuală și repetitivă la editare;

Metoda copy-paste pentru replicarea unor funcționalități;

Template-uri

- Pachetele Symfony sunt mult mai puternice în modelarea template-urilor Twig.

- Un template Twig este un fișier text care poate genera orice tip de conținut (HTML, CSS, JavaScript, XML, CSV, LaTeX, etc.). Practic, Twig permitescrierea concisă a șabloanelor, ce sunt mult mai prietenoase pentru web designeri, și, de asemenea, mult mai puternice decât șabloanele PHP.

- Caracteristici:

Rapiditate: Twig compilează șabloane și cod optimizat PHP.

Securitate: Twig are un mod sandbox pentru a evalua dacă un cod șablon nu este de încredere. Acest lucru permite Twig să fie folosit ca un limbaj șablon.

Flexibilitate: Twig permite dezvoltatorului să definească propriile etichete personalizate, propriile filtre, și crearea propriul DSL.

Exemplu Template

- In routing.yml adaugam:

test:

path: /partial/

defaults: {_controller: AppBundle:Test:index}

- In AppBundle adaugam un nou controller

Parțiale

- Reprezintă bucăți reutilizabile ale unui template.

- Sunt fișiere localizate în template-uri/directoare și conțin cod HTML cu cod PHP incorporat. Numele parțialelor încep întotdeauna cu “_” pentru a se distinge de template-uri, spre exemplu : “_nume partial.php“.

- Se folosesc parțiale atunci când se dorește afișarea unui conținut static sau în cazul în care toate datele care se doresc a fi afișate sunt pregătite deja.

Curs 6

Crearea unui proiect

Pentru acest tutorial vom folosi Symfony 2.7 deoarece e cea mai stabilă versiune.

Setăm ca workspace folder-ul xampp/htdocs.

Din Eclipse alegem File ->New->Symfony Project:

Trecem numele proiectului

La Symfony Version alegem versiunea 2.7 dev.

Apoi Next şi Finish

Configurarea bazei de date

Se editează fișierul app/config/parameters.yml corespunzător conexiunii cu baza de date

La database_name trecem numele bazei de date pe care vrem sa o creăm.

Utilizarea comenzilor PHP din Eclipse

Pentru utilizarea comenzilor php din mediul de dezvoltare Eclipse vom urma pașii:

1. Run->External Tools -> External Tools Configuration

2. Name: nume_comandă

3. Location: calea_către_php.exe

4. Working Directory: Browse Workspace -> Selectăm proiectul curent

5. Arguments: argumentele necesare comenzii

Apply

Run

Crearea unei baze de date

- In marea majoritate a cazurilor un site are în spate o bază de date în care se stochează datele afișate în diverse pagini.

- Nici Symfony nu face excepție.

- Pentru conectarea la diverse baze de date - Mysql, PostgreSQL, SQLite sau Microsoft SQL - se folosește librăria Doctrine.

Comanda pentru crearea bazei de date specificată în fișierul de configurare (parameters.yml): app/console doctrine:database:create

- app/console este înlocuit cu bin/console (pentru versiunea 3 de Symfony)

- Versiunea de Symfony se afla din folder-ul: vendor/symfony/symfony/src/ Symfony/Component/HttpKernel/Kernel.php

Dacă există deja o bază de date cu acest nume, mai întâi aceasta trebuie ștearsă: app/console doctrine:database:drop --force

Crearea unui tabel

- În directorul src se face un nou folder AppBundle, iar în cadrul său încă un folder Entity.

- Pentru a crea un tabel în baza de date este necesar să creăm o clasă .php corespuzătoare în folderul Entity (AppBundle\Entity)

- Clasa se va numi Job.php

- Entitatea - Job.php - e o clasă în care sunt descrise câmpurile unei tabele și va include metode de setare și afișare campuri.

- Se rulează comenzile folosind External Tools Configurations

Generarea de Getteri și Setteri pentru clasă: app/console doctrine:generate:entities AppBundle/Entity/Job

- Crearea tabelului si controller-ului aferente clasei php: app/console generate:doctrine:crud --entity=AppBundle:Job

- La opțiuni se alege:

AppBundle:Job

Yes

Enter

Annotations

Enter

- Se generează în folder-ul Controller o clasă JobController.php

- Se dă refresh pe proiect pentru a putea vedea clasa JobController.php.

- Se rulează comanda pentru persistarea datelor in baza de date: app/console doctrine:schema:update –force

- Se rulează comanda: bin/console generate:doctrine:form AppBundle:Job

- Se dă refresh pe proiect și vom vedea că au apărut următoarele fișiere:

pagini de bază pentru afișare(twig) în app/Resources/views/job

fișierul JobType.php în src/AppBundle/Form

- De asemenea sunt adăugate rute (descrieri ale acțiunilor definite) în fișierul Resources/config/routing.yml

- În proiect deschidem cmd și rulăm comanda: php bin/console debug:router pentru a vedea toate rutele.

- Apoi, pornim xampp(Apache şi MySQL )şi accesăm din browser: http://localhost:port/Numele proiectului nostru/web/app_dev.php/job

Formulare

Scopurile unui formlar sunt următoarele:

să ia date de la un obiect și să ofere un format potrivit pentru a putea fi generat într-un form HTML

să atribuie datele trimise de user la proprietățile unui obiect

- În urma comenzii pentru tabel se generează Form/JobType.php, răspunzătoare pentru crearea unui form asociat clasei Job și Controller/JobController.php ce conține metodele CRUD de tip action, și controlează adăugarea unei valori, afișarea, ștergerea, indexarea (afișarea liniei x)

- Un câmp se adaugă/îndepărtează prin: $builder->add('câmp')/$builder->remove('câmp')

- De asemenea, în Controller/JobController.php se regăsesc adnotările pentru rutare

- !Pentru Symfony 3, in Controller/JobController.php în metoda newAction modificăm: $form = $this->createForm(JobType::class, $job);

- Pentru Symfony 2 rămâne: $form = $this->createForm(new JobType(), $job);

TWIG

- Un șablon (template) este un fișier text care generează un răspuns în orice format text (HTML, XML, CSV ..) și care include un mix de text și cod PHP.

- Symfony include însă un limbaj de templating puternic numit Twig ce ne permite să scriem șabloane ușor și mai puternice decât un șablon clasic PHP.

- De asemenea Twig este și foarte rapid pentru că aceste șabloane sunt compilate în format nativ PHP și stocate în cache.

- De obicei aceste șabloane din proiect includ părți comune ca header, footer, bare laterale (sidebar) - definite sub formă de block-uri - ce pot fi reunite într-un șablon de bază care ulterior va fi extins / suprascris de către șablonul copil.

- Pentru a ordona elementele în pagină, se adaugă, în new.html.twig, la început: {% form_theme form 'bootstrap_3_horizontal_layout.html.twig' %}

- Iar pentru edit.html.twig se adaugă linia: {% form_theme edit_form 'bootstrap_3_horizontal_layout.html.twig' %}

- În JobType.php se șterg câmpurile ‘datetime‘

Se accesează în browser: http://localhost:port/numeproiect/web/app_dev.php/job

Validări

- Este nevoie sa avem siguranța că datele trimise sunt corecte.

- Validarea se aplica atât pentru datele într-un form, cât și înaintea introducerii de date în baza de date sau înainte de a fi pasate unui serviciu web.

http://symfony.com/doc/current/book/validation.html

- Se adaugă primele 2 linii în clasa Job.php, iar apoi validările pentru fiecare câmp:

- Se adaugă opțiunea de validarea prin adnotări în app/config/config.yml:

validation:      { enable_annotations: true }

- Dacă se încearcă în browser acum, vor intra înainte validările specifice HTML5. Pentru a le îndepărta, în src/AppBundle/Resources/views/job/new.html.twig se adaugă atributul novalidate:

{{ form(form, {'attr': {'novalidate': 'novalidate'}}) }}

- La fel şi pentru edit.html.twig:

{{ form(edit_form, {'attr': {'novalidate': 'novalidate'}}) }}

- În JobController.php se adaugă la început următoarea linii:

use Symfony\Component\HttpFoundation\Response;

use Symfony\Component\HttpFoundation\Request;

- Se adaugă în createAction() din JobController.php (după $form->handleRequest($request) ) codul de mai jos ce apelează metoda validate() pe toate entitățile.

- Se accesează formularul pe browser …/job/new și se trimite cu câmpurile goale. Se primește:

Object(AppBundle\Entity\Job).category: This value should not be blank.

Unit testing

- Teste generate de Doctrine

În C:\xampp\htdocs\Numeproiect rulăm: phpunit -c app

– ruleaza toate testele din phpunit.xml.dist

- ! Code coverage can be generated with the --coverage-* options

- Teste scrise manual (pentru forms)

În src/AppBundle/Tests creăm /Util/JobTest.php - clasa de test ce verifică dacă cele două câmpuri ale formularului sunt trimise.

- Pentru rularea testelor în htdocs: php phpunit -c src/AppBundle/Tests/Util/JobTest.php

http://symfony.com/doc/current/book/testing.html

Bibliografie Curs 6

http://cgherman.go.ro/articole/conectare-la-baza-de-date-tutorial-symfony/

http://symfony.com/doc/current/book/forms.html

http://cgherman.go.ro/articole/utilizare-sabloane-tutorial-symfony/

http://symfony.com/doc/current/book/validation.html

http://symfony.com/doc/current/book/testing.html

Curs 7

Ce este un Unit Test?

- Testarea unitară reprezintă o modalitate de testare care verifică dacă unităţile individuale de cod au comportamentul aşteptat. Se consideră o unitate o componentă software minimală care poate fi testată. În cazul programării orientate obiect metodele sunt considerate cele mai mici elemente care pot fi supuse testării unitare. Scopul testării unitare este de a izola fiecare unitate de restul sistemului şi de a stabili dacă specificaţiile corespunzătoare fiecărei unităţi au fost corect implementate. Printre beneficiile oferite de testarea unitară se enumeră faptul că poate fi utilizată într-o abordare de jos în sus pentru a facilita testarea la integrare.

- Această abordare se concentrează asupra intrărilor, ieşirilor şi funcţionalităţii modulelor software.

- Testarea funcţională (Functional Testing) este procesul de asigurare a calităţii software-ului şi este un tip de testare black box care se bazează pe scenariile de teste care acoperă specificaţiile proiectului supus testării. Funcţiile sunt testate prin introducerea diferitelor date de intrare şi analiza rezultatelor de ieşire. Structura internă a programului este rareori luată în considerare (nu ca şi în white-box testing). Testarea funcţională descrie de obicei ce face sistemul.

Instalarea PHPUnit

1. Se creează în C:\ fişierul bin (C:\bin); 2. Control Panel\System and Security\System\Advance System Settings\Advanced\Environment Variables…

3. Se copiază în C:\bin\phpunit.phar

4. Din linia de comandă se rulează următoarele comenzi:

5. Pentru a verifica că instalarea a decurs fără probleme se apelează comanda phpunit –version

Exemplu

Exemplu aplicaţie cu Unit Tests

- Se creează un proiect nou Symfony( de ex: FirstUnitTests), ce va avea următoarea structură:

- În src\AppBundle\Util se creează fişierul Calculator.php unde se vor vor scrie metodele (fiecare metodă având 2 parametrii) de:

Adunare

Scădere

Înmulţire

Împărţire(dacă al doilea parametru este zero, atunci metoda va arunca o excepţie)

- În src\AppBundle\Tests\Util se creează fişierul CalculatorTest ce derivă din \PHPUnit_Framework_TestCase

- În antetul fişierului adăugăm: use AppBundle\Util\Calculator;

- În acest fişier testăm metodele implementate în Calculator.php

Exemplu: testAdd() (testul trece)

assertEquals primeşte 2 parametri

Primul parametru este rezultatul la care ne aşteptăm

Al doilea parametru este rezultatul obţinut în urma apelării metodei

În cazul în care cei doi parametrii diferă, atunci testul va pica

Exemplu: testDivide() (testul aruncă o excepţie)

Pentru a rula testele trebuie să verificăm în fişierul app\phpunit.xml.dist existenţa căii de legatură către fişierul cu teste

Rularea Testelor

Rularea Unit Testelor

- Se porneşte XAMPP

- Click pe butonul Shell

- Ne ducem în folderul proiectului creat

- Şi se execută comanda: phpunit –c app src\AppBundle\Tests\Util\CalculatorTest.php

Rezultatul în urma rulării testelor

Functional Testing

- Un exemplu de test funcţional este generat odată cu crearea unui nou proiect, acesta aflându-se în src\AppBundle\Tests\Controller\DefaultControllerTest.php

- Acest test verifică dacă pagina de pornire conţine textul “Welcome to Symfony”

- Pentru a exemplifica mai mult testarea funcţională, vom reveni la proiecutl din cadrul laboratorului 5

- În src\AppBundle\Tests\Controller avem fişierul OrdersControllerTest

- Aici vom testa încărcarea corespunzătoare a două pagini, precum şi navigarea de pe o pagină pe alta

Bibliografie Curs 7

https://phpunit.de/manual/current/en/phpunit-book.pdf

http://symfony.com/doc/current/book/testing.html

https://phpunit.de/getting-started.html

http://www.sitepoint.com/functional-testing-symfony2

http://code.tutsplus.com/tutorials/basic-functional-testing-with-symfony-2s-crawler--cms-20666

http://www.theodo.fr/blog/2011/09/symfony2-unit-database-tests

http://tutorial.symblog.co.uk/docs/testing-unit-and-functional-phpunit.html

http://www.slideshare.net/fabpot/unit-and-functional-testing-with-symfony2

Curs 8

Instalarea composerului,crearea proiectului,conexiunea DB

- Instalarea composerului se va efectua prin accesarea: https://getcomposer.org/download/

- Vom crea un proiect Symfony utilizand linia de comanda: composer create-project symfony/framework-standard-edition sfEasyAdmin 2.7.*

- La sfarsitul procesului de instalare vom configura conexiunea DB prin introducerea liniei de comanda in folderul proiectului: php app/console doctrine:database:create

- Dupa configurarea conexiunii trebuie sa activam app translator in fisierul : app/config/config.yml adaugand:

framework:

translator: { fallback: "%locale%" }

- Vom avea nevoie de cel putin o entitate, astfel vom crea o clasa User goala care mai tarziu va fi extins la modelul FOSUser (Aceasta clasa ne va permite accesul la restrictionarile aplicatiei noastre):

- Vom scrie in linia de comanda urmatoare: php app/console doctrine:generate:entity --entity=AppBundle:User --format=annotation --fields=" " --no-interaction

- Pentru o gestiune mai usoara vom instala FOSUserBundle

Instalarea si configurarea FOSUserBundle

https://symfony.com/doc/master/bundles/FOSUserBundle/index.html

- Descarcam FOSUserBundle folosind composerul: composer require friendsofsymfony/user-bundle "~2.0@dev"

- Activam Bundle-ul:

Crearea clasei User

Clasa User poate contine proprietati si metode customizate de utilizator. Entitatea poate fi creata cu ajutorul unor clase predefinite ale Bundle-ului:

- Extinderea clasei de baza User (cu ajutorul Model folder daca folosim doctrine ca variant).

- Mapam campul id care trebuie protejat ca si cum ar fi fost mostenit din clasa parinte.

Configurarea fisierelor

Configurarea fisierului aplicatiei security.yml

- Vom accesa fisierul security.yml si il vom configura astfel:

- Adaugam configuratia urmatoare la fisierul config.yml

- Importarea fisierelor de rutare pentru FOSUserBundle

- Pentru a putea utiliza functionalitatile email-ului (confirmarea contului si resetarea parolei) trebuie sa activam si configuram SwiftmailerBundle

- Actualizarea informatiilor in urma initializarii clasei User. Dupa configurarea Bundle-ului va trebui sa actualizam baza de date deoarece am creat o noua clasa User.

Pentru ORM executam urmatoarea comanda: php app/console doctrine:schema:update --force

- Pentru a verifica functionalitatea aplicatiei vom accesa: http://localhost:81/sfEasyAdmin/web/app_dev.php/login (sfEasyAdmin = numele aplicatiei)

- Dupa verificarea functionalitatii aplicatiei vom avea nevoie de un User cu ROLE_ADMIN pentru a a avea acces de admin la aplicatie.Vom realiza accesul prin comenzile:

php app/console fos:user:create admin dnovac admin //dnovac -numele user//admin –parola

php app/console fos:user:promote admin ROLE_ADMIN

- Urmatorul pas este cel de a genera o entitate Customer pentru stocarea datelor utilizatorului:

php app/console doctrine:generate:entity --entity=AppBundle:Customer --format=annotation --fields="name:string(255) firstName:string(255) lastName:string(255) phone:string(100) email:string(100) companyName:string(255) website:string(255) note:text" --no-interaction

- Putem face legaturile in baza de date si anume:

Un user poate avea mai multi customers

Un customer are un singur user

- In entitatea User vom adauga proprietatiile din fisierul $customers salvat local.

- In entitatea Customer vom adauga proprietatiile din fisierul $user salvat local.

- Dupa adaugarea noilor entitati si setarea relatiilor va trebui sa actualizam schema DB prin:

php app/console doctrine:schema:update –force

Daca intampinam probleme dupa executia comenzii stergem: function __construct() din fisierul User.php

- In directorul proiectului vom executa comanda: composer require javiereguiluz/easyadmin-bundle pentru a putea realiza instalarea de EasyAdmin bundle.

- Activarea se va face dupa instalarea bundle-ului utilizand linia de comanda in fisierului app/AppKernel.php : new JavierEguiluz\Bundle\EasyAdminBundle\EasyAdminBundle(),

- Rutele se vor incarca in fisierul: app/config/routing.yml adaugand:

- Vom instala Web Assets executand comanda: php app/console assets:install –symlink

- Dupa procesul de instalare vom putea configura entitatile pentru EasyAdmin.Vom adauga in fisierul app/config/config.yml urmatoarele linii:

Testarea aplicatie

- Pentru a accesa aplicatia creata vom accesa link-ul:

http://localhost/sfEasyAdmin/web/app_dev.php/admin

- Folosind credentialele:

user: admin

parola: admin

Bibliografie Curs 8

http://level7systems.co.uk/en/symfony2-admin-panel-in-30-seconds/

https://symfony.com/doc/master/bundles/FOSUserBundle/index.html

Curs 9

Swift Mailer

- Swift Mailer se integreaza in orice aplicatie web scrisa in PHP 5.

- Ofera o abordare obiect-orientata pentru trimiterea e-mailurilor.

Instalare Swift Mailer

- Pentru instalarea Swift Mailer trebuie instalat mai intai composerul.

Se deschide o fereastra cmd

Se navigheaza la calea catre c:\xampp\php

Se foloseste comanda: php -r "readfile('https://getcomposer.org/installer');" | php

- Instalarea Swift Mailer se face cu urmatoarea comanda: php composer.phar require swiftmailer/swiftmailer @stable

Crearea proiectului in eclipse

- Se creeaza un nou proiect Symfony in Eclipse cu numele TestEmail.

- Se valideaza proiectul: properties->validation: enable project specific settings-se bifeaza, se debifeaza XML Schema Validator si XML Validator.

- Apoi click dreapta pe proiect si Validate.

- Apoi se creeaza un nou bundle

Crearea unui nou bundle

- Se deschide o fereastra cmd

- Se navigheaza la calea catre proiect C:\xampp\htdocs\TestEmail

- Se ruleaza urmatoarea comanda: php app/console generate:bundle --namespace=MailBundle --format=yml

Configurarea fisierelor parameters.yml

- In fisier se copiaza urmatorul cod:

Pentru acest exemplu am creat o adresa de gmail: test.mail.symfony.curs@gmail.com cu parola symfonytest.

Host-ul de gmail este: smtp.gmail.com

Configurare Swift Mailer

- Configurarea pentru Swift Mailer se afla in fisierul config.yml.

- Vom modifica aceasta configurare cu:

Rutarea

- In MailBundle\Resources\config\routing.yml adaugam:

Modificare controller

- In MailBundle\Controller\DefaultController adaugam urmatoarea actiune:

Crearea view-urilor

- Vom crea 2 view-uri: unul pentru formularul de trimitere de e-mail si celalalt pentru afisarea unui mesaj de succes.

sendMail.html.twig

- In MailBundle\Resources\views\Default cream un nou view pe care il numim sendMail.html.twig

- Acest view va contine:

emailSent.html.twig

Accesarea paginii

- In browser se acceseaza:

http://localhost:81/TestEmail/web/app_dev.php/sendMail

Sau

http://localhost/TestEmail/web/app_dev.php/sendMail

Probleme Întâlnite

Eroare 1

Solutie: In fisierul: vendor/sensio/generator-bundle/Resources/skeleton/form/FormType.php.twig Linia 29 {%- if fields_mapping[field]['type'] in ['date', 'time', 'datetime'] %} Va fi modificata cu: {%- if fields_mapping[field] is defined and fields_mapping[field]['type'] in ['date', 'time', 'datetime'] %}

Eroare 2

Solutie: Trebuie modificat in AppBundle\Entity\Controller\ProductController.php getId cu getIdproduct deoarece getId este cel generat default iar in acest caz a fost modificat cu getIdproduct

Eroare 3

Solutie: Se va adauga in clasa AppBundle\Entity\Utilitati.php functia __toString()