Laravel

Un framework qui rend heureux

Voir cette catégorie
Vers le bas
Voir cette série
Shop : les données 1/2
Vendredi 10 janvier 2025 13:02

Pour inaugurer la sortie de Laravel 7 je vous avais proposé une application de commerce en ligne. Je me suis alors rendu compte que ce projet avait bien intéressé et fait émerger un nombre considérable de questionnements.

L'application n'était pas très étendue mais circonscrites a des possibilités fondamentales. En effet ce genre de projet peut rapidement devenir volumineux. Donc au niveau des possibilités on a en gros :

  • une interface prévues multi-languages
  • 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 avais proposé de réaliser alors et que je vais poursuivre avec cette nouvelle version.

La grande différence sera au niveau de la technologie utilisée. Si vous me suivez ici vous avez remarqué que j'ai opté depuis quelques temps pour Livewire dans sa version la plus aboutie : Volt. D'ailleurs mon blog a définitivement migré vers cette technologie. J'ai d'ailleurs détaillé tout ça dans une série d'articles dont vous pouvez trouver le sommaire ici.

J'avais pour habitude pour mes séries de proposer en téléchargement le code final de chaque étape. Avec cette nouvelle année je change de stratégie et j'ai créé un dépôt Github que je mettrai à jour à mesure.

Installation de Laravel

Dans un premier temps on va installer la dernière version de Laravel :

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

On attend que tout se crée et se mette en place… Si vous obtenez la page d’accueil c’est parfait :

Créez également une base de données MySQL avec le même nom shop.

Dans le fichier .env on met à jour les identifiants :

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=shop
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 emails, donc on supprime la colonne email_verified_at.

D'autre part on ajoute ces colonnes :

  • 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 clients et les administrateurs)

Ce qui nous donne cette migration :

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

On va aussi compléter UserFactory en conséquence :

public function definition(): array
{
    return [
        'name' => fake()->lastName,
        'firstname' => fake()->firstName,
        'email' => fake()->unique()->safeEmail,
        'password' => static::$password ??= Hash::make('password'),
        'newsletter' => fake()->boolean(),
        'created_at' => fake()->dateTimeBetween('-4 years', '-6 months'),
        'remember_token' => Str::random(10),
    ];
}

Pour simplifier on aura le même mot de passe pour tous les utilisateurs générés : password. Les dates de création seront lissées dans le temps pour plus de réalisme.

Dans le modèle on complète la propriété $fillable :

protected $fillable = [
    'name', 'firstname', 'email', 'password', 'newsletter',
];

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 Country -m

On va se contenter de deux colonnes (nom et taxe) :

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

Et dans le modèle la propriété $fillable :

protected $fillable = [
    'name', 'tax',
];

public $timestamps = false;

On met la propriété $timestamps à false parce qu'on ne met pas les colonnes des dates. On va aussi se passer de factory pour cette table.

Les adresses

Les utilisateurs pourront définir plusieurs adresses (facturation, expédition...). On crée donc une table et un modèle :

php artisan make:model Address -m

 On va avoir besoin de pas mal de colonnes :

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');
});

Voyons ça en détail :

  • 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

On a aussi deux clés étrangères pour les relations avec l'utilisateur et le pays. On va créer une factory pour créer des adresses :

php artisan make:factory AddressFactory --model=Address

Avec ce code qui permet de générer des adresses assez variées :

public function definition(): array
{
    $professionnal = fake()->boolean();

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

Il faut renseigner la propriété $fillable dans le modèle Address. Mais aussi signaler qu'on utilise une factory :

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Factories\HasFactory;

class Address extends Model
{
    use HasFactory;

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

Les produits

Évidemment on va avoir des produits :

php artisan make:model Product -m

On prévoit ces colonnes :

  • 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é minimum 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

Ce qui donne :

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();
});

Et la propriété $fillable dans le modèle Product :

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Product extends Model
{
    protected $fillable = [
        'name', 'price', 'quantity', 'weight', 'active', 'quantity_alert', 'image', 'description',
    ];
}

Les états

Une commande passe par plusieurs états, on crée donc aussi une table (et un modèle associé) :

php artisan make:model Models\State -m

Avec 4 colonnes :

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

Voyons ça :

  • 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'autres états possibles. Par exemple si on a déjà confirmé un paiement, on ne pourra pas changer de mode de paiement. Cet indice va simplifier le codage.

On complète aussi $fillable dans le modèle State :

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class State extends Model
{
    protected $fillable = [
        'name', 
        'slug', 
        'color', 
        'indice', 
    ];
    
    public $timestamps = false;
}

On met la propriété $timestamps à false parce qu'on ne met pas les colonnes des dates. On ne crée pas de factory pour cette table.

Les commandes

Les commandes constituent la partie la plus importante de l'application :

php artisan make:model Order -m

On prévoie ces colonnes :

  • 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

On va aussi prévoir deux clés étrangères pour les utilisateurs et les états.

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');
});

Dans le modèle on ajoute la propriétée $fillable et on indique la factory :

...

use Illuminate\Database\Eloquent\Factories\HasFactory;  

class Order extends Model
{
    use HasFactory;

    protected $fillable = [
        'shipping', 'tax', 'user_id', 'state_id', 'payment', 'reference', 'pick', 'total',
    ];
}

On ajoute la factory pour disposer de commande d'exemple :

php artisan make:factory OrderFactory --model=Order
public function definition(): array
{
    $pick = fake()->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]) ? fake()->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' => fake()->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 distincte de celle de la facturation). 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.

En conséquence on crée une table pour mémoriser ces adresses :

php artisan make:model OrderAddress -m


Les colonnes vont faire écho à celles de la table addresses :

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');
});

La différence c'est qu'elle est liée à une commande au lieu d'un utilisateur. On complète la propriété $fillable du modèle OderAddress :

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

On va se passer de factory pour cette table.

Les produits pour les commandes

Pour les produits des 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 des changements ultérieurs et on doit figer les choses. D'autre part, on doit mémoriser le prix total et la quantité commandée.

Alors on crée une table et un modèle :

php artisan make:model OrderProduct -m

Avec ces colonnes :

  • name : le nom du produit
  • total_price_gross : le prix TTC total en tenant 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');
});

Et évidemment on a la clé étrangère pour la liaison avec la commande. On complète la propriété $fillable du modèle OderProduct :

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

Les frais de port

Le poids

Pour les frais de port on va avoir deux tables. Une première pour définir des plages de poids :

php artisan make:model Models\Range -m

Avec juste une colonne pour le poids maximal :

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

Et dans le modèle Range :

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

On et la propriété $timestamps à false parce qu'on ne met pas les colonnes des dates.

Colissimo

On crée une table pour les tarifs Colissimo :

php artisan make:model Models\Colissimo -m

Avec ces colonnes :

  • 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');
});

Et évidemment dans le modèle Colissimo :

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

public $timestamps = false;

La boutique

On doit aussi prévoir une table (et un modèle) pour tous les renseignements concernant la boutique :

php artisan make:model Shop -m

On aura de nombreuses colonnes (et a priori une seule ligne puisque une seule boutique) :

  • name : nom de la boutique
  • address : adresse de la boutique
  • holder : nom officiel de la boutique
  • email : email de contact
  • bic : 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 doit générer des factures
  • card : si la boutique accepte le paiement par carte bancaire
  • transfer : si la boutique accepte le paiement par virement
  • check : si la boutique accepte le paiement par chèque
  • mandat : si la boutique accepte 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->text('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);
});

On crée aussi une factory :

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

public function definition(): array
{
    return [
        'name' => fake()->sentence(2),
        'address' => fake()->address,
        'email' => fake()->email,
        'phone' => fake()->phoneNumber,
        'holder' => strtoupper(fake()->sentence(3)),
        'bic' => strtoupper(str()->random(8)),
        'iban' => fake()->iban,
        'bank' => fake()->sentence(2),
        'bank_address' => fake()->address,
        'facebook' => fake()->url,
        'home' => fake()->sentence(3),
        'home_infos' => fake()->text,
        'home_shipping' => fake()->text,
    ];
}

Et le modèle Shop :

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Shop extends Model
{
    use HasFactory;

    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 table pour mémoriser le contenu de ces pages :

php artisan make:model Page -m

On se contente de 3 colonnes classiques :

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

Et dans le modèle Page :

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Page extends Model
{
    use HasFactory;

    protected $fillable = [
        'title', 'slug', 'text',
    ];
    
    public $timestamps = false;
}

On crée une factory :

php artisan make:factory PageFactory --model=Page

Avec ce code :

public function definition(): array
{
    return [
        'text' => fake()->paragraph(10),
    ];
}

Les paiements

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

php artisan make:model Payment -m

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

Et dans le modèle Payment :

protected $fillable = [ 'payment_id', 'order_id', ];

Les notifications

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

php artisan make:notifications-table

Là c'est Laravel qui s'occupera de tout !

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.

 


Par bestmomo

Nombre de commentaires : 2

Suivant
Article suivant : Shop : les données 2/2