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 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 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 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 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 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 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 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 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 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 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 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 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 volumeArticle(ref):
'''
Retourne le volume d'un article
'''
(cur, conn) = bdd.ouvrirConnexion()
try:
bdd.executerReq(cur, "SELECT volume FROM articles WHERE reference=%s;",
(ref, ))
vol = cur.fetchone()
if vol == None:
raise Exception("Article non present")
bdd.validerModifs(conn)
except DatabaseError:
raise
finally:
bdd.fermerConnexion(cur, conn)
return vol
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)
def visUnCom(Commande):
'''
Affiche dans le terminal la liste une commande spécifique présents dans la base de données
'''
numero = Commande.numero
(cur, conn) = bdd.ouvrirConnexion()
try:
bdd.executerReq(cur, "SELECT * FROM commandes WHERE numero = %s;",
(numero))
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 ajoutClient(self, nom, prenom, adresse, accord_sub, telephone,
adresse_mail):
if nom != "" and prenom != "" and accord_sub != "" and telephone != "" and adresse_mail != "":
(cur, conn) = bdd.ouvrirConnexion()
try:
bdd.executerReq(
cur,
"INSERT INTO client (nom, prenom, adresse, accord_sub, telephone, adresse_mail) \
VALUES (%s, %s, %s, %s, %s, %s);",
(nom, prenom, adresse, accord_sub, telephone,
adresse_mail))
bdd.validerModifs(conn)
except Exception:
raise
finally:
bdd.fermerConnexion(cur, conn)
else:
raise exceptions.ExceptionEntreeVide()
def visUnArt(Article):
'''
Affiche dans le terminal la liste un article spécifique présent dans la base de données
'''
reference = Article.reference
(cur, conn) = bdd.ouvrirConnexion()
try:
bdd.executerReq(cur, "SELECT * FROM articles WHERE reference = %s;",
(reference))
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)
