Laravel

Pour inaugurer la sortie de Laravel 7 je vous propose une nouvelle application. Cette fois ça sera une application de commerce en ligne. Je suis en train d'en réaliser une et à cette occasion je me suis rendu compte que c'est vraiment intéressant et fait émerger un nombre considérable de questionnements. Jusque là je m'étais contenté d'utiliser Prestashop mais cette usine à gaz m'a posé tellement de problèmes que j'ai décidé de créer mon propre code.

Évidemment je ne vais pas ici présenter une application très étendue mais circonscrire les possibilités et imposer quelques contraintes. En effet ça peut rapidement devenir très volumineux. Donc au niveau des possibilités on va avoir en gros :

• une interface uniquement en français
• application de la TVA
• pour les possibilités de paiement : chèque, virement, mandat administratif et carte bancaire (Stripe)
• pour la facturation : utilisation d'une application tierce (vosfactures.fr). Pourquoi ce choix ? La loi anti-fraude à la TVA impose trop de contraintes pour gérer soi-même les factures, je précise que je n'ai aucun lien commercial avec ce site, c'est juste que j'ai trouvé là tout ce dont j'avais besoin pour un tarif raisonnable
• gestion complète des commandes
• gestion du catalogue mais sans catégories (on part du principe qu'il y a peu de produits)
• gestion des clients
• gestion des pays d'expédition
• gestion des tarifs postaux (utilisation exclusive de Colissimo)
• ...

Voilà les grandes lignes de ce que je vous propose de réaliser et il est fort probable que ça évolue en cours de route...

Installation de Laravel

composer create-project --prefer-dist laravel/laravel shopping

composer require laravel/ui

php artisan ui bootstrap --auth

npm install

npm run dev

DB_DATABASE=shopping
DB_USERNAME=root
DB_PASSWORD=

Les utilisateurs

On a par défaut une migration pour la table users. Mais on ne va pas utiliser la vérification des email, donc on supprime la colonne email_verified_at.

• firstname : pour le prénom
• newsletter : pour l'inscription à la lettre d'information
• admin : pour identifier les administrateurs (on n'aura donc que 2 rôles : les simples utilisateurs et les administrateurs)
• last_seen : la date et l'heure du dernier passage (pratique pour savoir qui est en ligne)

Schema::create('users', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->string('firstname');
    $table->string('email')->unique();
    $table->string('password');
    $table->boolean('newsletter');
    $table->boolean('admin')->default(false);
    $table->timestamp('last_seen')->nullable();    
    $table->rememberToken();
    $table->timestamps();
});

...

use App\Models\User;

...

$factory->define(User::class, function (Faker $faker) {
    return [
        'name' => $faker->lastName,
        'firstname' => $faker->firstName,
        'email' => $faker->unique()->safeEmail,
        'password' => '$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi', // password
        'remember_token' => Str::random(10),
        'newsletter' => $faker->boolean(),
        'last_seen' => $faker->dateTimeBetween('-6 months'),
        'admin' => false,
        'created_at' => $faker->dateTimeBetween('-4 years', '-6 months'),
    ];
});

Comme on aura pas mal de modèles on va déplacer User dans un dossier dédié :

Il nous faut donc changer l'espace de nom du modèle, mais aussi compléter la propriété $fillable pour l'assignement de masse. D'autre part comme on ajoute une colonne de date (last_seen) on va la déclarer dans la propriété $dates pour bénéficier de Carbon :

namespace App\Models;

use Illuminate\Contracts\Auth\MustVerifyEmail;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;

class User extends Authenticatable
{
    use Notifiable;

    /**
     * The attributes that are mass assignable.
     *
     * @var array
     */
    protected $fillable = [
        'name', 'firstname', 'email', 'password', 'newsletter', 'last_seen',
    ];

    /**
     * The attributes that should be mutated to dates.
     *
     * @var array
     */
    protected $dates = [
        'last_seen',
    ];

...

Comme on a déménagé le modèle User il faut aussi modifier le fichier config/auth.php pour que l'authentification continue à fonctionner :

'providers' => [
    'users' => [
        'driver' => 'eloquent',
        'model' => App\Models\User::class,
    ],

Les pays

Comme on peut expédier dans plusieurs pays il y a des différences au niveau des frais de port et des taxes. On a donc besoin d'une table (et d'un modèle associé) pour les pays :

php artisan make:model Models\Country -m

public function up()
{
    Schema::create('countries', function (Blueprint $table) {
        $table->id();
        $table->string('name', 100);
        $table->decimal('tax');
    });
}

protected $fillable = [
    'name', 'tax',
];
public $timestamps = false;

Les adresses

php artisan make:model Models\Address -m

public function up()
{
    Schema::create('addresses', function (Blueprint $table) {
        $table->id();
        $table->boolean('professionnal')->default(false);
        $table->enum('civility', ['Mme', 'M.']);
        $table->string('name', 100)->nullable();
        $table->string('firstname', 100)->nullable();
        $table->string('company', 100)->nullable();
        $table->string('address');
        $table->string('addressbis')->nullable();
        $table->string('bp', 100)->nullable();
        $table->string('postal', 10); 
        $table->string('city', 100);
        $table->string('phone', 25);
        $table->timestamps();
        $table->foreignId('user_id')->constrained()->onDelete('cascade');
        $table->foreignId('country_id')->constrained()->onDelete('cascade');
    });
}

• professionnal : indique si c'est une adresse professionnelle (dans ce cas nom et prénoms sont facultatifs mais company obligatoire)
• civility : monsieur ou madame (optionnel)
• name : le nom (optionnel si adresse professionnelle)
• firstname : le prénom (optionnel si adresse professionnelle)
• company : la société (que si adresse professionnelle)
• address : l'adresse
• addressbis : complément optionnel de l'adresse
• bp : boîte postale optionnelle
• postal : code postal
• city : ville
• phone : téléphone

php artisan make:factory AddressFactory --model=Models\Address

<?php

/** @var \Illuminate\Database\Eloquent\Factory $factory */

use App\Models\Address;
use Faker\Generator as Faker;

$factory->define(Address::class, function (Faker $faker) {
    $professionnal = $faker->boolean();
    if(!$professionnal || ($professionnal && $faker->boolean())) {
        $name = $faker->lastName;
        $firstName = $faker->firstName;
    } else {
        $name = null;
        $firstName = null;
    }
    return [
        'professionnal' => $professionnal,
        'civility' => $faker->boolean() ? 'Mme': 'M.',
        'name' => $name,
        'firstname' => $firstName,
        'company' => $professionnal ? $faker->company : null,
        'address' => $faker->streetAddress,
        'addressbis' => $faker->boolean() ? $faker->secondaryAddress : null,
        'bp' => $faker->boolean() ? $faker->numberBetween(100, 900) : null,
        'postal' => $faker->numberBetween(10000, 90000),
        'city' => $faker->city,
        'country_id' => mt_rand(1, 4),
        'phone' => $faker->numberBetween(1000000000, 9000000000),
    ];
});

protected $fillable = [
  'name', 
  'firstname',
  'professionnal',
  'civility',
  'company',
  'address',
  'addressbis',
  'bp',
  'postal',
  'city',
  'phone',
  'country_id',
];

Les produits

php artisan make:model Models\Product -m

• name : le nom
• price : le prix TTC
• weight : le poids pour le calcul des frais de port
• active : pour savoir si le produit est actif et doit être proposé à la vente
• quantity : la quantité disponible
• quantity_alert : la quantité qui déclenche une alerte à l'administrateur
• image : le nom de l'image du produit qui complètera le lien vers l'image
• description : la description du produit

Schema::create('products', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->decimal('price');
    $table->decimal('weight');
    $table->boolean('active')->default(false);
    $table->integer('quantity')->defaut(0);
    $table->integer('quantity_alert')->default(10);
    $table->string('image')->nullable();
    $table->text('description');
    $table->timestamps();
});

php artisan make:factory ProductFactory --model=Models\Product

$factory->define(Product::class, function (Faker $faker) {
    return [
        'name' => $faker->sentence(3),
        'price' => mt_rand(100, 1000) / 10.0,
        'weight' => mt_rand(1, 4) / 1.8,
        'quantity' => 50,
        'active' => $faker->boolean(),
        'image' => strval(mt_rand(1, 5)) . '.jpg',
        'description' => $faker->paragraph(),
    ];
});

protected $fillable = [
    'name', 'price', 'quantity', 'weight', 'active', 'quantity_alert', 'image', 'description',
];

Les états

php artisan make:model Models\State -m

Schema::create('states', function (Blueprint $table) {
    $table->id();
    $table->string('name', 100);
    $table->string('slug', 50);
    $table->string('color', 20);
    $table->integer('indice');
});

• name : le nom de létat à afficher
• slug : pour référencer l'état hors affichage
• color : un code couleur pour renforcer l'affichage de l'état
• indice : le degré de l'état. Selon l'état on ne disposera que d'un certain nombre d'autre état possible. Par exemple si on a déjà confirmer un paiement on ne pourra pas changer de mode de paiement. Cet indice va simplifier le codage.

protected $fillable = [
    'name', 
    'slug', 
    'color', 
    'indice', 
];
public $timestamps = false;

Les commandes

php artisan make:model Models\Order -m

• reference : une référence unique pour la commande
• shipping : les frais de port
• total : le coût total TTC des produits
• tax : le taux de TVA appliqué aux produits (on ne prévoit pas de taux par produit)
• payment : le mode de paiement (carte, mandat, virement ou chèque)
• purchase_order : le numéro éventuel du bon de commande
• pick : si le produit est récupéré sur place
• invoice_id : l'identifiant de la facture (pour pouvoir la récupérer avec l'API)
• invoice_number : le numéro de la facture

Schema::create('orders', function (Blueprint $table) {
    $table->id();
    $table->timestamps();
    $table->string('reference', 8);
    $table->decimal('shipping');
    $table->decimal('total');
    $table->decimal('tax');
    $table->enum('payment', [
        'carte',
        'mandat', 
        'virement', 
        'cheque'
    ]);
    $table->string('purchase_order', 100)->nullable();
    $table->boolean('pick')->default(false);
    $table->integer('invoice_id')->nullable();
    $table->string('invoice_number', 40)->nullable();
    $table->foreignId('state_id')->constrained()->onDelete('cascade');
    $table->foreignId('user_id')->constrained()->onDelete('cascade');
});

php artisan make:factory OrderFactory --model=Models\Order

<?php

/** @var \Illuminate\Database\Eloquent\Factory $factory */

use App\Models\Order;
use Faker\Generator as Faker;
use Illuminate\Support\Str;

$factory->define(Order::class, function (Faker $faker) {
  
    $pick = $faker->boolean();
    $payment = ['carte', 'mandat', 'virement', 'cheque'][mt_rand(0, 3)];
    if($payment === 'carte') {
        $state_id = [4, 5, 6, 8, 9, 10][mt_rand(0, 5)];
    } else if($payment === 'mandat') {
        $state_id = [2, 6, 7, 8, 9, 10][mt_rand(0, 5)];
        if($state_id > 6) {
            $purchaseOrder = Str::random(6);
        }
    } else if($payment === 'virement') {
        $state_id = [3, 6, 8, 9, 10][mt_rand(0, 4)];
    } else if($payment === 'cheque') {
        $state_id = [1, 6, 8, 9, 10][mt_rand(0, 4)];
    }
    if($payment === 'carte' && in_array($state_id, [8, 9, 10])) {
        $invoice_id = $payment === 'carte' && in_array($state_id, [8, 9, 10]) ? $faker->numberBetween(10000, 90000) : null;
        $invoice_number = Str::random(6);
    } else {
        $invoice_id = null;
        $invoice_number = null;
    }
    
    return [
        'reference' => strtoupper(Str::random(8)),
        'shipping' => $pick ? 0 : mt_rand (500, 1500) / 100,
        'payment' => $payment,
        'state_id' => $state_id,
        'user_id' => mt_rand(1, 20),
        'purchase_order' => isset($purchaseOrder) ? $purchaseOrder : null,
        'pick' => $pick,
        'total' => 0,
        'tax' => [0, .2][mt_rand(0, 1)],
        'invoice_id' => $invoice_id,
        'invoice_number' => $invoice_number,
        'created_at' => $faker->dateTimeBetween('-2 years'),
    ];
});

Le code est assez chargé pour obtenir un minimum de cohérence, en particulier selon le mode de paiment et les états. Ca deviendra plus compréhensible quand on verra la population des tables.

Les adresses pour les commandes

Pour chaque commande on va avoir une ou deux adresses (s'il y a une adresse spécifique pour la livraison). On ne peut pas se contenter de créer une relation avec la table des adresses parce que celles-ci peuvent changer ensuite et on doit figer les choses pour la commande et surtout la facture.

php artisan make:model Models\OrderAddress -m

Schema::create('order_addresses', function (Blueprint $table) {
    $table->id();
    $table->boolean('facturation')->default(true);
    $table->boolean('professionnal')->default(false);
    $table->enum('civility', ['Mme', 'M.']);
    $table->string('name', 100)->nullable();
    $table->string('firstname', 100)->nullable();
    $table->string('company', 100)->nullable();
    $table->string('address');
    $table->string('addressbis')->nullable();
    $table->string('bp', 100)->nullable();
    $table->string('postal', 10); 
    $table->string('city', 100);
    $table->string('phone', 25);
    $table->timestamps();
    $table->foreignId('order_id')->constrained()->onDelete('cascade');
    $table->foreignId('country_id')->constrained()->onDelete('cascade');
});

protected $fillable = [
    'name', 'firstname', 'professionnal', 'civility', 'company', 'address', 'addressbis', 'bp', 'postal', 'city', 'phone', 'country_id', 'facturation',
];

Les produits pour les commandes

Pour les produits pour les commandes on a le même raisonnement que pour les adresses, on ne peut pas se contenter d'une relation avec la table des produits parce qu'il peut y avoir dees changements ultérieurs et on doit figer les choses. d'autre part on doit mémoriser le prix total et la quantité commandée.

php artisan make:model Models\OrderProduct -m

• name : le nom du produit
• total_price_gross : le prix TTC total ne ténant compte de la quantité
• quantité : la quantité commandée pour ce produit

Schema::create('order_products', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->decimal('total_price_gross');
    $table->integer('quantity');
    $table->timestamps();
    $table->foreignId('order_id')->constrained()->onDelete('cascade');
});

protected $fillable = [
    'name', 'total_price_gross', 'quantity',
];

Les frais de port

Le poids

php artisan make:model Models\Range -m

Schema::create('ranges', function (Blueprint $table) {
    $table->id();
    $table->decimal('max');
});

protected $fillable = [ 'max', ];
public $timestamps = false;

Colissimo

php artisan make:model Models\Colissimo -m

• price : le prix
• country_id : la clé étrangère pour le pays
• range_id : la clé étrangère pour la plage de poids

Schema::create('colissimos', function (Blueprint $table) {
    $table->id();
    $table->decimal('price');
    $table->foreignId('country_id')->constrained()->onDelete('cascade');
    $table->foreignId('range_id')->constrained()->onDelete('cascade');
});

protected $fillable = [
    'price', 'country_id', 'range_id',
];

public $timestamps = false;

La boutique

php artisan make:model Models\Shop -m

• name : nom de la boutique
• address : adresse de la boutique
• holder : nom officiel de la boutique
• email : email de contact
• bic : le BIC pour les virements
• iban : l'IBAN pour les virements
• bank : nom de la banque
• bank_address : adresse de la banque
• phone : téléphone de contact
• facebook : lien vers la page Facebook
• home : texte pour la page d'accueil
• home_infos : texte d'information pour la page d'accueil
• home_shipping : texte d'information sur les frais de port pour la page d'accueil
• invoice : si la boutique va générer des factures
• card : si la boutique va accepter le paiement par carte bancaire
• transfer : si la boutique va accepter le paiement par virement
• check : si la boutique va accepter le paiement par chèque
• mandat : si la boutique va accepter le paiement par mandat administratif

Schema::create('shops', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->string('address');
    $table->string('holder');
    $table->string('email');
    $table->string('bic');
    $table->string('iban');
    $table->string('bank');
    $table->string('bank_address');
    $table->string('phone', 25);
    $table->string('facebook');
    $table->string('home');
    $table->text('home_infos');
    $table->text('home_shipping');
    $table->boolean('invoice')->default(true);
    $table->boolean('card')->default(true);
    $table->boolean('transfer')->default(true);
    $table->boolean('check')->default(true);
    $table->boolean('mandat')->default(true);
});

php artisan make:factory ShopFactory --model=Models\Shop

<?php

/** @var \Illuminate\Database\Eloquent\Factory $factory */

use App\Models\Shop;
use Faker\Generator as Faker;
use Illuminate\Support\Str;

$factory->define(Shop::class, function (Faker $faker) {
    return [
        'name' => $faker->sentence(2),
        'address' => $faker->address,
        'email' => $faker->email,
        'phone' => $faker->phoneNumber,
        'holder' => strtoupper($faker->sentence(3)),
        'bic' => strtoupper(Str::random(8)),
        'iban' => $faker->iban,
        'bank' => $faker->sentence(2),
        'bank_address' => $faker->address,
        'facebook' => $faker->url,
        'home' => $faker->sentence(3),
        'home_infos' => $faker->text,
        'home_shipping' => $faker->text,
    ];
});

protected $fillable = [
    'name', 
    'address', 
    'email', 
    'holder', 
    'bic', 
    'iban', 
    'bank', 
    'bank_address',
    'phone',
    'facebook',
    'home',
    'home_infos',
    'home_shipping',
    'invoice',
    'card',
    'transfer',
    'check',
    'mandat',
];

public $timestamps = false;

Les pages

On va avoir des pages d'information (conditions de vente, mentions légale...). On crée donc une tale pour mémoriser le contenu de ces pages :

php artisan make:model Models\Page -m

Schema::create('pages', function (Blueprint $table) {
    $table->id();
    $table->string('slug');
    $table->string('title');
    $table->text('text');
});

protected $fillable = [
    'title', 'slug', 'text',
];

public $timestamps = false;

php artisan make:factory PageFactory --model=Models\page

<?php

/** @var \Illuminate\Database\Eloquent\Factory $factory */

use App\Models\Page;
use Faker\Generator as Faker;

$factory->define(Page::class, function (Faker $faker) {
    return [
        'text' => $faker->paragraph(10),
    ];
});

Les paiements

Il ne nous reste plus qu'à prévoir une table pour mémoriser les identifiant de paiment des commandes dans le cas de paiment par carte bancaire :

php artisan make:model Models\Payment -m

Schema::create('payments', function (Blueprint $table) {
    $table->id();
    $table->timestamps();
    $table->string('payment_id');
    $table->foreignId('order_id')->constrained()->onDelete('cascade');
});

protected $fillable = [ 'payment_id', ];

Les notifications

Comme on va utiliser le système de notifications de Laravel on va aussi créer la table correspondante :

php artisan notifications:table

Conclusion

On a maintenant toutes les tables et les factories nécessaires pour avoir des données d'exemple. Dans le prochain article on mettra en place les relations, quelques accessors et mutators et on complètera avec une population complète de la boutique. On aura ainsi tout en place pour commencer à coder.