php bin/console debug:autowiring --all

Dans service.yaml, ajouter le service que le container doit prendre en compte si ce dernier ne se situe pas dans le dossier /src :
cebe\markdown\Markdown: ~


16 - Conteneur de service

composer req cors

- Dans le fichier nelmio_cors.yaml, on peut maintenant modifier les paramètres :

nelmio_cors:
    defaults:
        origin_regex: true
        allow_origin: ['%env(CORS_ALLOW_ORIGIN)%']
        allow_methods: ['GET', 'OPTIONS', 'POST', 'PUT', 'PATCH', 'DELETE']
        allow_headers: ['Content-Type', 'Authorization']
        expose_headers: ['Link']
        max_age: 3600000
    paths:
        '^/': null


CORS suite à un problème de fetch

//[GitHub - dunglas/mercure: Server-sent live updates: protocol and reference implementation](https://github.com/dunglas/mercure)
// Télécharger le logiciel dans le dossier qui accueillera la fonctionnalité

// Si on lance l'executable sans paramètre, ça ne fonctionnera pas :
./mercure/mercure
-> nécessite une clé JWT
// [Pushing Data to Clients Using the Mercure Protocol (Symfony Docs)](https://symfony.com/doc/current/mercure.html)

Pour lancer le serveur :
$ SERVER_NAME=:3000 MERCURE_PUBLISHER_JWT_KEY=’!ChangeMe!’ MERCURE_SUBSCRIBER_JWT_KEY=’!ChangeMe!’ ADDR='localhost:3000' ALLOW_ANONYMOUS=1 CORS_ALLOWED_ORIGINS="http://localhost:8000" ./mercure run -config Caddyfile.dev

Le serveur tourne bien sur localhost:3000

Sur Postman, utiliser l'url : http://localhost:3000/hub
- Ajouter le token d'autorisation avec le Bearer
- Utiliser jwt.io pour créer le token
- Ajouter le topic, dans le body : choisir une structure en form url Encoded
- topic   ping
- data    0

Avec ça, on peut envoyer des évènements.
Il faut ensuite ajouter des eventListener sur le navigateur pour la gérer la partie écoute 

- Ajouter le JS pour écouter:
// The subscriber subscribes to updates for the https://example.com/users/dunglas topic
// and to any topic matching https://example.com/books/{id}
const url = new URL('http://localhost:3000/hub');
url.searchParams.append('topic', 'https://example.com/ping');
// The URL class is a convenient way to generate URLs such as https://localhost/.well-known/mercure?topic=https://example.com/books/{id}&topic=https://example.com/users/dunglas

const eventSource = new EventSource(url);

// The callback will be called every time an update is published
eventSource.onmessage = e => console.log(e); // do something with the payload
-> les informations reçues peuvent être lues dans le message event

-> bonus Tip : on peut stocker le résultat d'une variable dans l'inspecteur en faisant click droit sur l'object puis "store as global variable". Une variable se créé est devient accessible.

Reprendre à 10:21

Protocole Mercure

composer create-project symfony/website-skeleton my-name-App-> créer la structure
composer require server --dev	-> Pour SF4.4, nécessite cette commande pour
php bin/console server:run		-> lancer l’application en local sur le serveur
symfony server:start -> à partir de SF5
yarn encore dev --watch

php bin/console doctrine:database:create 		-> Créer la BDD
php bin/console make:entity					-> créer une entité
php bin/console make:migration				-> créer fichiers de migration
php bin/console doctrine:migrations:migrate		-> Opérer la migration / --dry-run pour la prod ?
symfony check:security                                           -> détecter vulnérabilités dans les fichiers
/**
* @ORM\Column(type="boolean", options={"default": "0"})
*/

Dans twig : 
{% include 'blog/content.html.twig' %} -> inclure un bout de code
{% form_theme formArticle 'bootstrap_4_layout.html.twig' %} -> inclure bootstrap pour son formulaire
Appeler un chemin dans twig : <a href="{{path("article", {'id': article.id })}}">Lire</a>

2 - Base de Symfony - démarrer

// 2eme solution pour implémenter ReactJS dans Symfony

// -> reprendre tous les points jusqu'à l'installation des dépendances yarn. A partir de la configuration dans webpack.config.js

Dans le dossier assets, supprimer les fichiers et dossiers.
Vérifier qu'on soit dans le dossier assets, on peut y créer notre app ReactJS (ici nommée my-app)
<§yarn create react-app my-app§>

// Dans le webpack.config.js, enable react et diriger le point d'entrée sur src/index.js
<§
.enableReactPreset()
.addEntry('app', './assets/my-app/src/index.js')
§>

// Dans src/App.js, il peut y avoir une erreur dans le lancement si React n'est pas importé.
<§import React from 'react'
import logo from './logo.svg';
import './App.css';

function App() {
  return (
    <div className="App">
      <header className="App-header">
        <img src={logo} className="App-logo" alt="logo" />
      </header>
    </div>
  );
}

export default App;
§>

// Démarrer serveur JS
<§yarn encore dev-server§>

Avec le navigateur on devrait ainsi pouvoir arriver sur l'appli sans erreur.

Créer projet SF avec create-react-app

[Error 404 (Introuvable)!!1](https://www.google.com/recaptcha/admin/create -> enregistrer le site 
composer require google/recaptcha "^1.2"
Entrer les clés du site et clé secrètes (prod et dev)
Clé de dev passe partout :
GOOGLE_RECAPTCHA_SITE_KEY=6LeIxAcTAAAAAJcZVRqyHh71UMIEGNQ_MXjiZKhI
GOOGLE_RECAPTCHA_SECRET=6LeIxAcTAAAAAGG-vFI1TnRWxMZNFuojJ4WifJWe

Créer l'entité requise (pas forcément liée à la BDD) : make:entity
Créer le formulaire nécessaire basé sur l'entité : make:form
Ajouter dans le contrôleur :
        if ($form->isSubmitted()){
            $recaptcha = new \ReCaptcha\ReCaptcha($_SERVER['GOOGLE_RECAPTCHA_SECRET']);
            $resp = $recaptcha->verify($_POST['g-recaptcha-response'], $_SERVER['REMOTE_ADDR']);
        
            // if ($resp->isSuccess()) {
            //     dump($resp->isSuccess());

            // } else {
            //     $errors = $resp->getErrorCodes();
            //     dump($errors);
            // }
            
            if(!$resp->isSuccess()){
                $this->addFlash('success', 'Captcha invalide');
            }
        }
Ajouter dans la base.html.twig:
<script src="https://www.google.com/recaptcha/api.js" async defer></script>
Ajouter dans le formulaire : 
<div class="g-recaptcha" data-sitekey="6Lfjg8gUAAAAAJLTNvdMtPNrxysJ6vi0iqu9dxsR"></div>
)



11 - Ajouter un captcha


Jouer avec le JS et le CSS : méthode utilisant Encore (bonne pratique)
composer require symfony/webpack-encore-bundle 	->installer dossier assets (CSS/JS)
yarn install
ajouter {{ encore_entry_link_tags('app') }} et {{ encore_entry_script_tags('app') }} dans les blocs du template base.html.twig
ajouter le nom des fichiers dans le fichier webpack.config.js : .addEntry('app', './assets/js/nom_de_mon_fichier.js')
yarn encore dev								-> pour compiler les assets une seule fois
yarn encore dev --watch 						-> à faire si on modifie les fichiers CSS/JS à chaque sauvegarde
Ajouter les fichiers nécessaires dans le dossier JS/CSS et les modifier à notre guise

Autre solution (plus simple) : créer les fichiers dans public/css/style.css et appeler link href="style.css"

Pour compiler les images:
- Installer dossier assets (voir JS/CSS plus haut)
- Mettre les images dans le dossier : public/images
-  ajouter dans assets/js/_main.js :
const imagesContext = require.context('../images', true, /\.(png|jpg|jpeg|gif|ico|svg|webp)$/);
imagesContext.keys().forEach(imagesContext);
- Ajouter les images dans le manifest.json 



3 - Jouer avec le JS et le CSS

Créer une entity user : php bin/console make:user
dans le fichier security.yaml  :
        main:
            anonymous: lazy
            provider: app_user_provider	-> le provider app_user_provider a créé automatiquement avec la commande 

            form_login: 
                login_path: login	-> la route login est la même pour afficher le formulaire et se connecter
                check_path: login
            logout:
                path: logout
                target: home		-> nom de la route à suivre après logout

Faire un formulaire d'authentification:
php bin/console make:auth

Dans un contrôleur :
    /**
     * @Route("/login", name="app_login")
     */
    public function login(AuthenticationUtils $authenticationUtils): Response
    {
        // if ($this->getUser()) {
        //     return $this->redirectToRoute('target_path');
        // }

        // get the login error if there is one
        $error = $authenticationUtils->getLastAuthenticationError();
        // last username entered by the user
        $lastUsername = $authenticationUtils->getLastUsername();

        return $this->render('security/login.html.twig', ['email' => $email, 'error' => $error]);
    }

    /**
     * @Route("/logout", name="app_logout")
     */
    public function logout()
    {}

Puis dans twig :
<form method="post">
    {% if error %}
        <div class="alert alert-danger">{{ error.messageKey|trans(error.messageData, 'security') }}</div>
    {% endif %}

    {% if app.user %}
        <div class="mb-3">
            You are logged in as {{ app.user.username }}, <a href="{{ path('app_logout') }}">Logout</a>
        </div>
    {% endif %}

    <h1 class="h3 mb-3 font-weight-normal">Please sign in</h1>
    <label for="inputEmail">Email</label>
    <input type="email" value="{{ last_username }}" name="email" id="inputEmail" class="form-control" required autofocus>
    <label for="inputPassword">Password</label>
    <input type="password" name="password" id="inputPassword" class="form-control" required>

    <input type="hidden" name="_csrf_token"
           value="{{ csrf_token('authenticate') }}"
    >

    {#
        Uncomment this section and add a remember_me option below your firewall to activate remember me functionality.
        See https://symfony.com/doc/current/security/remember_me.html

        <div class="checkbox mb-3">
            <label>
                <input type="checkbox" name="_remember_me"> Remember me
            </label>
        </div>
    #}

    <button class="btn btn-lg btn-primary" type="submit">
        Sign in
    </button>
</form>

Plus d'info : https://symfony.com/doc/current/security/form_login_setup.html

Créer un formulaire lié à l'entity User :
php bin/console make:form
Ajuster la session :
https://symfony.com/doc/current/reference/configuration/framework.html


6 - Pour jouer sur les sessions

bin/console debug:autowiring cache

// On peut utiliser l'injection de dépendance avec l'objet CacheInterface 
<§
$value = $cache->get('resultat-calcul-long-en-cache', function (ItemInterface $item){
  // Si la valeur n'y est pas, on réalise le calcul
  $item->expiresAfter(3600)
  return  $this->fonctionQuiPrendDuTemps();
})
§>

Gestion du cache

[Symfony, High Performance PHP Framework for Web Development](https://symfony.com/doc/current/translation.html
https://symfony.com/doc/current/translation/locale.html
https://symfony.com/doc/current/translation/templates.html
https://symfony.com/doc/current/routing.html#routing-locale-parameter
composer require symfony/translation
Ajouter dans le fichier config/packages/translation.yaml
framework:
    default_locale: 'fr'
    translator:
        default_path: '%kernel.project_dir%/translations'
Créer les fichiers messages.fr.yaml et messages.en.yaml dans le dossier translation
Ajouter les traductions dans les fichiers (attentions aux ":" qui peuvent créer des erreurs)
Ajouter dans twig les balises : {% trans %}Symfony Like{% endtrans %}
)


15 - Traduire le site

Utiliser la commande ->mailcatcher  sur le terminal pour recevoir les mails: smtp://127.0.0.1:1025 et les visualiser sur le http://127.0.0.1:1080
Vérifier le .env pour définir les informations sur le compte à utiliser :
MAIL_USERNAME=johan@gmail.fr
MAIL_PASSWORD=mySecretPassword
MAIL_SERVOR_SEND=ssl0.ovh.net
MAILER_DSN=smtp://$MAIL_USERNAME:$MAIL_PASSWORD@$MAIL_SERVOR_SEND


13 - Envoyer des mails

source : https://github.com/dustin10/VichUploaderBundle/blob/master/docs/index.md
doc : https://github.com/dustin10/VichUploaderBundle/blob/master/docs/usage.md
composer require vich/uploader-bundle	-> choisir "y" pour exécuter la recette
- ajouter dans vich_uploader.yaml :
    mappings:
        article_image:
            uri_prefix: /img/articles
            upload_destination: '%kernel.project_dir%/public/img/articles'
            namer: Vich\UploaderBundle\Naming\UniqidNamer
-> C’est là où l’on placera les images et que nous définirons les noms

- Sur l’entité, ajouter:
namespace App\Entity;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\HttpFoundation\File\File;
use Vich\UploaderBundle\Mapping\Annotation as Vich;
use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Component\HttpFoundation\File\UploadedFile;

 * @Vich\Uploadable()							-> a ajouter dans l’annotation de la classe

et les propriétés :
    /**
     * @var string|null
     * @ORM\Column(type="string", length=255)
     */
    private $filename;

    /**
     * @var File|null
     * @Assert\Image(mimeTypes={"image/jpeg", "image/png", "image/jpg"})
     * @Vich\UploadableField(mapping="article_image", fileNameProperty="filename")
     */
    private $imageFile;
----------------------------------------
    /**
     * @return null|string
     */
    public function getFilename(): ?string
    {
        return $this->filename;
    }

    /**
     * @param null|string $filename
     * @return Article
     */
    public function setFilename(?string $filename): Article
    {
        $this->filename = $filename;

        return $this;
    }

    /**
     * @return File|null
     */
    public function getImageFile(): ?File
    {
        return $this->imageFile;
    }

   /** 
    * @param null|File $imageFile
    * @return Article 
    */
    public function setImageFile(?File $imageFile): Article
    {
        $this->imageFile = $imageFile;
        if ($this->imageFile instanceof UploadedFile) {
            $this->updatedAt = new \DateTime('now');
        }
        return $this;
    }
--------------------------------------------
- Dans le buildForm(articleType.php) :   
            ->add('imageFile', FileType::class,[
                'required' => false
            ])
	-> et ne pas oublier d'importer la classe

- Dans le formulaire du contrôleur :     ->add('imageFile', FileType::class)
- Dans le fichier twig contenant le formulaire :
        {{ form_start(formArticle) }}
            {{ form_errors(formArticle) }}
            {{ form_row(formArticle.title) }}
            {{ form_row(formArticle.imageFile) }}
            {{ form_row(formArticle.content) }}
            <input type="submit" value="Envoyer">
        {{ form_end(formArticle) }}

- Afficher le fichier twig : <img src="{{ vich_uploader_asset(article, 'imageFile') }}" alt="card" style="width:100%;height:auto">


8 - Gestion de l’upload

12 - Ajouter des charts, drop zone, cropperJS, LazyImage, Swup

Utiliser la doc de Symfony UX : https://github.com/symfony/ux



Test unitaires
Permet de valider une unité de code ou bien une méthode
PHPUnit permet de répondre à ce besoin

Tests fonctionnels
Permet de tester une classe dans un contexte spécifique
PHPUnit permet de répondre à ce besoin

Tests end to end
Tester l'application comme un utilisateur
Behat / Puppeteer / Cypress permettent de répondre à ce besoin

<§php bin/phpunit §>   -> pour lancer la commande des tests
php bin/phpunit --filter UserRepositoryTest -> tester qu'une seule partie
//// Tester une bdd ---------------------------------------

// créer des fixtures
<§composer require fzaninotto/faker§>
<§composer require orm-fixtures --dev§>
-> demander outils de fixtures
<§php bin/console make:fixtures§>
-> créer jeu de fixture

<§php bin/console doctrine:fixtures:load§>
Ajouter :  --group=UserFixtures -> pour ne lancer qu'une seule fixture. Ici UserFixtures

// Créer un test. Dans App\tests\AppTest.php (doit finir par test). Les fonctions doivent commencer par le mot test.

<§
namespace App\Tests;

use PHPUnit\Framework\TestCase;

class AppTest extends TestCase {
    public function testTestsAreWorking(){
        $this->assertEquals(2, 1+1);  
    }

}
§>
// classe extends KernelTestCase permet de faire des tests fonctionnels
// classe extends WebTestCase permet de tester des controlleurs

//// Dans App\Tests\Repository\UserRepositoryTest.php;

namespace App\Tests\Repository;

use App\Repository\UserRepository;
use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;

class UserRepositoryTest extends KernelTestCase
{
    public function testCount(){
        self::bootKernel();
        $users = self::$container->get(UserRepository::class)->count([]);
        $this->assertEquals(10, $users);
    }
}

// Pour l'environnement de test, on peut créer une BDD spcifique
php bin/console doctrine:database:create --env=test
php bin/console doctrine:schema:update --env=test --force

// https://github.com/liip/LiipTestFixturesBundle
composer require --dev liip/test-fixtures-bundle:^1.0.0

// Ceci permet d'ajouter un chargement de fixture plus facile ??? Dans UserRepositoryTest :

    use FixturesTrait;
    public function testCount(){
        self::bootKernel();
        $this->loadFixtures(UserFixtures::class);
        $users = self::$container->get(UserRepository::class)->count([]);
        $this->assertEquals(10, $users);
    }
// https://youtu.be/p_ONHGLv-xs?list=PLjwdMgw5TTLWtWmdMzPaoc45Iztu7tVQ8&t=488
// Il est conseillé d'utiliser sqlite pour les tests fin de gagner en performance

//// Tester une entité ------------------------------------
// On peut vérifier qu'il y a aucune erreur dans un bout de code executé en validant sa bonne execution :
namespace App\Tests\Entity;

use App\Entity\InvitationCode;
use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;

class InvitationCodeTest extends KernelTestCase{
    public function testValidEntity(){
        $code = (new InvitationCode())
            ->setCode('12345')
            ->setDescription("ma description")
            ...
        self::bootKernel();
        $error = self::container->get('validator')->validate($code)
        $this->assertCode(0, $error);
    }
}
//// Tester un validateur ---------------------------------
https://www.youtube.com/watch?v=u6Oy9tLnReA&list=PLjwdMgw5TTLWtWmdMzPaoc45Iztu7tVQ8&index=4

//// Tester un controller ---------------------------------
// Permet de tester le routing et la sécurité
// https://www.youtube.com/watch?v=zfwdc8xRyaI
// Dans App/Tests/Controller/PageControllerTest.php
namespace App\Tests\Controller;

use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;

class PageControllerTest extends WebTestCase{
    public function testHelloPage(){
        $client = static::createClient();
        client->request(methode: 'GET', url: '/hello');
        $this->assertResponseStatusCodeSame(Response::HTTP_OK);
    }
    
    public function testHelloPage(){
        $client = static::createClient();
        client->request(methode: 'GET', url: '/hello');
        $this->assertSelectorTextContains('h1', "Bienvenue sur mon site");
    }
    
    public function testAuthPageIsRestricted(){
        $client = static::createClient();
        client->request(methode: 'GET', url: '/auth');
        $this->assertResponseStatusCodeSame(Response::HTTP_UNAUTHORIZED);
    }
    
    public function testRedirectToLogin(){
        $client = static::createClient();
        client->request(methode: 'GET', url: '/auth');
        $this->assertResponseRedirects('/login');
    }
}









Faire des tests


private function myFunction(): QueryBuilder
{
	return $this->createQueryBuilder('p')
	->select('p', 'pics')
	->leftJoin('p.pictures', 'pics')
	->where('p.sold = false');
}


5 - Régler le problème N+1

composer require fzaninotto/faker
composer require orm-fixtures --dev			-> demander outils de fixtures
php bin/console make:fixtures				-> créer jeu de fixture

php bin/console doctrine:fixtures:load
Ajouter :  --group=UserFixtures -> pour ne lancer qu'une seule fixture. Ici UserFixtures



4 - Jouer avec les fixtures

Partie controlleur : 
$this->addFlash('success', 'Votre message a bien été envoyé');
Dans twig : 
{% for message in app.flashes('success') %}



10 - Flashdata

php bin/console make:form		-> puis associer à l'entité concernée

Dans le contrôleur, envoyer un formulaire à la vue :
$formRecipe = $this->createForm(RecipeType::class, $recipe);
return $this->render('cook_book/recipeEditor.html.twig', [
       'page_name' => 'Recipe editor',
       'formRecipe' => $formRecipe->createView(),
]);

Dans twig,  :
{{ form_start(formRecipe) }}
{{ form_row(formRecipe.title, {'attr':{'placeholder': "Titre de la recette"}}) }}
{{ form_row(formRecipe.steps, {'attr':{'placeholder': "Etapes de la recette"}}) }}
{{ form_row(formRecipe.ingredients, {'attr':{'placeholder': "Ingrédients de la recette"}}) }}
 
<button type="submit" class="btn btn-success">
{{ form_end(formArticle) }} 

Préciser des informations spécifiques pour la vue dans le formType en fonction des besoins :
->add('imageFile1', FileType::class, ['required' => $filerequired,
								'label'  => "Photo principale",
								'label_attr' => ['class' => 'custom-file-label firstPhoto'], 
								'attr' => ['class' => 'custom-file-input']])



7- Formulaires

- Vérifier si présence de vulnérabilité : symfony check:security
- Vérifier si la version de php est compatible (voir la version requise dans composer.json et faire upgrade si nécessaire)
- composer require symfony/apache-pack     -> créer les .htaccess
- Vérifier le .env
https://doc.ubuntu-fr.org/rsync
rsync -av ./ clementsqf@ssh.cluster023.hosting.ovh.net:~/hypnotherapie-tarbes-v3 --include=vendor --include=public/.htaccess --exclude-from=.gitignore --exclude=".*"
- créer fichier "deploy" à la racine du projet et définir une commande sh exécutable : #!/bin/sh
- chmod +x deploy
- commande deploy pour l'exécuter: ./deploy
- Créer sur le serveur le .env manuellement
- Sur OVH définir le dossier racine (dans hébergement et onglet multisite). Faire pointer la racine sur le dossier "public"
- Vérifier présence de composer sur le serveur. Sinon : alias composer="/usr/local/php7.1/bin/php ~/composer.phar"
Pour résumer, il faut surtout utiliser rsync pour envoyer tous les fichiers, lancer les migrations, tester la prod, et passer le .env en prod

Tester sur mobile :
chrome://inspect/#devices

Penser à générer les clé d'authentifications si utilisation de lexik :
php bin/console lexik:jwt:generate-keypair

Si les requêtes en POST ne marchent pas en prod mais marchent en dev, essayer cette commande sur le serveur en ssh :
export APP_ENV=prod


18 - Déployer le site en ligne

doc : https://github.com/froala/KMSFroalaEditorBundle
composer require kms/froala-editor-bundle
- Dans le kms_froala_editor.yaml, vérifier la langue et rajouter :
	pluginsDisabled: [ "save"]

php bin/console froala:install
php bin/console assets:install --symlink public
Dans le fichier twig, mettre le champ dans une div.fr-view: 
<div class="fr-view">
    {{ myContentHtml|raw }}
</div>


14 - Ajouter un éditeur WYSIWYG

composer require liip/imagine-bundle -> choisir "y" pour exécuter la recette
A ajouter dans liip_imagine.yaml :
liip_imagine:
    # valid drivers options include "gd" or "gmagick" or "imagick"
    driver: "gd"
    filter_sets:
        thumb:
            quality: 75
            filters:
                thumbnail:
                    size:           [360, 230]
                    mode:           outbound
        medium:
            quality: 75
            filters:
                thumbnail:
                    size:           [800, 530]
                    mode:           outbound
Puis dans twig, mettre le filtre imagine_filter : {{ vich_uploader_asset(article, 'imageFile') | imagine_filter('thumb') }}
									{{ vich_uploader_asset(article, 'imageFile') | imagine_filter(‘medium’) }}
Si il y a une erreur, ajouter l'image par défaut


Avoir une image par défaut :
ajouter image dans public/images/articles/empty.jpg
Ajouter l’image dans twig: 		{{ ‘/images/articles/empty.jpg’ | imagine_filter(‘medium’) }}

Gérer la gestion du cache pour les images :
Créer dossier Listener dans /src puis fichier ImageCacheSubscriber.php (snippet VSCode)
Ajouter un service dans fichier service.yaml :
    App\Listener\ImageCacheSubscriber:
      tags: 
        name: doctrine.event_subscriber


9 - Créer des thumbnails

source : https://www.wanadev.fr/56-comment-realiser-de-belles-requetes-sql-avec-doctrine/
// src/AppBundle/Repository/MyClassRepository.php

use Doctrine\ORM\Query\ResultSetMappingBuilder;

public function findItemsAndSortByStatus()
{
    // la table en base de données correspondant à l'entité liée au repository en cours
    $table = $this->getClassMetadata()->table["name"];

    // Dans mon cas je voulais trier mes résultats avec un ordre bien particulier
    $sql =  "SELECT m.* "
            ."FROM ".$table." AS m "
            ."WHERE (m.deleted_at IS NULL OR m.deleted_at > :current_time) "
            ."ORDER BY m.status = :status_available DESC, m.status = :status_unknown DESC, m.status = :status_unavailable DESC, m.priority ASC";

    $rsm = new ResultSetMappingBuilder($this->getEntityManager());
    $rsm->addEntityResult(MyClass::class, "m");

    // On mappe le nom de chaque colonne en base de données sur les attributs de nos entités
    foreach ($this->getClassMetadata()->fieldMappings as $obj) {
        $rsm->addFieldResult("m", $obj["columnName"], $obj["fieldName"]);
    }

    $stmt = $this->getEntityManager()->createNativeQuery($sql, $rsm);

    $stmt->setParameter(":current_time", new \DateTime("now"));
    $stmt->setParameter(":status_available", MyClass::STATUS_AVAILABLE);
    $stmt->setParameter(":status_unknown", MyClass::STATUS_UNKNOWN);
    $stmt->setParameter(":status_unavailable", MyClass::STATUS_UNAVAILABLE);

    $stmt->execute();

    return $stmt->getResult();
}


17 - Faire une requête SQL complexe

// Avoir le bundle de twig-pack installé
composer require symfony/twig-pack

Pour tester le fonctionnement de l'application et voir la page, il faut être en mode production :
.env.local => APP_ENV=production

Créer une arborescence templates/bundles/TwigBundle/Exception
Créer un fichier error404.html.twig
<§
{% extends 'base.html.twig' %}
{% block title %}
    Page 404
{% endblock title %}

{% block body %}
    <div class="text-center container">
        <h1>Page non trouvée...</h1>
    </div>
{% endblock %}
§>

Et enfin, supprimer le dossier prod du dossier en cache : var/cache/prod

Pour tester la page en mode dev, on ne peut que aller sur l'url :
BASE/index.php/_error/404 //mettre l'erreur voulue

Idéalement, il faudra faire un fichier twig pour :
la page 404 => error404.html.twig
la page 403 => error403.html.twig
Les autres erreurs => error.html.twig

Gérer la page 404

<VirtualHost *:80>
    ServerName happy.property.local
    ServerAlias happy.property.local
    DocumentRoot "/Johan/Desktop/Johan/Prog_web/Hap/hap
/public"
    <Directory  "/path/to/project/">
        AllowOverride None
        Order Allow,Deny
        Allow from All
        FallbackResource /index.php
    </Directory>

    <Directory "/path/to/project/public/bundles" >
        FallbackResource disabled
    </Directory>

    ErrorLog "/path/to/logs/happyproperty/error.log"
    CustomLog "/path/to/logs/happyproperty/acces.log" combined
</VirtualHost>

Rewrite rule pour https systématique (dans .htaccess):
RewriteEngine on
RewriteCond %{HTTPS} !=on
RewriteRule .* https://%{HTTP_HOST}%{REQUEST_URI} [R=301,L]

  sudo mkdir -p /usr/local/sbin
  sudo chown -R $(whoami) /usr/local/sbin
brew link php


Set virtual Host for project

// Créer le projet SF
<§composer create-project symfony/website-skeleton test-react§>

<§cd test-react§>

// Créer un controlleur principal et le nommer (ici dans cet exemple : PublicController)
<§php bin/console make:controller§>

// Dedans on peut y mettre une connexion api
<§<?php

namespace App\Controller;

use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;

class PublicController extends AbstractController
{
   public function __invoke()
    {
        return $this->render('public/index.html.twig', []);
    }
}
§>

// Définir le template base.html.twig
<§
<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>My app</title>
        {# Run `composer require symfony/webpack-encore-bundle`
           and uncomment the following Encore helpers to start using Symfony UX #}
        {% block stylesheets %}
            {{ encore_entry_link_tags('app') }}
        {% endblock %}

        
    </head>
    <body>
        {% block body %}{% endblock %}
    </body>
    {% block javascripts %}
        {{ encore_entry_script_tags('app') }}
    {% endblock %}
</html>
§>

// Et le index.html.twig
<§{% extends 'base.html.twig' %}


{% block body %}
    <div id="root"></div>
{% endblock %}
§>

// Connecter la BDD dans le .env
<§DATABASE_URL=mysql://identifiant:mdp@127.0.0.1:8889/my-awesome-bdd?serverVersion=5.7§>

// Si besoin, créer une BDD (ici ce sera my-awesome-bdd)
<§php bin/console doctrine:database:create§>

// Installer encore et les dépendances yarn
<§composer require symfony/webpack-encore-bundle§>

// info : symfony/webpack-encore-pack est déprécié

// Démarrer le serveur
<§symfony server:start§>


<§yarn install§>
<§yarn add --dev react react-dom prop-types @babel/preset-react@^7.0.0§>

// Dans le webpack.config.js, enable react
<§
.enableReactPreset()
.addEntry('app', './assets/app.js')
§>

// Et enfin définir le point d'entrée React dans assets/app.js
<§
import React from 'react';
import ReactDOM from 'react-dom';

function App(){
    return (
        <p>Yooooooooo !!!</p>
    )
}

ReactDOM.render(<App />, document.getElementById('root'));
§>

// Démarrer serveur JS
<§yarn encore dev-server§>


Symfony