Introduction :

Symfony est un framework PHP , il permet de mettre rapidement une structure MVC en oeuvre. Il est accompagner de divers module tel que :

• var_dumper
• swiftmailer... (voir tous les modules dans le fichier composer.json)

Il n'y a pas de compatibilité entre symfony 3 et symfony 4. L'installation ce passe sur composer

Les pré-requis :

• PHP 7.xx+
• SQLite
• Composer

Guide d'utilisation :

Nouveau projet :

Pour créer un nouveau projet avec la structure de base vous allez dans votre dossier SITE/. Ouvrez une console de commandes dans laquelle vous inscrirez : composer create-project symfony/website-skeleton <NomDuDossier>
Cela va créer toute la structure de base MVC/Symfony.

Récupérer un projet :

• Faire un clone du projet souhaiter dans votre dossier de travail
• Ajoutez le dossier vendor avec la commande composer update

Démarrer le serveur :

Pour démarrer le serveur plusieurs options s'offrent à nous :

• Via docker

• Via Wamp/Xamp/Lamp

• Via symfony server Utiliser la commande: php bin/console server:run

De base le serveur s'ouvre sur le port 8000 , on peut changer le port du serveur de cette mannière : php bin/console server:run <N° du port>

Les commandes de symfony :

Le framework s'utilise avec la commande php bin/console

Commandes principales :

• php bin/console --version : Affiche la version de Symfony
• php bin/console server:run 8000 : Démarre un serveur local sur le port 8000

Make :

• php bin/console make:controller : Créer un nouveau controller
• php bin/console make:entity : Créer une nouvelle entitée
• php bin/console make:form : Créer une nouvelle class Form
• php bin/console make:migration : Creates a new migration based on database changes
• php bin/console make:fixtures : Créer une nouvelle class pour charger les fixtures

Doctrine :

• php bin/console doctrine:migration : Créer les tables de la BDD
• php bin/console doctrine:migrations:migrate : Pousse les données en BDD
• php bin/console doctrine:mapping:info : Voir les tables créées

Fixtures :

• php bin/console fixtures:load : Charge les fixtures dans la base de données

Base de données :

Symfony utlise Doctrine ORM qui est une interface entre Mysql et php. ORM : Object Relational Mapping Ce n'est donc pas du SQL mais des objets associés à la base SQLite est une base de données qui n'est pas en ligne , c'est un fichier nommé data.db. C'est un fichier qui peut très vite devenir très lourd car ce n'est pas un fichier scalable. Il est plus rapide d'accès car nous ne passons pas par un serveur mais directement depuis le fichier donc il n'y à que la latence de lecture/écriture.

Pour lié une base de donnée au projet 2 solutions :

• docker
• locale Aller la le fichier .env Dans le fichier .env trouver la ligne correspondant à DATABASE_URL Remplacer par DATABASE_URL=sqlite:///%kernel.project_dir%/var/data.db

Pour voir votre base de donnée , rendez-vous sur https://sqliteonline.com/. Cliquez sur l'onglet file -> openDB : selectionnez votre fichier data.db disponible dans le dossier www/var/data.db

Votre BDD est à présent charger dans SQLiteOnline.com

Les routes :

La définitions des routes dans Symfony ce situe au niveau du contrôlleur , dans une annotation @Route suivi du chemin relatif et du nom de la route.

class BlogController extends AbstractController
{
    /**
     * @Route("/blog", name="blog")
     */
    public function index()
    {
        return $this->render('blog/index.html.twig', [
            'controller_name' => 'BlogController',
        ]);
    }
}

Attention ! Il existe un fichier src/config/routes.yaml où l'on trouve les définitions des autres routes mais les routes des annotations sont prioritaires.

Les Fixtures :

Les fixtures nous servent à générer des données (souvent aléatoires) dans la base de données, pour le développement.

Pour créer le dossier des fixtures , on fait appel à composer : composer req orm-fixtures qui créer src/dataFixtures/

Ensuite on créer le fichier par la commande : php bin/console make:fixtures <nom>Fixtures qui créer src/dataFixtures/Fixtures

Les annotations :

/**
* @ORM\Id()
* @ORM\GeneratedValue()
* @ORM\Column(type="integer")
*/

Ceci n'est pas un commentaire mais une annotation. Elles nous servent à donnée des indications pour symfony. Les annotations sont dans un commentaire suivi de @ Attention les annotations ne prennent pas en charge les cotes simples.

Fonction create()

Nous allons créer une fonction pour créer de nouveaux articles

Notes (à reprendre)

Ensuite vous allez créer vos controller pour cela la démarche est quasiment identique : php bin/console make:controller Pour faire les dossier nécéssaires pour les controllers : php bin/console make:controller

Fixtures n'est fait que pour les fausses données de développement. Fixure n'est pas directemment intégrer à symfony il faut alors le composer : composer orm-fixtures

$manager->persist($article); Nous permet de faire perssister l'objet.

php bin/console doctrine:fixtures:load Nous permet de pousser les données en BDD

Création d'un formuaire

Pour créer les fomulaires nous utiliserons la commande : php bin/console make:form <nom>Type Symfony nous demandera de choisir une entitée à qui lié le fomulaire.

public function create(Request $request, ObjectManager $manager){
        // Instance un nouvel Article
        $article = new Article();
        // Définition du formulaire
        $form = $this->createForm(ArticleType::class, $article);

        $form->handleRequest($request);

        if($form->isSubmitted() && $form->isValid()){
            $article->setCreatedAt(new \DateTime())
            ->setCreatedAt(new \DateTime());

        $manager->persist($article);
        $manager->flush();
        
        return $this->redirectToRoute('blog_show', ['id'=> $article->getId()]);
        }
        return $this->render('blog/new.html.twig', [
            'formArticle' => $form->createView()
        ]);
    }

Une méthode qu'on utilisera uniquement pour la gestion des formulaires

handleRequest() nous sert pour hydrater l'objet

Inscription Parti cours 07/10/2019

Pour faire la connexion :

Faire un fomulaire : soit en dur , soit déclarer un nouveau form avec la commande php bin/console make:form

Pour la connenxion comme d'habitude nous avons besoin de 3 champs :

• le mail
• le nom d'utilisateur
• le mot de passe

Il faut donc créer l'utilisateur (entitée) avec la commande : php bin/console make:entity Et donner les champs le composant.

Dans le controller ajout d'une fonction Registration(Request $request, ObjectManager $manager){}

     /**
     * @Route("/inscription", name="inscription")
     */
    public function Registration(Request $request , ObjectManager $manager)
    {
        // Appel d'un nouvel objet $user
        $user = new Users();
        // Création d'un formulaire lié au fichier RegistrationType lui passant la variable $user
        $form = $this->createForm(RegistrationType::class, $user);
        
        $form->handleRequest($request);
        // Condition de vérification du formulaire , s'il à été soumis est valide
        if($form->isSubmitted() && $form->isValid()){
            // On fait persister les données
            $manager->persist($user);
            // On pousse les données
            $manager->flush();
            // On retourne une redirection de page
            return $this->redirectToRoute('login');
        }
        // Retour de la vue inscription
        return $this->render('inscription/index.html.twig', [
            'form' => $form->createView(),
        ]);
    }

Ne pas oublier de déclarer les Use.

Pour faire la vérification des inputs

Symfony est de base assez bien sécurisé , mais nous allons quand même ajouter une couche : https://symfony.com/doc/current/validation.html

Dans le fichier d'entitée Ajout de la ligne // ... use Symfony\Component\Validator\Constraints as Assert; dans le fichier entité : /Entity/Article.php

Cela va nous permettre de faire des vérification sur les inputs.

Il faut ajouter @Assert dans l'annotation correspondante à la vaérification Par exemple pour vérifier que l'utlisateur donne un titre de minimum 10 et maximum 255 caractères et qu'on lui donne l'indication si il ne rempli pas les conditions :

@Assert\Length(
     *      min=10,
     *      max=255, minMessage="Titre trop court"

Encodage du mot de passe

La sécurité dans symfony ce gère dans un fichier particulier : config/package/security.yaml

Il faut paramétrer notre encodeur symfony , pour cela ajouter les lignes suivante au fichier security.yaml

encoders:
        App\Entity\User:
            algorithm: argon2i

Doc symfony Encodage password

Il faut ajouter les méthodes à notre fichier Entity :

public function getRoles(){

    }

    public function getSalt(){

    }

    public function eraseCredentials(){
        
    }

Dans le controller on code le hashage du mot de passe :

// Cryptage du mot de passe
            $hash = $encoder->encodePassword($user, $user->getPassword());
            // Hashage du mot de passe
            $user->setPassword($hash);

Pour vérifier si l'email existe :

Pour faire la vérification lors de l'inscription , savoir si notre utlisateur qui s'inscrit à déjà son adresse mail d'enregistrer il faut ajouter une annotation à l'entité : @UniqueEntity(fields={"usermail"}, message="L'e-mail existe déjà pov'naze")

Pour vérifier que les mot de passes correspondent :

La vérification ce fait une fois de plus grâce aux annotations à l'aide du @Assert\EqualTo(propertyPath="")

     /**
     * @Assert\EqualTo(propertyPath="confirm_password")
     */
    private $password;
    
    /**
    * @Assert\EqualTo(propertyPath="password", message="Les mots de passe doivent correspondrent")
    */
    public $confirm_password;

Pour créer un boutton de déconnection :

Connection :

Pour la connection il faut bien faire attention à ce que dans les inputs le name soit bien défini avec _username et _password

Commandes Symfony

php bin/console doctrine:schema:update --force pour pusher les données en base (sous docker)