def edit_personne_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 personne sélectionné dans le tableau dans le formulaire HTML
str_sql_ID_Personne = "SELECT ID_Personne, Nom_Pers, Prenom_Pers, Date_Naissance_Pers FROM t_personne " \
"WHERE ID_Personne = %(value_ID_Personne)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_Personne, 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_personne_data Data Gestions Personnes numéro de l'erreur : {erreur}"
)
# flash(f"Flash. Problèmes Data Gestions personnes 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_personne_data d'un personne Data Gestions Personnes {erreur}"
)
def type_equipements_serveurs_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_Serveur" et "id_type_equipement" dans la "t_serv_a_type_equipement"
strsql_delete_type_equipement_serveur = """DELETE FROM t_serv_a_type_equipement WHERE FK_Type_Equipement = %(value_FK_Type_Equipement)s AND FK_Serveur = %(value_FK_Serveur)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_type_equipement_serveur,
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 type_equipements_serveurs_delete Gestions type_equipements serveurs numéro de l'erreur : {erreur}"
)
# C'est une erreur à signaler à l'utilisateur de cette application WEB.
flash(
f"Flash. Problème type_equipements_serveurs_delete Gestions type_equipements serveurs numéro de l'erreur : {erreur}",
"danger")
raise Exception(
"Raise exception... Problème type_equipements_serveurs_delete Gestions type_equipements serveurs {erreur}"
)
def type_equipements_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_type_equipement"
# 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_type_equipements_afficher = """SELECT ID_Type_Equipement, Type_Equipement FROM t_type_equipement ORDER BY ID_Type_Equipement 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_type_equipements_afficher)
# Récupère les données de la requête.
data_type_equipements = mc_afficher.fetchall()
# Affichage dans la console
print("data_type_equipements ", data_type_equipements,
" Type : ", type(data_type_equipements))
# Retourne les données du "SELECT"
return data_type_equipements
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 delete_select_status_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 "nameEditIntitulestatusHTML" du form HTML "statusEdit.html"
# le "%s" permet d'éviter des injections SQL "simples"
# <td><input type = "text" name = "nameEditIntitulestatusHTML" value="{{ row.intitule_status }}"/></td>
# EZ 2020.07.17 C'EST LA QUE VOUS ALLEZ DEVOIR PLACER VOTRE PROPRE LOGIQUE MySql
# Commande MySql pour afficher le status sélectionné dans le tableau dans le formulaire HTML
str_sql_select_ID_Status = "SELECT ID_Status, Status FROM t_status WHERE ID_Status = %(value_ID_Status)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_select_ID_Status, 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_status_data Gestions status numéro de l'erreur : {erreur}")
# C'est une erreur à signaler à l'utilisateur de cette application WEB.
flash(f"Flash. Problème delete_select_status_data numéro de l'erreur : {erreur}", "danger")
raise Exception(
"Raise exception... Problème delete_select_status_data d\'un status Data Gestions status {erreur}")
def serveurs_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_serveurs"
# 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_serveurs_afficher = """SELECT ID_Serveur, Nom_Serv, Nombre_Port, Nombre_U,
Date_Conf_Serv, Description, Puissance, Date_Serveur FROM t_serveur"""
# 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_serveurs_afficher)
# Récupère les données de la requête.
data_serveurs = mc_afficher.fetchall()
# Affichage dans la console
print("data_serveurs ", data_serveurs, " Type : ", type(data_serveurs))
# Retourne les données du "SELECT"
return data_serveurs
except pymysql.Error as erreur:
print(f"DGF gad pymysql errror {erreur.args[0]} {erreur.args[1]}")
raise MaBdErreurPyMySl(f"DGG fad pymysql errror {msg_erreurs['ErreurPyMySql']['message']} {erreur.args[0]} {erreur.args[1]}")
except Exception as erreur:
print(f"DGF gad Exception {erreur.args}")
raise MaBdErreurConnexion(f"DGG fad Exception {msg_erreurs['ErreurConnexionBD']['message']} {erreur.args}")
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"{msg_erreurs['ErreurDoublonValue']['message']} et son status {msg_erreurs['ErreurDoublonValue']['status']}")
raise MaBdErreurConnexion(f"DGF fad pei {msg_erreurs['ErreurConnexionBD']['message']} {erreur.args[1]}")
def update_status_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 "nameEditstatusHTML" du form HTML "statusEdit.html"
# le "%s" permet d'éviter des injections SQL "simples"
# <td><input type = "text" name = "nameEditstatusHTML" value="{{ row.intitule_status }}"/></td>
str_sql_update_status = "UPDATE t_status SET Status = %(value_status)s WHERE ID_Status = %(value_ID_Status)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_status, valeur_update_dictionnaire)
except (Exception,
pymysql.err.OperationalError,
pymysql.ProgrammingError,
pymysql.InternalError,
pymysql.IntegrityError,
TypeError) as erreur:
# EZ 2020.07.11 Message en cas d'échec du bon déroulement des commandes ci-dessus.
print(f"Problème update_status_data Data Gestions status numéro de l'erreur : {erreur}")
# flash(f"Flash. Problèmes Data Gestions status numéro de l'erreur : {erreur}", "danger")
# raise Exception('Raise exception... Problème update_status_data d\'un status Data Gestions status {}'.format(str(erreur)))
if erreur.args[0] == 1062:
flash(f"Flash. Cette valeur existe déjà : {erreur}", "warning")
# 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_status_data Data Gestions status numéro de l'erreur : {erreur}")
raise Exception("Raise exception... Problème update_status_data d'un status DataGestionsstatus {erreur}")
def personnes_serveurs_afficher_data_concat(self, ID_Serveur_selected):
print("ID_Serveur_selected ", ID_Serveur_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_personne"
# 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_personnes_serveurs_afficher_data_concat = """SELECT ID_Serveur, Nom_Serv, Nombre_Port, Nombre_U, Date_Conf_Serv, Description, Puissance, Date_Serveur,
GROUP_CONCAT(Nom_Pers) as PersonnesServeurs FROM t_pers_a_serveur AS T1
RIGHT JOIN t_serveur AS T2 ON T2.ID_Serveur = T1.FK_Serveur
LEFT JOIN t_personne AS T3 ON T3.ID_Personne = T1.FK_Personne
GROUP BY ID_Serveur"""
# 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 serveurs
# Sinon le paramètre représente la valeur de l'id du serveur
if ID_Serveur_selected == 0:
mc_afficher.execute(
strsql_personnes_serveurs_afficher_data_concat)
else:
# Constitution d'un dictionnaire pour associer l'id du serveur sélectionné avec un nom de variable
valeur_ID_Serveur_selected_dictionnaire = {
"value_ID_Serveur_selected": ID_Serveur_selected
}
strsql_personnes_serveurs_afficher_data_concat += """ HAVING ID_Serveur= %(value_ID_Serveur_selected)s"""
# Envoi de la commande MySql
mc_afficher.execute(
strsql_personnes_serveurs_afficher_data_concat,
valeur_ID_Serveur_selected_dictionnaire)
# Récupère les données de la requête.
data_personnes_serveurs_afficher_concat = mc_afficher.fetchall(
)
# Affichage dans la console
print("dggf data_personnes_serveurs_afficher_concat ",
data_personnes_serveurs_afficher_concat, " Type : ",
type(data_personnes_serveurs_afficher_concat))
# Retourne les données du "SELECT"
return data_personnes_serveurs_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 type_equipements_afficher_data(self, valeur_order_by,
ID_Type_Equipement_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 type_equipements dans l'ordre inverse ou simplement le type_equipement sélectionné
# par l'action edit
if valeur_order_by == "ASC" and ID_Type_Equipement_sel == 0:
strsql_type_equipements_afficher = """SELECT ID_Type_Equipement, Type_Equipement FROM t_type_equipement ORDER BY ID_Type_Equipement ASC"""
mc_afficher.execute(strsql_type_equipements_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_type_equipement"
# 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 type_equipement sélectionné avec un nom de variable
valeur_ID_Type_Equipement_selected_dictionnaire = {
"value_ID_Type_Equipement_selected":
ID_Type_Equipement_sel
}
strsql_type_equipements_afficher = """SELECT ID_Type_Equipement, Type_Equipement FROM t_type_equipement WHERE ID_Type_Equipement = %(value_ID_Type_Equipement_selected)s"""
# Envoi de la commande MySql
mc_afficher.execute(
strsql_type_equipements_afficher,
valeur_ID_Type_Equipement_selected_dictionnaire)
else:
strsql_type_equipements_afficher = """SELECT ID_Type_Equipement, Type_Equipement FROM t_type_equipement ORDER BY ID_Type_Equipement ASC"""
# Envoi de la commande MySql
mc_afficher.execute(strsql_type_equipements_afficher)
# Récupère les données de la requête.
data_type_equipements = mc_afficher.fetchall()
# Affichage dans la console
print("data_type_equipements ", data_type_equipements,
" Type : ", type(data_type_equipements))
# Retourne les données du "SELECT"
return data_type_equipements
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 serveurs")
# 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 serveurs ...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 Gestionserveurs {erreur.args[0]}")
raise MaBdErreurConnexion(f"{msg_erreurs['ErreurConnexionBD']['message']} {erreur.args[0]}")
print("Classe constructeur Gestionserveurs ")
def __init__ (self):
try:
# DEBUG bon marché : Pour afficher un message dans la console.
print("dans le try de gestions type_equipements")
# EZ 2020.07 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(f"Dans Gestion type_equipements ...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 GestionType_Equipements {erreur.args[0]}")
# Ainsi on peut avoir un message d'erreur personnalisé.
raise MaBdErreurConnexion(f"{msg_erreurs['ErreurConnexionBD']['message']} {erreur.args[0]}")
print("Classe constructeur GestionType_Equipements ")
def delete_type_equipement_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 "type_equipementsEdit.html"
# le "%s" permet d'éviter des injections SQL "simples"
# <td><input type = "text" name = "nameEditType_EquipementHTML" value="{{ row.Type_Equipement }}"/></td>
str_sql_delete_Type_Equipement = "DELETE FROM t_type_equipement WHERE ID_Type_Equipement = %(value_ID_Type_Equipement)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_Type_Equipement,
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_type_equipement_data Data Gestions type_equipements numéro de l'erreur : {erreur}"
)
flash(
f"Flash. Problèmes Data Gestions type_equipements 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 type_equipement qui est associé à un serveur dans la table intermédiaire "t_serv_a_type_equipements"
# il y a une contrainte sur les FK de la table intermédiaire "t_serv_a_type_equipements"
# C'est une erreur à signaler à l'utilisateur de cette application WEB.
flash(
f"Flash. IMPOSSIBLE d'effacer !!! Ce type_equipement est associé à des serveurs dans la t_serv_a_type_equipements !!! : {erreur}",
"danger")
# DEBUG bon marché : Pour afficher un message dans la console.
print(
f"IMPOSSIBLE d'effacer !!! Ce type_equipement est associé à des serveurs dans la t_serv_a_type_equipements !!! : {erreur}"
)
raise MaBdErreurDelete(
f"DGG Exception {msg_erreurs['ErreurDeleteContrainte']['message']} {erreur}"
)
def add_type_equipement_data (self, valeurs_insertion_dictionnaire):
try:
print(valeurs_insertion_dictionnaire)
# EZ 2020.07.17 C'EST LA QUE VOUS ALLEZ DEVOIR PLACER VOTRE PROPRE LOGIQUE MySql
strsql_insert_type_equipement = """INSERT INTO t_type_equipement (ID_Type_Equipement,Type_Equipement)
VALUES (NULL,%(value_Type_Equipement)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_type_equipement, valeurs_insertion_dictionnaire)
except pymysql.err.IntegrityError as erreur:
# EZ 2020.07.19 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 locations_serveurs_add (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
# Insérer une (des) nouvelle(s) association(s) entre "ID_Serveur" et "id_location" dans la "t_serv_a_location"
strsql_insert_serv_a_location = """INSERT INTO t_serv_a_location (ID_Serv_A_Location, FK_Location, FK_Serveur)
VALUES (NULL, %(value_FK_Location)s, %(value_FK_Serveur)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_serv_a_location, 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 add_serveur_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_serveur = """INSERT INTO `t_serveur` (`ID_Serveur`, `Nom_Serv`, `Nombre_Port`, `Nombre_U`,
`Date_Conf_Serv`, `Description`, `Puissance`) VALUES (NULL, %(value_Nom_Serv)s,
%(value_Nombre_Port)s, %(value_Nombre_U)s, %(value_Date_Conf_Serv)s, %(value_Description)s,
%(value_Puissance)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_serveur, 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 type_equipements_serveurs_afficher_data(
self, valeur_ID_Serveur_selected_dict):
print("valeur_ID_Serveur_selected_dict...",
valeur_ID_Serveur_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_type_equipement"
# 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_serveur_selected = """SELECT ID_Serveur, Nom_Serv, Nombre_Port, Nombre_U, Date_Conf_Serv, Description, Puissance, Date_Serveur,
GROUP_CONCAT(ID_Type_Equipement) as Type_EquipementsServeurs FROM t_serv_a_type_equipement AS T1
INNER JOIN t_serveur AS T2 ON T2.ID_Serveur = T1.FK_Serveur
INNER JOIN t_type_equipement AS T3 ON T3.ID_Type_Equipement = T1.FK_Type_Equipement
WHERE ID_Serveur = %(value_ID_Serveur_selected)s"""
strsql_type_equipements_serveurs_non_attribues = """SELECT ID_Type_Equipement, Type_Equipement FROM t_type_equipement
WHERE ID_Type_Equipement not in(SELECT ID_Type_Equipement as idType_EquipementsServeurs FROM t_serv_a_type_equipement AS T1
INNER JOIN t_serveur AS T2 ON T2.ID_Serveur = T1.FK_Serveur
INNER JOIN t_type_equipement AS T3 ON T3.ID_Type_Equipement = T1.FK_Type_Equipement
WHERE ID_Serveur = %(value_ID_Serveur_selected)s)"""
strsql_type_equipements_serveurs_attribues = """SELECT ID_Serveur, ID_Type_Equipement, Type_Equipement FROM t_serv_a_type_equipement AS T1
INNER JOIN t_serveur AS T2 ON T2.ID_Serveur = T1.FK_Serveur
INNER JOIN t_type_equipement AS T3 ON T3.ID_Type_Equipement = T1.FK_Type_Equipement
WHERE ID_Serveur = %(value_ID_Serveur_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_type_equipements_serveurs_non_attribues,
valeur_ID_Serveur_selected_dict)
# Récupère les données de la requête.
data_type_equipements_serveurs_non_attribues = mc_afficher.fetchall(
)
# Affichage dans la console
print("dfad data_type_equipements_serveurs_non_attribues ",
data_type_equipements_serveurs_non_attribues, " Type : ",
type(data_type_equipements_serveurs_non_attribues))
# Envoi de la commande MySql
mc_afficher.execute(strsql_serveur_selected,
valeur_ID_Serveur_selected_dict)
# Récupère les données de la requête.
data_serveur_selected = mc_afficher.fetchall()
# Affichage dans la console
print("data_serveur_selected ", data_serveur_selected,
" Type : ", type(data_serveur_selected))
# Envoi de la commande MySql
mc_afficher.execute(strsql_type_equipements_serveurs_attribues,
valeur_ID_Serveur_selected_dict)
# Récupère les données de la requête.
data_type_equipements_serveurs_attribues = mc_afficher.fetchall(
)
# Affichage dans la console
print("data_type_equipements_serveurs_attribues ",
data_type_equipements_serveurs_attribues, " Type : ",
type(data_type_equipements_serveurs_attribues))
# Retourne les données du "SELECT"
return data_serveur_selected, data_type_equipements_serveurs_non_attribues, data_type_equipements_serveurs_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]}"
)
def mails_personnes_afficher_data(self, valeur_ID_Personne_selected_dict):
print("valeur_ID_Personne_selected_dict...",
valeur_ID_Personne_selected_dict)
try:
# EZ 2020.07.17 C'EST LA QUE VOUS ALLEZ DEVOIR PLACER VOTRE PROPRE LOGIQUE MySql
# la commande MySql classique est "SELECT * FROM t_mail"
# 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_personne_selected = """SELECT ID_Personne, Nom_Pers, Prenom_Pers, Date_Naissance_Pers, GROUP_CONCAT(ID_Mail) as MailsPersonnes FROM t_pers_a_mail AS T1
INNER JOIN t_personne AS T2 ON T2.ID_Personne = T1.FK_Personne
INNER JOIN t_mail AS T3 ON T3.ID_Mail = T1.FK_Mail
WHERE ID_Personne = %(value_ID_Personne_selected)s"""
strsql_mails_personnes_non_attribues = """SELECT ID_Mail, Adresse_Mail FROM t_mail
WHERE ID_Mail not in(SELECT ID_Mail as idMailsPersonnes FROM t_pers_a_mail AS T1
INNER JOIN t_personne AS T2 ON T2.ID_Personne = T1.FK_Personne
INNER JOIN t_mail AS T3 ON T3.ID_Mail = T1.FK_Mail
WHERE ID_Personne = %(value_ID_Personne_selected)s)"""
strsql_mails_personnes_attribues = """SELECT ID_Personne, ID_Mail, Adresse_Mail FROM t_pers_a_mail AS T1
INNER JOIN t_personne AS T2 ON T2.ID_Personne = T1.FK_Personne
INNER JOIN t_mail AS T3 ON T3.ID_Mail = T1.FK_Mail
WHERE ID_Personne = %(value_ID_Personne_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_mails_personnes_non_attribues,
valeur_ID_Personne_selected_dict)
# Récupère les données de la requête.
data_mails_personnes_non_attribues = mc_afficher.fetchall()
# Affichage dans la console
print("dfad data_mails_personnes_non_attribues ",
data_mails_personnes_non_attribues, " Type : ",
type(data_mails_personnes_non_attribues))
# Envoi de la commande MySql
mc_afficher.execute(strsql_personne_selected,
valeur_ID_Personne_selected_dict)
# Récupère les données de la requête.
data_personne_selected = mc_afficher.fetchall()
# Affichage dans la console
print("data_personne_selected ", data_personne_selected,
" Type : ", type(data_personne_selected))
# Envoi de la commande MySql
mc_afficher.execute(strsql_mails_personnes_attribues,
valeur_ID_Personne_selected_dict)
# Récupère les données de la requête.
data_mails_personnes_attribues = mc_afficher.fetchall()
# Affichage dans la console
print("data_mails_personnes_attribues ",
data_mails_personnes_attribues, " Type : ",
type(data_mails_personnes_attribues))
# Retourne les données du "SELECT"
return data_personne_selected, data_mails_personnes_non_attribues, data_mails_personnes_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:
# EZ 2020.07.19 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]}"
)
