Ejemplo n.º 1
0
    def get_by_event_id(event):
        """
        Cette fonction permet de renvoyer la billeterie d'un évènement
        
            Parameters:
                event: L'évènement
            Return:
                Un objet de type Billeterie()
        """
        billeterie = None
        if event != None:
            conn = DBConnexion().Instance
            cursor = conn.cursor()
            query = "SELECT * FROM `BILLETERIE` WHERE `EVENT_ID` = ?"
            cursor.execute(query, [event.id])

            billeterie_data = cursor.fetchone()
            billets = BilletDAO.get_by_event_id(event, conn=conn)
            billeterie = Billeterie(
                event=event,
                billets=billets,
                nbr_place_standard_disponible=int(billeterie_data[1]),
                nbr_place_premium_disponible=int(billeterie_data[2]),
                nbr_place_reservee=int(billeterie_data[3]),
                prix_place_standard=int(billeterie_data[4]),
                prix_place_premium=int(billeterie_data[5]))

            conn.close()
        return billeterie
Ejemplo n.º 2
0
    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
Ejemplo n.º 3
0
    def get_by_user_id(user_id):
        """
        Cette fonction permet de renvoyer la disponbilité de l'utilsateur 'user_id'
        
            Parameters:
                user_id: L'identifiant de l'utilisateur
            Return:
                Un objet de type Disponibilite()
        """
        dispo = None
        if user_id != None:
            conn = DBConnexion().Instance
            cursor = conn.cursor()
            query = "SELECT * FROM `USER_DISPONIBILITE` WHERE `ID_USER` = ?"
            cursor.execute(query, [user_id])

            dispo_data = cursor.fetchone()
            if dispo_data != None:
                dispo = Disponibilite(id_user=user_id,
                                      statut=int(dispo_data[1]),
                                      notes=dispo_data[2],
                                      date_debut=data_to_datetime(
                                          dispo_data[3]),
                                      date_fin=data_to_datetime(dispo_data[4]))
            conn.close()
        return dispo
Ejemplo n.º 4
0
    def get_by_event_id(event, conn=None):
        """
        Cette fonction permet de renvoyer les billets d'un évènement
        
            Parameters:
                event: L'évènement
            Return:
                Une liste d'objets de type Billet()
        """
        billets = []
        if event != None:
            conn = DBConnexion().Instance
            cursor = conn.cursor()
            query = "SELECT * FROM `BILLET` WHERE `EVENT_ID` = ?"
            cursor.execute(query, [event.id])

            billets_data = cursor.fetchall()
            for billet_data in billets_data:
                place = Place(int(billet_data[2]), int(billet_data[3]))
                billet = Billet(billet_data[0], event, place, billet_data[4],
                                billet_data[5], billet_data[6])
                billets.append(billet)

            conn.close()
        return billets
Ejemplo n.º 5
0
    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
Ejemplo n.º 6
0
    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)
Ejemplo n.º 7
0
    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)
Ejemplo n.º 8
0
    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
Ejemplo n.º 9
0
    def get_by_id(debat_id):
        """
        Cette fonction permet de renvoyer le debat d'identifiant 'debat_id'
        
            Parameters:
                debat_id: l'identifiant du debat
            Return:
                Un objet de type Debat()
        """
        debat = None
        if debat_id != None:
            conn = DBConnexion().Instance
            cursor = conn.cursor()
            query = "SELECT * FROM `DEBAT` WHERE `ID` = ?"
            cursor.execute(query, [debat_id])

            debat_data = cursor.fetchone()

            animateur_id = int(debat_data[1])
            animateur = UtilisateurDAO.get_by_id(animateur_id)
            duree = debat_data[2]
            notes = debat_data[3]

            debat = Debat(debat_id, animateur, duree, notes)

            conn.close()
        return debat
Ejemplo n.º 10
0
    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
Ejemplo n.º 11
0
    def get_all():
        """
        Cette fonction permet d'obtenir tout les évènements dans la base de donnée 
        
            Return:
                Liste de Evenement() / Projection()
        """
        liste = []
        conn = DBConnexion().Instance
        cursor = conn.cursor()
        query = "SELECT * FROM `EVENT`"
        cursor.execute(query)

        rows = cursor.fetchall()
        for row in rows:
            event_id = int(row[0])
            # Récuperer la salle
            salle_id = int(row[5])
            salle = SalleDAO.get_by_id(salle_id)
            etat = Etat.EN_ATTENTE
            if int(row[8]) == 1:
                etat = Etat.EN_COURS
            elif int(row[8]) == 2:
                etat = Etat.TERMINE
            if int(row[7]) == 1:
                # creer une projection
                e = ProjectionDAO.get_by_id(event_id, row, salle)
                e.etat = etat
            else:
                # creer une evenement
                e = Evenement(event_id, row[1],
                              row[2], data_to_datetime(row[3]),
                              data_to_datetime(row[4]), salle, row[6],
                              int(row[7]) == 1, etat,
                              int(row[9]) == 1,
                              int(row[10]) == 1)

            # Récuperer la liste des responsables
            query = "SELECT `ID_USER` FROM `EVENT_RESPONSABLE` WHERE `ID_EVENT`=?"
            cursor.execute(query, [event_id])

            rows_event_responsable = cursor.fetchall()
            for row_event_responsable in rows_event_responsable:
                id_user = int(row_event_responsable[0])
                # Récuperer le responsable ayant comme id 'id_user'
                responsable = UtilisateurDAO.get_by_id(id_user)
                e.ajouterResponsable(responsable)

            liste.append(e)

        conn.close()
        return liste
Ejemplo n.º 12
0
    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)
Ejemplo n.º 13
0
    def get_by_id(event_id, event_data, salle):
        """
        Cette fonction permet de renvoyer la projection d'identifiant 'event_id'
        
            Parameters:
                event_id: l'identifiant de le l'évènement (projection)
            Return:
                Un objet de type Projection()
        """
        projection = None
        if event_id != None:
            conn = DBConnexion().Instance
            cursor = conn.cursor()
            query = "SELECT * FROM `PROJECTION` WHERE `EVENT_ID` = ?"
            cursor.execute(query, [event_id])
            projection_data = cursor.fetchone()

            projection_auteur = None
            if projection_data[2] != None:
                projection_auteur = PresentationAuteur(projection_data[2],
                                                       projection_data[3])

            debat = None
            if projection_data[5] != None:
                debat_id = int(projection_data[5])
                debat = DebatDAO.get_by_id(debat_id)

            projection = Projection(event_id,
                                    nom=event_data[1],
                                    description=event_data[2],
                                    date_debut=data_to_datetime(event_data[3]),
                                    date_fin=data_to_datetime(event_data[4]),
                                    salle=salle,
                                    color=event_data[6],
                                    contexte=projection_data[4],
                                    presentationAuteur=projection_auteur,
                                    debat=debat,
                                    amuses_bouches=int(
                                        projection_data[6]) == 1)
            projection.salle_reservee = int(event_data[9]) == 1
            projection.disponibilite_invites = int(event_data[10]) == 1

            conn.close()
        return projection
Ejemplo n.º 14
0
 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)
Ejemplo n.º 15
0
    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
Ejemplo n.º 16
0
    def get_all_admins():
        """
        Cette fonction permet de renvoyer une liste des utilisateurs ayant status ADMIN
        
            Return:
                Une liste d'objets de type Utilisateur()
        """
        liste = []
        conn = DBConnexion().Instance
        cursor = conn.cursor()
        query = "SELECT * FROM `USER` WHERE `EST_ADMIN`=1"
        cursor.execute(query)

        rows = cursor.fetchall()
        for row in rows:
            dispo = DisponibiliteDAO.get_by_user_id(int(row[0]))
            u = Utilisateur(int(row[0]), row[1], row[2], row[3], row[4],
                            row[5], row[6], dispo, True)
            liste.append(u)

        conn.close()
        return liste
Ejemplo n.º 17
0
    def get_by_id(id):
        """
        Cette fonction permet de renvoyer l'utilisateur d'identifiant 'id'
        
            Parameters:
                id: l'identifiant de l'utilisateur voulu
            Return:
                Un objet de type Utilisateur()
        """
        user = None
        if id != None:
            conn = DBConnexion().Instance
            cursor = conn.cursor()
            query = "SELECT * FROM `USER` WHERE `ID` = ?"
            cursor.execute(query, [id])

            user_data = cursor.fetchone()
            dispo = DisponibiliteDAO.get_by_user_id(id)
            user = Utilisateur(id, user_data[1], user_data[2], user_data[3],
                               user_data[4], user_data[5], user_data[6], dispo,
                               int(user_data[7]) == 1)
            conn.close()
        return user
Ejemplo n.º 18
0
    def get_all():
        """
        Cette fonction permet de renvoyer une liste de toutes les salles
        
            Return:
                Une liste d'objets de type Salle()
        """
        liste = []
        conn = DBConnexion().Instance
        cursor = conn.cursor()
        query = "SELECT * FROM `SALLE`"
        cursor.execute(query)

        rows = cursor.fetchall()
        for row in rows:
            responsable_id = int(row[2])
            responsable = UtilisateurDAO.get_by_id(responsable_id)
            s = Salle(int(row[0]), row[1], responsable, int(row[3]),
                      int(row[4]))
            liste.append(s)

        conn.close()
        return liste
Ejemplo n.º 19
0
    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
Ejemplo n.º 20
0
    def get_all():
        """
        Cette fonction permet de renvoyer une liste des utilisateurs
        
            Return:
                Une liste de Utilisateur()
        """
        liste = []
        conn = DBConnexion().Instance
        cursor = conn.cursor()
        query = "SELECT * FROM `USER`"
        cursor.execute(query)

        rows = cursor.fetchall()
        for row in rows:
            user_id = int(row[0])
            dispo = DisponibiliteDAO.get_by_user_id(user_id)
            u = Utilisateur(user_id, row[1], row[2], row[3], row[4], row[5],
                            row[6], dispo,
                            int(row[7]) == 1)
            liste.append(u)

        conn.close()
        return liste
Ejemplo n.º 21
0
    def get_by_id(id):
        """
        Cette fonction permet de renvoyer la salle d'identifiant 'id'
        
            Parameters:
                id: L'identifiant de la salle
            Return:
                Un objet de type Salle()
        """
        salle = None
        if id != None:
            conn = DBConnexion().Instance
            cursor = conn.cursor()
            query = "SELECT * FROM `SALLE` WHERE `ID` = ?"
            cursor.execute(query, [id])

            salle_data = cursor.fetchone()
            responsable_id = int(salle_data[2])
            responsable = UtilisateurDAO.get_by_id(responsable_id)
            salle = Salle(id, salle_data[1], responsable, int(salle_data[3]),
                          int(salle_data[4]))

            conn.close()
        return salle
Ejemplo n.º 22
0
    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