def edit_genre_data(self, valeur_id_dictionnaire):
try:
print(valeur_id_dictionnaire)
# OM 2020.04.07 C'EST LA QUE VOUS ALLEZ DEVOIR PLACER VOTRE PROPRE LOGIQUE MySql
# Commande MySql pour afficher le genre sélectionné dans le tableau dans le formulaire HTML
str_sql_id_genre = "SELECT id_material, Material FROM t_material WHERE id_material = %(value_id_material)s"
# Du fait de l'utilisation des "context managers" on accède au curseur grâce au "with".
# la subtilité consiste à avoir une méthode "mabd_execute" dans la classe "MaBaseDeDonnee"
# ainsi quand elle aura terminé l'insertion des données le destructeur de la classe "MaBaseDeDonnee"
# sera interprété, ainsi on fera automatiquement un commit
with MaBaseDeDonnee().connexion_bd as mconn_bd:
with mconn_bd as mc_cur:
mc_cur.execute(str_sql_id_genre, valeur_id_dictionnaire)
data_one = mc_cur.fetchall()
print("valeur_id_dictionnaire...", data_one)
return data_one
except Exception as erreur:
# OM 2020.03.01 Message en cas d'échec du bon déroulement des commandes ci-dessus.
print(
f"Problème edit_genre_data Data Gestions Genres numéro de l'erreur : {erreur}"
)
# flash(f"Flash. Problèmes Data Gestions Genres numéro de l'erreur : {erreur}", "danger")
# OM 2020.04.09 On dérive "Exception" par le "@obj_mon_application.errorhandler(404)" fichier "run_mon_app.py"
# Ainsi on peut avoir un message d'erreur personnalisé.
raise Exception(
"Raise exception... Problème edit_genre_data d'un genre Data Gestions Genres {erreur}"
)
def genres_afficher_data(self):
try:
# OM 2020.04.07 C'EST LA QUE VOUS ALLEZ DEVOIR PLACER VOTRE PROPRE LOGIQUE MySql
# la commande MySql classique est "SELECT * FROM t_genres"
# Pour "lever"(raise) une erreur s'il y a des erreurs sur les noms d'attributs dans la table
# donc, je précise les champs à afficher
strsql_genres_afficher = """SELECT * FROM `t_material` ORDER BY `t_material`.`Id_material` ASC"""
# Du fait de l'utilisation des "context managers" on accède au curseur grâce au "with".
with MaBaseDeDonnee().connexion_bd.cursor() as mc_afficher:
# Envoi de la commande MySql
mc_afficher.execute(strsql_genres_afficher)
# Récupère les données de la requête.
data_genres = mc_afficher.fetchall()
# Affichage dans la console
print("data_material ", data_genres, " Type : ",
type(data_genres))
# Retourne les données du "SELECT"
return data_genres
except pymysql.Error as erreur:
print(f"DGG gad pymysql errror {erreur.args[0]} {erreur.args[1]}")
raise MaBdErreurPyMySl(
f"DGG gad pymysql errror {msg_erreurs['ErreurPyMySql']['message']} {erreur.args[0]} {erreur.args[1]}"
)
except Exception as erreur:
print(f"DGG gad Exception {erreur.args}")
raise MaBdErreurConnexion(
f"DGG gad Exception {msg_erreurs['ErreurConnexionBD']['message']} {erreur.args}"
)
except pymysql.err.IntegrityError as erreur:
# OM 2020.04.09 On dérive "pymysql.err.IntegrityError" dans le fichier "erreurs.py"
# Ainsi on peut avoir un message d'erreur personnalisé.
raise MaBdErreurConnexion(
f"DGG gad pei {msg_erreurs['ErreurConnexionBD']['message']} {erreur.args[1]}"
)
def add_film(self, valeurs_insertion_dictionnaire):
try:
# # Définitions d'un dictionnaire pour passer les valeurs en paramètres de façon un "peu" sécurisée dans la BD
# valeurs_insertion_dictionnaire = {'value_nom_film': valeur_ins_1, 'value_duree_film': valeur_ins_2,
# 'date_sortie_film': valeur_ins_3}
# Rssure la personne qui dévelloppe que les valeurs à insérer sont bien à disposition.
print(valeurs_insertion_dictionnaire)
str_sql_insert = "INSERT INTO t_user (id_user, Nom, Prenom, UserNom) VALUES (NULL, %(Nom)s, %(Prenom)s, %(UserNom)s"
with MaBaseDeDonnee() as ma_bd_curseur:
# OM Méthode "execute" définie simplement pour raccourcir la ligne de code
# ligne de code normale : ma_bd_moi.connexion_bd.cursor(str_sql_insert, valeurs_insertion_dictionnaire)
ma_bd_curseur.execute(str_sql_insert,
valeurs_insertion_dictionnaire)
except Exception as erreur:
# OM 2020.04.09 DIFFERENTS MOYENS D'INFORMER EN CAS D'ERREURS.
# Message dans la console en cas d'échec du bon déroulement des commandes ci-dessus.
print("Data Gestions Films ERREUR: {0}".format(erreur))
print(
f"Print console ... Data Gestions Films, numéro de l'erreur : {erreur}"
)
# Petits messages "flash", échange entre Python et Jinja dans une page en HTML
flash(
f"Flash ... Data Gestions Films, numéro de l'erreur : {erreur}"
)
# raise, permet de "lever" une exception et de personnaliser la page d'erreur
# voir fichier "run_mon_app.py"
print("erreur args.. ", erreur.args)
code, msg = erreur.args
print(" codes d'erreurs ---> ", error_codes.get(code, msg))
# OM 2020.04.09 On dérive "Exception" par le "@obj_mon_application.errorhandler(404)" fichier "run_mon_app.py"
# Ainsi on peut avoir un message d'erreur personnalisé.
raise Exception(f"Raise exception... Data Gestions Films {erreur}")
def delete_select_user_data (self, valeur_delete_dictionnaire):
try:
print(valeur_delete_dictionnaire)
# OM 2019.04.02 Commande MySql pour la MODIFICATION de la valeur "CLAVIOTTEE" dans le champ "nameEditIntituleuserHTML" du form HTML "userEdit.html"
# le "%s" permet d'éviter des injections SQL "simples"
# <td><input type = "text" name = "nameEditIntituleuserHTML" value="{{ row.prenom_user }}"/></td>
# OM 2020.04.07 C'EST LA QUE VOUS ALLEZ DEVOIR PLACER VOTRE PROPRE LOGIQUE MySql
# Commande MySql pour afficher le objet sélectionné dans le tableau dans le formulaire HTML
str_sql_select_id_user = "******"
# Du fait de l'utilisation des "context managers" on accède au curseur grâce au "with".
# la subtilité consiste à avoir une méthode "mabd_execute" dans la classe "MaBaseDeDonnee"
# ainsi quand elle aura terminé l'insertion des données le destructeur de la classe "MaBaseDeDonnee"
# sera interprété, ainsi on fera automatiquement un commit
with MaBaseDeDonnee().connexion_bd as mconn_bd:
with mconn_bd as mc_cur:
mc_cur.execute(str_sql_select_id_user, valeur_delete_dictionnaire)
data_one = mc_cur.fetchall()
print("valeur_id_dictionnaire...", data_one)
return data_one
except (Exception,
pymysql.err.OperationalError,
pymysql.ProgrammingError,
pymysql.InternalError,
pymysql.IntegrityError,
TypeError) as erreur:
# DEBUG bon marché : Pour afficher un message dans la console.
print(f"Problème delete_select_user_data Gestions user numéro de l'erreur : {erreur}")
# C'est une erreur à signaler à l'utilisateur de cette application WEB.
flash(f"Flash. Problème delete_select_user_data numéro de l'erreur : {erreur}", "danger")
raise Exception(
"Raise exception... Problème delete_select_user_data d\'un objet Data Gestions user {erreur}")
def materials_users_delete(self, valeurs_insertion_dictionnaire):
try:
print(valeurs_insertion_dictionnaire)
# OM 2020.04.07 C'EST LA QUE VOUS ALLEZ DEVOIR PLACER VOTRE PROPRE LOGIQUE MySql
# Effacer une (des) association(s) existantes entre "id_user" et "id_material" dans la "t_genre_film"
strsql_delete_material_user = """DELETE FROM t_user_material WHERE FK_material = %(value_fk_material)s AND FK_user = %(value_fk_user)s"""
# Du fait de l'utilisation des "context managers" on accède au curseur grâce au "with".
# la subtilité consiste à avoir une méthode "mabd_execute" dans la classe "MaBaseDeDonnee"
# ainsi quand elle aura terminé l'insertion des données le destructeur de la classe "MaBaseDeDonnee"
# sera interprété, ainsi on fera automatiquement un commit
with MaBaseDeDonnee() as mconn_bd:
mconn_bd.mabd_execute(strsql_delete_material_user,
valeurs_insertion_dictionnaire)
except (Exception, pymysql.err.OperationalError,
pymysql.ProgrammingError, pymysql.InternalError,
pymysql.IntegrityError, TypeError) as erreur:
# DEBUG bon marché : Pour afficher un message dans la console.
print(
f"Problème materials_users_delete Gestions Genres films numéro de l'erreur : {erreur}"
)
# C'est une erreur à signaler à l'utilisateur de cette application WEB.
flash(
f"Flash. Problème materials_users_delete Gestions Genres films numéro de l'erreur : {erreur}",
"danger")
raise Exception(
"Raise exception... Problème materials_users_delete Gestions Genres films {erreur}"
)
def materials_users_afficher_data_concat(self, id_user_selected):
print("id_user_selected ", id_user_selected)
try:
# OM 2020.04.07 C'EST LA QUE VOUS ALLEZ DEVOIR PLACER VOTRE PROPRE LOGIQUE MySql
# la commande MySql classique est "SELECT * FROM t_material"
# Pour "lever"(raise) une erreur s'il y a des erreurs sur les noms d'attributs dans la table
# donc, je précise les champs à afficher
strsql_materials_users_afficher_data_concat = """SELECT id_user, Nom,
GROUP_CONCAT(Material) as MaterialsUsers FROM t_user_material AS T1
RIGHT JOIN t_user AS T2 ON T2.id_user = T1.fk_user
LEFT JOIN t_material AS T3 ON T3.id_material = T1.fk_material
GROUP BY id_user"""
# Du fait de l'utilisation des "context managers" on accède au curseur grâce au "with".
with MaBaseDeDonnee().connexion_bd.cursor() as mc_afficher:
# le paramètre 0 permet d'afficher tous les films
# Sinon le paramètre représente la valeur de l'id du film
if id_user_selected == 0:
mc_afficher.execute(
strsql_materials_users_afficher_data_concat)
else:
# Constitution d'un dictionnaire pour associer l'id du film sélectionné avec un nom de variable
valeur_id_user_selected_dictionnaire = {
"value_id_user_selected": id_user_selected
}
strsql_materials_users_afficher_data_concat += """ HAVING id_user= %(value_id_user_selected)s"""
# Envoi de la commande MySql
mc_afficher.execute(
strsql_materials_users_afficher_data_concat,
valeur_id_user_selected_dictionnaire)
# Récupère les données de la requête.
data_materials_users_afficher_concat = mc_afficher.fetchall()
# Affichage dans la console
print("dggf data_materials_users_afficher_concat ",
data_materials_users_afficher_concat, " Type : ",
type(data_materials_users_afficher_concat))
# Retourne les données du "SELECT"
return data_materials_users_afficher_concat
except pymysql.Error as erreur:
print(
f"DGGF gfadc pymysql errror {erreur.args[0]} {erreur.args[1]}")
raise MaBdErreurPyMySl(
f"DGG gad pymysql errror {msg_erreurs['ErreurPyMySql']['message']} {erreur.args[0]} {erreur.args[1]}"
)
except Exception as erreur:
print(f"DGGF gfadc Exception {erreur.args}")
raise MaBdErreurConnexion(
f"DGG gfadc Exception {msg_erreurs['ErreurConnexionBD']['message']} {erreur.args}"
)
except pymysql.err.IntegrityError as erreur:
# OM 2020.04.09 On dérive "pymysql.err.IntegrityError" dans le fichier "erreurs.py"
# Ainsi on peut avoir un message d'erreur personnalisé.
raise MaBdErreurConnexion(
f"DGGF gfadc pei {msg_erreurs['ErreurConnexionBD']['message']} {erreur.args[1]}"
)
def material_afficher_data(self, valeur_order_by, id_material_sel):
try:
print("valeur_order_by ", valeur_order_by, type(valeur_order_by))
# Du fait de l'utilisation des "context managers" on accède au curseur grâce au "with".
with MaBaseDeDonnee().connexion_bd.cursor() as mc_afficher:
# Afficher soit la liste des material dans l'ordre inverse ou simplement le material sélectionné
# par l'action edit
if valeur_order_by == "ASC" and id_material_sel == 0:
strsql_material_afficher = """SELECT id_material, material FROM t_material ORDER BY id_material ASC"""
mc_afficher.execute(strsql_material_afficher)
elif valeur_order_by == "ASC":
# OM 2020.04.07 C'EST LA QUE VOUS ALLEZ DEVOIR PLACER VOTRE PROPRE LOGIQUE MySql
# la commande MySql classique est "SELECT * FROM t_material"
# Pour "lever"(raise) une erreur s'il y a des erreurs sur les noms d'attributs dans la table
# donc, je précise les champs à afficher
# Constitution d'un dictionnaire pour associer l'id du material sélectionné avec un nom de variable
valeur_id_material_selected_dictionnaire = {
"value_id_material_selected": id_material_sel
}
strsql_material_afficher = """SELECT id_material, material FROM t_material WHERE id_material = %(value_id_material_selected)s"""
# Envoi de la commande MySql
mc_afficher.execute(
strsql_material_afficher,
valeur_id_material_selected_dictionnaire)
else:
strsql_material_afficher = """SELECT id_material, material FROM t_material ORDER BY id_material DESC"""
# Envoi de la commande MySql
mc_afficher.execute(strsql_material_afficher)
# Récupère les données de la requête.
data_material = mc_afficher.fetchall()
# Affichage dans la console
print("data_material ", data_material, " Type : ",
type(data_material))
# Retourne les données du "SELECT"
return data_material
except pymysql.Error as erreur:
print(f"DGG gad pymysql errror {erreur.args[0]} {erreur.args[1]}")
raise MaBdErreurPyMySl(
f"DGG gad pymysql errror {msg_erreurs['ErreurPyMySql']['message']} {erreur.args[0]} {erreur.args[1]}"
)
except Exception as erreur:
print(f"DGG gad Exception {erreur.args}")
raise MaBdErreurConnexion(
f"DGG gad Exception {msg_erreurs['ErreurConnexionBD']['message']} {erreur.args}"
)
except pymysql.err.IntegrityError as erreur:
# OM 2020.04.09 On dérive "pymysql.err.IntegrityError" dans le fichier "erreurs.py"
# Ainsi on peut avoir un message d'erreur personnalisé.
raise MaBdErreurConnexion(
f"DGG gad pei {msg_erreurs['ErreurConnexionBD']['message']} {erreur.args[1]}"
)
def __init__(self):
try:
print("dans le try de gestions user")
# OM 2020.04.11 La connexion à la base de données est-elle active ?
# Renvoie une erreur si la connexion est perdue.
MaBaseDeDonnee().connexion_bd.ping(False)
except Exception as erreur:
flash("Dans Gestion user ...terrible erreur, il faut connecter une base de donnée", "danger")
# DEBUG bon marché : Pour afficher un message dans la console.
print(f"Exception grave Classe constructeur Gestionuser {erreur.args[0]}")
raise MaBdErreurConnexion(f"{msg_erreurs['ErreurConnexionBD']['message']} {erreur.args[0]}")
print("Classe constructeur Gestionuser ")
def delete_material_data(self, valeur_delete_dictionnaire):
try:
print(valeur_delete_dictionnaire)
# OM 2019.04.02 Commande MySql pour EFFACER la valeur sélectionnée par le "bouton" du form HTML "GenresEdit.html"
# le "%s" permet d'éviter des injections SQL "simples"
# <td><input type = "text" name = "nameEditIntituleGenreHTML" value="{{ row.Material }}"/></td>
str_sql_delete_material = "DELETE FROM t_material WHERE id_material = %(value_id_material)s"
# Du fait de l'utilisation des "context managers" on accède au curseur grâce au "with".
# la subtilité consiste à avoir une méthode "mabd_execute" dans la classe "MaBaseDeDonnee"
# ainsi quand elle aura terminé l'insertion des données le destructeur de la classe "MaBaseDeDonnee"
# sera interprété, ainsi on fera automatiquement un commit
with MaBaseDeDonnee().connexion_bd as mconn_bd:
with mconn_bd as mc_cur:
mc_cur.execute(str_sql_delete_material,
valeur_delete_dictionnaire)
data_one = mc_cur.fetchall()
print("valeur_id_dictionnaire...", data_one)
return data_one
except (Exception, pymysql.err.OperationalError,
pymysql.ProgrammingError, pymysql.InternalError,
pymysql.IntegrityError, TypeError) as erreur:
# DEBUG bon marché : Pour afficher un message dans la console.
print(
f"Problème delete_material_data Data Gestions Genres numéro de l'erreur : {erreur}"
)
flash(
f"Flash. Problèmes Data Gestions Genres numéro de l'erreur : {erreur}",
"danger")
if erreur.args[0] == 1451:
# OM 2020.04.09 Traitement spécifique de l'erreur 1451 Cannot delete or update a parent row: a foreign key constraint fails
# en MySql le moteur INNODB empêche d'effacer un genre qui est associé à un film dans la table intermédiaire "t_user_material"
# il y a une contrainte sur les FK de la table intermédiaire "t_user_material"
# C'est une erreur à signaler à l'utilisateur de cette application WEB.
flash(
f"Flash. IMPOSSIBLE d'effacer !!! Ce genre est associé à des films dans la t_user_material !!! : {erreur}",
"danger")
# DEBUG bon marché : Pour afficher un message dans la console.
print(
f"IMPOSSIBLE d'effacer !!! Ce genre est associé à des films dans la t_user_material !!! : {erreur}"
)
raise MaBdErreurDelete(
f"DGG Exception {msg_erreurs['ErreurDeleteContrainte']['message']} {erreur}"
)
def add_genre_data(self, valeurs_insertion_dictionnaire):
try:
print(valeurs_insertion_dictionnaire)
# OM 2020.04.07 C'EST LA QUE VOUS ALLEZ DEVOIR PLACER VOTRE PROPRE LOGIQUE MySql
strsql_insert_genre = """INSERT INTO t_material (id_material,Material) VALUES (NULL,%(Material)s)"""
# Du fait de l'utilisation des "context managers" on accède au curseur grâce au "with".
# la subtilité consiste à avoir une méthode "mabd_execute" dans la classe "MaBaseDeDonnee"
# ainsi quand elle aura terminé l'insertion des données le destructeur de la classe "MaBaseDeDonnee"
# sera interprété, ainsi on fera automatiquement un commit
with MaBaseDeDonnee() as mconn_bd:
mconn_bd.mabd_execute(strsql_insert_genre,
valeurs_insertion_dictionnaire)
except pymysql.err.IntegrityError as erreur:
# OM 2020.04.09 On dérive "pymysql.err.IntegrityError" dans "MaBdErreurDoublon" fichier "erreurs.py"
# Ainsi on peut avoir un message d'erreur personnalisé.
raise MaBdErreurDoublon(
f"DGG pei erreur doublon {msg_erreurs['ErreurDoublonValue']['message']} et son status {msg_erreurs['ErreurDoublonValue']['status']}"
)
def update_material_data(self, valeur_update_dictionnaire):
try:
print(valeur_update_dictionnaire)
# OM 2019.04.02 Commande MySql pour la MODIFICATION de la valeur "CLAVIOTTEE" dans le champ "nameEditIntitulematerialHTML" du form HTML "materialEdit.html"
# le "%s" permet d'éviter des injections SQL "simples"
# <td><input type = "text" name = "nameEditIntitulematerialHTML" value="{{ row.intitule_material }}"/></td>
str_sql_update_material = "UPDATE t_material SET material = %(value_material)s WHERE id_material = %(value_id_material)s"
# Du fait de l'utilisation des "context managers" on accède au curseur grâce au "with".
# la subtilité consiste à avoir une méthode "mabd_execute" dans la classe "MaBaseDeDonnee"
# ainsi quand elle aura terminé l'insertion des données le destructeur de la classe "MaBaseDeDonnee"
# sera interprété, ainsi on fera automatiquement un commit
with MaBaseDeDonnee().connexion_bd as mconn_bd:
with mconn_bd as mc_cur:
mc_cur.execute(str_sql_update_material,
valeur_update_dictionnaire)
except (Exception, pymysql.err.OperationalError,
pymysql.ProgrammingError, pymysql.InternalError,
pymysql.IntegrityError, TypeError) as erreur:
# OM 2020.03.01 Message en cas d'échec du bon déroulement des commandes ci-dessus.
print(
f"Problème update_material_data Data Gestions material numéro de l'erreur : {erreur}"
)
# flash(f"Flash. Problèmes Data Gestions material numéro de l'erreur : {erreur}", "danger")
# raise Exception('Raise exception... Problème update_material_data d\'un material Data Gestions material {}'.format(str(erreur)))
if erreur.args[0] == 1062:
flash(f"Flash. Cette valeur existe déjà : {erreur}", "danger")
# Deux façons de communiquer une erreur causée par l'insertion d'une valeur à double.
flash(f"'Doublon !!! Introduire une valeur différente",
"warning")
# Message en cas d'échec du bon déroulement des commandes ci-dessus.
print(
f"Problème update_material_data Data Gestions material numéro de l'erreur : {erreur}"
)
raise Exception(
"Raise exception... Problème update_material_data d'un material DataGestionsmaterial {erreur}"
)
def materials_users_afficher_data(self, valeur_id_user_selected_dict):
print("valeur_id_user_selected_dict...", valeur_id_user_selected_dict)
try:
# OM 2020.04.07 C'EST LA QUE VOUS ALLEZ DEVOIR PLACER VOTRE PROPRE LOGIQUE MySql
# la commande MySql classique est "SELECT * FROM t_material"
# Pour "lever"(raise) une erreur s'il y a des erreurs sur les noms d'attributs dans la table
# donc, je précise les champs à afficher
strsql_user_selected = """SELECT id_user, Nom, GROUP_CONCAT(id_material) as MaterialsUsers FROM t_user_material AS T1
INNER JOIN t_user AS T2 ON T2.id_user = T1.FK_user
INNER JOIN t_material AS T3 ON T3.id_material = T1.FK_material
WHERE id_user = %(value_id_user_selected)s"""
strsql_materials_users_non_attribues = """SELECT id_material, Material FROM t_material
WHERE id_material not in(SELECT id_material as idMaterialsUsers FROM t_user_material AS T1
INNER JOIN t_user AS T2 ON T2.id_user = T1.FK_user
INNER JOIN t_material AS T3 ON T3.id_material = T1.FK_material
WHERE id_user = %(value_id_user_selected)s)"""
strsql_materials_users_attribues = """SELECT id_user, id_material, Material FROM t_user_material AS T1
INNER JOIN t_user AS T2 ON T2.id_user = T1.FK_user
INNER JOIN t_material AS T3 ON T3.id_material = T1.FK_material
WHERE id_user = %(value_id_user_selected)s"""
# Du fait de l'utilisation des "context managers" on accède au curseur grâce au "with".
with MaBaseDeDonnee().connexion_bd.cursor() as mc_afficher:
# Envoi de la commande MySql
mc_afficher.execute(strsql_materials_users_non_attribues,
valeur_id_user_selected_dict)
# Récupère les données de la requête.
data_materials_users_non_attribues = mc_afficher.fetchall()
# Affichage dans la console
print("dfad data_materials_users_non_attribues ",
data_materials_users_non_attribues, " Type : ",
type(data_materials_users_non_attribues))
# Envoi de la commande MySql
mc_afficher.execute(strsql_user_selected,
valeur_id_user_selected_dict)
# Récupère les données de la requête.
data_user_selected = mc_afficher.fetchall()
# Affichage dans la console
print("data_user_selected ", data_user_selected, " Type : ",
type(data_user_selected))
# Envoi de la commande MySql
mc_afficher.execute(strsql_materials_users_attribues,
valeur_id_user_selected_dict)
# Récupère les données de la requête.
data_materials_users_attribues = mc_afficher.fetchall()
# Affichage dans la console
print("data_materials_users_attribues ",
data_materials_users_attribues, " Type : ",
type(data_materials_users_attribues))
# Retourne les données du "SELECT"
return data_user_selected, data_materials_users_non_attribues, data_materials_users_attribues
except pymysql.Error as erreur:
print(
f"DGGF gfad pymysql errror {erreur.args[0]} {erreur.args[1]}")
raise MaBdErreurPyMySl(
f"DGG gad pymysql errror {msg_erreurs['ErreurPyMySql']['message']} {erreur.args[0]} {erreur.args[1]}"
)
except Exception as erreur:
print(f"DGGF gfad Exception {erreur.args}")
raise MaBdErreurConnexion(
f"DGG gad Exception {msg_erreurs['ErreurConnexionBD']['message']} {erreur.args}"
)
except pymysql.err.IntegrityError as erreur:
# OM 2020.04.09 On dérive "pymysql.err.IntegrityError" dans le fichier "erreurs.py"
# Ainsi on peut avoir un message d'erreur personnalisé.
raise MaBdErreurConnexion(
f"DGGF gfad pei {msg_erreurs['ErreurConnexionBD']['message']} {erreur.args[1]}"
)