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_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_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 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 affiche_prix_distance(combinaisons, classe, choix=False):
combi_prix = []
combi_dist = []
combi_tout = []
for combi in combinaisons:
prix_combi = 0
dist_totale = 0
for route in combi:
prix_combi += route.calcul_prix_route(classe)
dist_totale += route.distance/1000
combi_prix.append(prix_combi)
combi_dist.append(dist_totale)
combi_tout.extend(zip(combinaisons, combi_prix, combi_dist))
combi_print = []
combi_tout.sort(key=lambda s: s[1])
for combi in combi_tout:
ligne = "{:.2f}€".format(combi[1])
ligne += " {:.0f}km".format(combi[2])
route0 = combi[0][0]
ligne += " - {} - {} ({},{})".format(
route0.compagnie.code_icao,
route0.aeroport_depart.id_code_iata,
route0.aeroport_depart.municipalite,
route0.aeroport_depart.code_pays)
for route in combi[0]:
ligne += " -> {} ({},{})".format(
route.aeroport_arrivee.id_code_iata,
route.aeroport_arrivee.municipalite,
route.aeroport_arrivee.code_pays)
combi_print.append(ligne)
if choix:
trajet = ihm.choisir_paginer(combi_print, "Choisissez un trajet")
return combi_print.index(trajet)
else:
ihm.afficher_paginer(combi_print, "Liste des trajets trouvés")
return
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 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 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
def faire_reservation(self, compagnies, aeroports):
"""
Methode qui consiste a faire une reservation
(saisir_critere, afficher_vols, choisir_vols, saisir_passager, payer..)
:param compagnies: listes de compagnies
:param aeroports: listes des aeroports
:return: None
"""
# Saisie des criteres
criteres = self.saisie_criteres(aeroports)
aer_dep, aer_arr, date_dep, nb_passagers, classe, escales_max = criteres
# Recherche des routes
combinaisons_total = []
for compagnie in compagnies:
combinaisons = compagnie.chercher_routes_escales(
aer_dep, aer_arr, escales_max)
if combinaisons:
combinaisons_total.extend(combinaisons)
if len(combinaisons_total) == 0:
ihm.afficher("Il n'y a pas de routes possibles entre ces destinations")
return
# Affiche les prix, distances
self.affiche_prix_distance(combinaisons_total, classe)
# On garde seulement les combinaisons avec horaires en base
combinaisons_avec_horaires = []
for combi in combinaisons_total:
combi_ok = True
for route in combi:
if len(route.horaires) == 0:
combi_ok = False
if combi_ok:
combinaisons_avec_horaires.append(combi)
if len(combinaisons_total) == 0:
ihm.afficher("Il n'y a pas d'horaires disponibles pour ces destinations")
return
# On recupere les vols pour chaque combinaison
combi_vols = self.recupere_vols(
combinaisons_avec_horaires, date_dep, nb_passagers, classe)
# On filtre les vols pour qu'ils s'enchainent bien
vols_ok = self.arrange_vols(combi_vols, date_dep)
if len(vols_ok) == 0:
ihm.afficher("Il n'y a pas de vols disponibles pour ces destinations")
return
ihm.afficher("Parmi les routes, {} possédaient des places a la date demandée"
.format(len(vols_ok)))
combi_test = []
for combi in vols_ok:
combi_new = []
for route, vols in combi:
combi_new.append(route)
combi_test.append(combi_new)
choix_combi = self.affiche_prix_distance(combi_test, classe, choix=True)
combi = vols_ok[choix_combi]
combi_final = []
for route, vols in combi:
ihm.afficher("Vols disponibles pour la route {} :".format(route))
vol = ihm.choisir_paginer(vols, "Choisissez un vol :")
combi_final.append(vol)
id_resa = 0
if Reservation.liste_ids:
id_resa = Reservation.liste_ids[-1]
id_resa += 1
new_resa = Reservation(id_resa, self, 0, datetime.now(), True)
for i in range(nb_passagers):
nom = ihm.demander("Saisissez le nom du passager :")
prenom = ihm.demander("Saisssez le prénom du passager :")
passeport = ihm.demander("Saisissez le numéro de passeport :")
date_naissance = None
while True:
try:
date_naissance = ihm.demander(
"Saisissez la date de naissance (AAAA-MM-JJ) :")
date_naissance = datetime.strptime(date_naissance, '%Y-%m-%d')
except ValueError:
ihm.afficher("Ceci n'est pas une date valide.")
pass
else:
date_naissance = date_naissance.date()
break
id_billet = 0
if Billet.liste_ids:
id_billet = Billet.liste_ids[-1]
id_billet += 1
billet = Billet(id_billet, new_resa, nom, prenom, passeport, date_naissance, [])
for vol in combi_final:
ihm.afficher("Choisissez une place pour ce vol (les places libres sont représentées par un O) :")
vol.afficher_places()
place = ihm.demander("Saisissez le numéro de la place (ex : 35A) :")
vol.reserver_place(int(place[:-1]),place[-1])
id_segment = 0
if Segment.liste_ids:
id_segment = Segment.liste_ids[-1]
id_segment += 1
seg = Segment(id_segment, billet, vol, vol.horaire, place, '', classe)
billet.segments.append(seg)
vol.segments.append(seg)
new_resa.billets.append(billet)
ihm.afficher("La réservation a été effectuée !")
ihm.afficher(new_resa)
print(*new_resa.billets)
self.reservations.append(new_resa)
return