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 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 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 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 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 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 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 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 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 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 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 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 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 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 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)
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 sauvegardeClient(Client):
'''
Sauvegarde un client dans la base de données
'''
nom1 = Client.nom
prenom1 = Client.prenom
if nom1 != "" and prenom1 != "":
(cur, conn) = bdd.ouvrirConnexion()
try:
bdd.executerReq(
cur, "INSERT INTO clients (nom, prenom)\
VALUES (%s, %s);", (nom1, prenom1))
bdd.validerModifs(conn)
except Exception:
raise
finally:
bdd.fermerConnexion(cur, conn)
else:
raise exceptions.ExceptionEntreeVide()
def sauvegardeModifComRetiree(Commande):
'''
Sauvegarde dans la base de données les modifications apportées à l'attribut retiree d'une commande
'''
retiree = Commande.retiree
numero = Commande.numero
if retiree != "":
(cur, conn) = bdd.ouvrirConnexion()
try:
bdd.executerReq(
cur, "UPDATE commandes SET retiree=%s\
WHERE numero = %s;", (retiree, numero))
bdd.validerModifs(conn)
except Exception:
raise
finally:
bdd.fermerConnexion(cur, conn)
else:
raise exceptions.ExceptionEntreeVide()
def suppression():
'''
Supprime les différentes tables dans la base de données
'''
cur, conn = bdd.ouvrirConnexion()
# commandes_clients
bdd.executerReq(cur, "DROP TABLE commandes_clients;")
# clients
bdd.executerReq(cur, "DROP TABLE clients;")
# commandes_articles
bdd.executerReq(cur, "DROP TABLE commandes_articles;")
# commandes
bdd.executerReq(cur, "DROP TABLE commandes;")
# articles
bdd.executerReq(cur, "DROP TABLE articles;")
bdd.validerModifs(conn)
bdd.fermerConnexion(cur, conn)
def annulerCommande(self, id_commande):
if id_commande != "":
(cur, conn) = bdd.ouvrirConnexion()
try:
bdd.executerReq(cur, "SELECT * FROM commande WHERE idc=%s;",
(id_commande, ))
tout = cur.fetchone()
if tout != None:
bdd.executerReq(cur, "DELETE FROM commande WHERE idc=%s;",
(id_commande, ))
bdd.validerModifs(conn)
bdd.fermerConnexion(cur, conn)
return True
except Exception:
raise
finally:
bdd.fermerConnexion(cur, conn)
else:
raise exceptions.ExceptionEntreeVide()
def creerListeCommandesEnAttente():
'''
Retorune la liste des comandes(numeros,poids,volume) qui ne sont pas encore traité (dont l'attribut prete en à False)
'''
(cur, conn) = bdd.ouvrirConnexion()
try:
bdd.executerReq(
cur, "SELECT numero, poids ,volume FROM commandes \
WHERE prete=False \
ORDER BY ddc;")
lca = []
for com in cur:
lca.append(com)
bdd.validerModifs(conn)
except DatabaseError:
raise
finally:
return lca
bdd.fermerConnexion(cur, conn)
def visUnCli(Client):
'''
Affiche dans le terminal un client spécifique présents dans la base de données
'''
nom = Client.nom
prenom = Client.prenom
(cur, conn) = bdd.ouvrirConnexion()
try:
bdd.executerReq(cur,
"SELECT * FROM clients WHERE nom=%s AND prenom=%s;",
(nom, prenom))
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 remplirCommandes_Articles(commande):
'''
Remplir la table de liens commandes_articles à partir d'un objet Commande
'''
(cur, conn) = bdd.ouvrirConnexion()
idc = commande.numero
try:
for elem in commande.lsa:
splitelem = elem.split(' ')
ida = splitelem[0]
qte = splitelem[2]
bdd.executerReq(
cur,
"INSERT INTO commandes_articles (idc,ida,quantite) VALUES (%s,%s,%s);",
(idc, ida, qte))
bdd.validerModifs(conn)
except DatabaseError:
raise
finally:
bdd.fermerConnexion(cur, conn)
def suppression():
cur, conn = bdd.ouvrirConnexion()
# Employe
bdd.executerReq(cur, "DROP TABLE employe;")
# Client
bdd.executerReq(cur, "DROP TABLE client;")
# Commande
bdd.executerReq(cur, "DROP TABLE commande;")
# Emplacement
bdd.executerReq(cur, "DROP TABLE emplacement;")
# Magasin
bdd.executerReq(cur, "DROP TABLE magasin;")
# Produit
bdd.executerReq(cur, "DROP TABLE produit;")
# Lien client-commande
bdd.executerReq(cur, "DROP TABLE lien_client_commande;")
bdd.validerModifs(conn)
bdd.fermerConnexion(cur, conn)
def enregistrerArticle(Article):
'''
Sauvegarde un article dans la base de données
'''
nom = Article.nom
poids = Article.poids
volume = Article.volume
if nom != "" and poids != "" and volume != "":
(cur, conn) = bdd.ouvrirConnexion()
try:
bdd.executerReq(
cur, "INSERT INTO articles (nom ,poids , volume) \
VALUES (%s,%s,%s);", (nom, poids, volume))
bdd.validerModifs(conn)
except Exception:
raise
finally:
bdd.fermerConnexion(cur, conn)
else:
raise exceptions.ExceptionEntreeVide()
def supprimerArticle(Article):
'''
Supprime si il existe un article dans la base de données
'''
nom = Article.nom
poids = Article.poids
volume = Article.volume
if nom != "" and poids != "" and volume != "":
(cur, conn) = bdd.ouvrirConnexion()
bdd.executerReq(
cur,
"SELECT reference FROM articles WHERE nom=%s AND poids=%s AND volume=%s;",
(nom, poids, volume))
id_Art = cur.fetchone()
if id_Art != None:
bdd.executerReq(
cur,
"DELETE FROM articles WHERE reference=%d;" % (int(id_Art[0])))
bdd.validerModifs(conn)
bdd.fermerConnexion(cur, conn)
