def sauvegardeClientmodif(Client1, Client2):
'''
Sauvegarde les modifications apportées à un client dans la base de données
'''
nom1 = Client1.nom
prenom1 = Client1.prenom
nom2 = Client2.nom
prenom2 = Client2.prenom
if nom1 != "" and prenom1 != "" and nom2 != "" and prenom2 != "":
(cur, conn) = bdd.ouvrirConnexion()
try:
bdd.executerReq(
cur, "SELECT id FROM clients WHERE nom = %s AND prenom = %s;",
(nom1, prenom1))
id_cli1 = cur.fetchone()
if id_cli1 != None:
bdd.executerReq(
cur, "UPDATE clients SET nom = %s,prenom=%s \
WHERE nom = %s AND prenom = %s;",
(nom2, prenom2, nom1, prenom1))
bdd.validerModifs(conn)
except Exception:
raise
finally:
bdd.fermerConnexion(cur, conn)
else:
raise exceptions.ExceptionEntreeVide()
def MarquerCommandeLivree(id_commande):
(cur, conn) = bdd.ouvrirConnexion()
bdd.executerReq(cur, "UPDATE commande SET livree=%s WHERE idc=%s;", (
True,
id_commande,
))
bdd.validerModifs(conn)
bdd.fermerConnexion(cur, conn)
#if __name__ == "__main__":
#com=Commande('2004-10-19 10:23:54','2004-10-25 16:20:00',True,'Dorade 1 Orange 5')
#ch=com.chaine_course
#print(ch)
#liste_course=com.conversion_liste_course(ch)
#date_commande=com.date_de_commande
#print(liste_course)
#ex=com.verification_existence(liste_course,date_commande)
#print(ex)
#qu=com.verification_quantite(liste_course,date_commande)
#print(qu)
#trie=com.trierListeDeCourse(liste_course)
#print(trie)
#poids=com.calculPoids(liste_course)
#print(poids)
#volume=com.calculVolume(liste_course)
#print(volume)
#com.interaction(liste_course)
#print(liste_course)
def retraitAJour(Client):
'''
Retroune la liste des attriubts retiree des commadnes passées par un client
'''
nom = Client.nom
prenom = Client.prenom
ls = list()
if nom != "" and prenom != "":
(cur, conn) = bdd.ouvrirConnexion()
try:
bdd.executerReq(
cur, "SELECT id FROM clients WHERE nom = %s AND prenom = %s;",
(nom, prenom))
id_cli = cur.fetchone()
bdd.executerReq(
cur,
"SELECT commandes.retiree FROM commandes,clients,commandes_clients \
WHERE commandes.numero=commandes_clients.idc\
AND commandes_clients.idcli=clients.id\
AND clients.id = %s AND commandes.prete=True;", (id_cli))
for pay in cur:
ls.append(pay)
except DatabaseError:
raise
finally:
bdd.fermerConnexion(cur, conn)
return ls
def ajoutProduit(self, nom, categorie, quantite):
#attention, le poids est celui du produit seul.
conf = False
if nom != "" and categorie != "" and quantite != "":
(cur, conn) = bdd.ouvrirConnexion()
try:
#on verifie si le produit ajouter existe deja. Si c'est la cas, on mettera a jour les stock.
#on part du principe que le poids et le volume est unique pour le nom.
bdd.executerReq(cur, "SELECT * FROM produit WHERE nom = %s ;",
(nom, ))
res1 = cur.fetchall()
if res1 != []:
res = res1[0]
conf = True
idd = res[0]
stockVirt_nouv = int(res[5]) + quantite
stockReel_nouv = int(res[6]) + quantite
bdd.executerReq(
cur,
"UPDATE produit SET stock_virtuel=%s, stock_reel=%s WHERE idp=%s;",
(
stockVirt_nouv,
stockReel_nouv,
idd,
))
bdd.validerModifs(conn)
except Exception:
raise
finally:
bdd.fermerConnexion(cur, conn)
else:
raise exceptions.ExceptionEntreeVide()
return conf
def verification_capacite(self,nom_emplacement,quantite):
"""On verifie que l'emplacement selectionne n'est pas en sur capacite"""
#on va faire la somme des stock_reel de la zone selectionnee, retourne True si cette somme est inferieur a la capacite de la zone.
#une zone pourra contenir plusieur categories differentes.
if nom_emplacement != "":
(cur, conn) = bdd.ouvrirConnexion()
try:
#on selectionne la ou les categories qui sont dans la zone demandee.
bdd.executerReq(cur, "SELECT categorie FROM emplacement WHERE nom=%s;" , (nom_emplacement,))
res = cur.fetchone()
#print(res)
#on fait la somme des produits qui sont dans cette zone.
bdd.executerReq(cur, "SELECT SUM(stock_reel) FROM produit WHERE categorie =%s;" , (res[0],))
summ = cur.fetchone()
somme_finale = int(summ[0])+quantite
#print(summ[0])
#on selectionne la capacite de la zone demandee.
bdd.executerReq(cur, "SELECT capacite FROM emplacement WHERE nom=%s;" , (nom_emplacement,))
capa = cur.fetchone()
#print(capa[0])
#on test en comparant capa[0] et summ[0].
if somme_finale > int(capa[0]) :
#print("Attention, la capacite de l'emplacement ne peut pas etre depassee. !")
return False
else:
#print("On peut encore ajouter des produits dans cet emplacement")
return True
except Exception:
raise
finally:
bdd.fermerConnexion(cur, conn)
else:
raise exceptions.ExceptionEntreeVide()
def suppressionClient(self, nom, prenom):
if nom != "" and prenom != "":
(cur, conn) = bdd.ouvrirConnexion()
try:
bdd.executerReq(
cur,
"SELECT * FROM client WHERE nom = %s AND prenom = %s;", (
nom,
prenom,
))
res = cur.fetchone()
if res != None:
bdd.executerReq(
cur, "DELETE FROM client WHERE nom=%s AND prenom=%s", (
nom,
prenom,
))
bdd.validerModifs(conn)
bdd.fermerConnexion(cur, conn)
return True
except Exception:
raise
finally:
bdd.fermerConnexion(cur, conn)
else:
raise exceptions.ExceptionEntreeVide()
def nouveauProduit(self, nom, categorie, volume, poids, quantite, frais):
if nom != "" and categorie != "" and volume != "" and poids != "" and quantite != "" and frais != "":
(cur, conn) = bdd.ouvrirConnexion()
try:
#verification que c'est bien un nouveau produit
bdd.executerReq(cur, "SELECT * FROM produit WHERE nom = %s ;",
(nom, ))
res = cur.fetchone()
if res == None:
bdd.executerReq(
cur,
"INSERT INTO produit (nom, categorie, volume, poids, stock_virtuel, stock_reel,frais) \
VALUES (%s, %s, %s, %s, %s, %s, %s);", (
nom,
categorie,
volume,
poids,
quantite,
quantite,
frais,
))
bdd.validerModifs(conn)
bdd.fermerConnexion(cur, conn)
return True
except Exception:
raise
finally:
bdd.fermerConnexion(cur, conn)
else:
raise exceptions.ExceptionEntreeVide()
def historiqueCommande(Client):
'''
Retorune la liste des commandes passées par un client
'''
nom = Client.nom
prenom = Client.prenom
ls = list()
if nom != "" and prenom != "":
(cur, conn) = bdd.ouvrirConnexion()
try:
bdd.executerReq(
cur, "SELECT id FROM clients WHERE nom = %s AND prenom = %s;",
(nom, prenom))
id_cli = cur.fetchone()
bdd.executerReq(
cur,
"SELECT commandes.numero,commandes.ddc,commandes.ddr FROM commandes,clients,commandes_clients \
WHERE commandes.numero=commandes_clients.idc\
AND commandes_clients.idcli=clients.id\
AND clients.id = %s;", (id_cli))
for pay in cur:
for ele in pay:
ls.append(str(ele))
except DatabaseError:
raise
finally:
bdd.fermerConnexion(cur, conn)
return ls
def historique(nom, prenom):
# Retourne l'ensemble des commandes d'un client spécifié
if nom != "" and prenom != "":
(cur, conn) = bdd.ouvrirConnexion()
try:
bdd.executerReq(
cur, "SELECT idc FROM client WHERE nom=%s AND prenom=%s ;",
(
nom,
prenom,
))
lst = []
res = cur.fetchone()[0]
if res != None:
bdd.executerReq(
cur,
"SELECT idco FROM lien_client_commande WHERE idcl=%s ;",
(res, ))
id_co = cur.fetchall()
for i in range(0, len(id_co)):
bdd.executerReq(
cur,
"SELECT date_de_commande, date_de_livrasion, en_preparation, prete, livree, idc FROM commande WHERE idc=%s ;",
(id_co[i], ))
com = cur.fetchall()
lst.extend(com)
else:
print("Le client n'existe pas.")
except Exception:
raise
finally:
bdd.fermerConnexion(cur, conn)
return lst
def interaction(self, liste_course):
# Fonction qui propose un produit de substitution au client en cas de rupture de stock
(cur, conn) = bdd.ouvrirConnexion()
for i in range(0, len(liste_course) - 1, 2):
article = liste_course[i]
nombre = liste_course[i + 1]
bdd.executerReq(cur,
"SELECT stock_virtuel FROM produit WHERE nom=%s;",
(article, ))
res = cur.fetchone()
if res == (0, ):
print('On vous propose les produits suivants :')
bdd.executerReq(cur,
"SELECT categorie FROM produit WHERE nom=%s;",
(article, ))
ca = cur.fetchone()
bdd.executerReq(
cur, "SELECT idp , nom FROM produit WHERE categorie=%s;",
(ca, ))
tr = False
while (tr == False):
for row in cur:
print(row)
nm = input('Entrez idp du produit : ')
bdd.executerReq(cur,
"SELECT nom FROM produit WHERE idp=%s;",
(nm, ))
fa = cur.fetchone()
if fa != None:
tr = True
liste_course[i] = fa[0]
bdd.fermerConnexion(cur, conn)
def verifComCli(Client, Commande):
'''
Verifie qu'une commande a bien était passées par Client
'''
nom = Client.nom
prenom = Client.prenom
numero = Commande.numero
pk = None
if nom != "" and prenom != "" and numero != "":
(cur, conn) = bdd.ouvrirConnexion()
try:
bdd.executerReq(
cur, "SELECT id FROM clients WHERE nom = %s AND prenom = %s;",
(nom, prenom))
id_cli = cur.fetchone()
bdd.executerReq(
cur,
"SELECT idc,idcli FROM commandes_clients WHERE idc=%s AND idcli=%s;",
(numero, id_cli))
pk = cur.fetchone()
except DatabaseError:
raise
finally:
bdd.fermerConnexion(cur, conn)
return pk != None
def AssocierCommandeClient(nom, prenom, id_commande):
conf = [False, False]
(cur, conn) = bdd.ouvrirConnexion()
bdd.executerReq(cur,
"SELECT idc FROM client WHERE nom=%s AND prenom=%s ;",
(
nom,
prenom,
))
client = cur.fetchone()
bdd.executerReq(cur, "SELECT * FROM commande WHERE idc=%s ;",
(id_commande, ))
tout = cur.fetchone()
if tout != None:
conf[0] = True
if client != None:
conf[1] = True
id_client = client[0]
bdd.executerReq(
cur,
"UPDATE lien_client_commande SET idcl=%s WHERE idco=%s ;",
(
id_client,
id_commande,
))
bdd.validerModifs(conn)
bdd.fermerConnexion(cur, conn)
return conf
def modificationClient(self, nom_ancien, prenom_ancien, nom_nouv,
prenom_nouv, adresse_nouv, accord_sub_nouv,
telephone_nouv, adresse_mail_nouv):
if nom_ancien != "" and prenom_ancien !="" and nom_nouv != "" and prenom_nouv !="" and adresse_nouv != "" \
and accord_sub_nouv !="" and telephone_nouv !="" and adresse_mail_nouv !="" :
(cur, conn) = bdd.ouvrirConnexion()
try:
#on verifie l'existence du client qui doit être modifie.
bdd.executerReq(
cur,
"SELECT idc FROM client WHERE nom = %s AND prenom = %s;", (
nom_ancien,
prenom_ancien,
))
res = cur.fetchone()
if res != None:
idd = res[0]
bdd.executerReq(cur, " UPDATE client SET nom=%s, prenom=%s, adresse=%s, accord_sub=%s, telephone=%s, adresse_mail=%s WHERE idc= %s ;", \
(nom_nouv, prenom_nouv, adresse_nouv, accord_sub_nouv, telephone_nouv, adresse_mail_nouv, idd, ))
bdd.validerModifs(conn)
bdd.fermerConnexion(cur, conn)
return True
except Exception:
raise
finally:
bdd.fermerConnexion(cur, conn)
else:
raise exceptions.ExceptionEntreeVide()
def MarquerCommandePrete(id_commande):
(cur, conn) = bdd.ouvrirConnexion()
bdd.executerReq(cur, "UPDATE commande SET prete=%s WHERE idc=%s;", (
True,
id_commande,
))
bdd.validerModifs(conn)
bdd.fermerConnexion(cur, conn)
def selection_chaine_course(self, id_commande):
# Cette fonction a un rôle uniquement dans l'interaction avec la base de donnée
(cur, conn) = bdd.ouvrirConnexion()
bdd.executerReq(cur,
"SELECT chaine_de_course FROM commande WHERE idc=%s;",
(id_commande, ))
chaine_course = cur.fetchone()[0]
bdd.fermerConnexion(cur, conn)
return chaine_course
def AfficherCommande():
(cur, conn) = bdd.ouvrirConnexion()
bdd.executerReq(
cur,
"SELECT date_de_commande, date_de_livrasion, en_preparation, prete, livree FROM commande;"
)
coco = cur.fetchall()
bdd.fermerConnexion(cur, conn)
return coco
def determinerEmplacement(self,categorie):
(cur, conn) = bdd.ouvrirConnexion()
try:
bdd.executerReq(cur, "SELECT nom FROM emplacement WHERE categorie=%s;" , (categorie,))
res = cur.fetchone()[0]
except Exception:
raise
finally:
bdd.fermerConnexion(cur, conn)
return res
def authentification(login, motDePasse):
(cur, conn) = bdd.ouvrirConnexion()
bdd.executerReq(cur, "SELECT mdp FROM employe WHERE login = %s ;",
(login, ))
resR = cur.fetchone()
if resR == None:
raise exceptions.ExceptionAuthentification("Utilisateur inconnu")
else:
if resR[0] != crypt(motDePasse, resR[0]):
raise exceptions.ExceptionAuthentification("MDP incorrect")
bdd.fermerConnexion(cur, conn)
def calculPoids(self, liste_course):
(cur, conn) = bdd.ouvrirConnexion()
poids_commande = 0
for i in range(0, len(liste_course) - 1, 2):
article = liste_course[i]
bdd.executerReq(cur, "SELECT poids FROM produit WHERE nom=%s;",
(article, ))
res = cur.fetchone()
poids_commande = poids_commande + res[0]
bdd.fermerConnexion(cur, conn)
print('La commande a un poids de ' + str(poids_commande) + ' grammes.')
return poids_commande
def supprCommande(Commande):
'''
Supprime si elle existe une commande de la base de données
'''
numero = Commande.numero
cur, conn = bdd.ouvrirConnexion()
id_Com = numero
if id_Com != None:
bdd.executerReq(
cur, "DELETE FROM commandes WHERE numero=%d;" % (int(id_Com[0])))
bdd.validerModifs(conn)
bdd.fermerConnexion(cur, conn)
def calculVolume(self, liste_course):
(cur, conn) = bdd.ouvrirConnexion()
volume_commande = 1
for i in range(0, len(liste_course) - 1, 2):
article = liste_course[i]
bdd.executerReq(cur, "SELECT volume FROM produit WHERE nom=%s;",
(article, ))
res = cur.fetchone()
volume_commande = volume_commande + res[0]
bdd.fermerConnexion(cur, conn)
print('La commande fait ' + str(volume_commande) + ' litres.')
return volume_commande
def enleverProduit(self, nom, quantite):
conf = [False, False, False]
if nom != "":
(cur, conn) = bdd.ouvrirConnexion()
try:
#on verifie si le produit que l'on souhaite supprimer existe.
bdd.executerReq(cur, "SELECT * FROM produit WHERE nom = %s; ",
(nom, ))
res = cur.fetchone()
if res != None:
conf[0] = True
if quantite == 0:
conf[1] = True
bdd.executerReq(
cur, "DELETE FROM produit WHERE nom = %s; ",
(nom, ))
bdd.validerModifs(conn)
else:
idp = res[0]
stockVirt_nouv = res[5] - quantite
#print(res[5])
#print(stockVirt_nouv)
stockReel_nouv = res[6] - quantite
#on s'assure de ne pas supprimer trop de produits
if stockVirt_nouv > 0 and stockReel_nouv > 0:
conf[2] = True
req1 = (
"UPDATE produit SET stock_virtuel=%s, stock_reel=%s WHERE idp=%s;"
% (
stockVirt_nouv,
stockReel_nouv,
idp,
))
bdd.executerReq(cur, req1)
bdd.validerModifs(conn)
print("suppression du produit reussie")
else:
print(
"impossible d'enlever autant de produit, diminuez la quantite!"
)
else:
print(
"suppression impossible, assurez-vous de l'existence de ce produit"
)
except Exception:
raise
finally:
bdd.fermerConnexion(cur, conn)
else:
raise exceptions.ExceptionEntreeVide()
return conf
def remplirCommandes_Clients(commande, idcli):
'''
Remplir la table de liens commandes_clients à partir d'un objet commande
'''
(cur, conn) = bdd.ouvrirConnexion()
idc = commande.numero
try:
bdd.executerReq(
cur, "INSERT INTO commandes_clients (idc,idcli) VALUES (%s,%s);",
(idc, idcli))
bdd.validerModifs(conn)
except DatabaseError:
raise
finally:
bdd.fermerConnexion(cur, conn)
def supprClient(Client):
'''
Supprime un client dans la base de données
'''
nom = Client.nom
prenom = Client.prenom
cur, conn = bdd.ouvrirConnexion()
bdd.executerReq(cur, "SELECT id FROM clients WHERE nom=%s AND prenom=%s;",
(nom, prenom))
id_Cli = cur.fetchone()
if id_Cli != None:
bdd.executerReq(
cur, "DELETE FROM clients WHERE id=%d;" % (int(id_Cli[0]), ))
bdd.validerModifs(conn)
bdd.fermerConnexion(cur, conn)
def retirerProduit(self, liste_course):
(cur, conn) = bdd.ouvrirConnexion()
for i in range(0, len(liste_course) - 1, 2):
article = liste_course[i]
bdd.executerReq(cur,
"SELECT stock_reel FROM produit WHERE nom=%s;",
(article, ))
quantite_nouv = int(cur.fetchone()[0]) - int(liste_course[i + 1])
bdd.executerReq(cur,
"UPDATE produit SET stock_reel=%s WHERE nom=%s;", (
quantite_nouv,
article,
))
bdd.validerModifs(conn)
bdd.fermerConnexion(cur, conn)
def trierListeDeCourse(self, liste_course):
# Cette fonction permet de trier une liste de course en fonction des zones et place les produits frais en dernier
(cur, conn) = bdd.ouvrirConnexion()
fruit = ['Allez à la zone fruit-légume', '']
viande = [
'Allez à la zone viande-poisson',
'(Stocker les produits au rayon frais)'
]
laitier = [
'Allez à la zone laitier-fromage',
'(Stocker les produits au rayon frais)'
]
drink = ['Allez à la zone boisson', '']
pain = ['Allez à la zone épicerie-pâtisserie', '']
quantite = 0
for i in range(0, len(liste_course) - 1, 2):
article = liste_course[i]
quantite = liste_course[i + 1]
bdd.executerReq(cur, "SELECT categorie FROM produit WHERE nom=%s;",
(article, ))
res = cur.fetchone()
if res != None:
if res[0] == 'laitier_fromage':
laitier.append(article)
laitier.append(quantite)
elif res[0] == 'viande_poisson':
viande.append(article)
viande.append(quantite)
elif res[0] == 'fruit_legume':
fruit.append(article)
fruit.append(quantite)
elif res[0] == 'boisson':
drink.append(article)
drink.append(quantite)
elif res[0] == 'epicerie_patisserie':
pain.append(article)
pain.append(quantite)
else:
print("Le produit %s n'est pas vendu par le magasin" %
(article, ))
bdd.fermerConnexion(cur, conn)
liste_triee = []
liste_triee.extend(pain)
liste_triee.extend(fruit)
liste_triee.extend(drink)
liste_triee.extend(viande)
liste_triee.extend(laitier)
return liste_triee
def visCli():
'''
Affiche dans le terminal la liste des clients présents dans la base de données
'''
(cur, conn) = bdd.ouvrirConnexion()
try:
bdd.executerReq(cur, "SELECT * FROM clients;")
for cli in cur:
for i in range(0, len(cli)):
print(cli[i])
print('---------')
bdd.validerModifs(conn)
except DatabaseError:
raise
finally:
bdd.fermerConnexion(cur, conn)
def listeCom():
'''
Retourne la liste des commandes présentes dans la base de données
'''
(cur, conn) = bdd.ouvrirConnexion()
lst = list()
try:
bdd.executerReq(cur, "SELECT * FROM commandes;")
for cli in cur:
for i in range(0, len(cli)):
lst.append(cli[i])
bdd.validerModifs(conn)
except DatabaseError:
raise
finally:
bdd.fermerConnexion(cur, conn)
return lst
def sauvegardeClient(nom, prenom):
'''
Sauvegarde un client dans la base de donnees à l'aide du nom et du prenom du client
'''
if nom != "" and prenom != "":
(cur, conn) = bdd.ouvrirConnexion()
try:
bdd.executerReq(
cur, "INSERT INTO clients (nom, prenom)\
VALUES (%s, %s);", (nom, prenom))
bdd.validerModifs(conn)
except Exception:
raise
finally:
bdd.fermerConnexion(cur, conn)
else:
raise exceptions.ExceptionEntreeVide()
def commandeNb(ddr):
'''
Retouren le nombre de commande ayant la même date de retrait que Commande
'''
ls = list()
if ddr != "":
(cur, conn) = bdd.ouvrirConnexion()
try:
bdd.executerReq(cur, "SELECT numero FROM commandes WHERE ddr=%s;",
(ddr))
for pay in cur:
ls.append(pay)
except DatabaseError:
raise
finally:
bdd.fermerConnexion(cur, conn)
return len(ls)