def gerer_route(compagnie, compagnies):
"""
Methode qui permet a la compagnie de gerer une route
:param compagnie: objet compagnie
:param compagnies: liste de toutes les compagnies
:return: None
"""
routes_tri = compagnie.routes
if len(routes_tri) == 0:
ihm.afficher("Il n'y a pas de route disponible !")
return
# On trie les routes par nombre d'horaires
routes_tri.sort(key=lambda s: len(s.horaires), reverse=True)
route = ihm.choisir_paginer(routes_tri, "Choisissez la route :")
ihm.afficher("Vous allez gérer la route {}".format(route))
# Proposer les actions
while True:
actions = ("Afficher une carte de la route",
"Afficher les horaires de la route", "Gérer un horaire",
"Ajouter un horaire", 'Revenir au menu précédent')
action = ihm.choisir(actions, "Choisissez une action :")
if action == actions[0]:
route.afficher_carte()
elif action == actions[1]:
route.afficher_horaires()
elif action == actions[2]:
gerer_horaire(route)
elif action == actions[3]:
route.creer_horaire(compagnies)
else:
break
return
def gerer_reservation(client):
"""
Methode qui permet au client de gerer sa reservation
:param client: objet client
:return:
"""
# Choisir une reservation
resas_tri = client.reservations
if len(resas_tri) == 0:
ihm.afficher("Il n'y a pas de réservations à afficher")
return
resas_tri.sort(key=lambda s: s.date_achat, reverse=True)
resa = ihm.choisir_paginer(resas_tri,
"Choisir la réservation à afficher :")
ihm.afficher("Vous avez choisi la réservation {}".format(resa))
while True:
# Demander action : Faire, Consulter, Modifier, Annuler
actions = ('Afficher le récapitulatif', 'Annuler la réservation',
'Revenir au début')
action = ihm.choisir(actions, "Choisissez une action :")
if action == actions[0]:
resa.fournir_recapitulatif()
elif action == actions[1]:
resa.annuler()
else:
break
return
def gerer_horaire(route):
"""
Methode qui permet a la compagnie de gerer un horaire sur une route en question
:param route: objet route
:return: None
"""
hor_tri = route.horaires
if len(hor_tri) == 0:
ihm.afficher("Il n'y a pas d'horaire disponible !")
return
# On trie les routes par nombre d'horaires
hor_tri.sort(key=lambda s: s.numero)
hor = ihm.choisir_paginer(hor_tri, "Choisissez l'horaire :")
ihm.afficher("Vous allez gérer l'horaire {}".format(hor))
# Proposer les actions
while True:
actions = ("Afficher les vols", "Ajouter des vols",
'Revenir au menu précédent')
action = ihm.choisir(actions, "Choisissez une action :")
if action == actions[0]:
hor.afficher_vols()
elif action == actions[1]:
hor.creer_vols()
else:
break
return
def gerer_avion(compagnie, aeroports):
"""
Methode qui permet a la compagnie de gerer un avion
:param compagnie: l'objet compagnie en question
:param aeroports: liste de tous les aeroports
:return: None
"""
avions = compagnie.avions
if len(avions) == 0:
ihm.afficher("Il n'y a pas d'avion disponible !")
return
avions.sort(key=lambda s: s.id, reverse=True)
avion = ihm.choisir_paginer(avions, "Choisissez un avion :")
ihm.afficher("Vous allez gérer l'avion {}".format(avion))
# Proposer les actions
while True:
actions = ("Afficher une carte de la position de l'avion",
"Afficher les vols de l'avion",
"Déplacer l'avion vers un aéroport",
'Revenir au menu précédent')
action = ihm.choisir(actions, "Choisissez une action :")
if action == actions[0]:
avion.afficher_carte()
elif action == actions[1]:
avion.afficher_vols()
elif action == actions[2]:
avion.deplacer_vers_aeroport(aeroports)
else:
break
return
def saisie_date(message, date_seuil, duree_limite=1):
"""
Methode qui permet de saisir la date du vol
:param message:
:param date_seuil:
:param duree_limite:
:return: la date saisie
"""
date_saisie = None
dans1an = date_seuil.replace(year=date_seuil.year + duree_limite)
while True:
try:
date_saisie = ihm.demander(
"Saisissez la {} (AAAA-MM-JJ) :".format(message))
date_saisie = datetime.strptime(date_saisie, '%Y-%m-%d')
if date_saisie <= date_seuil or date_saisie > dans1an:
raise ValueError
except ValueError:
ihm.afficher("Ceci n'est pas une date valide.")
pass
else:
break
ihm.afficher("Vous avez choisi le {:%d/%m/%Y}".format(date_saisie))
return date_saisie
def menu_racine(clients, compagnies, aeroports):
"""
Methode qui permet de choisir la façon dont on veut interagir avec l'interface
:param clients: liste des clients
:param compagnies: liste des compagnies
:param aeroports: liste des aeroports
:return: None
"""
while True:
# Choisir un mode d'utilisation
modes = ('Client', 'Compagnie', 'Visualisation seule', 'Quitter')
choix = ihm.choisir(modes, "Choisissez un mode d'utilisation :")
# Si Client
if choix == modes[0]:
actions_client(clients, compagnies, aeroports)
# Si Compagnie
elif choix == modes[1]:
actions_compagnie(compagnies, aeroports)
# Si Visualisation
elif choix == modes[2]:
actions_visualisation(compagnies, aeroports)
# Sinon on veut quitter le programme
else:
break
ihm.afficher("Vous quittez le programme.")
return
def ajouter_client(clients):
"""
Methode qui permet de creer un nouveau client
:param clients: liste des clients existants
:return: nouveau client
"""
new_id = 1
if len(clients) != 0:
new_id = clients[-1].id + 1
nom = ihm.demander("Saisissez votre nom :")
prenom = ihm.demander("Saisissez votre prénom :")
date_naiss = None
while True:
try:
date_naiss = ihm.demander(
"Saisissez votre date de naissance (AAAA-MM-JJ) :")
date_naiss = datetime.strptime(date_naiss, '%Y-%m-%d')
except ValueError:
ihm.afficher("Ceci n'est pas une date valide.")
pass
else:
date_naiss = date_naiss.date()
break
client = Client(new_id, nom, prenom, date_naiss)
return client
def afficher_configs(self):
"""
Methode qui permet d'afficher les configs d'avion utilisees par la compagnie
:return:
"""
ihm.afficher("Il y a {} configuration(s)".format(len(self._configs)))
ihm.afficher_paginer(self._configs, "Configurations", pas=10)
return
def afficher_infos_avions(self):
"""
Methode qui permet d'afficher les infos des differents avions
:return:
"""
ihm.afficher("Il y a {} avion(s)".format(len(self._avions)))
ihm.afficher_paginer(self._avions, "Avions", pas=10)
return
def afficher_infos_routes(self):
"""
Methode qui permet d'afficher la liste des routes de la compagnie
:return:
"""
ihm.afficher("Il y a {} route(s)".format(len(self._routes)))
ihm.afficher_paginer(self._routes, "Routes", pas=10)
return
def afficher_vols(self):
"""
Methode qui permet d'afficher les vols assures par l'avion
:return: None
"""
ihm.afficher("Il y a {} vol(s)".format(len(self._vols)))
ihm.afficher_paginer(self._vols, "Vols", pas=10)
return
def afficher_routes_entrantes(self):
"""
Affiche toutes les routes possibles qui arrivent a l'aeroport
:return: None
"""
ihm.afficher("Il y a {} route(s) entrante(s)"
.format(len(self.routes_entrantes)))
ihm.afficher_paginer(self.routes_entrantes, "Routes entrantes", pas=10)
return
def afficher_avions(self):
"""
Methode qui permet d'afficher tous les avions au sol
:return: None
"""
ihm.afficher("Il y a {} avion(s) au sol à l'aéroport"
.format(len(self._avions)))
ihm.afficher_paginer(self._avions, "Avions au sol", pas=10)
return
def afficher_routes_sortantes(self):
"""
Affiche toutes les routes possibles qui partent de l'aeroport
:return: None
"""
ihm.afficher("Il y a {} route(s) sortante(s)"
.format(len(self.routes_sortantes)))
ihm.afficher_paginer(self.routes_sortantes, "Routes sortantes", pas=10)
return
def consulter_reservations(self):
"""
Methode qui permet d'afficher la liste de toutes les reservations effectuees
:return: None
"""
resas_tri = self._reservations
resas_tri.sort(key=lambda s: s.date_achat, reverse=True)
ihm.afficher("Il y a {} réservation(s)".format(len(resas_tri)))
ihm.afficher_paginer(resas_tri, "Réservations", pas=10)
return
def saisie_nb_escales():
"""
Methode pour choisir combien d'escale le passager souhaite avoir au maximum
:return: le type de vol qu'il a choisi entre aucune, une ou deux escales
"""
liste_choix = ["Vol direct seulement","Jusqu'à 1 escale","Jusqu'à 2 escales"]
type_vol = ihm.choisir(liste_choix, "Choisissez un type de vol :")
ihm.afficher("Vous avez choisi : {}".format(type_vol))
return liste_choix.index(type_vol)
def afficher_vols(self):
"""
Methode qui permet d'afficher les vols disponibles
:return: None
"""
vols_tri = self._vols
vols_tri.sort(key=lambda s: s.datetime_depart, reverse=True)
ihm.afficher("Il y a {} vol(s)".format(len(vols_tri)))
ihm.afficher_paginer(vols_tri, "Vols", pas=10)
return
def saisie_passagers():
"""
Methode qui permet de saisir les informations concernant un passager
:return: le nombre de passager
"""
liste_choix = ["{} passagers".format(x) for x in range(1,6)]
nb_passagers = ihm.choisir(
liste_choix, "Saisissez le nombre de voyageurs :")
ihm.afficher("Vous avez choisi {}".format(nb_passagers))
nb_passagers = int(nb_passagers[0])
return nb_passagers
def executer_requete(cur, req, variables=()):
"""
Requête à la base de données
"""
try:
res = cur.execute(req, variables)
except sqlite3.ProgrammingError:
# nombre d'arguments incorrects
ihm.afficher(
"ERREUR : nombre d'arguments passés à la requête incorrects : {}".
format(req))
except sqlite3.OperationalError:
# erreur liée à une opération dans la bdd
ihm.afficher("ERREUR : requête non conforme {}".format(req))
except sqlite3.DataError:
# format inséré inadéquat
ihm.afficher(
"ERREUR : données insérées dans la BDD au mauvais format : {}".
format(req))
except sqlite3.IntegrityError:
# violation d'une contrainte du schéma de la bdd
ihm.afficher(
"ERREUR : requête viole contrainte d'intégrité de la BDD : {}".
format(req))
else:
return res
def afficher_horaires_arrivees(self):
"""
Affiche tous les horaires d'arrivee a l'aeroport
:return: None
"""
hor_arr = []
for route in self._routes_entrantes:
hor_arr.extend(route.horaires)
hor_arr.sort(key=lambda s: s.heure_arrivee)
ihm.afficher("Il y a {} horaire(s) d'arrivée(s)"
.format(len(hor_arr)))
ihm.afficher_paginer(hor_arr, "Horaires d'arrivées", pas=10)
return
def saisie_classe():
"""
Methode qui permet de choisir la classe de la place
:return: la classe choisie
"""
liste_choix = {
"Première" : 'F',
"Business" : 'C',
"Premium Eco" : 'P',
"Economique" : 'Y'
}
classe = ihm.choisir([*liste_choix.keys()], "Choisissez une classe :")
ihm.afficher("Vous avez choisi {}".format(classe))
return liste_choix[classe]
def afficher_horaires_departs(self):
"""
Affiche tous les horaires de depart l'aeroport
:return: None
"""
hor_arr = []
for route in self._routes_sortantes:
horaires = [x for x in route.horaires
if x.horaire_operateur is None]
hor_arr.extend(horaires)
hor_arr.sort(key=lambda s: s.heure_depart)
ihm.afficher("Il y a {} horaire(s) de départ(s)"
.format(len(hor_arr)))
ihm.afficher_paginer(hor_arr, "Horaires de départs", pas=10)
return
def gerer_config(compagnie):
"""
Methode qui permet a la compagnie de gerer une config d'avion
:param compagnie: l'objet compagnie en question
:return: None
"""
configs = compagnie.configs
if len(configs) == 0:
ihm.afficher("Il n'y a pas de configuration d'avion disponible !")
return
configs.sort(key=lambda s: s.nom, reverse=True)
config = ihm.choisir_paginer(configs, "Choisissez une configuration :")
ihm.afficher("Vous allez gérer la configuration {}".format(config))
config.afficher_disposition()
return
def saisie_compagnie(compagnies):
"""
Methode qui permet de choisir une compagnie par ses différents codes
:param compagnies: liste des compagnies
:return: la compagnie choisie
"""
compagnie = None
code = ihm.demander(
"Tapez le code IATA (2 caractères) ou ICAO (3 caractères) :")
results = [x for x in compagnies
if x.id_code_iata == code or x.code_icao == code]
if len(results) == 0:
ihm.afficher("Désolé, nous n'avons pas trouvé votre compagnie !")
else:
compagnie = results[0]
if compagnie is not None:
ihm.afficher("Vous avez choisi la compagnie {}".format(compagnie))
return compagnie
def actions_client(clients, compagnies, aeroports):
"""
Methode qui permet de laisser le client choisir les actions qu'ils souhaitent réaliser
:param clients: liste des clients
:param compagnies: liste des compagnies
:param aeroports: liste des aeroports
:return: None
"""
# Choisir un client existant ou nouveau
comptes = [client for client in clients]
comptes.append('Nouveau client')
client = ihm.choisir(
comptes, "Choisissez un client sauvegardé ou "
"créez un nouveau client")
# Si nouveau : demander infos et créer client
if client == 'Nouveau client':
client = ajouter_client(clients)
clients.append(client)
# Le client est chargé
ihm.afficher("Bonjour {} !".format(client.prenom))
while True:
# Demander action : Faire, Consulter, Modifier, Annuler
actions = ('Consulter ses réservations', 'Gérer une réservation',
'Faire une réservation', 'Revenir au début')
action = ihm.choisir(actions, "Choisissez une action :")
if action == actions[0]:
client.consulter_reservations()
elif action == actions[1]:
gerer_reservation(client)
elif action == actions[2]:
client.faire_reservation(compagnies, aeroports)
else:
break
return
def creer_route(self, aeroports):
"""
Methode pour creer une nouvelle route
:param aeroports: la liste de tous les aeroports
:return:
"""
# Saisir depart
aer_dep = saisie_aeroport("aéroport de départ", aeroports)
# Saisir arrivee
aer_arr = saisie_aeroport("aéroport d'arrivée", aeroports)
# Geometrie
geom = "LINESTRING({} {},{} {})".format(
aer_dep.longitude_deg, aer_dep.latitude_deg,
aer_arr.longitude_deg, aer_arr.longitude_deg
)
# Codeshare
choix = ihm.choisir(
['Oui','Non'],
"Cette route est-elle un codeshare d'une autre compagnie ?")
codeshare = False
if choix == 'Oui':
codeshare = True
# Creation de l'objet
new_route = Route(self, aer_dep, aer_arr, geom, codeshare)
# Confirmer ou pas
choix = ihm.choisir(
['Oui','Non'],
"Confirmez-vous la création de la route {} ?".format(new_route))
if choix == 'Oui':
self._routes.append(new_route)
ihm.afficher("La route a été créée")
else:
ihm.afficher("La route n'a pas été créée")
return
def choisir_par_continent(compagnies):
"""
Methode qui permet de choisir une compagnie en fonction du continent
:param compagnies: liste des compagnies
:return:
"""
# On choisit un continent
continents = {
'Amérique du Nord': 'NA',
'Amérique du Sud': 'SA',
'Europe': 'EU',
'Afrique': 'AF',
'Asie': 'AS',
'Océanie': 'OC'
}
nom = ihm.choisir([*continents.keys()], "Choisissez un continent :")
# On ne garde que les compagnies du continent
compagnies_filtre = [
x for x in compagnies if x.code_continent == continents[nom]
]
if len(compagnies_filtre) == 0:
ihm.afficher("Il n'y a pas de compagnie disponible !")
return None
# On trie les compagnies par nombre de routes
compagnies_filtre.sort(key=lambda s: len(s.routes), reverse=True)
# Choix dans une liste paginee
compagnie = ihm.choisir_paginer(compagnies_filtre,
"Choisissez une compagnie :",
pas=10)
ihm.afficher("Vous allez gérer la compagnie {}".format(compagnie))
return compagnie
def saisie_aeroport(message, aeroports):
"""
Methode qui permet de saisir un aeroport
:param message:
:param aeroports:
:return:
"""
aero = None
while aero is None:
code = ihm.demander(
"Saisissez l'{} (code IATA ou ICAO ou ville) :".format(message))
results = [x for x in aeroports
if x.id_code_iata == code or x.code_icao == code or
x.municipalite.lower().startswith(code)]
if len(results) == 0:
ihm.afficher("Désolé, nous n'avons pas trouvé votre aéroport !")
elif len(results) > 1:
aero = ihm.choisir_paginer(results, "Précisez votre choix :")
else:
aero = results[0]
ihm.afficher("Vous avez choisi : {}".format(aero))
return aero
def ajouter_vols_toutes_routes(self):
"""
Ajoute des vols entre deux dates donnees pour toutes les routes
qui ont des horaires
:return:
"""
debut = saisie_date("date de début", datetime.today())
nb_jours = 0
while True:
try:
nb_jours = int(ihm.demander("Saisissez un nombre de jours :"))
except ValueError:
ihm.afficher("Ce nombre n'est pas valide !")
else:
break
for route in self._routes:
ihm.afficher(route)
for horaire in route.horaires:
ihm.afficher(horaire)
horaire.creer_vols(debut=debut, nb_jours=nb_jours)
return
from datetime import date, datetime, timedelta
import ihm.console as ihm
from bdd.config_bdd import (creer_bdd, inserer_jeu_test, inserer_jeu_fichiers)
from utilitaires.chargement import (charger_bd, update_bd)
import utilitaires.menus as menus
if __name__ == '__main__':
db_name = "bdd/resavion.db"
if not os.path.exists(db_name):
creer_bdd(db_name)
# inserer_jeu_test(db_name)
inserer_jeu_fichiers(db_name)
aeroports, compagnies, clients = charger_bd(db_name)
print("\n\nBienvenue dans Resavion\n\n")
# On lance l'interface
menus.menu_racine(clients, compagnies, aeroports)
liste_choix = ('Oui', 'Non')
choix = ihm.choisir(liste_choix,
"Voulez-vous sauvegarder vos modifications ?")
if choix == 'Oui':
update_bd(db_name, compagnies, clients)
ihm.afficher("Sauvegarde effectuée ! À bientôt !")
else:
ihm.afficher("Les modifications n'ont pas été enregistrées.\n"
"À bientôt !")
