def actions_visualisation(compagnies, aeroports):
"""
Methode qui permet a la compagnie de choisir les actions qu'elle souhaite réaliser pour la visualisation
:param compagnies: liste des comapgnies
:param aeroports: liste des aeroports
:return: None
"""
# Proposer les actions
while True:
actions = ('Gérer un aéroport',
'Afficher la carte de tous les aéroports',
'Afficher la carte de toutes les routes',
'Revenir au menu précédent')
action = ihm.choisir(actions, "Choisissez une action :")
if action == actions[0]:
gerer_aeroport(aeroports)
elif action == actions[1]:
afficher_carte_aeroports(aeroports)
elif action == actions[2]:
afficher_carte_routes(compagnies)
else:
break
return
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 gerer_aeroport(aeroports):
aero = saisie_aeroport("aéroport à gérer", aeroports)
# Proposer les actions
while True:
actions = ("Afficher la liste des routes entrantes",
"Afficher la liste des routes sortantes",
"Afficher la carte des routes",
"Afficher les horaires arrivant",
"Afficher les horaires partant",
"Afficher la liste des avions au sol",
'Revenir au menu précédent')
action = ihm.choisir(actions, "Choisissez une action :")
if action == actions[0]:
aero.afficher_routes_entrantes()
elif action == actions[1]:
aero.afficher_routes_sortantes()
elif action == actions[2]:
aero.afficher_carte(routes=True)
elif action == actions[3]:
aero.afficher_horaires_arrivees()
elif action == actions[4]:
aero.afficher_horaires_departs()
elif action == actions[5]:
aero.afficher_avions()
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_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_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 actions_routes(compagnie, compagnies, aeroports):
"""
Methode qui permet a la compagnie de choisir les actions qu'ils souhaitent réaliser sur une route
:param compagnie: objet compagnie
:param compagnies: liste de toutes les compagnies
:param aeroports: liste de tous les aeroports
:return: None
"""
# Proposer les actions
while True:
actions = ('Afficher la liste des routes',
'Afficher une carte des routes',
'Afficher la liste des aéroports desservis',
'Gérer une route', 'Ajouter une route',
'Ajouter des vols pour toutes les routes',
'Revenir au menu précédent')
action = ihm.choisir(actions, "Choisissez une action :")
if action == actions[0]:
compagnie.afficher_infos_routes()
elif action == actions[1]:
compagnie.afficher_carte_routes()
elif action == actions[2]:
compagnie.afficher_aeroports()
elif action == actions[3]:
gerer_route(compagnie, compagnies)
elif action == actions[4]:
compagnie.creer_route(aeroports)
elif action == actions[5]:
compagnie.ajouter_vols_toutes_routes()
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_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 actions_compagnie(compagnies, aeroports):
"""
Methode qui permet a la compagnie de choisir les actions qu'elle souhaite réaliser
:param compagnies: liste des compagnies
:param aeroports: liste de tous les aeroports
:return: None
"""
compagnie = None
while compagnie is None:
# On demande comment choisir une compagnie
actions = ('Recherche par continent',
'Recherche par code IATA ou ICAO', 'Revenir au début')
recherche = ihm.choisir(
actions, "Choisissez un mode de recherche de la compagnie :")
# Si recherche par continents
if recherche == actions[0]:
compagnie = choisir_par_continent(compagnies)
# Si recherche par code
elif recherche == actions[1]:
compagnie = saisie_compagnie(compagnies)
# Sinon on revient au début
else:
return recherche
# Proposer les actions
while True:
actions = ('Gérer les avions', "Gérer les configurations d'avion",
'Gérer les routes', 'Revenir au début')
action = ihm.choisir(actions, "Choisissez une action :")
if action == actions[0]:
actions_avions(compagnie, aeroports)
elif action == actions[1]:
actions_configs(compagnie)
elif action == actions[2]:
actions_routes(compagnie, compagnies, aeroports)
else:
break
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 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 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 actions_configs(compagnie):
"""
Sous-menu de gestion des configurations d'avions d'une compagnie
:param compagnie: l'objet compagnie en question
:return: None
"""
# Proposer les actions
while True:
actions = ("Afficher la liste des configurations d'avions",
"Afficher le plan de cabine d'une configuration",
'Revenir au menu précédent')
action = ihm.choisir(actions, "Choisissez une action :")
if action == actions[0]:
compagnie.afficher_configs()
elif action == actions[1]:
gerer_config(compagnie)
else:
break
return
def actions_avions(compagnie, aeroports):
"""
Sous-menu de gestion des avions d'une compagnie
:param compagnie: l'objet compagnie en question
:param aeroports: liste de tous les aeroports
:return: None
"""
# Proposer les actions
while True:
actions = ('Afficher la liste des avions',
'Afficher une carte de la position des avions',
'Gérer un avion', 'Revenir au menu précédent')
action = ihm.choisir(actions, "Choisissez une action :")
if action == actions[0]:
compagnie.afficher_infos_avions()
elif action == actions[1]:
compagnie.afficher_carte_avions()
elif action == actions[2]:
gerer_avion(compagnie, aeroports)
else:
break
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
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 !")
def creer_horaire(self, compagnies):
"""
Methode pour creer un horaire pour la route
:return:
"""
new_hor = None
# Saisir numero de vol
num_vol = ihm.demander("Saisissez un numéro de vol (1 à 4 chiffres) :")
# Si c'est un codeshare,
choix_codeshare = ihm.choisir(
['Oui', 'Non'],
"Est-ce que cet horaire est le codeshare de l'horaire "
"d'une autre compagnie ?")
if choix_codeshare == 'Oui':
# alors saisir compagnie
compagnie = saisie_compagnie(compagnies)
cle_route = "{}{}{}".format(compagnie.id_code_iata,
self._aeroport_depart.id_code_iata,
self._aeroport_arrivee.id_code_iata)
route = Route.cle_index[cle_route]
# et choisir horaire
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 avez choisi l'horaire {}".format(hor))
# Creation du nouvel horaire
new_hor = Horaire(self, num_vol, None, None, None, None, hor, None)
# Si ce n'est pas un codeshare
else:
# Saisir heure de depart
str_h_dep = ihm.demander("Saisissez l'heure de départ (HH:MM) :")
h_dep = datetime.strptime(str_h_dep, "%H:%M").time()
# Saisir heure d'arrivee
str_h_arr = ihm.demander("Saisissez l'heure d'arrivée (HH:MM) :")
h_arr = datetime.strptime(str_h_arr, "%H:%M").time()
# Saisir duree
str_dur = ihm.demander("Saisissez la durée (HHhMM, ex : 0h55) :")
t = datetime.strptime(str_dur, "%Hh%M")
dur = timedelta(hours=t.hour, minutes=t.minute)
# Saisir la periodicite : TODO
period = ''
configs = self.compagnie.configs
configs_tri = [
x for x in configs
if x.type_avion.distance_franchissable_km > self._distance /
1000
]
configs_tri.sort(key=lambda s: s.nom)
if len(configs_tri) == 0:
ihm.afficher("Il n'y a pas de configuration disponible !")
return
# Choisir la config
conf = ihm.choisir_paginer(self.compagnie.configs,
"Choisissez une configuration d'avion")
# Creation du nouvel horaire
new_hor = Horaire(self, num_vol, h_dep, h_arr, dur, period, None,
conf)
# Confirmer ou pas
choix = ihm.choisir(
['Oui', 'Non'],
"Confirmez-vous la création de l'horaire {} ?".format(new_hor))
if choix == 'Oui':
self._horaires.append(new_hor)
if new_hor.horaire_operateur is not None:
new_hor.horaire_operateur.horaires_codeshare.append(new_hor)
ihm.afficher("L'horaire a été créé")
else:
ihm.afficher("L'horaire n'a pas été créé")
return
