Live Coding : Créer une API REST

14 septembre 2019 - : PHP API Tutoriel Live-Coding - : 0 commentaire - : 430 - Tutoriel API PHP Live-Coding REST

Visualisez les fichiers de cette série sur GitHub

Suite au live coding d'aujourd'hui, voici les différentes étapes pour créer une API REST.

Une API REST ? C'est quoi ?

API ?

Avant de définir ce qu'est une API REST, définissons API.

L'acronyme API signifie "Application Programming Interface" en Anglais, et peut être traduit simplement par "Interface de Programmation d'Application".

Bien sûr, ça ne vous aide pas à comprendre ce que c'est.

Pour rester simple, il s'agit de créer un accès à une application et permettre de venir y consommer des données ou des fonctionnalités. Ainsi, vous pouvez, avec une autre application ou un site, venir interroger l'application et utiliser ses données.

REST ?

L'acronyme REST, quant à lui, signifie "REpresentative State Transfer".

Le standard a été créé en 2000 par Roy Fielding, informaticien américain et cofondateur d'Apache, dans sa thèse.

Globalement, une API REST sera conforme au standard créé en 2000. Ce standard ayant créé un haut niveau de certification, il est très difficile d'être considéré comme "RESTful".

Mise en pratique

Nous allons traiter ici les bases de la création d'une API REST, en utilisant l'exemple de l'accès à une base de données de produits.

Lors de la création de notre API, nous devons garder en tête les critères qui en font une API REST. Une API REST se doit d'être :

  • Sans état : le serveur ne fait aucune relation entre les différents appels d'un même client. Il ne connaît pas l'état du client entre ces transactions

  • Cacheable : le client doit être capable de garder nos données en cache pour optimiser les transactions

  • Orienté client-serveur : Il nous faut une architecture client-serveur

  • Avec une interface uniforme : ceci permet à tout composant qui comprend le protocole HTTP de communiquer avec votre API

  • Avec un système de couches : avec des serveurs intermédiaires, le client final ne doit pas savoir si il est connecté au serveur principal ou à un serveur intermédiaire

La base de données

Pour notre API, nous allons utiliser une base de données simple, contenant des "categories" et des "produits".

Sa modélisation est la suivante

Modèle BDD

Elle pourra être créée avec les commandes sql suivantes :

  • Création de la base de données
CREATE DATABASE IF NOT EXISTS `api_rest` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;
  • Création de la table "categories"
CREATE TABLE `categories` (
  `id` int(11) NOT NULL,
  `nom` varchar(256) NOT NULL,
  `description` text NOT NULL,
  `created_at` datetime NOT NULL,
  `updated_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  • Création de la table "produits"
CREATE TABLE `produits` (
  `id` int(11) NOT NULL,
  `nom` varchar(32) NOT NULL,
  `description` text NOT NULL,
  `prix` decimal(10,0) NOT NULL,
  `categories_id` int(11) NOT NULL,
  `created_at` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `updated_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  • Ajout des clés primaires, incréments, index et clés étrangères
--
-- Index pour la table `categories`
--
ALTER TABLE `categories` ADD PRIMARY KEY (`id`);

--
-- Index pour la table `produits`
--
ALTER TABLE `produits`
  ADD PRIMARY KEY (`id`),
  ADD KEY `categories_id` (`categories_id`);

--
-- AUTO_INCREMENT pour la table `categories`
--
ALTER TABLE `categories` MODIFY `id` int(11) NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=14;

--
-- AUTO_INCREMENT pour la table `produits`
--
ALTER TABLE `produits` MODIFY `id` int(11) NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=67;

--
-- Contraintes pour la table `produits`
--
ALTER TABLE `produits` ADD CONSTRAINT `produits_ibfk_1` FOREIGN KEY (`categories_id`) REFERENCES `categories` (`id`) ON DELETE CASCADE ON UPDATE CASCADE;
  • Insertion des données
INSERT INTO `categories` (`id`, `nom`, `description`, `created_at`, `updated_at`) VALUES
(1, 'Mode', 'Catégorie pour tout ce qui est en rapport avec la mode.', '2019-06-01 00:32:07', '2019-08-30 15:34:33'),
(2, 'Electronique', 'Gadgets, drones et plus.', '2018-06-03 02:34:11', '2019-01-30 16:34:33'),
(3, 'Moteurs', 'Sports mécaniques', '2018-06-01 10:33:07', '2019-07-30 15:34:54'),
(5, 'Films', 'Produits cinématographiques.', '2018-06-01 10:33:07', '2018-01-08 12:27:26'),
(6, 'Livres', 'E-books, livres audio...', '2018-06-01 10:33:07', '2019-01-08 12:27:47'),
(13, 'Sports', 'Articles de sport.', '2018-01-09 02:24:24', '2019-01-09 00:24:24');

INSERT INTO `produits` (`id`, `nom`, `description`, `prix`, `categories_id`, `created_at`, `updated_at`) VALUES
(65, 'Samsung Galaxy S 10', 'Le dernier né des téléphones Samsung', '899', 2, '2019-09-07 21:19:09', '2019-09-07 19:19:09'),
(66, 'Habemus Piratam', 'Le livre à propos d\'un pirate informatique', '13', 6, '2019-09-07 21:21:11', '2019-09-07 19:21:11');

Création de la connexion

Nous pouvons maintenant nous connecter à notre base de données.

Pour ce faire, dans notre projet, nous allons créer un dossier "config" et y ajouter un fichier que nous appellerons "Database.php".

Ce fichier contiendra une classe "Database" qui nous permettra d'effectuer la connexion.

class Database{
    // Propriétés de la base de données
    private $host = "localhost";
    private $db_name = "api_rest";
    private $username = "root";
    private $password = "";
    public $connexion;

    // getter pour la connexion
    public function getConnection(){
        // On commence par fermer la connexion si elle existait
        $this->connexion = null;

        // On essaie de se connecter
        try{
            $this->connexion = new PDO("mysql:host=" . $this->host . ";dbname=" . $this->db_name, $this->username, $this->password);
            $this->connexion->exec("set names utf8"); // On force les transactions en UTF-8
        }catch(PDOException $exception){ // On gère les erreurs éventuelles
            echo "Erreur de connexion : " . $exception->getMessage();
        }

        // On retourne la connexion
        return $this->connexion;
    }   
}

Création des modèles

Une fois la base de données créée, sa connexion fonctionnelle, nous allons créer nos modèles premettant d'effectuer les différentes tâches associées.

Pour ce faire, nous allons créer un dossier "models" dans lequel nous allons créer un fichier portant le nom de nos tables.

Commençons par le fichier "Produits.php". Celui-ci contiendra la classe "Produits" qui aura comme propriétés les différents champs de la table "produits" et la connexion à la base de données.

class Produits{
    // Connexion
    private $connexion;
    private $table = "produits"; // Table dans la base de données

    // Propriétés
    public $id;
    public $nom;
    public $description;
    public $prix;
    public $categories_id;
    public $categories_nom;
    public $created_at;

    /**
     * Constructeur avec $db pour la connexion à la base de données
     *
     * @param $db
     */
    public function __construct($db){
        $this->connexion = $db;
    }
}

Les méthodes CRUD

Nous allons maintenant ajouter les différentes méthodes CRUD (Create, Read, Update, Delete) qui nous seront nécessaires pour intéragir avec la base de données.

Create

La méthode "Create" va nous servir à créer un produit. Nous allons l'appeler "creer" mais elle peut prendre le nom qui vous convient.

Cette méthode utilisera les propriétés du produit qui auront préalablement été définies et les écrira en base de données.

/**
 * Créer un produit
 *
 * @return void
 */
public function creer(){

    // Ecriture de la requête SQL en y insérant le nom de la table
    $sql = "INSERT INTO " . $this->table . " SET nom=:nom, prix=:prix, description=:description, categories_id=:categories_id, created_at=:created_at";

    // Préparation de la requête
    $query = $this->connexion->prepare($sql);

    // Protection contre les injections
    $this->nom=htmlspecialchars(strip_tags($this->nom));
    $this->prix=htmlspecialchars(strip_tags($this->prix));
    $this->description=htmlspecialchars(strip_tags($this->description));
    $this->categories_id=htmlspecialchars(strip_tags($this->categories_id));
    $this->created_at=htmlspecialchars(strip_tags($this->created_at));

    // Ajout des données protégées
    $query->bindParam(":nom", $this->nom);
    $query->bindParam(":prix", $this->prix);
    $query->bindParam(":description", $this->description);
    $query->bindParam(":categories_id", $this->categories_id);
    $query->bindParam(":created_at", $this->created_at);

    // Exécution de la requête
    if($query->execute()){
        return true;
    }
    return false;
}
Read

La méthode "Read" va nous servir à lire dans la table "produits". Nous allons en préparer deux, l'une pour lire la liste entière, l'autre pour lire un seul produit.

Ces méthodes utiliseront les informations transmises dans l'instance du produit, si nécessaire.

  • Charger la liste de tous les produits
/**
 * Lecture des produits
 *
 * @return void
 */
public function lire(){
    // On écrit la requête
    $sql = "SELECT c.nom as categories_nom, p.id, p.nom, p.description, p.prix, p.categories_id, p.created_at FROM " . $this->table . " p LEFT JOIN categories c ON p.categories_id = c.id ORDER BY p.created_at DESC";

    // On prépare la requête
    $query = $this->connexion->prepare($sql);

    // On exécute la requête
    $query->execute();

    // On retourne le résultat
    return $query;
}
  • Charger un seul produit
/**
 * Lire un produit
 *
 * @return void
 */
public function lireUn(){
    // On écrit la requête
    $sql = "SELECT c.nom as categories_nom, p.id, p.nom, p.description, p.prix, p.categories_id, p.created_at FROM " . $this->table . " p LEFT JOIN categories c ON p.categories_id = c.id WHERE p.id = ? LIMIT 0,1";

    // On prépare la requête
    $query = $this->connexion->prepare( $sql );

    // On attache l'id
    $query->bindParam(1, $this->id);

    // On exécute la requête
    $query->execute();

    // on récupère la ligne
    $row = $query->fetch(PDO::FETCH_ASSOC);

    // On hydrate l'objet
    $this->nom = $row['nom'];
    $this->prix = $row['prix'];
    $this->description = $row['description'];
    $this->categories_id = $row['categories_id'];
    $this->categories_nom = $row['categories_nom'];
}
Update

La méthode "Update" va nous servir à modifier un produit. Nous allons l'appeler "modifier".

Cette méthode utilisera les propriétés du produit qui auront préalablement été définies et les modifiera en base de données.

/**
 * Mettre à jour un produit
 *
 * @return void
 */
public function modifier(){
    // On écrit la requête
    $sql = "UPDATE " . $this->table . " SET nom = :nom, prix = :prix, description = :description, categories_id = :categories_id WHERE id = :id";
    
    // On prépare la requête
    $query = $this->connexion->prepare($sql);
    
    // On sécurise les données
    $this->nom=htmlspecialchars(strip_tags($this->nom));
    $this->prix=htmlspecialchars(strip_tags($this->prix));
    $this->description=htmlspecialchars(strip_tags($this->description));
    $this->categories_id=htmlspecialchars(strip_tags($this->categories_id));
    $this->id=htmlspecialchars(strip_tags($this->id));
    
    // On attache les variables
    $query->bindParam(':nom', $this->nom);
    $query->bindParam(':prix', $this->prix);
    $query->bindParam(':description', $this->description);
    $query->bindParam(':categories_id', $this->categories_id);
    $query->bindParam(':id', $this->id);
    
    // On exécute
    if($query->execute()){
        return true;
    }
    
    return false;
}
Delete

La méthode "Delete" va nous servir à supprimer un produit. Nous allons l'appeler "supprimer".

Cette méthode utilisera l'id du produit.

/**
 * Supprimer un produit
 *
 * @return void
 */
public function supprimer(){
    // On écrit la requête
    $sql = "DELETE FROM " . $this->table . " WHERE id = ?";

    // On prépare la requête
    $query = $this->connexion->prepare( $sql );

    // On sécurise les données
    $this->id=htmlspecialchars(strip_tags($this->id));

    // On attache l'id
    $query->bindParam(1, $this->id);

    // On exécute la requête
    if($query->execute()){
        return true;
    }
    
    return false;
}

Création de l'API

Lors de la création des fichiers de notre API, nous allons devoir prendre en compte une contrainte REST concernant la méthode utilisée pour effectuer nos différentes requêtes HTTP.

En effet, le standard est très strict. Il indique le rôle exact de chaque méthode HTTP dans notre API. Ainsi :

  • GET sera exclusivement utilisé pour lire des données
  • POST servira uniquement à créer des données
  • PUT servira uniquement à mettre à jour des données
  • DELETE sera réservé à la suppression de données

Nous devrons donc toujours indiquer quelle méthode sera utilisée en entête et vérifier que celle-ci est effectivement utilisée.

Lire des données

Commençons par la lecture des données. Nous allons tout d'abord créer le fichier permettant d'obtenir la liste complète des produits.

Nous appellerons ce fichier "lire.php", il se trouvera dans un dossier "produits" comme tous les fichiers concernant les produits.

Les entêtes

Tout d'abord, au début du fichier, nous définirons les entêtes HTTP nécessaires au bon fonctionnement de l'API.

// Headers requis
// Accès depuis n'importe quel site ou appareil (*)
header("Access-Control-Allow-Origin: *");

// Format des données envoyées
header("Content-Type: application/json; charset=UTF-8");

// Méthode autorisée
header("Access-Control-Allow-Methods: GET");

// Durée de vie de la requête
header("Access-Control-Max-Age: 3600");

// Entêtes autorisées
header("Access-Control-Allow-Headers: Content-Type, Access-Control-Allow-Headers, Authorization, X-Requested-With");
La méthode

Nous allons ensuite vérifier la méthode utilisée pour effectuer la requête. Nous devons nous assurer qu'il s'agit de la méthode "GET" et envoyer un message d'erreur si ça n'est pas le cas.

if($_SERVER['REQUEST_METHOD'] == 'GET'){
    // La bonne méthode est utilisée

}else{
    // Mauvaise méthode, on gère l'erreur
    http_response_code(405);
    echo json_encode(["message" => "La méthode n'est pas autorisée"]);
}
Accès aux données

Une fois la méthode vérifiée, nous allons instancier la base de données et l'objet "Produits"

// On inclut les fichiers de configuration et d'accès aux données
include_once '../config/Database.php';
include_once '../models/Produits.php';

// On instancie la base de données
$database = new Database();
$db = $database->getConnection();

// On instancie les produits
$produit = new Produits($db);
Récupération des données et envoi

L'accès aux données étant créé, nous allons appeler la méthode permettant de lire la liste des produits puis créer le tableau json à envoyer.

// On récupère les données
$stmt = $produit->lire();

// On vérifie si on a au moins 1 produit
if($stmt->rowCount() > 0){
    // On initialise un tableau associatif
    $tableauProduits = [];
    $tableauProduits['produits'] = [];

    // On parcourt les produits
    while($row = $stmt->fetch(PDO::FETCH_ASSOC)){
        extract($row);

        $prod = [
            "id" => $id,
            "nom" => $nom,
            "description" => $description,
            "prix" => $prix,
            "categories_id" => $categories_id,
            "categories_nom" => $categories_nom
        ];

        $tableauProduits['produits'][] = $prod;
    }
    // On envoie le code réponse 200 OK
    http_response_code(200);

    // On encode en json et on envoie
    echo json_encode($tableauProduits);
}

Le fichier complet est disponible sur le compte Github de Nouvelle-Techno.fr

Lire une seule donnée

Sur le même modèle nous allons créer un fichier permettant de lire la table "produits" mais qui ne retournera qu'un seul produit, en fonction de son id.

Les entêtes et la vérification de la méthode et l'accès aux données seront strictement identiques. La différence se fera sur le fait que nous devrons recevoir l'id de l'élément à lire, celui-ci étant transmis en json.

Traiter les données reçues

Nous allons recevoir des données en json, il sera nécessaire de les traiter afin de décider si nous allons plus loin dans le traitement ou si nous stoppons.

Pour récupérer les données reçues, nous allons devoir utiliser la méthode php "file_get_contents", puis vérifier si les données ne sont pas vides.

// On récupère les données reçues
$donnees = json_decode(file_get_contents("php://input"));

// On vérifie qu'on a bien un id
if(!empty($donnees->id)){

}
Récupération des données et envoi

L'accès aux données étant créé, et l'id étant existant, nous allons appeler la méthode permettant de lire un produit puis créer le tableau json à envoyer.

// On récupère le produit
$produit->lireUn();

// On vérifie si le produit existe
if($produit->nom != null){
    // On crée un tableau contenant le produit
    $prod = [
        "id" => $produit->id,
        "nom" => $produit->nom,
        "description" => $produit->description,
        "prix" => $produit->prix,
        "categories_id" => $produit->categories_id,
        "categories_nom" => $produit->categories_nom
    ];
    // On envoie le code réponse 200 OK
    http_response_code(200);

    // On encode en json et on envoie
    echo json_encode($prod);
}else{
    // 404 Not found
    http_response_code(404);
    
    echo json_encode(array("message" => "Le produit n'existe pas."));
}

Le fichier complet est disponible sur le compte Github de Nouvelle-Techno.fr

Créer un élément

Une API REST peut également nous permettre de créer des éléments. Dans ce cas, la méthode autorisée est la méthode "POST".

Le fonctionnement global sera identique, à la différence près que nous allons recevoir les données détaillées de l'élément à créer et que nous devrons les traiter.

Les entêtes

Tout d'abord, au début du fichier, nous définirons les entêtes HTTP nécessaires au bon fonctionnement de l'API, dont l'une sera légèrement différente, celle concernant la méthode.

// Headers requis
// Accès depuis n'importe quel site ou appareil (*)
header("Access-Control-Allow-Origin: *");

// Format des données envoyées
header("Content-Type: application/json; charset=UTF-8");

// Méthode autorisée
header("Access-Control-Allow-Methods: POST");

// Durée de vie de la requête
header("Access-Control-Max-Age: 3600");

// Entêtes autorisées
header("Access-Control-Allow-Headers: Content-Type, Access-Control-Allow-Headers, Authorization, X-Requested-With");
La méthode

Nous allons ensuite vérifier la méthode utilisée pour effectuer la requête. Nous devons nous assurer qu'il s'agit de la méthode "POST" et envoyer un message d'erreur si ça n'est pas le cas.

if($_SERVER['REQUEST_METHOD'] == 'POST'){
    // La bonne méthode est utilisée

}else{
    // Mauvaise méthode, on gère l'erreur
    http_response_code(405);
    echo json_encode(["message" => "La méthode n'est pas autorisée"]);
}
Accès aux données

Une fois la méthode vérifiée, nous allons instancier la base de données et l'objet "Produits"

// On inclut les fichiers de configuration et d'accès aux données
include_once '../config/Database.php';
include_once '../models/Produits.php';

// On instancie la base de données
$database = new Database();
$db = $database->getConnection();

// On instancie les produits
$produit = new Produits($db);
Traiter les données reçues

Pour récupérer les données reçues, nous allons devoir utiliser de nouveau la méthode php "file_get_contents", puis vérifier si les données ne sont pas vides.

// On récupère les données reçues
$donnees = json_decode(file_get_contents("php://input"));

// On vérifie qu'on a bien toutes les données
if(!empty($donnees->nom) && !empty($donnees->description) && !empty($donnees->prix) && !empty($donnees->categories_id)){

}
Récupération des données et envoi

L'accès aux données étant créé, nous allons appeler la méthode permettant de lire la liste des produits puis créer le tableau json à envoyer.

// On hydrate notre objet
$produit->nom = $donnees->nom;
$produit->description = $donnees->description;
$produit->prix = $donnees->prix;
$produit->categories_id = $donnees->categories_id;

if($produit->creer()){
    // Ici la création a fonctionné
    // On envoie un code 201
    http_response_code(201);
    echo json_encode(["message" => "L'ajout a été effectué"]);
}else{
    // Ici la création n'a pas fonctionné
    // On envoie un code 503
    http_response_code(503);
    echo json_encode(["message" => "L'ajout n'a pas été effectué"]);         
}

Le fichier complet est disponible sur le compte Github de Nouvelle-Techno.fr

Supprimer un élément

Une API REST peut aussi nous permettre de supprimer des éléments. Dans ce cas, la méthode autorisée est la méthode "DELETE".

Les entêtes

Encore une fois, au début du fichier, nous définirons les entêtes HTTP nécessaires au bon fonctionnement de l'API, dont l'une sera légèrement différente, celle concernant la méthode.

// Headers requis
// Accès depuis n'importe quel site ou appareil (*)
header("Access-Control-Allow-Origin: *");

// Format des données envoyées
header("Content-Type: application/json; charset=UTF-8");

// Méthode autorisée
header("Access-Control-Allow-Methods: DELETE");

// Durée de vie de la requête
header("Access-Control-Max-Age: 3600");

// Entêtes autorisées
header("Access-Control-Allow-Headers: Content-Type, Access-Control-Allow-Headers, Authorization, X-Requested-With");
La méthode

Nous allons ensuite vérifier la méthode utilisée pour effectuer la requête. Nous devons nous assurer qu'il s'agit de la méthode "DELETE" et envoyer un message d'erreur si ça n'est pas le cas.

if($_SERVER['REQUEST_METHOD'] == 'DELETE'){
    // La bonne méthode est utilisée

}else{
    // Mauvaise méthode, on gère l'erreur
    http_response_code(405);
    echo json_encode(["message" => "La méthode n'est pas autorisée"]);
}
Accès aux données

Une fois la méthode vérifiée, nous allons instancier la base de données et l'objet "Produits"

// On inclut les fichiers de configuration et d'accès aux données
include_once '../config/Database.php';
include_once '../models/Produits.php';

// On instancie la base de données
$database = new Database();
$db = $database->getConnection();

// On instancie les produits
$produit = new Produits($db);
Traiter les données reçues

Pour récupérer les données reçues, nous allons devoir utiliser de nouveau la méthode php "file_get_contents", puis vérifier si les données ne sont pas vides.

// On récupère les données reçues
$donnees = json_decode(file_get_contents("php://input"));

// On vérifie qu'on a bien toutes les données
if(!empty($donnees->id)){

}
Récupération des données et envoi

L'accès aux données étant créé, nous allons appeler la méthode permettant de supprimer un produit puis créer le tableau json à envoyer.

$produit->id = $donnees->id;

if($produit->supprimer()){
    // Ici la suppression a fonctionné
    // On envoie un code 200
    http_response_code(200);
    echo json_encode(["message" => "La suppression a été effectuée"]);
}else{
    // Ici la création n'a pas fonctionné
    // On envoie un code 503
    http_response_code(503);
    echo json_encode(["message" => "La suppression n'a pas été effectuée"]);         
}

Le fichier complet est disponible sur le compte Github de Nouvelle-Techno.fr

Modifier un élément

Une API REST peut enfin nous permettre de modifier des éléments. Dans ce cas, la méthode autorisée est la méthode "PUT".

Les entêtes

Encore une fois, au début du fichier, nous définirons les entêtes HTTP nécessaires au bon fonctionnement de l'API, dont l'une sera légèrement différente, celle concernant la méthode.

// Headers requis
// Accès depuis n'importe quel site ou appareil (*)
header("Access-Control-Allow-Origin: *");

// Format des données envoyées
header("Content-Type: application/json; charset=UTF-8");

// Méthode autorisée
header("Access-Control-Allow-Methods: PUT");

// Durée de vie de la requête
header("Access-Control-Max-Age: 3600");

// Entêtes autorisées
header("Access-Control-Allow-Headers: Content-Type, Access-Control-Allow-Headers, Authorization, X-Requested-With");
La méthode

Nous allons ensuite vérifier la méthode utilisée pour effectuer la requête. Nous devons nous assurer qu'il s'agit de la méthode "PUT" et envoyer un message d'erreur si ça n'est pas le cas.

if($_SERVER['REQUEST_METHOD'] == 'PUT'){
    // La bonne méthode est utilisée

}else{
    // Mauvaise méthode, on gère l'erreur
    http_response_code(405);
    echo json_encode(["message" => "La méthode n'est pas autorisée"]);
}

ATTENTION !!! La requête "PUT" utilisée exactement comme décrit dans le standard HTTP doit :

  • Mettre à jour l'enregistrement si il existe
  • Créer l'enregistrement si il n'existe pas
Accès aux données

Une fois la méthode vérifiée, nous allons instancier la base de données et l'objet "Produits"

// On inclut les fichiers de configuration et d'accès aux données
include_once '../config/Database.php';
include_once '../models/Produits.php';

// On instancie la base de données
$database = new Database();
$db = $database->getConnection();

// On instancie les produits
$produit = new Produits($db);
Traiter les données reçues

Pour récupérer les données reçues, nous allons devoir utiliser de nouveau la méthode php "file_get_contents", puis vérifier si les données ne sont pas vides.

// On récupère les données reçues
$donnees = json_decode(file_get_contents("php://input"));

// On vérifie qu'on a bien toutes les données
if(!empty($donnees->id) && !empty($donnees->nom) && !empty($donnees->description) && !empty($donnees->prix) && !empty($donnees->categories_id)){

}
Récupération des données et envoi

L'accès aux données étant créé, nous allons appeler la méthode permettant de supprimer un produit puis créer le tableau json à envoyer.

// On hydrate notre objet
$produit->id = $donnees->id;
$produit->nom = $donnees->nom;
$produit->description = $donnees->description;
$produit->prix = $donnees->prix;
$produit->categories_id = $donnees->categories_id;

if($produit->modifier()){
    // Ici la modification a fonctionné
    // On envoie un code 200
    http_response_code(200);
    echo json_encode(["message" => "La modification a été effectuée"]);
}else{
    // Ici la création n'a pas fonctionné
    // On envoie un code 503
    http_response_code(503);
    echo json_encode(["message" => "La modification n'a pas été effectuée"]);         
}

Le fichier complet est disponible sur le compte Github de Nouvelle-Techno.fr

Utiliser l'API

A quoi bon créer une API si c'est pour ne pas l'utiliser.

Il y a de nombreuses façons d'utiliser une API, mais pour la tester, je vous conseille le logiciel Postman, qui est très flexible et permet d'effectuer de nombreux tests.

Dans tous les cas, vous enverrez une requête à une url, http://api-rest.test/produits/lire.php, par exemple.

Envoyer un id

Dans nos requêtes GET, pour lire un seul élément, et DELETE, pour supprimer un élément, nous aurons à envoyer un id dans le corps de la requête.

Cet id sera envoyé en json sous la forme suivante (si l'id = 5 par exemple)

{
    "id": 5
}

Envoyer des données

Dans les requêtes POST et PUT, les données complètes d'un élément sont requises, et seront formatées comme ci-dessous, en json

{
    "id": "68",
    "nom": "Produit1",
    "description": "Ma nouvelle description",
    "prix": "50",
    "categories_id": 5
}

Voilà qui termine cet article, n'hésitez pas à commenter.

Obtenir de l'aide

Pour obtenir de l'aide, vous pouvez accéder aux forums de Nouvelle-Techno.fr ou au serveur Discord pour une entraide par chat

Visualisez les fichiers de cette série sur GitHub

Partager

Partager sur Facebook Partager sur Twitter Partager sur LinkedIn

Commentaires

Ecrire un commentaire

Pas encore de commentaire

Ecrire un commentaire