DEV Community: Quentin Ferrer

Lire un gros fichier ligne par ligne en PHP (Array, Itérateur & Générateur)

Quentin Ferrer — Fri, 02 Apr 2021 13:38:00 +0000

Sorry English readers, this post goes to my French followers. Let me know if you would like me to translate this one. In the meantime, you can Google translate it.

Dans une carrière de développeur, nous sommes souvent amenés à travailler avec des fichiers. Que ce soit pour importer des données dans un système ou exporter des données dans un fichier il faudra ouvrir le fichier et effectuer des opérations sur chaque ligne du fichier. Il existe plusieurs façons de lire un fichier ligne par ligne en PHP mais certaines peuvent très vite devenir problématique lorsqu'il s'agit de lire des gros fichiers.

Array

Il existe plusieurs façons de lire un fichier dans un tableau PHP, mais voici celle que je vois le plus souvent dans des projets :

<?php
require_once('utils.php');

$rows = $this->read('input.txt');
foreach($rows as $row) {
    // traiter les données
}

<?php
// utils.php
public function read(string $filename): array
{
    $handle = fopen($filename, "r");

    $rows = [];
    while(!feof($handle)) {
        $rows[] = fgets($handle);
    }

    fclose($handle);

    return $rows;
}

Problèmes

Le temps d'exécution est trop long

Plus le fichier est volumineux, plus le temps d'exécution sera long. Cela est logique car PHP aura besoin de stocker un grand nombre d'éléments et donc générer un très grand tableau.

La limite de mémoire est atteinte

Lorsque le fichier est léger, il n'y a pas de question à se poser, mais lorsque celui-ci contient un gros volume de données, c'est là que ce message d'erreur apparaît :

Fatal Error: Allowed memory size of XXXXX bytes exhausted.

En effet, dans l'exemple ci-dessus, PHP stocke toutes les données du tableau en mémoire. La taille de votre tableau sera donc limitée par la quantité de mémoire allouée au script définie par la variable memory_limit de PHP. Il m'arrive de voir la valeur de cette variable égale à memory_limit=-1 en production, ce qui signifie que PHP utilisera toute la mémoire disponible sur le serveur ! Je ne vous recommande donc pas cette pratique mais vous propose plutôt d'utiliser un Itérateur ou un Générateur.

Itérateur

Un Itérateur est un patron de conception comportemental qui permet de parcourir les éléments d'une collection de façon séquentielle. Chaque itérateur doit indiquer la façon dont il doit être traversé, et quelles valeurs seront disponibles à chaque itération.

Depuis la version 5, PHP fournit une interface Iterator qui peut être utilisée pour créer des itérateurs personnalisées :

Iterator extends Traversable {
    /* Méthodes */
    abstract public current () : mixed
    abstract public key () : scalar
    abstract public next () : void
    abstract public rewind () : void
    abstract public valid () : bool
}

L'interface déclare les opérations nécessaires au parcours d'une collection :

current() : donne la position actuelle
key() : donne la clé de l'élement actuel
next() : donne le prochain élément de la collection
rewind() : recommence la boucle depuis le début
valid() : vérifie si la position actuelle est valide.

Il est donc possible de créer un itérateur qui permet de parcourir un fichier ligne par ligne :

<?php

class FileIterator implements \Iterator
{
    protected $fileHandle;
    protected $row;
    protected $lineNumber;

    public function __construct(string $fileName)
    {
        if (!$this->fileHandle = fopen($fileName, 'r')) {
            throw new \RuntimeException('Unable to open file "' . $fileName . '" ');
        }
    }

    /**
     * Revient au début du fichier.
     */
    public function rewind()
    {
        fseek($this->fileHandle, 0);
        $this->row = fgets($this->fileHandle);
        $this->lineNumber = 0;
    }

    /**
     * Vérifie que la fin du fichier n'est pas atteinte.
     */
    public function valid()
    {
        return !feof($this->fileHandle);
    }

    /**
     * Retourne la ligne actuelle.
     */
    public function current()
    {
        return $this->row;
    }

    /**
     * Retourne le numéro de la ligne actuel.
     */
    public function key()
    {
        return $this->lineNumber;
    }

    /**
     * Déplace le pointeur à la ligne suivante.
     */
    public function next()
    {
        if ($this->valid()) {
            $this->row = fgets($this->fileHandle);
            $this->lineNumber++;
        }
    }

    public function __destruct()
    {
        fclose($this->fileHandle);
    }
}

La fonction read() peut donc être simplifiée avec l'utilisation de cet itérateur :

public function read(string $filename): FileIterator
{
    return new FileIterator($filename);
}

Vous pouvez ensuite parcourir l'itérateur avec l'utilisation de foreach :

$rows = $this->read('input.txt');
foreach($rows as $row) {
    // traiter les données
}

Voici l'ordre des opérations exécutées au moment où vous bouclez sur l'itérateur :

Avant la première itération de la boucle, la méthod rewind() est appelée.
Avant chaque itération de la boucle, la méthode valid() est appelée :
- Si la méthode valid() retourne false, la boucle est terminée.
- Si la méthode valid() retourne true, les méthodes current() et key() sont appelées.
Le corps de la boucle est évalué.
Après chaque itération de la boucle, la méthode next() est appelée et nous répétons les opérations à partir de l'étape 2 ci-dessus.

À la différence d'un tableau, l'itérateur consommera très peu de mémoire (<1 Mo) car PHP aura besoin de stocker uniquement la position du pointeur et la ligne actuelle du fichier. Les précédentes lignes ne seront pas gardées en mémoire.

Problème

Les itérateurs peuvent être complexes à créer en fonction du type de fichier. Bien qu'il s'agit d'une optimisation au niveau de la mémoire utilisée, le code est plus conséquent pour une simple opération de lecture d'un fichier. Voyons une façon plus simple de créer des itérateurs à l'aide des générateurs PHP.

Genérateur

Depuis la version PHP 5.5, il est aussi possible d'économiser de la mémoire en utilisant des générateurs PHP :

Un générateur permet de parcourir les éléments d'une collection sans avoir à construire un tableau en mémoire pouvant conduire à dépasser la limite de la mémoire ou nécessiter un temps important pour sa génération.

En réalité, un générateur est un objet PHP qui implémente l'interface Iterator. Il permet de simplifier la création des itérateurs en écrivant une seule fonction chargée de construire le tableau, sans se soucier de toutes les autres fonctions de l'itérateur permettant d’obtenir l’entrée courante du tableau ou de savoir si le tableau contient une autre entrée pour continuer son parcours par exemple. Il sera capable de le gérer tout seul.

Pour créer un générateur, il suffit de créer une fonction qui à la place de retourner un tableau, utilisera autant de fois que nécessaire le mot-clé yield pour indiquer à la foncction générateur, les éléments à parcourir au moment où vous bouclerez dessus :

<?php
public function read(string $filename): \Generator
{
    $handle = fopen($filename, "r");

    // $rows = [];
    while(!feof($handle)) {
        // $rows[] = fgets($handle);
        yield fgets($handle);
    }

    fclose($handle);

    // return $rows;
}

Comme vous pouvez le voir, on parcourt toujours les lignes du fichier mais plutôt que de renvoyer le tableau avec toutes les lignes, on utilise le mot-clé yield pour indiquer à PHP les lignes du fichier que le générateur devra parcourir.

Lorsque la fonction read est appelée, elle retourne un objet Generator que l'on peut parcourir avec foreach :

$rows = $this->read('input.txt');
foreach($rows as $row) {
    // traiter les données
}

Lorsque vous parcourez cet objet, PHP appellera les méthodes d'itération de l'objet (rewind(), valid(), key(), current()) chaque fois qu'il a besoin d'une valeur. Ensuite, il sauvegardera le statut du générateur en appelant la méthode next() de l'itérateur au moment où il génère une valeur. Lorsqu'il n'y a plus de valeur à fournir (valid() retourne false), la fonction générateur peut simplement sortir, et le code appelant continuera comme si un tableau n'avait plus de valeur.

Le générateur consommera autant de mémoire qu'un itérateur, c'est à dire très peu.

Problème

À la différence des itérateurs, le générateur est capable d'aller uniquement vers l'avant. Il ne peut donc pas être ré-initialisé une fois que le parcours a commencé. Cela signifie que le même générateur ne peut pas être utilisé à plusieurs reprises : il devra être reconstruit en appelant une nouvelle fois la fonction générateur.

$rows = $this->read('input.txt');
foreach($rows as $row) {
    // traiter les données
}

foreach($rows as $row) {
    // vous ne passerez jamais ici car le générateur a déjà été consommé.
}

Conclusion

La lecture d'un fichier ligne par ligne avec un tableau PHP est à bannir si vous travailler avec des gros fichiers.

Le générateur ne vous permettra pas de lire plusieurs fois le fichier, vous devrez appeler une nouvelle fois la fonction générateur à chaque fois que vous voulez revenir au début du fichier. Si vous devez parcourir une seule fois le fichier, je vous recommande d'utiliser les générateurs qui sont plus simple à créer par rapport à des itérateurs.

L'itérateur est la solution à retenir si vous avez besoin de traiter plusieurs fois les données du fichier. Vous serez capable de revenir au début du fichier à n'importe quel moment.

Ressources

Lire un fichier dans un tableau avec la fonction file() ou fgets()
Générateur PHP
Interface Iterator
Comparaison des générateurs avec les objets Itérateurs
Patron de conception Itérateur

Credits

Image de Jordi Koalitic

Creating a COVID-19 Data Visualization with Symfony UX

Quentin Ferrer — Thu, 14 Jan 2021 12:46:03 +0000

Creating the Project
Lauching the Local Web Server
Installing Webpack Encore
Installing UX Chart.js
Creating the Covid-19 Http Client
Creating the Covid Controller
Rendering the Chart

At the beginning of December, Symfony started the keynote with the presentation of Symfony UX, a new JavaScript ecosystem for Symfony.

Symfony UX is a series of tools to create a bridge between Symfony and the JavaScript ecosystem.

To get a full overview of the initiative, you can also watch the Symfony World replay, especially the Fabien’s keynote and Titouan’s talk.

For now, Symfony provides 5 packages:

UX Chart.js
UX Cropper.js
UX Dropzone
UX LazyImage
UX Swup

In this tutorial, I will introduce you to the UX Chart.js package by graphing some COVID-19 data with the Chart.js library. To do this, we will create a line chart that will display the total number of cases and deaths by country from a free Covid-19 API.

Creating the project

First of all, we need to set up and configure a project:

$ symfony new covid --full
$ cd covid/

Launching the Local Web Server

Start a local web server executing the command:

$ symfony server:start

For the tutorial, we will suppose that the webserver is listening to http://localhost:8000.

Installing Webpack Encore

As we will use a JavaScript library, we need to manage JavaScript in Symfony using Webpack:

$ symfony composer req symfony/webpack-encore-bundle
$ yarn install

Symfony now integrates Stimulus to organize JavaScript code inside projects. If you take a look at the assets/ directory, you can see a new JavaScript directory structure:

controllers/: it contains Stimulus controllers of the application. They are automatically registered in app.js,
controllers.json: it references Stimulus controllers provided by installed Symfony UX packages.

Installing UX Chart.js

Let's install our first UX package:

$ symfony composer req symfony/ux-chartjs

Symfony Flex has just added a reference to the Javascript code of UX-Chart.js in the package.json:

{
    "devDependencies": {
        "@symfony/ux-chartjs": "file:vendor/symfony/ux-chartjs/Resources/assets"
    },
}

Symfony Flex also added a reference to the Stimulus controller of UX-Chart.js in the assets/controllers.json:

{
    "controllers": {
        "@symfony/ux-chartjs": {
            "chart": {
                "enabled": true,
                "webpackMode": "eager"
            }
        }
    },
    "entrypoints": []
}

Because of these changes, we now need to install the new JavaScript dependencies and compile the new files:

$ yarn install
$ yarn encore dev

Now, the UX package is ready.

Creating the Covid-19 Http Client

Thanks to a free Covid-19 API (https://api.covid19api.com), we will able to fetch the total number of cases and deaths by country by using the following endpoint:

GET https://api.covid19api.com/total/country/$country

$country must be the slug from https://api.covid19api.com/countries.

Symfony provides a HttpClient component to consume APIs. Add a scoped client to auto-configure the client based on the requested URL:

# config/packages/framework.yaml
framework:
   http_client:
        scoped_clients:
            covid:
                base_uri: https://api.covid19api.com

The covid client will have a unique service named covid.

Create a CovidHttpClient service that will be responsible for fetching the total number of cases and deaths by country and group all by date.

<?php

namespace App\HttpClient;

use Symfony\Contracts\HttpClient\HttpClientInterface;

/**
 * Class CovidHttpClient
 * @package App\Client
 */
class CovidHttpClient
{
    /**
     * @var HttpClientInterface
     */
    private $httpClient;

    /**
     * CovidHttpClient constructor.
     *
     * @param HttpClientInterface $covid
     */
    public function __construct(HttpClientInterface $covid)
    {
        $this->httpClient = $covid;
    }

    /**
     * Get total number of cases and deaths by the given country.
     * 
     * @param string $country
     * 
     * @return array
     */
    public function getTotalByCountry(string $country): array
    {
        $response = $this->httpClient->request('GET', "/total/country/$country");
        $data = json_decode($response->getContent(), true);

        $total = [];

        foreach ($data as $dailyData) {
            $date = (new \DateTime($dailyData['Date']))->format('Y-m-d');
            $total[$date] = $dailyData;
        }

        return $total;
    }
}

As we have an argument $covid as HttpClientInterface type, autowiring inject the covid service into the class.

We are now ready to build the chart.

Creating the Covid Controller

Create the controller using the Maker bundle:

symfony console make:controller CovidController

The command creates a CovidController class under the src/Controller/ directory and a template file to templates/covid/index.html.twig.

In the CovidController, implement the index() method:

Fetch the total number of cases and deaths by country using the CovidHttpClient service and group all by status;
Create a Chart object by using the ChartBuilderInterface builder;
Set the data (labels & datasets) to the Chart object;
Finally, pass the Chart object to the Twig template covid/index.html.twig.

<?php

namespace App\Controller;

use App\HttpClient\CovidHttpClient;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\UX\Chartjs\Builder\ChartBuilderInterface;
use Symfony\UX\Chartjs\Model\Chart;

class CovidController extends AbstractController
{
    /**
     * @Route("/{country}", name="covid")
     */
    public function index(CovidHttpClient $covidClient, ChartBuilderInterface $chartBuilder, $country = 'france'): Response
    {
        $total = $covidClient->getTotalByCountry($country);
        $totalByStatus = [];
        foreach ($total as $dailyTotal) {
            $totalByStatus['confirmed'][] = $dailyTotal['Confirmed'];
            $totalByStatus['deaths'][] = $dailyTotal['Deaths'];
            $totalByStatus['recovered'][] = $dailyTotal['Recovered'];
            $totalByStatus['active'][] = $dailyTotal['Active'];
        }

        $chart = $chartBuilder->createChart(Chart::TYPE_LINE);
        $chart
            ->setData([
                'labels' => array_keys($total),
                'datasets' => [
                    [
                        'label' => 'Confirmed',
                        'backgroundColor' => 'rgb(120, 161, 187, 0.5)',
                        'data' => $totalByStatus['confirmed']
                    ],
                    [
                        'label' => 'Death',
                        'backgroundColor' => 'rgb(219, 80, 74, 0.5)',
                        'data' => $totalByStatus['deaths']
                    ],
                    [
                        'label' => 'Recovered',
                        'backgroundColor' => 'rgb(147, 196, 139, 0.5)',
                        'data' => $totalByStatus['recovered']
                    ],
                    [
                        'label' => 'Active',
                        'backgroundColor' => 'rgb(252, 191, 73, 0.5)',
                        'data' => $totalByStatus['active']
                    ]
                ]
            ]);

        return $this->render('covid/index.html.twig', [
            'chart' => $chart,
            'country' => $country
        ]);
    }
}

You can read Chart.js documentation to discover all options.

Rendering the Chart

The last step is to update the templates/covid/index.html.twig file:

{% extends 'base.html.twig' %}

{% block body %}
    <h1>Total number of cases and deaths in {{ country|capitalize }}</h1>
    {{ render_chart(chart) }}
{% endblock %}

It's done! Go to the homepage by specifying the country parameter. The list of countries is available on https://api.covid19api.com/countries.
Here are some examples:

Testing the Cart | Building a Shopping Cart with Symfony

Quentin Ferrer — Mon, 21 Dec 2020 12:57:03 +0000

Configuring the Test Environment
- Configuring a Database for Tests
- Configuring PHPUnit
- Configuring a Session
Writing Cart Assertions
- assertCartIsEmpty()
- assertCartTotalEquals()
- assertCartItemsCountEquals()
- assertCartContainsProductWithQuantity()
- assertCartNotContainsProduct()
Writing Functional Tests
- testCartIsEmpty()
- testAddProductToCart()
- testAddProductTwiceToCart()
- testRemoveProductFromCart()
- testClearCart()
- testUpdateQuantity()
- testQuantityIsInvalid()
Executing Tests

The last step is to test the cart page. We will check that all of the cart features we have developed are working. This will also ensure that when you write a new line of code, your cart will still work.

Configuring the Test Environment

Symfony runs tests in a special test environment. It loads the config/packages/test/*.yaml settings specifically for testing.

Configuring a Database for Tests

We should use a separate database for tests to not mess with the databases used in the other configuration environments.

To do that, edit the .env.test file at the root directory of your project and define the new value for the DATABASE_URL env var:

DATABASE_URL="mysql://root:happy@127.0.0.1:3306/happy_shop_test"

Next, create the database and update the database schema by executing the following command:

$ bin/console doctrine:database:create -e test
$ bin/console doctrine:migrations:migrate -e test

For now, the database is empty, load the products fixtures with:

$ bin/console doctrine:fixtures:load -e test

Configuring PHPUnit

Symfony provides a phpunit.xml.dist file with default values for testing:

<?xml version="1.0" encoding="UTF-8"?>

<!-- https://phpunit.readthedocs.io/en/latest/configuration.html -->
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="bin/.phpunit/phpunit.xsd"
         backupGlobals="false"
         colors="true"
         bootstrap="tests/bootstrap.php"
>
    <php>
        <ini name="error_reporting" value="-1" />
        <server name="APP_ENV" value="test" force="true" />
        <server name="SHELL_VERBOSITY" value="-1" />
        <server name="SYMFONY_PHPUNIT_REMOVE" value="" />
        <server name="SYMFONY_PHPUNIT_VERSION" value="7.5" />
    </php>

    <testsuites>
        <testsuite name="Project Test Suite">
            <directory>tests</directory>
        </testsuite>
    </testsuites>

    <filter>
        <whitelist processUncoveredFilesFromWhitelist="true">
            <directory suffix=".php">src</directory>
        </whitelist>
    </filter>

    <listeners>
        <listener class="Symfony\Bridge\PhpUnit\SymfonyTestsListener" />
    </listeners>
</phpunit>

We will reset the database after each test to be sure that one test is not dependent on the previous ones. To do that, enable the PHPUnit listener provided by the DoctrineTestBundle bundle:

<extensions>
    <extension class="DAMA\DoctrineTestBundle\PHPUnit\PHPUnitExtension" />
</extensions>

Configuring the Session

The cart depends on the session. Testing code using a real session is tricky, that's why Symfony provides a MockFileSessionStorage mock that simulates the PHP session workflow. It's already set in the config/packages/test/framework.yaml settings:

framework:
    test: true
    session:
        storage_id: session.storage.mock_file

Writing Cart Assertions

When doing functional tests, sometimes we need to make complex assertions in order to check whether the Request, the Response, or the Crawler contain the expected information to make our test succeed.

Symfony already provides a lot of assertions but we will write our own assertions specifically for the cart. It will help us to make the functional test more readable and to avoid writing duplicate code.

Create a CartAssertionsTrait trait that will provide methods to make assertions on the cart page:

<?php

namespace App\Tests;

use PHPUnit\Framework\Assert;
use Symfony\Component\DomCrawler\Crawler;

trait CartAssertionsTrait
{
}

We will use the Crawler to find DOM elements in the Response and the PHPUnit Assertions provided by theAssert class to make assertions.

`assertCartIsEmpty()`

When a cart is empty, we display a specific message to the user. To assert that the cart is empty, add a assertCartIsEmpty() method and check that the message is displayed by using the Crawler object:

public static function assertCartIsEmpty(Crawler $crawler)
{
    $infoText = $crawler
        ->filter('.alert-info')
        ->getNode(0)
        ->textContent;

    $infoText = self::normalizeWhitespace($infoText);

    Assert::assertEquals(
       'Your cart is empty. Go to the product list.',
        $infoText,
        "The cart should be empty."
   );
}

private static function normalizeWhitespace(string $value): string
{
    return trim(preg_replace('/(?:\s{2,}+|[^\S ])/', ' ', $value));
}

`assertCartTotalEquals()`

To assert that the cart totals equals an expected value, add a assertCartTotalEquals() method to retrieve the cart total and compare it with the expected value:

public static function assertCartTotalEquals(Crawler $crawler, $expectedTotal)
{
    $actualTotal = (float)$crawler
        ->filter('.col-md-4 .list-group-item span')
        ->getNode(0)
        ->textContent;

    Assert::assertEquals(
        $expectedTotal,
        $actualTotal,
        "The cart total should be equal to \"$expectedTotal €\". Actual: \"$actualTotal €\"."
    );
}

`assertCartItemsCountEquals()`

Add a assertCartItemsCountEquals method to count the number of items in the cart and compare it with the expected value:

public static function assertCartItemsCountEquals(Crawler $crawler, $expectedCount): void
{
    $actualCount = $crawler
        ->filter('.col-md-8 .list-group-item')
        ->count();

    Assert::assertEquals(
        $expectedCount,
        $actualCount,
        "The cart should contain \"$expectedCount\" item(s). Actual: \"$actualCount\" item(s)."
    );
}

`assertCartContainsProductWithQuantity()`

It will help us assert that the quantity of product a user wants to purchase in the cart is equal to the expected quantity. Add a method assertCartContainsProductWithQuantity to retrieve the item from the product name and compare the quantity of the given product with the expected quantity:

public static function assertCartContainsProductWithQuantity(Crawler $crawler, string $productName, int $expectedQuantity): void
{
    $actualQuantity = (int)self::getItemByProductName($crawler, $productName)
        ->filter('input[type="number"]')
        ->attr('value');

    Assert::assertEquals($expectedQuantity, $actualQuantity);
}

private static function getItemByProductName(Crawler $crawler, string $productName)
{
    $items = $crawler->filter('.col-md-8 .list-group-item')->reduce(
        function (Crawler $node) use ($productName) {
            if ($node->filter('h5')->getNode(0)->textContent === $productName) {
                return $node;
            }

            return false;
        }
    );

    return empty($items) ? null : $items->eq(0);
}

`assertCartNotContainsProduct()`

Add a assertCartNotContainsProduct method to check that the cart does not contain a product given as argument:

public static function assertCartNotContainsProduct(Crawler $crawler, string $productName): void
{
    Assert::assertEmpty(
        self::getItemByProductName($crawler, $productName),
        "The cart should not contain the product \"$productName\"."
    );
}

Writing Functional Tests

In Symfony, a functional test consists to test a Controller. As you want to test a Controller, you need to generate a functional test for this controller.

Generate a functional test for testing the CartController:

symfony console make:functional-test Controller\\CartController

A CartControllerTest class has been generated in the tests/Controller/ directory:

<?php

namespace App\Tests\Controller;

use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;

class CartControllerTest extends WebTestCase
{
    public function testSomething()
    {
        $client = static::createClient();
        $crawler = $client->request('GET', '/');

        $this->assertResponseIsSuccessful();
        $this->assertSelectorTextContains('h1', 'Hello World');
    }
}

It extends a special WebTestCase class that provides a client object to help us making requests on the application pages. In fact, the test client simulates an HTTP client like a browser and makes requests into your Symfony application. As we don't use JavaScript, we don't need to test in a real browser. The request() method takes the HTTP method and a URL as arguments and returns a Crawler instance. The Crawler is used to find DOM elements in the Response. We have used it before to make cart assertions.

We will need to add products to the cart to test the cart page. Since we already have the product fixtures, we will go to the homepage (/) to get a random product from the product list with its name, price, and URL. Let's create a getRandomProduct() method to do that:

<?php

namespace App\Tests\Controller;

use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
use Symfony\Component\BrowserKit\AbstractBrowser;

class CartControllerTest extends WebTestCase
{
    private function getRandomProduct(AbstractBrowser $client): array
    {
        $crawler = $client->request('GET', '/');
        $productNode = $crawler->filter('.card')->eq(rand(0, 9));
        $productName = $productNode->filter('.card-title')->getNode(0)->textContent;
        $productPrice = (float)$productNode->filter('span.h5')->getNode(0)->textContent;
        $productLink = $productNode->filter('.btn-dark')->link();

        return [
            'name' => $productName,
            'price' => $productPrice,
            'url' => $productLink->getUri()
        ];
    }
}

Now, thanks to this method we will be able to add a random product to the cart. Let's create a addRandomProductToCart() method, get a random product, and go to the product detail page thanks to the product URL. Then, add the product to the cart using the form.

<?php

namespace App\Tests\Controller;

use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
use Symfony\Component\BrowserKit\AbstractBrowser;

class CartControllerTest extends WebTestCase
{
    // ...

    private function addRandomProductToCart(AbstractBrowser $client, int $quantity = 1): array
    {
        $product = $this->getRandomProduct($client);

        $crawler = $client->request('GET', $product['url']);
        $form = $crawler->filter('form')->form();
        $form->setValues(['add_to_cart[quantity]' => $quantity]);

        $client->submit($form);

        return $product;
    }
}

Now, for each functional test, we will able to add a random product, go to the cart page (/cart) and check the cart total, product quantity, and the number of items in the cart using the product name and price extracted from the homepage.

`testCartIsEmpty()`

The first test is to verify that the cart is empty when we go to the cart page and that we have never added products to the cart.

Add a testCartIsEmpty() method, go to the cart page (/cart) and assert that the cart is empty thanks to the CartAssertionsTrait trait:

<?php

namespace App\Tests\Controller;

use App\Tests\CartAssertionsTrait;
use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;

class CartControllerTest extends WebTestCase
{
    use CartAssertionsTrait;

    public function testCartIsEmpty()
    {
        $client = static::createClient();
        $crawler = $client->request('GET', '/cart');

        $this->assertResponseIsSuccessful();
        $this->assertCartIsEmpty($crawler);
    }
}

`testAddProductToCart()`

Add a testAddProductToCart() method to test the product form that allows adding products to the cart. We will add a product to the cart and assert that the cart has only 1 item with a quantity equals to 1. We also check the cart total is equal to the product price.

<?php

namespace App\Tests\Controller;

use App\Tests\CartAssertionsTrait;
use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
use Symfony\Component\BrowserKit\AbstractBrowser;

class CartControllerTest extends WebTestCase
{
    use CartAssertionsTrait;

    // ...

    public function testAddProductToCart()
    {
        $client = static::createClient();
        $product = $this->addRandomProductToCart($client);
        $crawler = $client->request('GET', '/cart');

        $this->assertResponseIsSuccessful();
        $this->assertCartItemsCountEquals($crawler, 1);
        $this->assertCartContainsProductWithQuantity($crawler, $product['name'], 1);
        $this->assertCartTotalEquals($crawler, $product['price']);
    }
}

`testAddProductTwiceToCart()`

We need to test when we add a product twice to the cart that the product is not duplicated in the cart and the quantity is increased.

Add a method testAddProductTwiceToCart() method, get a random product and go to the product page. Add the product twice to the cart using the product form and assert then that the cart has only 1 item with a quantity equals to 2. We will also assert that the cart total is equal to the product price multiplied by 2.

<?php

namespace App\Tests\Controller;

use App\Tests\CartAssertionsTrait;
use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
use Symfony\Component\BrowserKit\AbstractBrowser;

class CartControllerTest extends WebTestCase
{
    use CartAssertionsTrait;

    // ...

    public function testAddProductTwiceToCart()
    {
        $client = static::createClient();

        // Gets a random product form the homepage
        $product = $this->getRandomProduct($client);

        // Go to a product page from
        $crawler = $client->request('GET', $product['url']);

        // Adds the product twice to the cart
        for ($i=0 ; $i<2 ;$i++) {
            $form = $crawler->filter('form')->form();
            $form->setValues(['add_to_cart[quantity]' => 1]);
            $client->submit($form);
            $crawler = $client->followRedirect();
        }

        // Go to the cart
        $crawler = $client->request('GET', '/cart');

        $this->assertResponseIsSuccessful();
        $this->assertCartItemsCountEquals($crawler, 1);
        $this->assertCartContainsProductWithQuantity($crawler, $product['name'], 2);
        $this->assertCartTotalEquals($crawler, $product['price'] * 2);
    }
}

`testRemoveProductFromCart()`

Add a testRemoveProductFromCart() to test that the Remove button on the cart page removes the product from the cart:

<?php

namespace App\Tests\Controller;

use App\Tests\CartAssertionsTrait;
use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
use Symfony\Component\BrowserKit\AbstractBrowser;

class CartControllerTest extends WebTestCase
{
    use CartAssertionsTrait;

    // ...

    public function testRemoveProductFromCart()
    {
        $client = static::createClient();
        $product = $this->addRandomProductToCart($client);

        // Go to the cart page
        $client->request('GET', '/cart');

        // Removes the product from the cart
        $client->submitForm('Remove');
        $crawler = $client->followRedirect();

        $this->assertCartNotContainsProduct($crawler, $product['name']);
    }
}

`testClearCart()`

Add a testClearCart() to test that the Clear button on the cart page removes all items from the cart:

<?php

namespace App\Tests\Controller;

use App\Tests\CartAssertionsTrait;
use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
use Symfony\Component\BrowserKit\AbstractBrowser;

class CartControllerTest extends WebTestCase
{
    use CartAssertionsTrait;

    // ...

    public function testClearCart()
    {
        $client = static::createClient();
        $this->addRandomProductToCart($client);

        // Go to the cart page
        $client->request('GET', '/cart');

        // Clears the cart
        $client->submitForm('Clear');
        $crawler = $client->followRedirect();

        $this->assertCartIsEmpty($crawler);
    }
}

`testUpdateQuantity()`

Add a testUpdateQuantity method to check that updating product quantities are working. To do that, use the cart form and set the product's quantity value to 4. Then, assert that the cart contains the product with a quantity equal to 4 and the cart total is equal to the product price multiplied by 4.

<?php

namespace App\Tests\Controller;

use App\Tests\CartAssertionsTrait;
use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
use Symfony\Component\BrowserKit\AbstractBrowser;

class CartControllerTest extends WebTestCase
{
    use CartAssertionsTrait;

    // ...

    public function testUpdateQuantity()
    {
        $client = static::createClient();
        $product = $this->addRandomProductToCart($client);

        // Go to the cart page
        $crawler = $client->request('GET', '/cart');

        // Updates the quantity
        $cartForm = $crawler->filter('.col-md-8 form')->form([
            'cart[items][0][quantity]' => 4
        ]);
        $client->submit($cartForm);
        $crawler = $client->followRedirect();

        $this->assertCartTotalEquals($crawler, $product['price'] * 4);
        $this->assertCartContainsProductWithQuantity($crawler, $product['name'], 4);
    }
}

Executing Tests

If you are familiar with PHPUnit, running the tests in Symfony is done the same way:

$ bin/phpunit
PHPUnit 7.5.20 by Sebastian Bergmann and contributors.

Testing Project Test Suite
......                                                              6 / 6 (100%)

Time: 1.62 seconds, Memory: 34.00 MB

OK (6 tests, 14 assertions)

All tests should be passed. If so, that marks the end of the tutorial. You did it, congrats!

Purging Expired Carts | Building a Shopping Cart with Symfony

Quentin Ferrer — Mon, 21 Dec 2020 12:56:48 +0000

Creating the Command
- Generating the Command
- Configuring the Command
Writing the Logic of the Command
- Finding Expired Carts
- Deleting Expired Carts
Executing the Command

The carts are saved in the database. It is, therefore, necessary to purge the expired carts in order to avoid keeping old carts that are no longer used due to the expiration of the session. To do that, we will create a CLI command with the goal of running it every day in production automatically using a cron job.

Writing the Command

Generating the command

Use the Maker bundle to generate the command:

$ symfony console make:command RemoveExpiredCartsCommand

The command creates a RemoveExpiredCartsCommand class under the src/Command/ directory.

<?php

namespace App\Command;

use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Style\SymfonyStyle;

class RemoveExpiredCartsCommand extends Command
{
    protected static $defaultName = 'RemoveExpiredCartsCommand';

    protected function configure()
    {
        $this
            ->setDescription('Add a short description for your command')
            ->addArgument('arg1', InputArgument::OPTIONAL, 'Argument description')
            ->addOption('option1', null, InputOption::VALUE_NONE, 'Option description')
        ;
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $io = new SymfonyStyle($input, $output);
        $arg1 = $input->getArgument('arg1');

        if ($arg1) {
            $io->note(sprintf('You passed an argument: %s', $arg1));
        }

        if ($input->getOption('option1')) {
            // ...
        }

        $io->success('You have a new command! Now make it your own! Pass --help to see your options.');

        return Command::SUCCESS;
    }
}

Configuring the Command

In the RemoveExpiredCartsCommand class, set the default command name:

protected static $defaultName = 'app:remove-expired-carts';

And update the configure() method to:

define a command description and,
add an optional input argument to define the number of days a cart can remain inactive. By default, a cart will be deleted after 2 days of inactivity.

protected function configure()
{
    $this
        ->setDescription('Removes carts that have been inactive for a defined period')
        ->addArgument(
            'days',
            InputArgument::OPTIONAL,
            'The number of days a cart can remain inactive',
            2
        )
    ;
}

Writing the Logic of the Command

Finding Expired Carts

When we created the OrderEntity entity, a OrderRepository class was generated.

A repository helps you fetch entities of a certain class.

Doctrine recommends centralizing all queries in this repository. So, let's add a method findCartsNotModifiedSince to find inactive cards since a period.

<?php

namespace App\Repository;

use App\Entity\Order;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\Persistence\ManagerRegistry;

/**
 * @method Order|null find($id, $lockMode = null, $lockVersion = null)
 * @method Order|null findOneBy(array $criteria, array $orderBy = null)
 * @method Order[]    findAll()
 * @method Order[]    findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
 */
class OrderRepository extends ServiceEntityRepository
{
    public function __construct(ManagerRegistry $registry)
    {
        parent::__construct($registry, Order::class);
    }

    /**
     * Finds carts that have not been modified since the given date.
     *
     * @param \DateTime $limitDate
     * @param int $limit
     *
     * @return int|mixed|string
     */
    public function findCartsNotModifiedSince(\DateTime $limitDate, int $limit = 10): array
    {
        return $this->createQueryBuilder('o')
            ->andWhere('o.status = :status')
            ->andWhere('o.updatedAt < :date')
            ->setParameter('status', Order::STATUS_CART)
            ->setParameter('date', $limitDate)
            ->setMaxResults($limit)
            ->getQuery()
            ->getResult()
        ;
    }
}

Doctrine provides a Query Builder object to help you building a DQL query.

First, we add a filter to find the carts that have not been modified since the given limit date.
Then, as a cart is an Order in acart status, we don't forget to filter by status.
Finally, we might have a lot of expired carts, so we add a limit filter to avoid running out of memory.

Deleting Expired Carts

The execute() method must contain the logic we want the command to execute. It must return an integer to inform the command status. Implement it to bulk delete expired carts based on the input argument value:

<?php

namespace App\Command;

use App\Repository\OrderRepository;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

class RemoveExpiredCartsCommand extends Command
{
    /**
     * @var EntityManagerInterface 
     */
    private $entityManager;

    /**
     * @var OrderRepository
     */
    private $orderRepository;

    protected static $defaultName = 'app:remove-expired-carts';

    /**
     * RemoveExpiredCartsCommand constructor.
     *
     * @param EntityManagerInterface $entityManager
     * @param OrderRepository $orderRepository
     */
    public function __construct(EntityManagerInterface $entityManager, OrderRepository $orderRepository)
    {
        parent::__construct();
        $this->entityManager = $entityManager;
        $this->orderRepository = $orderRepository;
    }

    /**
     * @inheritDoc
     */
    protected function configure()
    {
        $this
            ->setDescription('Removes carts that have been inactive for a defined period')
            ->addArgument(
                'days',
                InputArgument::OPTIONAL,
                'The number of days a cart can remain inactive',
                2
            )
        ;
    }

    /**
     * @inheritDoc
     */
    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $io = new SymfonyStyle($input, $output);

        $days = $input->getArgument('days');

        if ($days <= 0) {
            $io->error('The number of days should be greater than 0.');
            return Command::FAILURE;
        }

        // Subtracts the number of days from the current date.
        $limitDate = new \DateTime("- $days days");
        $expiredCartsCount = 0;

        while($carts = $this->orderRepository->findCartsNotModifiedSince($limitDate)) {
            foreach ($carts as $cart) {
                // Items will be deleted on cascade
                $this->entityManager->remove($cart);
            }

            $this->entityManager->flush(); // Executes all deletions
            $this->entityManager->clear(); // Detaches all object from Doctrine

            $expiredCartsCount += count($carts);
        };

        if ($expiredCartsCount) {
            $io->success("$expiredCartsCount cart(s) have been deleted.");
        } else {
            $io->info('No expired carts.');
        }

        return Command::SUCCESS;
    }
}

We set the date limit by subtracting the number of days from the current date.
Next, we iterate and handle batches of carts instead of loading all the expired carts into memory. It's a good way to avoid running out of memory with bulk operations like this. The items of the cart have been deleted on cascade.
Then, we write the number of expired carts we deleted to the console and return the command status.

Executing the Command

After configuring and handling the command, you can run it in the terminal:

$ symfony console app:remove-expired-carts

[OK] 1 cart(s) have been deleted.

If there are no expired carts, the command should write the following message in the output:

$ symfony console app:remove-expired-carts

[INFO] No expired carts.

Now you know how to create a CLI command in Symfony. Of course, this command should be executed automatically in production using a cron job but that is not the purpose of this tutorial.

There is one last step left to complete this tutorial. Let's test the cart in the final step.

Clearing the Cart | Building a Shopping Cart with Symfony

Quentin Ferrer — Mon, 21 Dec 2020 12:56:28 +0000

Creating the Event Subscriber
Registering the Event Subscriber

In the same way as the Remove button of the cart, we will use the form events to manage the Clear button of the cart.

Creating the Event Subscriber

Create a ClearCartListener subscriber and subscribe to the FormEvents::POST_SUBMIT event:

<?php

namespace App\Form\EventListener;

use App\Entity\Order;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\Form\FormEvent;
use Symfony\Component\Form\FormEvents;

class ClearCartListener implements EventSubscriberInterface
{
    /**
     * @inheritDoc
     */
    public static function getSubscribedEvents(): array
    {
        return [FormEvents::POST_SUBMIT => 'postSubmit'];
    }

    /**
     * Removes all items from the cart when the clear button is clicked.
     *
     * @param FormEvent $event
     */
    public function postSubmit(FormEvent $event): void
    {
        $form = $event->getForm();
        $cart = $form->getData();

        if (!$cart instanceof Order) {
            return;
        }

        // Is the clear button clicked?
        if (!$form->get('clear')->isClicked()) {
            return;
        }

        // Clears the cart
        $cart->removeItems();
    }
}

The current cart is available from the main form by using the FormEvent::getData() method. It should be an instance of an Order entity.

If the Clear button has been clicked, we remove all items from the cart. In other words, we clear the cart.

Registering the Event Subscriber

To register the CleartCartListener subscriber to the CartType form, use the addEventListener method using the form builder:

<?php

namespace App\Form;

use App\Entity\Order;
use App\Form\EventListener\ClearCartListener;
use App\Form\EventListener\RemoveItemListener;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\CollectionType;
use Symfony\Component\Form\Extension\Core\Type\SubmitType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;

class CartType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('items', CollectionType::class, [
                'entry_type' => CartItemType::class
            ])
            ->add('save', SubmitType::class)
            ->add('clear', SubmitType::class);

        $builder->addEventSubscriber(new RemoveItemListener());
        $builder->addEventSubscriber(new ClearCartListener());
    }

    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults([
            'data_class' => Order::class,
        ]);
    }
}

Of course, you can merge the two listeners into one but the goal was to show you how to use the form events to dynamically modify form data.

At this point, we have managed all the cart features, but there is still some work to be done. Let's go to the next step, it's almost done.

Removing Products from the Cart | Building a Shopping Cart with Symfony

Quentin Ferrer — Mon, 21 Dec 2020 12:56:14 +0000

Creating the Event Subscriber
Registering the Event Subscriber

So far, the Remove button has no effect. As we have multiple submit buttons and the default button is Save, we need to check if a Remove button has been clicked and reorder the cart by removing the product the user wants to remove from the cart.

To modify the form data (the Order entity in our case) based on the submitted data, the best practice is to use Form Events. To do that, we need to create an Event Subscriber class, subscribe to the FormEvents::POST_SUBMIT event, and reorder the cart.

Creating the Event Subscriber

Create a RemoveCartItemListener subscriber and subscribe to the FormEvents::POST_SUBMIT event:

<?php

namespace App\Form\EventListener;

use App\Entity\Order;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\Form\FormEvent;
use Symfony\Component\Form\FormEvents;

/**
 * Class RemoveCartItemListener
 * @package App\Form\EventListener
 */
class RemoveCartItemListener implements EventSubscriberInterface
{
    /**
     * @inheritDoc
     */
    public static function getSubscribedEvents(): array
    {
        return [FormEvents::POST_SUBMIT => 'postSubmit'];
    }

    /**
     * Removes items from the cart based on the data sent from the user.
     *
     * @param FormEvent $event
     */
    public function postSubmit(FormEvent $event): void
    {
        $form = $event->getForm();
        $cart = $form->getData();

        if (!$cart instanceof Order) {
            return;
        }

        // Removes items from the cart
        foreach ($form->get('items')->all() as $child) {
            if ($child->get('remove')->isClicked()) {
                $cart->removeItem($child->getData());
                break;
            }
        }
    }
}

The postSubmit() method will be invoked after the form is submitted. This will allow us to manipulate the form data mapped with the submitted data.

The current cart is available from the main form by using the FormEvent::getData() method. It should be an instance of an Order entity.

For each item field, we check if a Remove button has been clicked by the user with the button's isClicked() method. If so, we get the OrderItem entity by using the form field's getData() method and remove it from the current cart.

Now, we need to register this event subscriber to the CartType form.

Registering the Event Subscriber

To register the RemoveCartItemListener subscriber to the CartType form, use the addEventListener method of the builder in the form type class:

<?php

namespace App\Form;

use App\Entity\Order;
use App\Form\EventListener\RemoveCartItemListener;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\CollectionType;
use Symfony\Component\Form\Extension\Core\Type\SubmitType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;

class CartType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('items', CollectionType::class, [
                'entry_type' => CartItemType::class
            ])
            ->add('save', SubmitType::class)
            ->add('clear', SubmitType::class);

        $builder->addEventSubscriber(new RemoveCartItemListener());
    }

    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults([
            'data_class' => Order::class,
        ]);
    }
}

That's all. Nothing to do in the CartController because we added the logic in the form. Now you are familiar with the form events, let's do the same to clear the cart.

Creating the Cart Page | Building a Shopping Cart with Symfony

Quentin Ferrer — Mon, 21 Dec 2020 12:55:46 +0000

Building Forms
- The CartItemType Form
- The CartType Form
Creating the Controller
Rendering the Cart Page
- List of items
- The Cart summary
Handling the Form
Adding a Link to the Cart Page

The cart page will allow the user to manage the products it wants to purchase. The user will be able to:

Update the quantity of products in the cart,
Remove products from the cart,
Clear the cart,
See the list of products in the cart,
See the quantity of products in the cart,
See the summary of the cart.

Building Forms

The `CartItemType` Form

The CartItemType form will manage the form fields for an OrderItem object of an Order. It will contain the following fields:

quantity: the number of quantity of the product the customer wants to purchase,
remove: a submit button to remove the product from the cart.

Use the Maker to generate the form:

$ symfony console make:form CartItemType OrderItem

Customize it to have the fields we need:

<?php

namespace App\Form;

use App\Entity\OrderItem;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\SubmitType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;

class CartItemType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('quantity')
            ->add('remove', SubmitType::class)
        ;
    }

    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults([
            'data_class' => OrderItem::class
        ]);
    }
}

The `CartType` Form

The CartType form will be the main form and manage all items in the cart. It will contain the following fields:

items: a collection of CartItemType form type. It will allow us to modify all OrderItem items of an Order right inside the cart form itself,
save: a submit button to save the cart,
clear: a submit button to clear the cart.

Use the Maker to generate this class:

$ symfony console make:form CartType Order

Customize it to have the fields we need:

<?php

namespace App\Form;

use App\Entity\Order;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\CollectionType;
use Symfony\Component\Form\Extension\Core\Type\SubmitType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;

class CartType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('items', CollectionType::class, [
                'entry_type' => CartItemType::class
            ])
            ->add('save', SubmitType::class)
            ->add('clear', SubmitType::class);
    }

    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults([
            'data_class' => Order::class,
        ]);
    }
}

Creating the Controller

Create the CartController controller via the Maker:

$ symfony console make:controller CartController

The command creates a CartController class under the src/Controller/ directory and a template file to templates/cart/index.html.twig.

<?php

namespace App\Controller;

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

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

In the CartController controller, implement the index() method:

Get the current cart using the CartManager and,
Create the CartType form with the cart as form data and,
Pass the form view and the cart to the Twig template cart/index.html.twig

<?php

namespace App\Controller;

use App\Form\CartType;
use App\Manager\CartManager;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;

/**
 * Class CartController
 * @package App\Controller
 */
class CartController extends AbstractController
{
    /**
     * @Route("/cart", name="cart")
     */
    public function index(CartManager $cartManager): Response
    {
        $cart = $cartManager->getCurrentCart();
        $form = $this->createForm(CartType::class, $cart);

        return $this->render('cart/index.html.twig', [
            'cart' => $cart,
            'form' => $form->createView()
        ]);
    }
}

Rendering the Cart Page

In the cart/index.html.twig file, add the two-column layout grid below:

{% extends 'base.html.twig' %}

{% block title %}Cart{% endblock %}

{% block body %}
    <div class="container mt-4">
        <h1>Your Cart</h1>
        {% if cart.items.count > 0 %}
            <div class="row mt-4">
                <!-- List of items -->
                <div class="col-md-8"></div>
                <!-- Summary -->
                <div class="col-md-4"></div>
            </div>
        {% else %}
            <div class="alert alert-info">
                Your cart is empty. Go to the <a href="{{ path('home') }}">product list</a>.
            </div>
        {% endif %}
    </div>
{% endblock %}

If the cart is empty, we add a link to the product list.

List of items

In the left column, render the cart form (list of items in the cart) by using the form_start(), form_end(), form_widget() and form_errors() Twig functions:

<div class="col-md-8">
    {{ form_start(form) }}
    <div class="card">
        <div class="card-header bg-dark text-white d-flex">
            <h5>Items</h5>
            <div class="ml-auto">
                {{ form_widget(form.save, {'attr': {'class': 'btn btn-warning'}}) }}
                {{ form_widget(form.clear, {'attr': {'class': 'btn btn-light'}}) }}
            </div>
        </div>
        <ul class="list-group list-group-flush">
            {% for item in form.items %}
                <li class="list-group-item d-flex">
                    <div class="flex-fill mr-2">
                        <img src="https://via.placeholder.com/200x150" width="64" alt="Product image">
                    </div>
                    <div class="flex-fill mr-2">
                        <h5 class="mt-0 mb-0">{{ item.vars.data.product.name }}</h5>
                        <small>{{ item.vars.data.product.description[:50] }}...</small>
                        <div class="form-inline mt-2">
                            <div class="form-group mb-0 mr-2">
                                {{ form_widget(item.quantity, {
                                    'attr': {
                                        'class': 'form-control form-control-sm ' ~ (item.quantity.vars.valid ? '' : 'is-invalid')
                                    }
                                }) }}
                                <div class="invalid-feedback">
                                    {{ form_errors(item.quantity) }}
                                </div>
                            </div>
                            {{ form_widget(item.remove, {'attr': {'class': 'btn btn-dark btn-sm'}}) }}
                        </div>
                    </div>
                    <div class="flex-fill mr-2 text-right">
                        <b>{{ item.vars.data.product.price }} €</b>
                    </div>
                </li>
            {% endfor %}
        </ul>
    </div>
    {{ form_end(form, {'render_rest': false}) }}
</div>

As we don't use Javascript, we need to put the Save button at the beginning of the form to avoid submitting another submit button (such as the Delete button) when the customer press Enter. This is because when we have multiple submit buttons and you press Enter, the form will, by default, use the first submit button it finds.

The Cart summary

In the right column, add the cart summary:

<div class="col-md-4">
    <div class="card mt-4 mt-md-0">
        <h5 class="card-header bg-dark text-white">Summary</h5>
        <ul class="list-group list-group-flush">
            <li class="list-group-item d-flex justify-content-between">
                <div><b>Total</b></div>
                <span><b>{{ cart.total }} €</b></span>
            </li>
        </ul>
        <div class="card-body">
            <a href="#" class="btn btn-warning w-100">Checkout</a>
        </div>
    </div>
</div>

You already can see the cart page on http://localhost:8000/cart.

Handling the Form

In the CartController controller, update the index() method and handle the form to map the submitted data to the form data, the cart as Order entity in this case.

<?php

namespace App\Controller;

use App\Form\CartType;
use App\Manager\CartManager;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;

/**
 * Class CartController
 * @package App\Controller
 */
class CartController extends AbstractController
{
    /**
     * @Route("/cart", name="cart")
     */
    public function index(CartManager $cartManager, Request $request): Response
    {
        $cart = $cartManager->getCurrentCart();

        $form = $this->createForm(CartType::class, $cart);
        $form->handleRequest($request);

        if ($form->isSubmitted() && $form->isValid()) {
            $cart->setUpdatedAt(new \DateTime());
            $cartManager->save($cart);

            return $this->redirectToRoute('cart');
        }

        return $this->render('cart/index.html.twig', [
            'cart' => $cart,
            'form' => $form->createView()
        ]);
    }
}

When the form is submitted, we have just to save the cart in session and database and then redirect the customer to the cart page. That's all.

In fact, the Order entity is automatically updated according to the submitted data. The data for the items field is used to construct an ArrayCollection of OrderItem entities. Each of them has been updated with the quantity chosen by the customer. The collection is then set on the items property of the Order.

For the moment, we only manage the edition of items in the cart. We will manage the deletion of each of them and the clearing of the cart later.

Adding a Link to the Cart Page

The customer needs a button to access the cart. Add a Cart button to the navbar in the base layout base.html.twig into the header block:

{% block header %}
    <nav class="navbar navbar-dark bg-dark sticky-top">
        {# ... #}
        <div class="navbar-nav">
            <a href="{{ path('cart') }}" class="btn btn-light">
                Cart
            </a>
        </div>
    </nav>
{% endblock %}

Now, the navbar contains a button to the cart page.

What's about the Remove and Clear buttons? We will manage them in the next two steps.

Adding Products to the Cart | Building a Shopping Cart with Symfony

Quentin Ferrer — Mon, 21 Dec 2020 12:55:22 +0000

Building the AddToCartType Form
Displaying the Form
Validating the Model
Handling the Form

In this step, we will handle the form on the product detail page:

Building a `AddToCartType` form

Use the Maker bundle to generate a form class:

$ symfony console make:form AddToCartType OrderItem

The AddToCartType class defines a form for the OrderItem entity. Customize it to have the following fields:

quantity: the number of quantity of products the user wants to purchase,
add: the submit button to add the product to the cart.

<?php

namespace App\Form;

use App\Entity\OrderItem;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\SubmitType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;

class AddToCartType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder->add('quantity');
        $builder->add('add', SubmitType::class, [
            'label' => 'Add to cart'
        ]);
    }

    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults([
            'data_class' => OrderItem::class,
        ]);
    }
}

The form fields are bound to the model. The submitted data will be automatically mapped to the model class properties.

Displaying the Form

To display the form to the user, create the form in the ProductController controller using the FormFactory factory and pass it to the template:

<?php
namespace App\Controller;
use App\Entity\Product;
use App\Form\AddToCartType;
use App\Repository\ProductRepository;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;

/**
 * Class ProductController
 * @package App\Controller
 */
class ProductController extends AbstractController
{
    /**
     * @Route("/product/{id}", name="product.detail")
     */
    public function detail(Product $product)
    {
        $form = $this->createForm(AddToCartType::class);

        return $this->render('product/detail.html.twig', [
            'product' => $product,
            'form' => $form->createView()
        ]);
    }
}

In the template product/detail.html.twig, display the form by using the form Twig function:

<div class="col-md-8">
    <h1 class="mt-4 mt-md-0">{{ product.name }}</h1>
    <h2>{{ product.price }} €</h2>
    <hr>
    <b>Description: </b>{{ product.description }}
    {{ form_start(form, {'attr': {'class': 'mt-4 p-4 bg-light'}}) }}
    <div class="form-group">
        {{ form_label(form.quantity) }}
        {{ form_widget(form.quantity, {
            'attr': {
                'class': 'form-control ' ~ (form.quantity.vars.valid ? '' : 'is-invalid')
            }
        }) }}
        <div class="invalid-feedback">
            {{ form_errors(form.quantity) }}
        </div>
    </div>
    {{ form_widget(form.add, {'attr': {'class': 'btn btn-warning w-25'}}) }}
    {{ form_end(form) }}
</div>

Validating the Model

We need to add some validation constraints on the OrderItem model to ensure that the submitted quantity is:

not empty and,
greater than or equal to 1.

<?php

namespace App\Entity;

use App\Repository\OrderItemRepository;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Validator\Constraints as Assert;

/**
 * @ORM\Entity(repositoryClass=OrderItemRepository::class)
 */
class OrderItem
{
    // ...

    /**
     * @ORM\Column(type="integer")
     * @Assert\NotBlank()
     * @Assert\GreaterThanOrEqual(1)
     */
    private $quantity;

    // ...
}

Handling the Form

Now, we can handle the form submission and add the product to the cart by using the CartManager manager.

<?php

namespace App\Controller;

use App\Entity\Product;
use App\Form\AddToCartType;
use App\Manager\CartManager;
use App\Repository\ProductRepository;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;

/**
 * Class ProductController
 * @package App\Controller
 */
class ProductController extends AbstractController
{
    // ...

    /**
     * @Route("/product/{id}", name="product.detail")
     */
    public function detail(Product $product, Request $request, CartManager $cartManager)
    {
        $form = $this->createForm(AddToCartType::class);

        $form->handleRequest($request);

        if ($form->isSubmitted() && $form->isValid()) {
            $item = $form->getData();
            $item->setProduct($product);

            $cart = $cartManager->getCurrentCart();
            $cart
                ->addItem($item)
                ->setUpdatedAt(new \DateTime());

            $cartManager->save($cart);

            return $this->redirectToRoute('product.detail', ['id' => $product->getId()]);
        }

        return $this->render('product/detail.html.twig', [
            'product' => $product,
            'form' => $form->createView()
        ]);
    }
}

When the form is submitted, the OrderItem object is updated according to the submitted data. We retrieve it by using the Form::getData() method and we don't forget to link the product to the OrderItem object. Then, we add the item to the current cart and persist it in the session and database by using the CartManager::save() method. Finally, we redirect the user to the product page.

If the form is not valid, we display the page with the form containing the submitted values and error messages.

For the moment, the user can add products to the cart but cannot review their cart because the page does not yet exist. Let's create the cart page in the next step.

Managing the Cart Storage | Building a Shopping Cart with Symfony

Quentin Ferrer — Mon, 21 Dec 2020 12:54:53 +0000

Creating the Session Storage
Creating the Cart Manager
Retrieving the current Cart
Saving the Cart

Each user will have their own cart. As soon as a product is added to the cart, an Order is created in a database and then associated with the user via an Order ID in the session.

We will not manage user accounts, so the cart will be always associated with an anonymous user - a user who does not have a user account.

Creating the Session Storage

The cart has to be stored in the session to keep the items in the user's cart during their visit. Once the session has expired, the cart will be cleared. A new cart will be created and stored when the user adds a product to the cart.

Create a CartSessionStorage service to manage the cart in the session and add the following operations:

Add a setCart() method to save the cart in the cart_id session key by using the cart ID,
Add a getCart() method to retrieve the cart in the session. Get the cart ID from the cart_id session key, fetch the cart object by using the OrderRepository repository, and return it.

<?php

namespace App\Storage;

use App\Entity\Order;
use App\Repository\OrderRepository;
use Symfony\Component\HttpFoundation\RequestStack;
use Symfony\Component\HttpFoundation\Session\SessionInterface;

class CartSessionStorage
{
    /**
     * The request stack.
     *
     * @var RequestStack
     */
    private $requestStack;

    /**
     * The cart repository.
     *
     * @var OrderRepository
     */
    private $cartRepository;

    /**
     * @var string
     */
    const CART_KEY_NAME = 'cart_id';

    /**
     * CartSessionStorage constructor.
     *
     * @param RequestStack $requestStack
     * @param OrderRepository $cartRepository
     */
    public function __construct(RequestStack $requestStack, OrderRepository $cartRepository)
    {
        $this->requestStack = $requestStack;
        $this->cartRepository = $cartRepository;
    }

    /**
     * Gets the cart in session.
     *
     * @return Order|null
     */
    public function getCart(): ?Order
    {
        return $this->cartRepository->findOneBy([
            'id' => $this->getCartId(),
            'status' => Order::STATUS_CART
        ]);
    }

    /**
     * Sets the cart in session.
     *
     * @param Order $cart
     */
    public function setCart(Order $cart): void
    {
        $this->getSession()->set(self::CART_KEY_NAME, $cart->getId());
    }

    /**
     * Returns the cart id.
     *
     * @return int|null
     */
    private function getCartId(): ?int
    {
        return $this->getSession()->get(self::CART_KEY_NAME);
    }

    private function getSession(): SessionInterface
    {
        return $this->requestStack->getSession();
    }
}

Creating the Cart Manager

Create the CartManager class that helps us retrieve the current cart of a user and saving the cart.

<?php

namespace App\Manager;

/**
 * Class CartManager
 * @package App\Manager
 */
class CartManager
{
}

Retrieving the current cart

For each action performed on the cart, we will need to retrieve the current cart:

If the cart is already associated with the user in the session, it's the current cart,
If the cart does not exist in the session, a new cart is created and becomes the current cart. It will be associated with the user in the session after being persisted in the database.

Add a getCurrentCart() method to the CartManager and retrieve the current cart. Get the cart already associated with the user using the CartSessionStorage. If the cart does not exist, create a new cart by using the OrderFactory factory. Finally, return the cart.

<?php

namespace App\Manager;

use App\Entity\Order;
use App\Factory\OrderFactory;
use App\Storage\CartSessionStorage;

/**
 * Class CartManager
 * @package App\Manager
 */
class CartManager
{
    /**
     * @var CartSessionStorage
     */
    private $cartSessionStorage;

    /**
     * @var OrderFactory
     */
    private $cartFactory;

    /**
     * CartManager constructor.
     *
     * @param CartSessionStorage $cartStorage
     * @param OrderFactory $orderFactory
     */
    public function __construct(
        CartSessionStorage $cartStorage,
        OrderFactory $orderFactory
    ) {
        $this->cartSessionStorage = $cartStorage;
        $this->cartFactory = $orderFactory;
    }

    /**
     * Gets the current cart.
     * 
     * @return Order
     */
    public function getCurrentCart(): Order
    {
        $cart = $this->cartSessionStorage->getCart();

        if (!$cart) {
            $cart = $this->cartFactory->create();
        }

        return $cart;
    }
}

Saving the Cart

Rather than storing the whole object in the session, we will persist the cart in the database to associate it with the user by using the Order ID.

Add a save() method to the CartManager, persist the cart in the database by using the EntityManager service, and store the cart in session by using the CartSessionStorage service.

<?php

namespace App\Manager;

use App\Entity\Order;
use App\Factory\OrderFactory;
use App\Storage\CartSessionStorage;
use Doctrine\ORM\EntityManagerInterface;

/**
 * Class CartManager
 * @package App\Manager
 */
class CartManager
{
    /**
     * @var CartSessionStorage
     */
    private $cartSessionStorage;

    /**
     * @var OrderFactory
     */
    private $cartFactory;

    /**
     * @var EntityManagerInterface
     */
    private $entityManager;

    /**
     * CartManager constructor.
     *
     * @param CartSessionStorage $cartStorage
     * @param OrderFactory $orderFactory
     * @param EntityManagerInterface $entityManager
     */
    public function __construct(
        CartSessionStorage $cartStorage,
        OrderFactory $orderFactory,
        EntityManagerInterface $entityManager
    ) {
        $this->cartSessionStorage = $cartStorage;
        $this->cartFactory = $orderFactory;
        $this->entityManager = $entityManager;
    }

    // ...

    /**
     * Persists the cart in database and session.
     *
     * @param Order $cart
     */
    public function save(Order $cart): void
    {
        // Persist in database
        $this->entityManager->persist($cart);
        $this->entityManager->flush();
        // Persist in session
        $this->cartSessionStorage->setCart($cart);
    }
}

With this approach, you will be able to associate a cart with a database user if you want to have a cart for logged in users. It is also a good way to let the user manage their cart on different devices and create an abandoned cart workflow.

Now that we can save carts and retrieve the current cart of the visitor, we are ready to add products to the cart.

Creating Cart Entities | Building a Shopping Cart with Symfony

Quentin Ferrer — Mon, 21 Dec 2020 12:54:20 +0000

Generating entities
- Generating the OrderItem entity
- Generating the Order entity
- Setting Cascade Opeations
Migrating the Database
Setting the default Order status
Avoiding adding duplicate item
Removing all items from the Order
Calculating the Order totals
Creating the Factory

Throughout the tutorial, we will talk about a cart as an Order. It's an Order that is in progress, not placed yet.

Actually, a cart is an Order in a cart status.

Generating entities

The Order entity contains:

a collection of OrderItem entity: it represents products as its physical copies, with chosen quantities,
a status: it will be initialized to cart,
a creation date: the creation date of the order,
a modification date: the date the order was last modified.

Generating the `OrderItem` entity

Use the Maker bundle to generate the OrderItem entity:

$ symfony console make:entity OrderItem

Add the fields that we need:

product, relation, related to the Product entity, ManyToOne, no, no
quantity, integer, no

<?php

namespace App\Entity;

use App\Repository\OrderItemRepository;
use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity(repositoryClass=OrderItemRepository::class)
 */
class OrderItem
{
    /**
     * @ORM\Id
     * @ORM\GeneratedValue
     * @ORM\Column(type="integer")
     */
    private $id;

    /**
     * @ORM\ManyToOne(targetEntity=Product::class)
     * @ORM\JoinColumn(nullable=false)
     */
    private $product;

    /**
     * @ORM\Column(type="integer")
     */
    private $quantity;

    public function getId(): ?int
    {
        return $this->id;
    }

    public function getProduct(): ?Product
    {
        return $this->product;
    }

    public function setProduct(?Product $product): self
    {
        $this->product = $product;

        return $this;
    }

    public function getQuantity(): ?int
    {
        return $this->quantity;
    }

    public function setQuantity(int $quantity): self
    {
        $this->quantity = $quantity;

        return $this;
    }
}

Generating the `Order` entity

One more time, use Maker bundle to generate the Order entity:

$ symfony console make:entity Order

Add the fields that we need:

items, relation, related to the OrderItem entity, OneToMany, orderRef (order is a reserved word in Mysql), no, yes
status, string, 255, no
createdAt, datetime, no
updatedAt, datetime, no

<?php

namespace App\Entity;

use App\Repository\OrderRepository;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity(repositoryClass=OrderRepository::class)
 * @ORM\Table(name="`order`")
 */
class Order
{
    /**
     * @ORM\Id
     * @ORM\GeneratedValue
     * @ORM\Column(type="integer")
     */
    private $id;

    /**
     * @ORM\OneToMany(targetEntity=OrderItem::class, mappedBy="orderRef", orphanRemoval=true)
     */
    private $items;

    /**
     * @ORM\Column(type="string", length=255)
     */
    private $status;

    /**
     * @ORM\Column(type="datetime")
     */
    private $createdAt;

    /**
     * @ORM\Column(type="datetime")
     */
    private $updatedAt;

    public function __construct()
    {
        $this->items = new ArrayCollection();
    }

    public function getId(): ?int
    {
        return $this->id;
    }

    /**
     * @return Collection|OrderItem[]
     */
    public function getItems(): Collection
    {
        return $this->items;
    }

    public function addItem(OrderItem $item): self
    {
        if (!$this->items->contains($item)) {
            $this->items[] = $item;
            $item->setOrderRef($this);
        }

        return $this;
    }

    public function removeItem(OrderItem $item): self
    {
        if ($this->items->removeElement($item)) {
            // set the owning side to null (unless already changed)
            if ($item->getOrderRef() === $this) {
                $item->setOrderRef(null);
            }
        }

        return $this;
    }

    public function getStatus(): ?string
    {
        return $this->status;
    }

    public function setStatus(string $status): self
    {
        $this->status = $status;

        return $this;
    }

    public function getCreatedAt(): ?\DateTimeInterface
    {
        return $this->createdAt;
    }

    public function setCreatedAt(\DateTimeInterface $createdAt): self
    {
        $this->createdAt = $createdAt;

        return $this;
    }

    public function getUpdatedAt(): ?\DateTimeInterface
    {
        return $this->updatedAt;
    }

    public function setUpdatedAt(\DateTimeInterface $updatedAt): self
    {
        $this->updatedAt = $updatedAt;

        return $this;
    }

}

The OrderItem has been updated with the following changes:

<?php

namespace App\Entity;

use App\Repository\OrderItemRepository;
use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity(repositoryClass=OrderItemRepository::class)
 */
class OrderItem
{
    // ...
    /**
     * @ORM\ManyToOne(targetEntity=Order::class, inversedBy="items")
     * @ORM\JoinColumn(nullable=false)
     */
    private $orderRef;
    // ...
    public function getOrderRef(): ?Order
    {
        return $this->orderRef;
    }

    public function setOrderRef(?Order $orderRef): self
    {
        $this->orderRef = $orderRef;

        return $this;
    }
}

Setting Cascade Operations

When we add a new OrderItem entity to an Order entity, we should persist it before persisting the Order entity. Also, when we will want to remove an Order entity, we should remove all OrderItem entities before removing the Order entity.

It can be really boring, so we will let Doctrine take care of this internally by using the cascade operations. To do that, add a new cascade option on the items property of the Order entity:

/**
 * @ORM\OneToMany(targetEntity=OrderItem::class, mappedBy="orderRef", cascade={"persist", "remove"}, orphanRemoval=true)
 */
private $items;

Therefore, when we will persist/remove an Order entity, Doctrine will automatically call persist/remove on each of the OrderItem objects associated with the Order entity.

Migrating the Database

Create a migration file via the Maker bundle:

$ symfony console make:migration

A migration file has been stored under the migrations/ directory:

<?php

declare(strict_types=1);

namespace DoctrineMigrations;

use Doctrine\DBAL\Schema\Schema;
use Doctrine\Migrations\AbstractMigration;

/**
 * Auto-generated Migration: Please modify to your needs!
 */
final class Version20201215150141 extends AbstractMigration
{
    public function getDescription() : string
    {
        return '';
    }

    public function up(Schema $schema) : void
    {
        // this up() migration is auto-generated, please modify it to your needs
        $this->addSql('CREATE TABLE `order` (id INT AUTO_INCREMENT NOT NULL, status VARCHAR(255) NOT NULL, created_at DATETIME NOT NULL, updated_at DATETIME NOT NULL, PRIMARY KEY(id)) DEFAULT CHARACTER SET utf8mb4 COLLATE `utf8mb4_unicode_ci` ENGINE = InnoDB');
        $this->addSql('CREATE TABLE order_item (id INT AUTO_INCREMENT NOT NULL, product_id INT NOT NULL, order_ref_id INT NOT NULL, quantity INT NOT NULL, INDEX IDX_52EA1F094584665A (product_id), INDEX IDX_52EA1F09E238517C (order_ref_id), PRIMARY KEY(id)) DEFAULT CHARACTER SET utf8mb4 COLLATE `utf8mb4_unicode_ci` ENGINE = InnoDB');
        $this->addSql('ALTER TABLE order_item ADD CONSTRAINT FK_52EA1F094584665A FOREIGN KEY (product_id) REFERENCES product (id)');
        $this->addSql('ALTER TABLE order_item ADD CONSTRAINT FK_52EA1F09E238517C FOREIGN KEY (order_ref_id) REFERENCES `order` (id)');
    }

    public function down(Schema $schema) : void
    {
        // this down() migration is auto-generated, please modify it to your needs
        $this->addSql('ALTER TABLE order_item DROP FOREIGN KEY FK_52EA1F09E238517C');
        $this->addSql('DROP TABLE `order`');
        $this->addSql('DROP TABLE order_item');
    }
}

Now, we can update the local database schema:

$ symfony console doctrine:migrations:migrate

Setting the default Order status

All new orders must be in the default cart state. In the generated Order entity, initialize the status using a STATUS_CART constant:

<?php

namespace App\Entity;

// ...

/**
 * @ORM\Entity(repositoryClass=OrderRepository::class)
 * @ORM\Table(name="`order`")
 */
class Order
{
    // ...

    /**
     * @ORM\Column(type="string", length=255)
     */
    private $status = self::STATUS_CART;

    /**
     * An order that is in progress, not placed yet.
     *
     * @var string
     */
    const STATUS_CART = 'cart';

    // ...
}

Avoiding adding duplicate `OrderItem`

Currently, it's possible to add duplicate OrderItem entities (with the same Product) to the Order entity. Let's fix it.

Add a equals() method to the OrderItem class to know if the item corresponds to an item given as an argument.

/**
 * Tests if the given item given corresponds to the same order item.
 *
 * @param OrderItem $item
 *
 * @return bool
 */
public function equals(OrderItem $item): bool
{
    return $this->getProduct()->getId() === $item->getProduct()->getId();
}

Update the addItem() method of the Order entity to sum the quantity if the item already exists:

public function addItem(OrderItem $item): self
{
    foreach ($this->getItems() as $existingItem) {
        // The item already exists, update the quantity
        if ($existingItem->equals($item)) {
            $existingItem->setQuantity(
                $existingItem->getQuantity() + $item->getQuantity()
            );
            return $this;
        }
    }

    $this->items[] = $item;
    $item->setOrderRef($this);

    return $this;
}

Removing all items from the Order

Add a removeItems() method to the Order class to remove all items from the Order:

/**
 * Removes all items from the order.
 *
 * @return $this
 */
public function removeItems(): self
{
    foreach ($this->getItems() as $item) {
        $this->removeItem($item);
    }

    return $this;
}

Calculating the Order totals

We will need to show the cart summary. Note that we ignore adjustments that order could have such as shipping cost, promo code, etc.

First, add a getTotal() method to the OrderItem entity to calculate the item total:

/**
 * Calculates the item total.
 *
 * @return float|int
 */
public function getTotal(): float
{
    return $this->getProduct()->getPrice() * $this->getQuantity();
}

Finally, add a getTotal() method to the Order entity to calculate the order total:

/**
 * Calculates the order total.
 *
 * @return float
 */
public function getTotal(): float
{
    $total = 0;

    foreach ($this->getItems() as $item) {
        $total += $item->getTotal();
    }

    return $total;
}

Creating the Factory

The OrderFactory factory will help us to create Order and OrderItem entities with default data. It also allows you to change the Order entity easily.

<?php

namespace App\Factory;

use App\Entity\Order;
use App\Entity\OrderItem;
use App\Entity\Product;

/**
 * Class OrderFactory
 * @package App\Factory
 */
class OrderFactory
{
    /**
     * Creates an order.
     *
     * @return Order
     */
    public function create(): Order
    {
        $order = new Order();
        $order
            ->setStatus(Order::STATUS_CART)
            ->setCreatedAt(new \DateTime())
            ->setUpdatedAt(new \DateTime());

        return $order;
    }

    /**
     * Creates an item for a product.
     *
     * @param Product $product
     *
     * @return OrderItem
     */
    public function createItem(Product $product): OrderItem
    {
        $item = new OrderItem();
        $item->setProduct($product);
        $item->setQuantity(1);

        return $item;
    }
}

Let's go to the next step to manage cart storage.

Managing Products | Building a Shopping Cart with Symfony

Quentin Ferrer — Mon, 21 Dec 2020 12:52:57 +0000

Creating the Entity
Migrating the Database
Generating Fake Products
- Creating the Product Fixtures
- Loading Data Fixtures
Creating the Product List Page
- Updating the Home Controller
- Rendering the Product List Page
Creating the Product Detail Page
- Creating the Product Controller
- Rendering the Product Detail Page
Adding a Link to the Product Page
- Updating the Home Page

A shopping cart without products does not make sense. In this part, to simplify the project, we will load fake products instead of managing them from an admin backend. We will also create a product list page and a product details page to allow users to add products to the cart.

We will not manage product stocks.

Creating the Entity

A Product can be described with a few properties:

Name
Description
Price

Use the Maker bundle to generate a class that represents a Product:

$ symfony console make:entity Product

The command is interactive, let's add the fields we need:

name, string, 255, no
description, text, no
price, float, no

A Product entity has been stored under the App\Entity namespace and a ProductRepository repository under the App\Repository.

<?php

namespace App\Entity;

use App\Repository\ProductRepository;
use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity(repositoryClass=ProductRepository::class)
 */
class Product
{
    /**
     * @ORM\Id
     * @ORM\GeneratedValue
     * @ORM\Column(type="integer")
     */
    private $id;

    /**
     * @ORM\Column(type="string", length=255)
     */
    private $name;

    /**
     * @ORM\Column(type="text")
     */
    private $description;

    /**
     * @ORM\Column(type="float")
     */
    private $price;

    public function getId(): ?int
    {
        return $this->id;
    }

    public function getName(): ?string
    {
        return $this->name;
    }

    public function setName(string $name): self
    {
        $this->name = $name;

        return $this;
    }

    public function getDescription(): ?string
    {
        return $this->description;
    }

    public function setDescription(string $description): self
    {
        $this->description = $description;

        return $this;
    }

    public function getPrice(): ?float
    {
        return $this->price;
    }

    public function setPrice(float $price): self
    {
        $this->price = $price;

        return $this;
    }
}

Migrating the Database

For now, the database is empty. We need to create the database tables related to the entity.

One more time, use the Maker bundle to generate a migration file:

$ symfony console make:migration

A migration file has been stored under the migrations/ directory.

<?php

declare(strict_types=1);

namespace DoctrineMigrations;

use Doctrine\DBAL\Schema\Schema;
use Doctrine\Migrations\AbstractMigration;

/**
 * Auto-generated Migration: Please modify to your needs!
 */
final class Version20201215122946 extends AbstractMigration
{
    public function getDescription() : string
    {
        return '';
    }

    public function up(Schema $schema) : void
    {
        // this up() migration is auto-generated, please modify it to your needs
        $this->addSql('CREATE TABLE product (id INT AUTO_INCREMENT NOT NULL, name VARCHAR(255) NOT NULL, description LONGTEXT NOT NULL, price DOUBLE PRECISION NOT NULL, PRIMARY KEY(id)) DEFAULT CHARACTER SET utf8mb4 COLLATE `utf8mb4_unicode_ci` ENGINE = InnoDB');
    }

    public function down(Schema $schema) : void
    {
        // this down() migration is auto-generated, please modify it to your needs
        $this->addSql('DROP TABLE product');
    }
}

We can now ready to update the local database schema:

$ symfony console doctrine:migrations:migrate

Generating Fake Products

Creating the Product Fixtures

To add some fake products to your database, create a ProductFixtures class via the Maker bundle:

$ symfony console make:fixtures ProductFixtures

In the load() method, add ten products with fake data:

<?php

namespace App\DataFixtures;

use App\Entity\Product;
use Doctrine\Bundle\FixturesBundle\Fixture;
use Doctrine\Persistence\ObjectManager;

/**
 * Class ProductFixtures
 */
class ProductFixtures extends Fixture
{
    public function load(ObjectManager $manager): void
    {
        for ($i = 1; $i <= 10; $i++) {
            $product = new Product();
            $product
                ->setName('Product ' . $i)
                ->setDescription('Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua')
                ->setPrice(mt_rand(10, 600));

            $manager->persist($product);
        }

        $manager->flush();
    }
}

Loading Data Fixtures

Load the fixtures by executing this command:

$ symfony console doctrine:fixtures:load

Creating the Products List Page

The list of products page will be the homepage.

Updating the Home Controller

In the HomeController controller, implement the index() method:

Fetch all products by using the ProductRepository and pass them to the Twig template products/index.html.twig.

<?php

namespace App\Controller;

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

class HomeController extends AbstractController
{
    /**
     * @Route("/", name="home")
     */
    public function index(ProductRepository $productRepository): Response
    {
        return $this->render('home/index.html.twig', [
            'products' => $productRepository->findAll(),
        ]);
    }
}

Rendering the Product List Page

The last step is to update the templates/home/index.html.twig file:

{% extends 'base.html.twig' %}

{% block body %}
<div class="container">
    <h1 class="mt-3 mb-4">Products</h1>
    <div class="row">
        {% for product in products %}
            <div class="col-md-4">
                <div class="card mb-4">
                    <img src="https://via.placeholder.com/200x150" alt="{{ product.name }}" class="card-img-top">
                    <div class="card-body">
                        <h5 class="card-title">{{ product.name }}</h5>
                        <p class="card-text">{{ product.description }}</p>
                        <div class="d-flex justify-content-between align-item-center">
                            <a href="#" class="btn btn-dark">View details</a>
                            <span class="h5 mt-auto">{{ product.price }} €</span>
                        </div>
                    </div>
                </div>
            </div>
        {% endfor %}
    </div>
</div>
{% endblock %}

Now, you can see the list of products on the homepage http://localhost:8000.

Creating the Product Detail Page

The detail page will be used to view the details of a product and allow a user to add one or more items to the cart.

Creating the Product Controller

Create the ProductController controller via the Maker bundle:

$ symfony console make:controller ProductController

The command creates a ProductController class under the src/Controller/ directory and a template file to templates/product/index.html.twig.

<?php

namespace App\Controller;

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

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

Rename the index() method with a detail() method in the ProductController and implement it:

Define a route with a product ID parameter,
Get the product and pass it to the Twig template product/detail.html.twig.

<?php

namespace App\Controller;

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

class ProductController extends AbstractController
{
    /**
     * @Route("/product/{id}", name="product.detail")
     */
    public function index(Product $product): Response
    {
        return $this->render('product/detail.html.twig', [
            'product' => $product,
        ]);
    }
}

Thanks to the ParamConverters, Symfony will automatically query for the Product entity and pass it as an argument to the controller. It will also show a 404 page if no entity can be found.

Rendering the Product Detail Page

Rename the template product/index.html.twig file with product/detail.html.twig and design the product page:

{% extends 'base.html.twig' %}

{% block title %}{{ product.name }}{% endblock %}

{% block body %}
    <div class="container">
        <div class="row mt-3 mb-4">
            <div class="col-md-4">
                <img src="https://via.placeholder.com/600x400" alt="{{ product.name }}" class="img-fluid">
            </div>
            <div class="col-md-8">
                <h1 class="mt-4 mt-md-0">{{ product.name }}</h1>
                <h2>{{ product.price }} €</h2>
                <hr>
                <b>Description: </b>{{ product.description }}
                <form class="mt-4 p-4 bg-light" method="post">
                    <div class="form-group">
                        <label for="quantity">Quantity</label>
                        <input type="number" class="form-control" id="quantity">
                    </div>
                    <button class="btn btn-warning">Add to Cart</button>
                </form>
            </div>
        </div>
    </div>
{% endblock %}

Now you can see the detail of the products. For example, to see the Product 1, go to the page http://localhost:8000/product/1.

Note that the form will be handled later.

Adding a Link to the Product Page

Updating the Home Page

The View details button gets nowhere. Open the template home/index.html.twig and replace the hyperlink with the route to the product page:

<a href="{{ path('product.detail', {id: product.id}) }}" class="btn btn-dark">
    View details
</a>

It's done! Go to the homepage and click on the View details button of a product and take a look at your product page.

Let's manage the cart to the next step.

Getting Started | Building a Shopping Cart with Symfony

Quentin Ferrer — Mon, 21 Dec 2020 12:52:13 +0000

Requirements
Setting up the Project
- Creating the project
- Launching the Local Web Server
- Installing dependencies
Setting up the Database
- Adding MySQL to Docker Compose
- Starting Docker Compose
- Changing the Environment Variable
- Creating the Database
Creating the Home Page
- Creating the Home Controller
- Updating the base Layout

Before coding, we need to set up the working environment and make sure that everything is working well.

Requirements

Setting up the Project

Creating the project

Create a new Symfony project using the Symfony CLI tool:

$ symfony new happy-shop

Launching the Local Web Server

From the project directory, start the web server in the background:

$ cd happy-shop
$ symfony server:start -d

The server started on the port 8000. Open the website http://localhost:8000 in a browser.

Installing dependencies

We will need some dependencies for our project. To install these packages, we will use the Symfony CLI:

$ symfony composer req form validator annotations orm twig

Form: we will need to build forms for the shopping cart,
Validator: it will allow us to validate the data models,
Annotations: we will use the annotations format for the configuration of the project,
ORM: known as Doctrine, it will help us to persist entities in a database,
Twig: all templates will be created using Twig.

Dependencies for developing

The following components will be installed only for developing the project:

$ symfony composer req profiler maker orm-fixtures phpunit browser-kit dama/doctrine-test-bundle --dev

Profiler: useful to debug and see details of all requests we will execute,
Maker: it helps you to generate a lot of different classes. We will use it all the time during the project,
Fixtures: it will be used to load fake products to help us developing the shopping cart,
PHPUnit: essential for writing tests,
BrowserKit: to test with a Client service that simulates a browser,
DoctrineTestBundle: provides a listener to reset the database between tests.

Setting up the Database

We will need to persist entities in permanent storage. We will use the MySQL database.

Adding MySQL to Docker Compose

From the project directory, create a docker-compose.yaml file:

# docker-compose.yaml
version: '3'
services:
  database:
    image: library/mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: happy
      MYSQL_DATABASE: happy_shop
    ports:
      - 3306:3306

This will install the MySQL server at version 8.0 and configure some environment variables that control the database name and credentials. The exposed port will help us access the database from Symfony.

Starting Docker Compose

Start Docker Compose in the background:

$ docker-compose up -d

Changing the Environment Variable

Set up the default DATABASE_URL value to use MySQL:

# .env
###> doctrine/doctrine-bundle ###
DATABASE_URL="mysql://root:happy@127.0.0.1:3306/happy_shop?serverVersion=8.0"
###< doctrine/doctrine-bundle ###

Creating the Database

To create the database, run the following command:

$ bin/console doctrine:database:create --if-not-exists

Creating the Home Page

Creating the Home Controller

Create the HomeController controller via the Maker:

$ symfony console make:controller HomeController

The command creates a HomeController class under the src/Controller/ directory and a template file to templates/home/index.html.twig.

In the HomeController class, define a route to make it match the homepage:

<?php

namespace App\Controller;

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

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

You already can go to the homepage http://localhost:8000. Try it!

Updating the base Layout

All templates will be depending on the base layout to share common elements, like the meta, title, header, and more.

We will use Bootstrap for designing the pages of the project but please note that the design is not the goal of this project so we will just make it functional.

{# templates/base.html.twig #}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
    <title>{% block title %}Happy Shop{% endblock %}</title>
    {% block stylesheets %}
        <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@4.5.3/dist/css/bootstrap.min.css"
              integrity="sha384-TX8t27EcRE3e/ihU7zmQxVncDAy5uIKz4rEkgIXeMed4M0jlfIDPvg6uqKI2xXr2"
              crossorigin="anonymous">
    {% endblock %}
</head>
<body>
{% block header %}
    <nav class="navbar navbar-dark bg-dark sticky-top">
        <a href="{{ path('home') }}" class="navbar-brand">
            Happy Shop
        </a>
    </nav>
{% endblock %}

{% block body %}{% endblock %}
</body>
</html>

This template defines the base HTML skeleton. We've defined the title, header, and body blocks. We also set the viewport to make the app responsive.

To see the result, let's go back to the homepage http://localhost:8000:

We are ready! Let's manage products to the next step.

DEV Community: Quentin Ferrer

Lire un gros fichier ligne par ligne en PHP (Array, Itérateur & Générateur)

Array

Problèmes

Le temps d'exécution est trop long

La limite de mémoire est atteinte

Itérateur

Problème

Genérateur

Problème

Conclusion

Ressources

Credits

Creating a COVID-19 Data Visualization with Symfony UX

Creating the project

Launching the Local Web Server

Installing Webpack Encore

Installing UX Chart.js

Creating the Covid-19 Http Client

Creating the Covid Controller

Rendering the Chart

Testing the Cart | Building a Shopping Cart with Symfony

Configuring the Test Environment

Configuring a Database for Tests

Configuring PHPUnit

Configuring the Session

Writing Cart Assertions

assertCartIsEmpty()

assertCartTotalEquals()

assertCartItemsCountEquals()

assertCartContainsProductWithQuantity()

assertCartNotContainsProduct()

Writing Functional Tests

testCartIsEmpty()

testAddProductToCart()

testAddProductTwiceToCart()

testRemoveProductFromCart()

testClearCart()

testUpdateQuantity()

Executing Tests

Purging Expired Carts | Building a Shopping Cart with Symfony

Writing the Command

Generating the command

Configuring the Command

Writing the Logic of the Command

Finding Expired Carts

Deleting Expired Carts

Executing the Command

Clearing the Cart | Building a Shopping Cart with Symfony

Creating the Event Subscriber

Registering the Event Subscriber

Removing Products from the Cart | Building a Shopping Cart with Symfony

Creating the Event Subscriber

Registering the Event Subscriber

Creating the Cart Page | Building a Shopping Cart with Symfony

Building Forms

The CartItemType Form

The CartType Form

Creating the Controller

Rendering the Cart Page

List of items

The Cart summary

Handling the Form

Adding a Link to the Cart Page

Adding Products to the Cart | Building a Shopping Cart with Symfony

Building a AddToCartType form

Displaying the Form

Validating the Model

Handling the Form

Managing the Cart Storage | Building a Shopping Cart with Symfony

Creating the Session Storage

Creating the Cart Manager

Retrieving the current cart

Saving the Cart

Creating Cart Entities | Building a Shopping Cart with Symfony

Generating entities

Generating the OrderItem entity

Generating the Order entity

Setting Cascade Operations

Migrating the Database

`assertCartIsEmpty()`

`assertCartTotalEquals()`

`assertCartItemsCountEquals()`

`assertCartContainsProductWithQuantity()`

`assertCartNotContainsProduct()`

`testCartIsEmpty()`

`testAddProductToCart()`

`testAddProductTwiceToCart()`

`testRemoveProductFromCart()`

`testClearCart()`

`testUpdateQuantity()`

The `CartItemType` Form

The `CartType` Form

Building a `AddToCartType` form

Generating the `OrderItem` entity

Generating the `Order` entity

Avoiding adding duplicate `OrderItem`