Université Abdelmalek Essaâdi

Faculté des Sciences et Techniques-Tanger

Département Génie Informatique

Master Securite IT et Big Data

03/11/2023 2024/2025

Python Avance

Atelier 5

Realise Par: ZINE-EDDINE SOFIANE

 Table des matiers
Partie I :Mysql………………………………………………………………………………..

1.1.Transaltion de diagramme de classe en code source python……………………………………………

1.12. Translation de diagramme de classe en schéma de bdd………………………………………………

1.3.les methodes CRUD selon le patron DAO………………………………………………………………..

Partie 2 :Flask………………………………………………………………………………..

2.1.Home page………………………………………………………………………………………………..

2.2.Authentification JWT……………………………………………………………………………………

2.3.Page d’utilisateur…………………………………………………………………………………….

2.4.Ajouter commande…………………………………………………………………………………….

2.5.Voir les commandes…………………………………………………………………………………….

2.5.structure de l’application et base de donnees…………………………………………………………

2
Partie I :Mysql
1.1.Transaltion de diagramme de classe en code source python

Class User :

class User:

def __init__(self,nom:str,login:str,password:str,id_user=None):
self._nom=nom
self._login=login
self._password=password
self._id_user=id_user

def getPassword(self):
return self._password

def getIdUser(self):
return self._id_user

def getNom(self):
return self._nom

def getLogin(self):
return self._login

def __repr__(self):
return f'[{self._nom} - {self._login} - {self.getPassword()}]'

3
Class Client

class Client(User):

def __init__(self,numero:str,nom:str,login:str,password:str,id_user=None):
super().__init__(nom,login,password,id_user)
self.__numero=numero
self.cmds=[]

def ajouterCmd(self,ref:int,date:str):

cmd = Commande(ref,date)
self.cmds.append(cmd)

def getNumero(self):
return self.__numero

def __repr__(self):
return 'user info:' + super().__repr__() + f' numero {self.__numero}'

Class Commande

class Commande :

def __init__(self,reference:int,date:str,id_client:int,id_cmd:int=None):
self.id_cmd=id_cmd
self.__reference=reference
self.date = date
self.id_client=id_client # foreign key
self.produits=[]

def ajouterProd(self,prod):
self.produits.append(prod)

def __repr__(self):
return f'id_cmd :{self.id_cmd} - ref {self.__reference} - date {self.date} -
id_client {self.id_client}'

def getReference(self):
return self.__reference

4
Class Produit

class Produit :

def __init__(self,libelle:str,prix:float,id_prod:int=None):
self.id_prod=id_prod
self.libelle=libelle
self.prix=prix
self.cmds=[]

def ajouterCmd(self,cmd):
self.cmds.append(cmd)

def trierProduit(self,ls):

sorted_ls=sorted(ls,key=lambda p : (p.libelle,p.prix))
return sorted_ls

def Operator_(self,pr):
pass

def __repr__(self):
return f'prod : {self.libelle} - {self.prix} dh'

Class Lign Commande

class Lign_cmd:

def __init__(self,qte:float,id_prod:int,id_cmd:int,id_lign_cmd:int=None) -> None:

self.id_lign_cmd=id_lign_cmd
self.qte=qte
self.id_produit=id_prod
self.id_cmd=id_cmd

def __repr__(self):
return f'lign cmd : {self.produit} - {self.cmd} - {self.qte}'

5
1.2.Translation de diagramme de classe en schéma de bdd

1.3.les methodes CRUD selon le patron DAO

1.3.1. abstract class DAO
from abc import ABC , abstractmethod
import mysql.connector

class DAO(ABC):
def __init__(self) -> None:
super().__init__()
self._connection =
mysql.connector.connect(host='localhost',user='root',password='',database='store')

@abstractmethod
def create(self,obj):
pass

@abstractmethod
def readOne(self,id) :
pass

@abstractmethod
def readAll(self, obj) -> list:
pass

@abstractmethod
def update(self,obj):
pass

@abstractmethod
def delete(self,obj):
pass

6
1.3.2. class USERDAO
from dao import DAO
from entities import *

class USERDAO(DAO):

def __init__(self):
super().__init__()

self.mycursor= self._connection.cursor()

def create(self, obj:User):

sql='insert into user (nom,login,password) values (%s,%s,%s)'
val=(obj.getNom(),obj.getLogin(),obj.getPassword())
self.mycursor.execute(sql,val)
self._connection.commit()

def readOne(self, id) -> User:

sql='select * from user where id_user = %s'
val = (id,)
self.mycursor.execute(sql,val)
user =self.mycursor.fetchone()
return User(user[0],user[1],user[2],user[3])

def readAll(self) -> list:

self.mycursor.execute('select * from user')
users_table=self.mycursor.fetchall()
users = []
for user in users_table:
users.append(User(user[0],user[1],user[2],user[3]))
return users

def update(self, obj: User):

sql = 'UPDATE user SET login = %s , password=%s WHERE id_user = %s'
val = (obj.getLogin(),obj.getPassword(), obj.getIdUser())
self.mycursor.execute(sql, val)
self._connection.commit()

def delete(self, id):

sql='delete from user where id_user=%s'
val=(id,)
self.mycursor.execute(sql,val)
self._connection.commit()

7
 def verifieLogin(self,username,password):
sql='select * from user where login=%s and password=%s'
val=(username,password)
self.mycursor.execute(sql,val)
user=self.mycursor.fetchone()
if user :
return True
return False

def getidUser(self,username,password):
sql='select id_user from user where login=%s and password=%s'
val=(username,password)
self.mycursor.execute(sql,val)
id_user=self.mycursor.fetchone()
return id_user

1.3.3. class CLIENTDAO

from dao import DAO
from entities import *

class CLIENTDAO(DAO):
def __init__(self):
super().__init__()
self.mycursor= self._connection.cursor()

def create(self, obj:Client):

sql='insert into client (id_client,numero) values (%s,%s)'
val=(obj.getIdUser(),obj.getNumero())
self.mycursor.execute(sql,val)
self._connection.commit()

def readOne(self, numero) -> Client:

sql='select * from user , client where id_client = id_user and numero = %s'
val = (numero,)
self.mycursor.execute(sql,val)
client =self.mycursor.fetchone()
return Client(client[0],client[1],client[2],client[3],client[5])

def readAll(self) -> list:

self.mycursor.execute('select * from user,client where id_user=id_client')
clients=self.mycursor.fetchall()
clientss = []
for client in clients:
clientss.append( Client(client[0],client[1],client[2],client[3],client[5]))
return clientss

8
def update(self, obj: Client):
sql = 'UPDATE client SET numero = %s WHERE id_client = %s'
val = (obj.getNumero(),obj.getIdUser())
self.mycursor.execute(sql, val)
self._connection.commit()

def delete(self, numero):

sql='delete from client where numero=%s'
val=(numero,)
self.mycursor.execute(sql,val)
self._connection.commit()

1.3.3. class PRODUITDAO

from dao import DAO
from entities import *

class PRODUITDAO(DAO):

def __init__(self):
super().__init__()

self.mycursor= self._connection.cursor()

def create(self, obj:Produit):

sql='insert into produit (libelle,prix) values (%s,%s)'
val=(obj.libelle,obj.prix)
self.mycursor.execute(sql,val)
self._connection.commit()

def readOne(self, id) -> Produit:

sql='select * from produit where id_prod = %s'
val = (id,)
self.mycursor.execute(sql,val)
prod =self.mycursor.fetchone()
return Produit(prod[0],prod[1],prod[2])

def readAll(self) -> list:

self.mycursor.execute('select * from produit')
prods_table=self.mycursor.fetchall()
prods = []
for prod in prods_table:
prods.append(Produit(prod[0],prod[1],prod[2]))
return prods

9
 def update(self, obj: Produit):
sql = 'UPDATE produit SET prix=%s WHERE id_prod = %s'
val = (obj.prix,obj.id_prod)
self.mycursor.execute(sql, val)
self._connection.commit()

def delete(self, id):

sql='delete from produit where id_prod=%s'
val=(id,)
self.mycursor.execute(sql,val)
self._connection.commit()

1.3.4. class COMMANDEDAO

from dao import DAO
from entities import *

class COMMANDEDAO(DAO):

def __init__(self):
super().__init__()
self.mycursor= self._connection.cursor()

def create(self, obj:Commande):

sql='insert into commande (reference,date,client_id) values (%s,%s,%s)'
val=(obj.getReference(),obj.date,obj.id_client)
self.mycursor.execute(sql,val)
self._connection.commit()

def readOne(self, id) -> Commande:

sql='select * from commande where id_cmd = %s'
val = (id,)
self.mycursor.execute(sql,val)
cmd =self.mycursor.fetchone()
return Commande(cmd[0],cmd[1],cmd[2],cmd[3])

def readAll(self) -> list:

self.mycursor.execute('select * from commande')
cmds_table=self.mycursor.fetchall()
cmds = []
for cmd in cmds_table:
cmds.append(Commande(cmd[0],cmd[1],cmd[2],cmd[3]))
return cmds

10
def update(self, obj: Commande):
sql = 'UPDATE produit SET date=%s WHERE id_cmd = %s'
val = (obj.date,obj.id_cmd)
self.mycursor.execute(sql, val)
self._connection.commit()

def delete(self, id):

sql='delete from commande where id_cmd=%s'
val=(id,)
self.mycursor.execute(sql,val)
self._connection.commit()

def readCmdClient(self,id):
sql='select * from commande where client_id=%s'
val=(id,)
self.mycursor.execute(sql,val)
cmds=self.mycursor.fetchall()
client_cmds=[]
for cmd in cmds:
client_cmds.append(Commande(cmd[1],cmd[2],cmd[3],cmd[0]))
return client_cmds

1.3.5 class LIGNCOMMANDEDAO

from dao import DAO
from entities import *

class LIGNCOMMANDEDAO(DAO):

def __init__(self):
super().__init__()

self.mycursor= self._connection.cursor()

def create(self, obj:Lign_cmd):

sql='insert into lign_cmd (commande_id,produit_id,qte) values (%s,%s,%s)'
val=(obj.id_cmd,obj.id_produit,obj.qte)
self.mycursor.execute(sql,val)
self._connection.commit()

11
def readOne(self, id) -> Lign_cmd:
sql='select * from lign_cmd where commande_id = %s'
val = (id,)
self.mycursor.execute(sql,val)
l_cmd =self.mycursor.fetchone()
return Lign_cmd(l_cmd[3],l_cmd[2],l_cmd[1],l_cmd[0])

def readAll(self) -> list:

self.mycursor.execute('select * from produit')
prods_table=self.mycursor.fetchall()
prods = []
for prod in prods_table:
prods.append(Produit(prod[0],prod[1],prod[2]))
return prods

def update(self, obj: Produit):

sql = 'UPDATE produit SET prix=%s WHERE id_prod = %s'
val = (obj.prix,obj.id_prod)
self.mycursor.execute(sql, val)
self._connection.commit()

def delete(self, id):

sql='delete from produit where id_prod=%s'
val=(id,)
self.mycursor.execute(sql,val)
self._connection.commit()

12
Partie 2 :Flask
Backend Flask
from flask import Flask , render_template,redirect, url_for,request,flash,make_response
from flask_wtf.csrf import CSRFProtect
from forms import *

from commandedao import COMMANDEDAO

from userdao import USERDAO
from entities import *

from flask_jwt_extended import JWTManager, create_access_token

storeapp = Flask(__name__)
storeapp.config['SECRET_KEY'] = '12345678'
storeapp.config['JWT_SECRET_KEY'] = '67584654233287'
csrf = CSRFProtect(storeapp)
jwt = JWTManager(storeapp)

# Home page
@storeapp.route('/')
def home():
return render_template('home.html' , pagetitle='Home')

#login
@storeapp.route('/login', methods=['GET', 'POST'])
def login():
form = LoginForm()
userdao=USERDAO()

if form.validate_on_submit():
username = str(form.username.data).strip()
password = str(form.password.data).strip()

# Vérifier les informations de connexion

if userdao.verifieLogin(username,password):
# Créer un token JWT pour l'utilisateur authentifié
access_token = create_access_token(identity=username)
flash("Connexion réussie", "success")
# Rediriger ou traiter le token (par exemple, l'envoyer dans les cookies)
user_id=userdao.getidUser(username,password)
return
redirect(url_for('user_page',token=access_token,id_user=user_id,username=username))
else:
flash("Nom d'utilisateur ou mot de passe incorrect", "danger")

return render_template('login.html', form=form)

13
# user page after connection
@storeapp.route('/user_page', methods=['GET'])
def user_page():
token = request.args.get('token') # Récupérer le token transmis dans l'URL
id_user = request.args.get('id_user') # Récupère l'ID utilisateur de l'URL
username=request.args.get('username')
return render_template('user_page.html',
token=token,id_user=id_user,username=username,pagetitle='User Page')

# user commande
@storeapp.route('/cmd_client/<id>')
def affiche_cmd_client(id):

cmddao=COMMANDEDAO()
client_cmd=cmddao.readCmdClient(id)
return render_template('client_cmd.html',pagetitle='Client Commands',client_cmds=client_cmd)

# ajouter commande

@storeapp.route('/ajouter_commande', methods=['GET', 'POST'])

def ajouter_commande():
form = CommandeForm()
commandedao=COMMANDEDAO()

if form.validate_on_submit():
# Ici vous pouvez ajouter la logique pour enregistrer la commande dans la base de
données
reference = form.reference.data
date = str(form.date.data)
client_id = form.client_id.data
commandedao.create(Commande(reference,date,client_id))
# Rediriger vers une page de confirmation ou d'affichage
return redirect(url_for('confirmation'))

return render_template('ajouter_commande.html', form=form,pagetitle='Ajouter Commande')

# Page de confirmation
@storeapp.route('/confirmation')
def confirmation():
return "Commande ajoutée avec succès!"

14
@storeapp.route('/logout', methods=['GET'])
# @jwt_required() # Assurez-vous que l'utilisateur est authentifié pour se déconnecter
def logout():
# Créer une réponse de redirection vers la page de connexion
response = make_response(redirect(url_for('login')))

# Supprimer le cookie contenant le token JWT

response.delete_cookie('access_token',path='/') # Nom du cookie contenant le token JWT

# Afficher un message de déconnexion réussie

flash("Vous avez été déconnecté avec succès.", "success")

return response

if __name__=='__main__':

storeapp.run(debug=True,port=4400)

2.1.Home page
C’est le premier page apparait apres l’execution de l’application , ou l’utilisateur peut connecter en cliquant sur
login

2.2.Authentification JWT
apres l’utilisateur click sur login , cette page sera apparait, en utilisant l’authentification JWT , on peut generer le
tocken associe au l’utilisateur authentifie :

15
2.3.Page d’utilisateur
Apres avoir authentifie , l’utilisateur doit rediriger vers son page ou il a la possibilité de ajouter des commandes,
Voir son commandes , ou logout

2.4.Ajouter commande
L’utilisateur peur ajouter des commandes en specifiant la reference , la date du commande et l’ID du client

Apres ca laa commande a été ajoute avec succes

16
2.5.Voir les commandes
Le client peut voir les commandes a été effectue par lui-même :

Et enfin le client peut se deconnecter .

2.5.structure de l’application et base de donnees

17