def add_billeterie(billeterie, conn=None):
        """
        Cette fonction permet d'ajouter la billeterie
        
            Paramaters:
                billeterie: La billeterie
        """
        close = False
        try:
            if conn == None:
                conn = DBConnexion().Instance
                close = True
            cursor = conn.cursor()

            # Ajouter le la billeterie
            query = "INSERT INTO `BILLETERIE` VALUES (?, ?, ?, ?, ?, ?)"
            cursor.execute(
                query,
                (billeterie.event.id,
                 billeterie.event.salle.nbr_place_standard,
                 billeterie.event.salle.nbr_place_premium,
                 billeterie.nbr_place_reservee, billeterie.prix_place_standard,
                 billeterie.prix_place_premium))

            if close:
                conn.commit()
                conn.close()
            return True
        except sqlite3.Error as e:
            print("add_billeterie error:", str(e))
        return False
    def reserver_billet(billet, billeterie):
        """
        Cette fonction permet d'ajouter un billet d'un évènement donnée
        
            Parameters:
                billet: La billet a réservé
        """
        try:
            conn = DBConnexion().Instance
            cursor = conn.cursor()

            # Ajouter le la billeterie
            query = "INSERT INTO `BILLET` VALUES (NULL, ?, ?, ?, ?, ?, ?)"
            cursor.execute(
                query,
                (billet.event.id, billet.place.num, billet.place.type_place,
                 billet.nom, billet.prenom, billet.tel))

            billeterie.nbr_place_reservee += 1
            if billet.place.type_place == 1:
                billeterie.nbr_place_standard_disponible -= 1
            else:
                billeterie.nbr_place_premium_disponible -= 1
            BilleterieDAO.update_billeterie(billeterie, conn=conn)

            conn.commit()
            conn.close()
            return True
        except sqlite3.Error as e:
            print("reserver_billet error:", str(e))
        return False
    def rembourser_billet(billet, billeterie):
        """
        Cette fonction permet de rembourser un billet
        
            Parameters:
                billet: La billet a rembourser
            Return:
                un booléen: a été rembourser ou pas
        """
        try:
            conn = DBConnexion().Instance
            cursor = conn.cursor()

            # Ajouter le la billeterie
            query = "DELETE FROM `BILLET` WHERE ID=?"
            cursor.execute(query, [billet.id])

            if billet.place.type_place == 1:
                billeterie.nbr_place_standard_disponible += 1
            else:
                billeterie.nbr_place_premium_disponible += 1
            BilleterieDAO.update_billeterie(billeterie, conn=conn)

            conn.commit()
            conn.close()
            return True
        except sqlite3.Error as e:
            print("rembourser_billet error:", str(e))
        return False
    def add_disponibilite(user_id, conn=None):
        """
        Cette fonction permet d'ajouter la disponbilité de l'utilsateur 'user_id'
        
            Parameters:
                user_id: L'identifiant de l'utilisateur
            Return:
                Un booléen: ajout avec succée ou pas
        """
        close = False
        try:
            if conn == None:
                conn = DBConnexion().Instance
                close = True
            cursor = conn.cursor()

            query = "INSERT INTO `USER_DISPONIBILITE` VALUES (?, 0, NULL, NULL, NULL)"
            cursor.execute(query, [user_id])

            if close:
                conn.commit()
                conn.close()
            return (True, None)
        except sqlite3.Error as e:
            print("add_disponibilite error:", e)
            return (False, e)
    def update_projection(projection):
        """
        Cette fonction permet de mettre à jour une projection
        
            Parameters:
                projection: La projection à MAJ
        """
        try:
            conn = DBConnexion().Instance
            cursor = conn.cursor()
            query = """UPDATE `PROJECTION` SET 
                `AUTEUR`=?,
                `DUREE_PRESENTATION_AUTEUR`=?,
                `CONTEXTE`=?,
                `AMUSES_BOUCHES`=? WHERE `ID` = ?"""

            auteur = None
            duree = None
            amuses_bouches = 0
            if projection.presentationAuteur != None:
                auteur = projection.presentationAuteur.auteur
            if projection.presentationAuteur != None:
                duree = projection.presentationAuteur.duree
            if projection.amuses_bouches:
                amuses_bouches = 1

            cursor.execute(query, (auteur, duree, projection.contexte,
                                   amuses_bouches, projection.id))
            conn.commit()
            conn.close()
        except sqlite3.Error as e:
            print("update_projection Error ", e)
    def add_user(user):
        """
        Cette fonction permet d'ajouter un utilisateur dans la base de donnée 
        
            Parameters:
                user: L'utilisateur a ajouter
        """
        try:
            conn = DBConnexion().Instance
            cursor = conn.cursor()
            # Ajouter l'utilisateur
            query = "INSERT INTO `USER` VALUES (NULL, ?, ?, ?, ?, ?, ?, 0)"
            cursor.execute(query,
                           (user.email, user.password, user.nom, user.prenom,
                            user.adresse, str(user.metier)))

            if user.metier in [Metier.MEMBRE_CLUB, Metier.MEMBRE_MAIRIE]:
                user_id = cursor.lastrowid
                (r, ex) = DisponibiliteDAO.add_disponibilite(user_id,
                                                             conn=conn)
                if not r:
                    raise (ex)

            conn.commit()
            conn.close()
            return True
        except sqlite3.Error as e:
            print("add_user error:", str(e))
        return False
    def update_evenement(event):
        """
        Cette fonction permet de mettre à jour un evenement
        
            Parameters:
                event: L'évènement à MAJ
        """
        try:
            conn = DBConnexion().Instance
            cursor = conn.cursor()
            query = """UPDATE `EVENT` SET 
                `NOM`=?,
                `DESCRIPTION`=?,
                `DATE_DEBUT`=?,
                `DATE_FIN`=?,
                `SALLE`=?,
                `COLOR`=?,
                `EST_PROJECTION`=?,
                `ETAT`=?,
                `RESERVATION_SALLE`=?,
                `DISPONIBILITE_INVITES`=? WHERE `ID` = ?"""

            etat = 0
            if event.etat == Etat.EN_COURS:
                etat = 1
            elif event.etat == Etat.TERMINE:
                etat = 2

            est_projection = 0
            if event.est_projection:
                est_projection = 1
            salle_reservee = 0
            if event.salle_reservee:
                salle_reservee = 1
            disponibilite_invites = 0
            if event.disponibilite_invites:
                disponibilite_invites = 1
            cursor.execute(
                query,
                (event.nom, event.description, format_date(
                    event.date_debut), format_date(event.date_fin),
                 event.salle.id, event.color, est_projection, etat,
                 salle_reservee, disponibilite_invites, event.id))
            conn.commit()
            conn.close()
        except sqlite3.Error as e:
            print("Error ", e)
 def update_state(event):
     """
     Cette fonction permet de mettre à jour l'etat un evenement
     
         Parameters:
             event: L'évènement à MAJ
     """
     try:
         conn = DBConnexion().Instance
         cursor = conn.cursor()
         query = "UPDATE `EVENT` SET `ETAT` = ? WHERE `ID` = ?"
         etat = 0
         if event.etat == Etat.EN_COURS:
             etat = 1
         elif event.etat == Etat.TERMINE:
             etat = 2
         cursor.execute(query, (etat, event.id))
         conn.commit()
         conn.close()
     except sqlite3.Error as e:
         print("Error ", e)
    def add_projection(projection, event_id, debat_id, conn=None):
        """
        Cette fonction permet d'ajouter une projection dans la base de donnée 
        
            Parameters:
                - projection: La projection a ajoutée
                - event_id: L'identifiant de l'évenement
                - debat_id: L'identifiant du debat
        """
        close = False
        try:
            if conn == None:
                conn = DBConnexion().Instance
                close = True
            cursor = conn.cursor()
            query_add_projection = "INSERT INTO `PROJECTION` VALUES (NULL, ?, ?, ?, ?, ?, ?)"

            auteur = None
            duree = None
            if projection.presentationAuteur != None:
                auteur = projection.presentationAuteur.auteur
            if projection.presentationAuteur != None:
                duree = projection.presentationAuteur.duree

            amuses_bouches = 0
            if debat_id == None:
                amuses_bouches = 1

            cursor.execute(query_add_projection,
                           (event_id, auteur, duree, projection.contexte,
                            debat_id, amuses_bouches))

            if close:
                conn.commit()
                conn.close()
            return True
        except sqlite3.Error as e:
            print("add_projection error:", str(e))
        return False
    def update_billeterie(billeterie, conn=None):
        """
        Cette fonction permet de MAJ une billeterie
        
            Paramaters:
                billeterie: La billeterie donnée
        """
        close = False
        try:
            if conn == None:
                conn = DBConnexion().Instance
                close = True
            cursor = conn.cursor()

            # Ajouter le la billeterie
            query = """UPDATE `BILLETERIE` SET 
                `NBR_PLACE_STANDARD_DISPONIBLE`=?,
                `NBR_PLACE_PREMIUM_DISPONIBLE`=?,
                `NBR_PLACE_RESERVEE`=?,
                `PRIX_PLACE_STANDARD`=?,
                `PRIX_PLACE_PREMIUM`=? WHERE EVENT_ID = ?"""

            cursor.execute(
                query,
                (billeterie.nbr_place_standard_disponible,
                 billeterie.nbr_place_premium_disponible,
                 billeterie.nbr_place_reservee, billeterie.prix_place_standard,
                 billeterie.prix_place_premium, billeterie.event.id))

            if close:
                conn.commit()
                conn.close()
            return True
        except sqlite3.Error as e:
            print("update_billeterie error:", str(e))
        return False
    def add_event(new_event):
        """
        Cette fonction permet d'ajouter un évènement dans la base de donnée 
        
            Parameters:
                new_event: L'évènement a ajouté
        """
        try:
            conn = DBConnexion().Instance
            cursor = conn.cursor()

            # Ajouter l'évènement
            query_add_event = "INSERT INTO `EVENT` VALUES (NULL, ?, ?, ?, ?, ?, ?, ?, 0, 0, 0)"
            cursor.execute(
                query_add_event,
                (new_event.nom, new_event.description,
                 format_date(new_event.date_debut),
                 format_date(new_event.date_fin), new_event.salle.id,
                 new_event.color.name(), int(new_event.est_projection)))
            event_id = cursor.lastrowid

            # Ajout de la billeterie
            new_event.id = event_id
            billeterie = Billeterie(new_event)
            BilleterieDAO.add_billeterie(billeterie, conn)

            # Ajouter les responsables
            query_add_responsable = "INSERT INTO `EVENT_RESPONSABLE` VALUES (?, ?)"
            responsables_data = []
            for r in new_event.responsables:
                # Ajouter la liaison du responsable avec l'évèenement à la base de donnée
                responsables_data.append((event_id, r.id))
            cursor.executemany(query_add_responsable, responsables_data)

            # Si l'évènement est une projection alors ajouter la projection à la base de donéee
            if new_event.est_projection:
                debat_id = None
                if new_event.debat != None:
                    # Ajouter le débat
                    ## Ajouter un animateur à la base de donnée
                    query_add_animateur = "INSERT INTO `USER` VALUES (NULL, ?, NULL, ?, ?, ?, ?, 0)"
                    cursor.execute(query_add_animateur,
                                   (new_event.debat.animateur.email,
                                    new_event.debat.animateur.nom,
                                    new_event.debat.animateur.prenom,
                                    new_event.debat.animateur.adresse,
                                    new_event.debat.animateur.metier))

                    ## Récupérer son ID
                    animateur_id = cursor.lastrowid

                    ## Ajoute le débat à la base de donnée
                    query_add_debat = "INSERT INTO `DEBAT` VALUES (NULL, ?, ?, ?)"
                    cursor.execute(query_add_debat,
                                   (animateur_id, new_event.debat.duree,
                                    new_event.debat.notes))

                    ## Récupérer son ID
                    debat_id = cursor.lastrowid

                # Ajouter la projection
                ProjectionDAO.add_projection(new_event,
                                             event_id,
                                             debat_id,
                                             conn=conn)

            conn.commit()
            conn.close()
            return True
        except sqlite3.Error as e:
            print("add_event Error:", str(e))
        return False