[Application 61] Passage de l’ ancien Back End Php-Mysql à PDO Mysql.

logo-phppompestation

Introduction


Avec Php 7 , mysql_real_escape_string() est discontinué.

Je passe donc le back end au format PDO en 1h30 de temps.

Cela ne change rien à ma technique de copié-collé pour chaque CRUD ..

Note : On peut spécifier le typage de variables dans les insert et les update pour ajouter à la sécurité, mais là je ne le fais pas.

Note 2 : A la fin d’une action SQL,le back end peut renvoyer un message JSON au front end qui peut l’afficher directement dans le front end dans la fonction de rappel de AngularJs, c’est le json nommé « data » qui contiendra le message… J’ai mis un exemple :
print_r(json_encode(‘Procédure Back end Ok’));

Pourquoi utiliser PDO et les requêtes préparées ?


  • Les requêtes préparées empêchent les injections SQL (Pour tester, essayer de rentrer un quote ‘, cela ne passe pas, hi hi !)
  • PDO devient le standard avec mysqli, mais est mieux que mysqli

Schéma :


vues

Le nouveau code :


Présence de 2 fichiers :

  • 1 pour la connexion
  • 1 pour tout le back end qui récupère les datas du front end (AngularJs dans ce cas). tout le back end est centralisé dans un seul fichier.

connexionConfig.php :

<?php
function connection(){
    static $DBH;
	$DBH = new PDO('mysql:host=localhost;dbname=test', 'root', 'root');
          $DBH->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
		  /* $DBH->query("SET CHARACTER SET utf8"); */
	return $DBH;
}
?>

crud.php

remarquer que le messages d’erreur sont centralisés dans le fichier PDOErreurs.txt à la racine de l’application

<?php

/* -------------------------------------------------BACK END EN PDO------------------------------------------  */

include('connexionConfig.php');
/* mysql_set_charset('utf-8'); */  /// très important
header( 'content-type: text/html; charset=utf-8' );
error_reporting(E_ALL ^ E_NOTICE); // important pour ne pas afficher les notice PHP sans cela le script ne marche pas.

/**  Switch Case pour récupérer la l'action demandée par le controleur  Angular **/

switch($_GET['action'])  {
	case 'get_stations' :	get_stations();
    break;
	case 'insert_station' :	insert_station();
    break;
	case 'delete_station' :	delete_station();
    break;
	case 'update_station' :	update_station();
    break;
    case 'get_produits' :	get_produits();
    break;
	case 'insert_produit' :	insert_produit();
    break;
	case 'delete_produit' :	delete_produit();
    break;
	case 'update_produit' :	update_produit();
    break;
	case 'get_citernes' :	get_citernes();
    break;
	case 'insert_citerne' :	insert_citerne();
    break;
	case 'delete_citerne' :	delete_citerne();
    break;
	case 'update_citerne' :	update_citerne();
    break;
	case 'get_pompes' :		get_pompes();
    break;
	case 'insert_pompe' :	insert_pompe();
    break;
	case 'delete_pompe' :	delete_pompe();
    break;
	case 'update_pompe' :	update_pompe();
    break;
	case 'get_intervenants' :	get_intervenants();
    break;
	case 'insert_intervenant' :	insert_intervenant();
    break;
	case 'delete_intervenant' :	delete_intervenant();
    break;
	case 'update_intervenant' :	update_intervenant();
    break;
	case 'get_fournisseurs' :	get_fournisseurs();
    break;
	case 'insert_fournisseur' :	insert_fournisseur();
    break;
	case 'delete_fournisseur' :	delete_fournisseur();
    break;
	case 'update_fournisseur' :	update_fournisseur();
    break;
	case 'get_tresoreries' :	get_tresoreries();
    break;
	case 'insert_tresorerie' :	insert_tresorerie();
    break;
	case 'delete_tresorerie' :	delete_tresorerie();
    break;
	case 'update_tresorerie' :	update_tresorerie();
    break;
	case 'get_reglements' :		get_reglements();
    break;
	case 'insert_reglement' :	insert_reglement();
    break;
	case 'delete_reglement' :	delete_reglement();
    break;
	case 'update_reglement' :	update_reglement();
    break;
}

/* --------------------------------------------------CRUD  ------------------------------------------*/

function get_stations() { 

	try
	{
		$DB = connection();
		$data = $DB->query('SELECT * from stations');
		$arrAll = $data->fetchAll();

		/* Convertit en JSON  */
		print_r(json_encode($arrAll));
		/* ferme la connexion ? */
		$DB=null;
	}
	catch(PDOException $e)
	{
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
	}
}

function insert_station() {
	/* Récupération des données POST Provenant du Front end*/
	 $data = json_decode(file_get_contents("php://input")); 

	/* Insertion en Bdd avec PDO */
	try {
		$DB = connection();
		$req = $DB->prepare("INSERT INTO stations VALUES (?,?,?,?,?,?,?)");
		$req->execute(array(null,$data->nom,$data->type,$data->image,$data->telephone,$data->email,$data->taille));
		$DB=null;
                print_r(json_encode('Procédure Back end Ok'));
	} catch (PDOException $e) {
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
		die();
	}
}

 function delete_station() {
	/* Récupération des données POST */
	 $data = json_decode(file_get_contents("php://input")); 

	/* Delete en Bdd avec PDO */
	try {
		$DB = connection();
		$sql = "DELETE FROM stations WHERE  id=:id";
		$stmt = $DB->prepare($sql);
		$stmt->bindParam(':id',$data->id,PDO::PARAM_INT);
		$stmt->execute();
		$DB=null;
	} catch (PDOException $e) {
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
		die();
	}
}

 function update_station() {
	$data = json_decode(file_get_contents("php://input"));

	/* Update en Bdd avec PDO (pour la sécurité ce serait mieux de spécifier le typage de vars pour le prepared statement)*/
	try {
		$DB = connection();
		$sql = "UPDATE stations SET nom='".$data->nom."',type='".$data->type."',image='".$data->image."',telephone='".$data->telephone."',email='".$data->email."',taille='".$data->taille."' WHERE  id=".$data->id." ";
		$stmt = $DB->prepare($sql); // Est ce sur que cela fonctionne comme ça ?
		/* $stmt->bindParam(':id',$data->id,PDO::PARAM_INT); */
		$stmt->execute();
		$DB=null;
	} catch (PDOException $e) {
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
		die();
	}
}

/* --------------------------------------------------CRUD  ------------------------------------------*/

 function get_produits() {  

	try
	{
		$DB = connection();
		$data = $DB->query('SELECT * from produits');
		$arrAll = $data->fetchAll();

		/* Convertit en JSON  */
		print_r(json_encode($arrAll));
		/* ferme la connexion ? */
		$DB=null;
	}
	catch(PDOException $e)
	{
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
	} 	

}

function insert_produit() {  

	/* Récupération des données POST */
	 $data = json_decode(file_get_contents("php://input")); 

	/* Insertion en Bdd avec PDO */
	try {
		$DB = connection();
		$req = $DB->prepare("INSERT INTO produits VALUES (?,?,?,?,?,?)");
		$req->execute(array(null,$data->reference,$data->designation,$data->prixachat,$data->prixvente,$data->idfournisseur));
		$DB=null;
	} catch (PDOException $e) {
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
		die();
	}
}

 function delete_produit() {
	/* Récupération des données POST */
	 $data = json_decode(file_get_contents("php://input")); 

	/* Delete en Bdd avec PDO */
	try {
		$DB = connection();
		$sql = "DELETE FROM produits WHERE  id=:id";
		$stmt = $DB->prepare($sql);
		$stmt->bindParam(':id',$data->id,PDO::PARAM_INT);
		$stmt->execute();
		$DB=null;
	} catch (PDOException $e) {
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
		die();
	}
}

 function update_produit() {
	$data = json_decode(file_get_contents("php://input"));

	/* Update en Bdd avec PDO (pour la sécurité ce serait mieux de spécifier le typage de vars pour le prepared statement)*/
	try {
		$DB = connection();
		$sql = "UPDATE produits SET reference='".$data->reference."',designation='".$data->designation."',prixachat='".$data->prixachat."',prixvente='".$data->prixvente."',idfournisseur='".$data->idfournisseur."' WHERE  id=".$data->id." ";
		$stmt = $DB->prepare($sql); // Est ce sur que cela fonctionne comme ça ?
		$stmt->execute();
		$DB=null;
	} catch (PDOException $e) {
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
		die();
	}
}

/* --------------------------------------------------CRUD  ------------------------------------------*/

function get_citernes() {
	try
	{
		$DB = connection();
		$data = $DB->query('SELECT * from citernes');
		$arrAll = $data->fetchAll();

		/* Convertit en JSON  */
		print_r(json_encode($arrAll));
		/* ferme la connexion ? */
		$DB=null;
	}
	catch(PDOException $e)
	{
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
	}
}

function insert_citerne() {
	/* Récupération des données POST */
	 $data = json_decode(file_get_contents("php://input")); 

	/* Insertion en Bdd avec PDO */
	try {
		$DB = connection();
		$req = $DB->prepare("INSERT INTO citernes VALUES (?,?,?,?)");
		$req->execute(array(null,$data->nom,$data->volumemax,$data->typecarburant));
		$DB=null;
	} catch (PDOException $e) {
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
		die();
	}
}

 function delete_citerne() {
	/* Récupération des données POST */
	 $data = json_decode(file_get_contents("php://input"));
	/* Delete en Bdd avec PDO */
	try {
		$DB = connection();
		$sql = "DELETE FROM citernes WHERE  id=:id";
		$stmt = $DB->prepare($sql);
		$stmt->bindParam(':id',$data->id,PDO::PARAM_INT);
		$stmt->execute();
		$DB=null;
	} catch (PDOException $e) {
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
		die();
	}
}

 function update_citerne() {
	$data = json_decode(file_get_contents("php://input"));

	/* Update en Bdd avec PDO (pour la sécurité ce serait mieux de spécifier le typage de vars pour le prepared statement)*/
	try {
		$DB = connection();
		$sql = "UPDATE citernes SET nom='".$data->nom."',volumemax='".$data->volumemax."',typecarburant='".$data->typecarburant."' WHERE  id=".$data->id." ";
		$stmt = $DB->prepare($sql); // Est ce sur que cela fonctionne comme ça ?
		$stmt->execute();
		$DB=null;
	} catch (PDOException $e) {
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
		die();
	}
}

/* --------------------------------------------------CRUD  ------------------------------------------*/

function get_pompes() {
	try
	{
		$DB = connection();
		$data = $DB->query('SELECT * from pompes');
		$arrAll = $data->fetchAll();

		/* Convertit en JSON  */
		print_r(json_encode($arrAll));
		/* ferme la connexion ? */
		$DB=null;
	}
	catch(PDOException $e)
	{
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
	}
}

function insert_pompe() {
	/* Récupération des données POST */
	 $data = json_decode(file_get_contents("php://input")); 

	/* Insertion en Bdd avec PDO */
	try {
		$DB = connection();
		$req = $DB->prepare("INSERT INTO pompes VALUES (?,?,?,?)");
		$req->execute(array(null,$data->nom,$data->type,$data->idciterne));
		$DB=null;
	} catch (PDOException $e) {
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
		die();
	}
}

 function delete_pompe() {
	/* Récupération des données POST */
	 $data = json_decode(file_get_contents("php://input"));
	/* Delete en Bdd avec PDO */
	try {
		$DB = connection();
		$sql = "DELETE FROM pompes WHERE  id=:id";
		$stmt = $DB->prepare($sql);
		$stmt->bindParam(':id',$data->id,PDO::PARAM_INT);
		$stmt->execute();
		$DB=null;
	} catch (PDOException $e) {
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
		die();
	}
}

 function update_pompe() {
	$data = json_decode(file_get_contents("php://input"));

	/* Update en Bdd avec PDO (pour la sécurité ce serait mieux de spécifier le typage de vars pour le prepared statement)*/
	try {
		$DB = connection();
		$sql = "UPDATE pompes SET nom='".$data->nom."',type='".$data->type."',idciterne='".$data->idciterne."'  WHERE  id=".$data->id." ";
		$stmt = $DB->prepare($sql); // Est ce sur que cela fonctionne comme ça ?
		$stmt->execute();
		$DB=null;
	} catch (PDOException $e) {
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
		die();
	}
}

/* --------------------------------------------------CRUD  ------------------------------------------*/

function get_intervenants() {
	try
	{
		$DB = connection();
		$data = $DB->query('SELECT * from intervenants');
		$arrAll = $data->fetchAll();

		/* Convertit en JSON  */
		print_r(json_encode($arrAll));
		/* ferme la connexion ? */
		$DB=null;
	}
	catch(PDOException $e)
	{
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
	}
}

function insert_intervenant() {
	/* Récupération des données POST */
	 $data = json_decode(file_get_contents("php://input")); 

	/* Insertion en Bdd avec PDO */
	try {
		$DB = connection();
		$req = $DB->prepare("INSERT INTO intervenants VALUES (?,?,?,?,?,?,?)");
		$req->execute(array(null,$data->nom,$data->prenom,$data->photo,$data->telephone,$data->email,$data->fonction));
		$DB=null;
	} catch (PDOException $e) {
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
		die();
	}
}

 function delete_intervenant() {
	/* Récupération des données POST */
	 $data = json_decode(file_get_contents("php://input"));
	/* Delete en Bdd avec PDO */
	try {
		$DB = connection();
		$sql = "DELETE FROM intervenants WHERE  id=:id";
		$stmt = $DB->prepare($sql);
		$stmt->bindParam(':id',$data->id,PDO::PARAM_INT);
		$stmt->execute();
		$DB=null;
	} catch (PDOException $e) {
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
		die();
	}
}

 function update_intervenant() {
	$data = json_decode(file_get_contents("php://input"));

	/* Update en Bdd avec PDO (pour la sécurité ce serait mieux de spécifier le typage de vars pour le prepared statement)*/
	try {
		$DB = connection();
		$sql = "UPDATE intervenants SET nom='".$data->nom."',prenom='".$data->prenom."',photo='".$data->photo."',telephone='".$data->telephone."',email='".$data->email."',fonction='".$data->fonction."' WHERE  id=".$data->id." ";
		$stmt = $DB->prepare($sql); // Est ce sur que cela fonctionne comme ça ?
		$stmt->execute();
		$DB=null;
	} catch (PDOException $e) {
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
		die();
	}
}

/* --------------------------------------------------CRUD  ------------------------------------------*/

function get_fournisseurs() {  

	try
	{
		$DB = connection();
		$data = $DB->query('SELECT * from fournisseurs');
		$arrAll = $data->fetchAll();

		/* Convertit en JSON  */
		print_r(json_encode($arrAll));
		/* ferme la connexion ? */
		$DB=null;
	}
	catch(PDOException $e)
	{
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
	}
}

function insert_fournisseur() {
	/* Récupération des données POST */
	 $data = json_decode(file_get_contents("php://input")); 

	/* Insertion en Bdd avec PDO */
	try {
		$DB = connection();
		$req = $DB->prepare("INSERT INTO fournisseurs VALUES (?,?,?,?)");
		$req->execute(array(null,$data->nom,$data->adresse,$data->photo));
		$DB=null;
	} catch (PDOException $e) {
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
		die();
	}
}

 function delete_fournisseur() {
	/* Récupération des données POST */
	 $data = json_decode(file_get_contents("php://input"));
	/* Delete en Bdd avec PDO */
	try {
		$DB = connection();
		$sql = "DELETE FROM fournisseurs WHERE  id=:id";
		$stmt = $DB->prepare($sql);
		$stmt->bindParam(':id',$data->id,PDO::PARAM_INT);
		$stmt->execute();
		$DB=null;
	} catch (PDOException $e) {
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
		die();
	}
}

 function update_fournisseur() {
	$data = json_decode(file_get_contents("php://input"));

	/* Update en Bdd avec PDO (pour la sécurité ce serait mieux de spécifier le typage de vars pour le prepared statement)*/
	try {
		$DB = connection();
		$sql = "UPDATE fournisseurs SET nom='".$data->nom."',adresse='".$data->adresse."',photo='".$data->photo."' WHERE  id=".$data->id." ";
		$stmt = $DB->prepare($sql); // Est ce sur que cela fonctionne comme ça ?
		$stmt->execute();
		$DB=null;
	} catch (PDOException $e) {
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
		die();
	}
}

/* --------------------------------------------------CRUD  ------------------------------------------*/

function get_tresoreries() {
	try
	{
		$DB = connection();
		$data = $DB->query('SELECT * from tresoreries');
		$arrAll = $data->fetchAll();

		/* Convertit en JSON  */
		print_r(json_encode($arrAll));
		/* ferme la connexion ? */
		$DB=null;
	}
	catch(PDOException $e)
	{
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
	}
}

function insert_tresorerie() {
	/* Récupération des données POST */
	 $data = json_decode(file_get_contents("php://input")); 

	/* Insertion en Bdd avec PDO */
	try {
		$DB = connection();
		$req = $DB->prepare("INSERT INTO tresoreries VALUES (?,?,?)");
		$req->execute(array(null,$data->nom,$data->adresse));
		$DB=null;
	} catch (PDOException $e) {
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
		die();
	}
}

 function delete_tresorerie() {
	/* Récupération des données POST */
	 $data = json_decode(file_get_contents("php://input"));
	/* Delete en Bdd avec PDO */
	try {
		$DB = connection();
		$sql = "DELETE FROM tresoreries WHERE  id=:id";
		$stmt = $DB->prepare($sql);
		$stmt->bindParam(':id',$data->id,PDO::PARAM_INT);
		$stmt->execute();
		$DB=null;
	} catch (PDOException $e) {
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
		die();
	}
}

 function update_tresorerie() {
	$data = json_decode(file_get_contents("php://input"));

	/* Update en Bdd avec PDO (pour la sécurité ce serait mieux de spécifier le typage de vars pour le prepared statement)*/
	try {
		$DB = connection();
		$sql = "UPDATE tresoreries SET nom='".$data->nom."',adresse='".$data->adresse."' WHERE  id=".$data->id." ";
		$stmt = $DB->prepare($sql); // Est ce sur que cela fonctionne comme ça ?
		$stmt->execute();
		$DB=null;
	} catch (PDOException $e) {
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
		die();
	}
}

/* --------------------------------------------------CRUD  ------------------------------------------*/

function get_reglements() {
	try
	{
		$DB = connection();
		$data = $DB->query('SELECT * from reglements');
		$arrAll = $data->fetchAll();

		/* Convertit en JSON  */
		print_r(json_encode($arrAll));
		/* ferme la connexion ? */
		$DB=null;
	}
	catch(PDOException $e)
	{
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
	}
}

function insert_reglement() {
	/* Récupération des données POST */
	 $data = json_decode(file_get_contents("php://input")); 

	/* Insertion en Bdd avec PDO */
	try {
		$DB = connection();
		$req = $DB->prepare("INSERT INTO reglements VALUES (?,?)");
		$req->execute(array(null,$data->type));
		$DB=null;
	} catch (PDOException $e) {
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
		die();
	}
}

 function delete_reglement() {
	/* Récupération des données POST */
	 $data = json_decode(file_get_contents("php://input"));
	/* Delete en Bdd avec PDO */
	try {
		$DB = connection();
		$sql = "DELETE FROM reglements WHERE  id=:id";
		$stmt = $DB->prepare($sql);
		$stmt->bindParam(':id',$data->id,PDO::PARAM_INT);
		$stmt->execute();
		$DB=null;
	} catch (PDOException $e) {
		file_put_contents(' PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
		die();
	}
}

 function update_reglement() {
	$data = json_decode(file_get_contents("php://input"));

	/* Update en Bdd avec PDO (pour la sécurité ce serait mieux de spécifier le typage de vars pour le prepared statement)*/
	try {
		$DB = connection();
		$sql = "UPDATE reglements SET type='".$data->type."' WHERE  id=".$data->id." ";
		$stmt = $DB->prepare($sql); // Est ce sur que cela fonctionne comme ça ?
		$stmt->execute();
		$DB=null;
	} catch (PDOException $e) {
		file_put_contents('PDOErreurs.txt', $e->getMessage(), FILE_APPEND);
		die();
	}
}
?>
Publicités