def facture_update_wtf():

    # L'utilisateur vient de cliquer sur le bouton "EDIT". Récupère la valeur de "id_facture"
    id_facture_update = request.values['id_facture_btn_edit_html']

    # Objet formulaire pour l'UPDATE
    form_update = FormWTFUpdateGenre()
    try:
        print(" on submit ", form_update.validate_on_submit())
        if form_update.validate_on_submit():
            # Récupèrer la valeur du champ depuis "facture_update_wtf.html" après avoir cliqué sur "SUBMIT".
            # Puis la convertir en lettres minuscules.
            numero_facture_update = form_update.numero_facture_update_wtf.data
            somme_update = form_update.somme_update_wtf.data
            delai_update = form_update.delai_update_wtf.data

            numero_facture_update = numero_facture_update.lower()
            somme_update = somme_update.lower()
            delai_update = delai_update.lower()

            valeur_update_dictionnaire = {
                "value_id_facture": id_facture_update,
                "value_numerous_facture": numero_facture_update,
                "value_somme": somme_update,
                "value_delai": delai_update
            }
            print("valeur_update_dictionnaire ", valeur_update_dictionnaire)

            str_sql_update_intitulegenre = """UPDATE t_facture SET numero_facture = %(value_numerous_facture)s WHERE id_facture = %(value_id_facture)s"""
            with MaBaseDeDonnee() as mconn_bd:
                mconn_bd.mabd_execute(str_sql_update_intitulegenre,
                                      valeur_update_dictionnaire)

            str_sql_update_intitulegenre = """UPDATE t_facture SET somme = %(value_somme)s WHERE id_facture = %(value_id_facture)s"""
            with MaBaseDeDonnee() as mconn_bd:
                mconn_bd.mabd_execute(str_sql_update_intitulegenre,
                                      valeur_update_dictionnaire)

            str_sql_update_intitulegenre = """UPDATE t_facture SET delai = %(value_delai)s WHERE id_facture = %(value_id_facture)s"""
            with MaBaseDeDonnee() as mconn_bd:
                mconn_bd.mabd_execute(str_sql_update_intitulegenre,
                                      valeur_update_dictionnaire)

            flash(f"Donnée mise à jour !!", "success")
            print(f"Donnée mise à jour !!")

            # afficher et constater que la donnée est mise à jour.
            # Affiche seulement la valeur modifiée, "ASC" et l'"id_facture_update"
            return redirect(
                url_for('genres_afficher',
                        order_by="ASC",
                        id_genre_sel=id_facture_update))
        elif request.method == "GET":
            # Opération sur la BD pour récupérer "id_facture" et "numero_facture" de la "t_facture"
            str_sql_id_facture = "SELECT id_facture, numero_facture, somme, delai FROM t_facture WHERE id_facture = %(value_id_facture)s"
            valeur_select_dictionnaire = {
                "value_id_facture": id_facture_update
            }
            mybd_curseur = MaBaseDeDonnee().connexion_bd.cursor()
            mybd_curseur.execute(str_sql_id_facture,
                                 valeur_select_dictionnaire)
            # Une seule valeur est suffisante "fetchone()", vu qu'il n'y a qu'un seul champ "nom genre" pour l'UPDATE
            data_nom_genre = mybd_curseur.fetchone()
            print("data_nom_genre ", data_nom_genre, " type ",
                  type(data_nom_genre), " genre ",
                  data_nom_genre["numero_facture"])

            # Afficher la valeur sélectionnée dans le champ du formulaire "facture_update_wtf.html"
            form_update.numero_facture_update_wtf.data = data_nom_genre[
                "numero_facture"]
            form_update.somme_update_wtf.data = data_nom_genre["somme"]
            form_update.delai_update_wtf.data = data_nom_genre["delai"]

    # OM 2020.04.16 ATTENTION à l'ordre des excepts, il est très important de respecter l'ordre.
    except KeyError:
        flash(
            f"__KeyError dans facture_update_wtf : {sys.exc_info()[0]} {sys.exc_info()[1]} {sys.exc_info()[2]}",
            "danger")
    except ValueError:
        flash(
            f"Erreur dans facture_update_wtf : {sys.exc_info()[0]} {sys.exc_info()[1]}",
            "danger")
    except (pymysql.err.OperationalError, pymysql.ProgrammingError,
            pymysql.InternalError, pymysql.err.IntegrityError,
            TypeError) as erreur_gest_genr_crud:
        code, msg = erreur_gest_genr_crud.args
        flash(
            f"attention : {error_codes.get(code, msg)} {erreur_gest_genr_crud} ",
            "danger")
        flash(
            f"Erreur dans facture_update_wtf : {sys.exc_info()[0]} "
            f"{erreur_gest_genr_crud.args[0]} , "
            f"{erreur_gest_genr_crud}", "danger")
        flash(
            f"__KeyError dans facture_update_wtf : {sys.exc_info()[0]} {sys.exc_info()[1]} {sys.exc_info()[2]}",
            "danger")

    return render_template("factures/facture_update_wtf.html",
                           form_update=form_update)
def facture_delete_wtf():
    data_films_attribue_genre_delete = None
    btn_submit_del = None
    # L'utilisateur vient de cliquer sur le bouton "DELETE". Récupère la valeur de "id_facture"
    id_facture_delete = request.values['id_facture_btn_delete_html']

    # Objet formulaire pour effacer le genre sélectionné.
    form_delete = FormWTFDeleteGenre()
    try:
        print(" on submit ", form_delete.validate_on_submit())
        if request.method == "POST" and form_delete.validate_on_submit():

            if form_delete.submit_btn_annuler.data:
                return redirect(
                    url_for("factures_afficher",
                            order_by="ASC",
                            id_genre_sel=0))

            if form_delete.submit_btn_conf_del.data:
                # Récupère les données afin d'afficher à nouveau
                # le formulaire "genres/facture_delete_wtf.html" lorsque le bouton "Etes-vous sur d'effacer ?" est cliqué.
                data_films_attribue_genre_delete = session[
                    'data_films_attribue_genre_delete']
                print("data_films_attribue_genre_delete ",
                      data_films_attribue_genre_delete)

                flash(f"Effacer le genre de façon définitive de la BD !!!",
                      "danger")
                # L'utilisateur vient de cliquer sur le bouton de confirmation pour effacer...
                # On affiche le bouton "Effacer genre" qui va irrémédiablement EFFACER le genre
                btn_submit_del = True

            if form_delete.submit_btn_del.data:
                valeur_delete_dictionnaire = {
                    "value_id_facture": id_facture_delete
                }
                print("valeur_delete_dictionnaire ",
                      valeur_delete_dictionnaire)

                str_sql_delete_destinataire = """DELETE FROM t_destinataire WHERE fk_facture = %(value_id_facture)s"""
                str_sql_delete_attente = """DELETE FROM  t_attente WHERE fk_facture = %(value_id_facture)s"""
                str_sql_delete_motif = """DELETE FROM  t_motif WHERE fk_facture = %(value_id_facture)s"""
                str_sql_delete_payement = """DELETE FROM  t_payement WHERE fk_facture = %(value_id_facture)s"""
                str_sql_delete_rappel = """DELETE FROM  t_rappel WHERE fk_facture = %(value_id_facture)s"""

                str_sql_delete_idgenre = """DELETE FROM t_facture WHERE id_facture = %(value_id_facture)s"""
                # Manière brutale d'effacer d'abord la "fk_facture", même si elle n'existe pas dans la "t_destinataire"
                # Ensuite on peut effacer le genre vu qu'il n'est plus "lié" (INNODB) dans la "t_destinataire"
                with MaBaseDeDonnee() as mconn_bd:
                    mconn_bd.mabd_execute(str_sql_delete_destinataire,
                                          valeur_delete_dictionnaire)
                    mconn_bd.mabd_execute(str_sql_delete_attente,
                                          valeur_delete_dictionnaire)
                    mconn_bd.mabd_execute(str_sql_delete_motif,
                                          valeur_delete_dictionnaire)
                    mconn_bd.mabd_execute(str_sql_delete_payement,
                                          valeur_delete_dictionnaire)
                    mconn_bd.mabd_execute(str_sql_delete_rappel,
                                          valeur_delete_dictionnaire)
                    mconn_bd.mabd_execute(str_sql_delete_idgenre,
                                          valeur_delete_dictionnaire)

                flash(f"Genre définitivement effacé !!", "success")
                print(f"Genre définitivement effacé !!")

                # afficher les données
                return redirect(
                    url_for('factures_afficher',
                            order_by="ASC",
                            id_genre_sel=0))

        if request.method == "GET":
            valeur_select_dictionnaire = {
                "value_id_facture": id_facture_delete
            }
            print(id_facture_delete, type(id_facture_delete))

            # Requête qui affiche tous les films qui ont le genre que l'utilisateur veut effacer
            str_sql_genres_films_delete = """SELECT id_destinataire, destinataire, id_facture, numero_facture FROM t_destinataire 
                                            INNER JOIN t_facture ON t_destinataire.fk_facture = t_facture.id_facture
                                            INNER JOIN t_user ON t_destinataire.fk_user = t_user.id_user
                                            WHERE fk_facture = %(value_id_facture)s"""

            mybd_curseur = MaBaseDeDonnee().connexion_bd.cursor()

            mybd_curseur.execute(str_sql_genres_films_delete,
                                 valeur_select_dictionnaire)
            data_films_attribue_genre_delete = mybd_curseur.fetchall()
            print("data_films_attribue_genre_delete...",
                  data_films_attribue_genre_delete)

            # Nécessaire pour mémoriser les données afin d'afficher à nouveau
            # le formulaire "genres/facture_delete_wtf.html" lorsque le bouton "Etes-vous sur d'effacer ?" est cliqué.
            session[
                'data_films_attribue_genre_delete'] = data_films_attribue_genre_delete

            # Opération sur la BD pour récupérer "id_facture" et "numero_facture" de la "t_facture"
            str_sql_id_facture = "SELECT id_facture, numero_facture, somme, delai FROM t_facture WHERE id_facture = %(value_id_facture)s"

            mybd_curseur.execute(str_sql_id_facture,
                                 valeur_select_dictionnaire)
            # Une seule valeur est suffisante "fetchone()",
            # vu qu'il n'y a qu'un seul champ "nom genre" pour l'action DELETE
            data_nom_genre = mybd_curseur.fetchone()
            print("data_nom_genre ", data_nom_genre, " type ",
                  type(data_nom_genre), " genre ",
                  data_nom_genre["numero_facture"])

            # Afficher la valeur sélectionnée dans le champ du formulaire "facture_delete_wtf.html"
            form_delete.numero_facture_delete_wtf.data = data_nom_genre[
                "numero_facture"]

            # Le bouton pour l'action "DELETE" dans le form. "facture_delete_wtf.html" est caché.
            btn_submit_del = False

    # OM 2020.04.16 ATTENTION à l'ordre des excepts, il est très important de respecter l'ordre.
    except KeyError:
        flash(
            f"__KeyError dans facture_update_wtf : {sys.exc_info()[0]} {sys.exc_info()[1]} {sys.exc_info()[2]}",
            "danger")
    except ValueError:
        flash(
            f"Erreur dans facture_update_wtf : {sys.exc_info()[0]} {sys.exc_info()[1]}",
            "danger")
    except (pymysql.err.OperationalError, pymysql.ProgrammingError,
            pymysql.InternalError, pymysql.err.IntegrityError,
            TypeError) as erreur_gest_genr_crud:
        code, msg = erreur_gest_genr_crud.args
        flash(
            f"attention : {error_codes.get(code, msg)} {erreur_gest_genr_crud} ",
            "danger")

        flash(
            f"Erreur dans facture_update_wtf : {sys.exc_info()[0]} "
            f"{erreur_gest_genr_crud.args[0]} , "
            f"{erreur_gest_genr_crud}", "danger")

        flash(
            f"__KeyError dans facture_update_wtf : {sys.exc_info()[0]} {sys.exc_info()[1]} {sys.exc_info()[2]}",
            "danger")

    return render_template(
        "factures/facture_delete_wtf.html",
        form_delete=form_delete,
        btn_submit_del=btn_submit_del,
        data_films_associes=data_films_attribue_genre_delete)
def personne_update_wtf():
    # L'utilisateur vient de cliquer sur le bouton "EDIT". Récupère la valeur de "id_genre"
    id_personne_update = request.values['id_personne_btn_edit_html']

    # Objet formulaire pour l'UPDATE
    form_update = FormWTFUpdatePersonne()
    try:
        print(" on submit ", form_update.validate_on_submit())
        if form_update.validate_on_submit():
            # Récupèrer la valeur du champ depuis "genre_update_wtf.html" après avoir cliqué sur "SUBMIT".
            # Puis la convertir en lettres minuscules.
            name_personne_update_wtf = form_update.nom_personne_update_wtf.data
            firstName_personne_update_wtf = form_update.prenom_personne_update_wtf.data
            birthDate_personne_update_wtf = form_update.dateDeNaissance_personne_update_wtf.data
            name_personne_update = name_personne_update_wtf.capitalize()
            firstName_personne_update = firstName_personne_update_wtf.capitalize(
            )
            birthDate_personne_update = birthDate_personne_update_wtf

            valeur_update_dictionnaire = {
                "value_id_update": id_personne_update,
                "value_name_update": name_personne_update,
                "value_firstName_update": firstName_personne_update,
                "value_birthDate_update": birthDate_personne_update
            }
            print("valeur_update_dictionnaire ", valeur_update_dictionnaire)

            str_sql_update_personne = """UPDATE `t_personne` SET `pers_nom` = %(value_name_update)s, `pers_prenom` = %(value_firstName_update)s, `pers_dateDeNaissance` = %(value_birthDate_update)s WHERE `t_personne`.`id_personne` = %(value_id_update)s;"""
            #str_sql_update_personne = """UPDATE `t_personne` SET `pers_nom` = 'Wead', `pers_prenom` = 'asd', `pers_dateDeNaissance` = '1990-04-13' WHERE `t_personne`.`id_personne` = 16;"""
            with MaBaseDeDonnee() as mconn_bd:
                mconn_bd.mabd_execute(str_sql_update_personne,
                                      valeur_update_dictionnaire)

            flash(f"Donnée mise à jour !!", "success")
            print(f"Donnée mise à jour !!")

            # afficher et constater que la donnée est mise à jour.
            # Affiche seulement la valeur modifiée, "ASC" et l'"id_genre_update"
            return redirect(
                url_for('personne_afficher',
                        order_by="ASC",
                        id_personne_sel=id_personne_update))
        elif request.method == "GET":
            # Opération sur la BD pour récupérer "id_genre" et "intitule_genre" de la "t_genre"
            str_sql_id_personne = """SELECT id_personne, pers_nom, pers_prenom, pers_dateDeNaissance FROM t_personne WHERE id_personne = %(value_id_personne)s"""
            valeur_select_dictionnaire = {
                "value_id_personne": id_personne_update
            }
            mybd_curseur = MaBaseDeDonnee().connexion_bd.cursor()
            mybd_curseur.execute(str_sql_id_personne,
                                 valeur_select_dictionnaire)
            # Une seule valeur est suffisante "fetchone()", vu qu'il n'y a qu'un seul champ "nom genre" pour l'UPDATE
            data_personne = mybd_curseur.fetchone()
            print("data_personne ", data_personne, " type ",
                  type(data_personne), " personne ", data_personne["pers_nom"])

            # Afficher la valeur sélectionnée dans le champ du formulaire "genre_update_wtf.html"
            form_update.nom_personne_update_wtf.data = data_personne[
                "pers_nom"]
            form_update.prenom_personne_update_wtf.data = data_personne[
                "pers_prenom"]
            form_update.dateDeNaissance_personne_update_wtf.data = data_personne[
                "pers_dateDeNaissance"]

    # OM 2020.04.16 ATTENTION à l'ordre des excepts, il est très important de respecter l'ordre.
    except KeyError:
        flash(
            f"__KeyError dans prenom_update_wtf : {sys.exc_info()[0]} {sys.exc_info()[1]} {sys.exc_info()[2]}",
            "danger")
    except ValueError:
        flash(
            f"Erreur dans prenom_update_wtf : {sys.exc_info()[0]} {sys.exc_info()[1]}",
            "danger")
    except (pymysql.err.OperationalError, pymysql.ProgrammingError,
            pymysql.InternalError, pymysql.err.IntegrityError,
            TypeError) as erreur_gest_pers_crud:
        code, msg = erreur_gest_pers_crud.args
        flash(
            f"attention : {error_codes.get(code, msg)} {erreur_gest_pers_crud} ",
            "danger")
        flash(
            f"Erreur dans personne_update_wtf : {sys.exc_info()[0]} "
            f"{erreur_gest_pers_crud.args[0]} , "
            f"{erreur_gest_pers_crud}", "danger")
        flash(
            f"__KeyError dans personne_update_wtf : {sys.exc_info()[0]} {sys.exc_info()[1]} {sys.exc_info()[2]}",
            "danger")

    return render_template("personne/personne_update_wtf.html",
                           form_update=form_update)