Scribd
Upload
8 views17 pages

Master en Sécurité IT et Big Data 2024

Uploaded by

salaheddinegb8
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
8 views17 pages

Master en Sécurité IT et Big Data 2024

Uploaded by

salaheddinegb8
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd

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………………………………………………………………………………..

[Link] de diagramme de classe en code source python……………………………………………

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

[Link] methodes CRUD selon le patron DAO………………………………………………………………..

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

[Link] page………………………………………………………………………………………………..

[Link] JWT……………………………………………………………………………………

[Link] d’utilisateur…………………………………………………………………………………….

[Link] commande…………………………………………………………………………………….

[Link] les commandes…………………………………………………………………………………….

[Link] de l’application et base de donnees…………………………………………………………

2
Partie I :Mysql
[Link] 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} - {[Link]()}]'

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
[Link]=[]

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

cmd = Commande(ref,date)
[Link](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
[Link] = date
self.id_client=id_client # foreign key
[Link]=[]

def ajouterProd(self,prod):
[Link](prod)

def __repr__(self):
return f'id_cmd :{self.id_cmd} - ref {self.__reference} - date {[Link]} -
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
[Link]=libelle
[Link]=prix
[Link]=[]

def ajouterCmd(self,cmd):
[Link](cmd)

def trierProduit(self,ls):

sorted_ls=sorted(ls,key=lambda p : ([Link],[Link]))
return sorted_ls

def Operator_(self,pr):
pass

def __repr__(self):
return f'prod : {[Link]} - {[Link]} 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
[Link]=qte
self.id_produit=id_prod
self.id_cmd=id_cmd

def __repr__(self):
return f'lign cmd : {[Link]} - {[Link]} - {[Link]}'

5
[Link] de diagramme de classe en schéma de bdd

[Link] methodes CRUD selon le patron DAO


1.3.1. abstract class DAO
from abc import ABC , abstractmethod
import [Link]

class DAO(ABC):
def __init__(self) -> None:
super().__init__()
self._connection =
[Link](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__()

[Link]= self._connection.cursor()

def create(self, obj:User):


sql='insert into user (nom,login,password) values (%s,%s,%s)'
val=([Link](),[Link](),[Link]())
[Link](sql,val)
self._connection.commit()

def readOne(self, id) -> User:


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

def readAll(self) -> list:


[Link]('select * from user')
users_table=[Link]()
users = []
for user in users_table:
[Link](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 = ([Link](),[Link](), [Link]())
[Link](sql, val)
self._connection.commit()

def delete(self, id):


sql='delete from user where id_user=%s'
val=(id,)
[Link](sql,val)
self._connection.commit()

7
def verifieLogin(self,username,password):
sql='select * from user where login=%s and password=%s'
val=(username,password)
[Link](sql,val)
user=[Link]()
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)
[Link](sql,val)
id_user=[Link]()
return id_user

1.3.3. class CLIENTDAO


from dao import DAO
from entities import *

class CLIENTDAO(DAO):
def __init__(self):
super().__init__()
[Link]= self._connection.cursor()

def create(self, obj:Client):


sql='insert into client (id_client,numero) values (%s,%s)'
val=([Link](),[Link]())
[Link](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,)
[Link](sql,val)
client =[Link]()
return Client(client[0],client[1],client[2],client[3],client[5])

def readAll(self) -> list:


[Link]('select * from user,client where id_user=id_client')
clients=[Link]()
clientss = []
for client in clients:
[Link]( 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 = ([Link](),[Link]())
[Link](sql, val)
self._connection.commit()

def delete(self, numero):


sql='delete from client where numero=%s'
val=(numero,)
[Link](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__()

[Link]= self._connection.cursor()

def create(self, obj:Produit):


sql='insert into produit (libelle,prix) values (%s,%s)'
val=([Link],[Link])
[Link](sql,val)
self._connection.commit()

def readOne(self, id) -> Produit:


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

def readAll(self) -> list:


[Link]('select * from produit')
prods_table=[Link]()
prods = []
for prod in prods_table:
[Link](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 = ([Link],obj.id_prod)
[Link](sql, val)
self._connection.commit()

def delete(self, id):


sql='delete from produit where id_prod=%s'
val=(id,)
[Link](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__()
[Link]= self._connection.cursor()

def create(self, obj:Commande):


sql='insert into commande (reference,date,client_id) values (%s,%s,%s)'
val=([Link](),[Link],obj.id_client)
[Link](sql,val)
self._connection.commit()

def readOne(self, id) -> Commande:


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

def readAll(self) -> list:


[Link]('select * from commande')
cmds_table=[Link]()
cmds = []
for cmd in cmds_table:
[Link](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 = ([Link],obj.id_cmd)
[Link](sql, val)
self._connection.commit()

def delete(self, id):


sql='delete from commande where id_cmd=%s'
val=(id,)
[Link](sql,val)
self._connection.commit()

def readCmdClient(self,id):
sql='select * from commande where client_id=%s'
val=(id,)
[Link](sql,val)
cmds=[Link]()
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__()

[Link]= 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,[Link])
[Link](sql,val)
self._connection.commit()

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

def readAll(self) -> list:


[Link]('select * from produit')
prods_table=[Link]()
prods = []
for prod in prods_table:
[Link](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 = ([Link],obj.id_prod)
[Link](sql, val)
self._connection.commit()

def delete(self, id):


sql='delete from produit where id_prod=%s'
val=(id,)
[Link](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__)
[Link]['SECRET_KEY'] = '12345678'
[Link]['JWT_SECRET_KEY'] = '67584654233287'
csrf = CSRFProtect(storeapp)
jwt = JWTManager(storeapp)

# Home page
@[Link]('/')
def home():
return render_template('[Link]' , pagetitle='Home')

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

if form.validate_on_submit():
username = str([Link]).strip()
password = str([Link]).strip()

# Vérifier les informations de connexion


if [Link](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=[Link](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('[Link]', form=form)

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

# user commande
@[Link]('/cmd_client/<id>')
def affiche_cmd_client(id):

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

# ajouter commande

@[Link]('/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 = [Link]
date = str([Link])
client_id = form.client_id.data
[Link](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
@[Link]('/confirmation')
def confirmation():
return "Commande ajoutée avec succès!"

14
@[Link]('/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__':

[Link](debug=True,port=4400)

[Link] page
C’est le premier page apparait apres l’execution de l’application , ou l’utilisateur peut connecter en cliquant sur
login

[Link] 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
[Link] 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

[Link] 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
[Link] les commandes
Le client peut voir les commandes a été effectue par lui-même :

Et enfin le client peut se deconnecter .


[Link] de l’application et base de donnees

17

You might also like