def classes_age(self, contenu, liste_pays_a_afficher=[]):
"""Afficher le tableau des classes d'âge pour certains pays"""
resume = Resume()
if len(liste_pays_a_afficher) == 0:
return self._ajout_pays_table_criteres(contenu,
liste_pays_a_afficher,
self.classes_age)
contenu_menu_classes_age = {}
contenu_menu_classes_age['individu'] = contenu['individu']
contenu_menu_classes_age['pseudo'] = contenu['pseudo']
contenu_menu_classes_age['question'] = resume.tableau_classes_age(
liste_pays_a_afficher)
contenu_menu_classes_age["options"] = [
"Ajouter un pays à la table", "Retirer un pays de la table"
]
contenu_menu_classes_age['options basiques'] = [[
"RETOUR", 'R'
], ["RETOUR AU MENU DE L'ACTEUR", 'RMA'], ["QUITTER", 'Q']]
contenu_menu_classes_age["actions"] = [
lambda var: self._ajout_pays_table_criteres(
var, liste_pays_a_afficher, self.classes_age),
lambda var: self._retrait_pays_table_criteres(
var, liste_pays_a_afficher, self.classes_age),
lambda var: self.resume_stat(var),
lambda var: Menu_Ouvert(self.contenu_initial), self.quitter
]
return Menu_Ouvert(contenu_menu_classes_age)
def gestion_compte(self, contenu):
"""Cette méthode permet d'accéder aux tâches Suppression/Création d'un compte employeur.
Elle renvoie les différentes tâches que peut effectuer l'administrateur :
- Créer un compte
- Supprimer un compte
- Voir la liste des comptes"""
if self.verification_connexion():
choix_gestion = {}
choix_gestion['pseudo'] = contenu['pseudo']
choix_gestion['individu'] = contenu['individu']
choix_gestion['question'] = 'Que voulez vous faire ?'
choix_gestion['options'] = [
'Créer un compte', 'Supprimer un compte',
'Voir la liste des comptes'
]
choix_gestion['options basiques'] = [['RETOUR', 'R'],
['QUITTER', 'Q']]
choix_gestion['actions'] = [
self._creer_compte, self._supprimer_compte,
self._afficher_liste_des_comptes,
lambda var: Menu_Ouvert(contenu), self.quitter
]
return Menu_Ouvert(choix_gestion)
else:
return Menu_Ouvert(contenu)
def gestion_corrections(self, contenu):
gestionnaire = Gestionnaire()
liste_des_corrections = gestionnaire.read(
'../media/files/props_corrections')
if self.verification_connexion():
choix_prop = {}
choix_prop['pseudo'] = contenu['pseudo']
choix_prop['individu'] = contenu['individu']
if len(liste_des_corrections) == 0:
choix_prop[
'question'] = "Il n'y a pas de propositions à examiner."
else:
choix_prop[
"question"] = "Choisissez une proposition de correction.\nLe chemin indiqué est celui de l'emplacement du texte susceptible d'être modifié."
choix_prop['options basiques'] = [['RETOUR', 'R'],
['QUITTER', 'Q']]
choix_prop['options'] = liste_des_corrections
choix_prop['actions'] = [
lambda var, prop_cor=prop_cor: self._decider_correction(
contenu, prop_cor) for prop_cor in liste_des_corrections
]
choix_prop['actions'].append(lambda var: Menu_Ouvert(contenu))
choix_prop['actions'].append(self.quitter)
return Menu_Ouvert(choix_prop)
else:
return Menu_Ouvert(contenu)
def criteres_usuels(self, contenu, liste_pays_a_afficher=[]):
resume = Resume()
if len(liste_pays_a_afficher) == 0:
return self._ajout_pays_table_criteres(contenu,
liste_pays_a_afficher,
self.criteres_usuels)
contenu_menu_criteres = {}
contenu_menu_criteres['individu'] = contenu['individu']
contenu_menu_criteres['pseudo'] = contenu['pseudo']
contenu_menu_criteres['question'] = resume.table_criteres(
liste_pays_a_afficher)
contenu_menu_criteres["options"] = [
"Ajouter un pays à la table", "Retirer un pays de la table"
]
contenu_menu_criteres['options basiques'] = [[
"RETOUR", 'R'
], ["RETOUR AU MENU DE L'ACTEUR", 'RMA'], ["QUITTER", 'Q']]
contenu_menu_criteres["actions"] = [
lambda var: self._ajout_pays_table_criteres(
var, liste_pays_a_afficher, self.criteres_usuels),
lambda var: self._retrait_pays_table_criteres(
var, liste_pays_a_afficher, self.criteres_usuels),
lambda var: self.resume_stat(var),
lambda var: Menu_Ouvert(self.contenu_initial), self.quitter
]
return Menu_Ouvert(contenu_menu_criteres)
def resume_stat(self, contenu):
if self.verification_connexion():
if self.contenu_initial == {}:
self.contenu_initial = contenu
choix_resume = {}
choix_resume["question"] = "Choisissez une option d'affichage."
choix_resume["individu"] = contenu["individu"]
choix_resume["pseudo"] = contenu["pseudo"]
choix_resume["options"] = [
"Afficher les critères usuels d'un ou plusieurs pays",
"Afficher les premiers/derniers pays selon un certain critère",
"Afficher les pays dont un critère dépasse un certain seuil",
"Afficher le tableau des classes d'âge pour certains pays",
"Afficher la somme des critères cumulables",
"Afficher le summary d'un critère",
"Afficher les différents profils de pays"
]
choix_resume['options basiques'] = [[
"RETOUR AU MENU DE L'ACTEUR", 'R'
], ["QUITTER", 'Q']]
choix_resume["actions"] = [
lambda var: self.criteres_usuels(contenu),
lambda var: self.top_flop(contenu),
lambda var: self.resume_seuil(contenu),
lambda var: self.classes_age(contenu),
lambda var: self.somme(contenu),
lambda var: self.summary(contenu),
lambda var: self.profils_pays(contenu),
lambda var: Menu_Ouvert(self.contenu_initial), self.quitter
]
return Menu_Ouvert(choix_resume)
else:
return Menu_Ouvert(contenu)
def _supprimer_compte(self, contenu):
gestionnaire = Gestionnaire()
liste_des_comptes = gestionnaire.read(Compte().get_chemin_fichier())
liste_des_pseudos = [
compte.get_pseudo() for compte in liste_des_comptes
]
pseudo_compte_a_supprimer = input(
'\nEntrez le pseudo du compte à supprimer\n> ')
if pseudo_compte_a_supprimer not in liste_des_pseudos:
input(
"\nCe compte n'existe pas.\nAppuyez sur entrer pour continuer.\n"
)
return Menu_Ouvert(contenu)
if pseudo_compte_a_supprimer != contenu['pseudo']:
confirmation = input(
'\nConfirmation de la suppression du compte (O/N) ?\n> ')
if confirmation in ['o', 'O']:
gestionnaire.suppr_elm(Compte(pseudo_compte_a_supprimer))
input(
"\nLe compte de {} a bien été supprimé.\nAppuyez sur entrer pour continuer."
.format(pseudo_compte_a_supprimer))
else:
input(
"\nLa tentative de suppression de compte n'a pas abouti\nAppuyez sur entrer pour continuer.\n"
)
else:
input(
'\nVous ne pouvez pas supprimer votre propre compte.\nAppuyez sur entrer pour continuer.'
)
return Menu_Ouvert(contenu)
def criteres_usuels(self, contenu, liste_pays_a_afficher=[]):
"""Cette fonction permet au data scientist d'avoir le choix entre ajouter un pays, supprimer un pays d'une
liste ou bien de faire un résumé d'informations de cette même liste."""
resume = Resume()
if len(liste_pays_a_afficher) == 0:
return self._ajout_pays_table_criteres(contenu,
liste_pays_a_afficher,
self.criteres_usuels)
contenu_menu_criteres = {}
contenu_menu_criteres['individu'] = contenu['individu']
contenu_menu_criteres['pseudo'] = contenu['pseudo']
contenu_menu_criteres['question'] = resume.table_criteres(
liste_pays_a_afficher)
contenu_menu_criteres["options"] = [
"Ajouter un pays à la table", "Retirer un pays de la table"
]
contenu_menu_criteres['options basiques'] = [[
"RETOUR", 'R'
], ["RETOUR AU MENU DE L'ACTEUR", 'RMA'], ["QUITTER", 'Q']]
contenu_menu_criteres["actions"] = [
lambda var: self._ajout_pays_table_criteres(
var, liste_pays_a_afficher, self.criteres_usuels),
lambda var: self._retrait_pays_table_criteres(
var, liste_pays_a_afficher, self.criteres_usuels),
lambda var: self.resume_stat(var),
lambda var: Menu_Ouvert(self.contenu_initial), self.quitter
]
return Menu_Ouvert(contenu_menu_criteres)
def gestion_corrections(self, contenu):
"""La gestion des corrections se fait par cette méthode. Elle affiche les
différentes propositions que les autres acteurs ont suggérés. Le géographe n'a plus qu'à
choisir quelle correction il veut observer"""
gestionnaire = Gestionnaire()
liste_des_corrections = gestionnaire.read('../media/files/props_corrections')
if self.verification_connexion():
choix_prop = {}
choix_prop['pseudo'] = contenu['pseudo']
choix_prop['individu'] = contenu['individu']
if len(liste_des_corrections) == 0:
choix_prop['question'] = "Il n'y a pas de propositions à examiner."
else :
choix_prop["question"] = "Choisissez une proposition de correction.\nLe chemin indiqué est celui de l'emplacement du texte susceptible d'être modifié."
choix_prop['options basiques'] = [['RETOUR', 'R'], ['QUITTER', 'Q']]
choix_prop['options'] = liste_des_corrections
choix_prop['actions'] = [lambda var, prop_cor = prop_cor : self._decider_correction(contenu, prop_cor) for prop_cor in liste_des_corrections]
choix_prop['actions'].append(lambda var : Menu_Ouvert(contenu))
choix_prop['actions'].append(self.quitter)
return Menu_Ouvert(choix_prop)
else:
return Menu_Ouvert(contenu)
def se_connecter(self, contenu):
"""Cette méthode permet à l'acteur de se connecter.
L'individu entre son pseudo et son mot de passe. Il sera comparé au
gestionnaire des comptes."""
gestionnaire = Gestionnaire()
liste_des_comptes = gestionnaire.read(Compte().get_chemin_fichier())
pseudo = input("\nEntrez votre pseudo : ")
mot_de_passe = gp.getpass("Entrez votre mot de passe : ")
for compte in liste_des_comptes:
if self.statut == compte.get_statut(
) and pseudo == compte.get_pseudo(
) and mot_de_passe == compte.get_mot_de_passe():
self.est_connecte = True
del contenu['options'][0]
del contenu['actions'][0]
contenu['pseudo'] = pseudo
print("\nVous êtes connecté !")
input("Appuyez sur entrer pour continuer.")
return Menu_Ouvert(contenu)
print("\nVotre connexion a échouée.")
input("Appuyez sur entrer pour continuer.")
return Menu_Ouvert(contenu)
def representation_graphique(self, contenu):
"""Cette méthode fonctionne de la même façon que la méthode resume_stat.
Le data scientist a le choix d'afficher un diagramme en barres ou une boîte à moustache."""
if self.verification_connexion():
if self.contenu_initial == {}:
self.contenu_initial = contenu
choix_representaion = {}
choix_representaion[
"question"] = "Choisissez le type de graphique."
choix_representaion["individu"] = contenu["individu"]
choix_representaion['pseudo'] = contenu['pseudo']
choix_representaion["options"] = [
"Diagramme en barres", "Boîte à moustache"
]
choix_representaion['options basiques'] = [[
"RETOUR AU MENU DE L'ACTEUR", 'R'
], ["QUITTER", 'Q']]
choix_representaion["actions"] = [
lambda var: self.diag_barres(contenu),
lambda var: self.box_plot(contenu),
lambda var: Menu_Ouvert(self.contenu_initial), self.quitter
]
return Menu_Ouvert(choix_representaion)
else:
return Menu_Ouvert(contenu)
def afficher_section(self, section, contenu):
donnees = Data_Base().donnees
num_pays = section.num_pays
chemin = section.chemin
choix_section = {}
chemin_a_afficher = Pays(section.num_pays, donnees).get_name()
for partie in chemin:
chemin_a_afficher += ' -> {}'.format(partie)
if section.is_section_de_texte():
print('\n{} :\n'.format(chemin_a_afficher))
print(section.contenu['text'])
self.correction(choix_section, section)
return self.afficher_section(Section(num_pays, donnees, chemin[:-1]), contenu)
sous_sections = section.get_noms_sous_sections()
if len(sous_sections) == 0:
choix_section['question'] = '{}\n\nCette section est vide.'.format(chemin_a_afficher)
else :
choix_section['question'] = '{}\n\nChoisissez une option.'.format(chemin_a_afficher)
choix_section['individu'] = contenu['individu']
choix_section['options'] = sous_sections
choix_section['options basiques'] = []
choix_section['actions'] = []
for partie in sous_sections:
nouveau_chemin = chemin + [partie]
choix_section['actions'].append((lambda contenu, nouveau_chemin=nouveau_chemin : self.afficher_section(Section(num_pays, donnees, nouveau_chemin), contenu)))
if self.statut == 'g' or self.statut == 'a':
if len(sous_sections) == 0:
choix_section['options basiques'].append(['AJOUTER UN TEXTE', 'AT'])
choix_section['actions'].append(lambda var : self.ajout_texte(contenu, section))
choix_section['options basiques'].append(['AJOUTER UNE SECTION', 'AS'])
choix_section['actions'].append(lambda var : self.ajout_section(contenu, section))
if self.statut == 'a' and len(sous_sections) != 0:
choix_section['options basiques'].append(['SUPPRIMER UNE SECTION', 'S'])
choix_section['actions'].append(lambda var : self.supprimer_section(contenu, section))
choix_section['options basiques'].append(['RETOUR', 'R'])
if len(chemin) == 0:
choix_section['actions'].append(lambda var : self.afficher_pays(contenu))
else:
choix_section['actions'].append(lambda var : self.afficher_section(Section(num_pays, donnees, chemin[:-1]), contenu))
choix_section['options basiques'].append(["RETOUR AU MENU DE L'ACTEUR", 'RMA'])
choix_section['actions'].append(lambda contenu : Menu_Ouvert(self.contenu_initial))
choix_section['options basiques'].append(['QUITTER', 'Q'])
choix_section['actions'].append(self.quitter)
return Menu_Ouvert(choix_section)
def derouler(
self
): # Méthode permettant de dérouler les menus en commençant avec le menu initial.
gestionnaire = Gestionnaire_des_Menus()
menu_actuel = Menu_Ouvert(gestionnaire.contenu_du_menu_initial)
while menu_actuel:
# La boucle s'arrète après être tombée sur un menu fermé. En effet, le fait
# de "run" un menu fermé renvoie None, ce qui permet de sortir de la boucle.
self.bordure() # On affiche une bordure pour séparer les menus
menu_actuel = menu_actuel.run()
def _retrait_pays_table_criteres(self, contenu, liste_pays_a_afficher,
fonction_a_appliquer):
"""Cette méthode permet de retirer un pays d'une liste.
Cette méthode est utilisée par la fonction critere_usuel."""
if len(liste_pays_a_afficher) == 1:
input(
"\nIl doit y avoir au moins un pays dans la table.\nAppuyez sur entrer pour continuer."
)
return fonction_a_appliquer(contenu, liste_pays_a_afficher)
choix_pays = {}
choix_pays['question'] = 'Choisissez un pays à retirer de la table.'
choix_pays['individu'] = contenu['individu']
choix_pays['pseudo'] = contenu['pseudo']
choix_pays['options'] = [
pays.get_name() for pays in liste_pays_a_afficher
]
choix_pays['options basiques'] = []
choix_pays['actions'] = [
lambda var, i=i: fonction_a_appliquer(
contenu, liste_pays_a_afficher[:i] + liste_pays_a_afficher[
i + 1:]) for i in range(len(liste_pays_a_afficher))
]
return Menu_Ouvert(choix_pays)
def taches_permises(self, liste_des_taches_permises, individu):
# Cette fonction permet de diriger l'utilisateur vers le menu où sont
# poposé toutes les actions qu'il a le droit d'effectuer.
# Elle prend en argument un liste des numéros de tâches permises pour
# l'utilisateur et le statut de l'utilisateur. individu est donc de
# type Individu(), il peut s'agir d'un Consultant, d'un Géographe,
# d'un data_scientist ou d'un administrateur.
# Cette fonction renvoie le menu corresondant à l'utilisateur.
contenu_menu_acteur = {}
contenu_menu_acteur['individu'] = individu
contenu_menu_acteur['question'] = self.contenu_du_menu_des_acteurs[
'question']
contenu_menu_acteur['options'] = [
self.contenu_du_menu_des_acteurs['options'][i]
for i in liste_des_taches_permises
]
contenu_menu_acteur[
'options basiques'] = self.contenu_du_menu_des_acteurs[
'options basiques']
contenu_menu_acteur['actions'] = []
for i in range(len(self.contenu_du_menu_des_acteurs['actions'])):
if i in liste_des_taches_permises or i >= len(
self.contenu_du_menu_des_acteurs['options']):
contenu_menu_acteur['actions'].append(
self.contenu_du_menu_des_acteurs['actions'][i])
return Menu_Ouvert(contenu_menu_acteur)
def afficher_pays(self, contenu):
""" Cette méthode permet au consultant d'afficher la liste des différents pays
et d'en choisir un par le nombre correspondant au pays affiché dans le menu"""
if self.contenu_initial == {}:
self.contenu_initial = contenu
donnees = Data_Base().donnees
nb_pays = len(donnees)
choix_pays = {}
choix_pays['question'] = 'Choisissez un pays.'
choix_pays['individu'] = contenu['individu']
liste_des_pays = []
for num_pays in range(nb_pays):
nom_pays = Pays(num_pays, donnees).get_name()
if nom_pays:
liste_des_pays.append((nom_pays, num_pays))
liste_des_pays.sort()
liste_des_noms = [pays[0] for pays in liste_des_pays]
liste_des_nums = [pays[1] for pays in liste_des_pays]
choix_pays['options'] = liste_des_noms
choix_pays['options basiques'] = []
choix_pays['actions'] = [
lambda var, num=num: self.afficher_section(Section(
num, donnees), contenu) for num in liste_des_nums
]
if self.statut == 'g' or self.statut == 'a':
choix_pays['options basiques'].append(['AJOUTER UN PAYS', 'A'])
choix_pays['actions'].append(lambda var: self.ajout_pays(contenu))
if self.statut == 'a':
choix_pays['options basiques'].append(['SUPPRIMER UN PAYS', 'S'])
choix_pays['actions'].append(
lambda var: self.supprimer_pays(contenu))
choix_pays['options basiques'].append(
["RETOUR AU MENU DE L'ACTEUR", 'R'])
choix_pays['actions'].append(
lambda var: Menu_Ouvert(self.contenu_initial))
choix_pays['options basiques'].append(['QUITTER', 'Q'])
choix_pays['actions'].append(self.quitter)
return Menu_Ouvert(choix_pays)
def __init__(self):
# On définit en attribu du gestionnaire des menus
# le contenu du menu initial de l'application
# ainsi que le contenu du menu regroupant toutes
# les actions disponibles.
self.contenu_du_menu_initial = {
'question':
'Quel est votre statut ?',
'options':
['Consultant', 'Data Scientist', 'Géographe', 'Administrateur'],
'options basiques': [['QUITTER', 'Q']],
'actions':
[(lambda contenu: self.taches_permises([1], Consultant())),
(lambda contenu: self.taches_permises([0, 1, 2, 3],
Data_Scientist())),
(lambda contenu: self.taches_permises([0, 1, 4], Geographe())),
(lambda contenu: self.taches_permises([0, 1, 2, 3, 4, 5], Admin())
),
Individu().quitter],
'individu':
Individu(),
'pseudo':
None
}
self.contenu_du_menu_des_acteurs = {
'question':
'Que voulez vous faire ?',
'options': [
'Se connecter',
"Afficher les données d'un pays",
'Acceder aux résumés statistiques',
'Représentations graphiques',
'Décider de valider ou de refuser une correction',
'Créer ou supprimer un compte',
],
'options basiques': [['RETOUR AU MENU DE CHOIX DU STATUT', 'R'],
['QUITTER', 'Q']],
'actions': [
lambda contenu: contenu['individu'].se_connecter(contenu),
lambda contenu: contenu['individu'].afficher_pays(contenu),
(lambda contenu: contenu['individu'].resume_stat(contenu)),
(lambda contenu: contenu['individu'].representation_graphique(
contenu)),
(lambda contenu: contenu['individu'].gestion_corrections(
contenu)),
(lambda contenu: contenu['individu'].gestion_compte(contenu)),
(lambda contenu: Menu_Ouvert(self.contenu_du_menu_initial)),
Individu().quitter
],
'individu':
Individu(),
'pseudo':
None
}
def quitter(self, contenu):
# Cette méthode est commune à tous les individus. Elle prend en argument
# un contenu de menu (dict) et renvoie un menu ouvert ou fermé selon la
# confirmation de l'utilisateur.
confirmation = input('\nVoulez-vous vraiment quitter (O/N) ?\n> ')
if confirmation in ['o', 'O']:
return Menu_Ferme(contenu)
else:
return Menu_Ouvert(contenu)
def _afficher_liste_des_comptes(self, contenu):
gestionnaire = Gestionnaire()
liste_des_comptes = gestionnaire.read(Compte().get_chemin_fichier())
print('\n--------------------------------')
for compte in liste_des_comptes:
print(compte)
print('\n--------------------------------')
input('\nAppuyez sur entrer pour continuer.')
return Menu_Ouvert(contenu)
def gestion_compte(self, contenu):
if self.verification_connexion():
choix_gestion = {}
choix_gestion['pseudo'] = contenu['pseudo']
choix_gestion['individu'] = contenu['individu']
choix_gestion['question'] = 'Que voulez vous faire ?'
choix_gestion['options'] = [
'Créer un compte', 'Supprimer un compte',
'Voir la liste des comptes'
]
choix_gestion['options basiques'] = [['RETOUR', 'R'],
['QUITTER', 'Q']]
choix_gestion['actions'] = [
self._creer_compte, self._supprimer_compte,
self._afficher_liste_des_comptes,
lambda var: Menu_Ouvert(contenu), self.quitter
]
return Menu_Ouvert(choix_gestion)
else:
return Menu_Ouvert(contenu)
def _creer_compte(self, contenu):
"""Cette méthode permet à l'administrateur de créer un nouveau compte.
D'abord, il doit choisir le statut du nouveau acteur. Ensuite son pseudo et enfin son mot de passe.
Une fois validé, le nouveau compte sera inséré dans le gestionnaire des comptes."""
gestionnaire = Gestionnaire()
liste_des_comptes = gestionnaire.read(Compte().get_chemin_fichier())
liste_des_pseudos = [
compte.get_pseudo() for compte in liste_des_comptes
]
while True:
type_de_compte = input(
'\nVous voulez créer un compte Administrateur, Géographe ou Data Scientist (a/g/d) ? : '
)
if type_de_compte in ['a', 'g', 'd']:
break
print(
'\nLa réponse attendue doit être : a pour Admin, g pour Géographe ou d pour Data Scientist.'
)
while True:
pseudo = input('Entrez le pseudo : ')
if len(pseudo) >= 2:
if pseudo not in liste_des_pseudos:
break
else:
print(
"\nCe pseudo est déjà attribué à quelqu'un, veuillez en choisir un autre.\n"
)
else:
print('\nVotre pseudo doit contenir au moins 2 caractères.\n')
while True:
while True:
mot_de_passe = gp.getpass("Entrez le mot de passe : ")
if len(mot_de_passe) >= 4:
break
print(
"\nVotre mot de passe doit contenir au moins 4 caractères.\n"
)
mot_de_passe_confirmation = gp.getpass(
"Confirmez le mot de passe : ")
if mot_de_passe == mot_de_passe_confirmation:
break
print(
"\nLa confirmation ne correspond pas au mot de passe initial.\n"
)
gestionnaire.save_elm(Compte(pseudo, mot_de_passe, type_de_compte))
input(
"\nLe compte a bien été enregistré.\nAppuyez sur entrer pour continuer."
)
return Menu_Ouvert(contenu)
def _choix_critere(self, contenu, fonction_a_appliquer, graphique=False):
"""Cette méthode permet à l'utilisateur de choisir un critère sur les pays qu'il aura selectionné
dans la liste créée au préalable."""
criteres = [
'Superficie', 'Population', 'Croissance démographique',
'Inflation', 'Dette', 'Taux de chômage',
'Taux de dépenses en santé', 'Taux de dépenses en éducation',
'Taux de dépenses militaires'
]
return_function = lambda var: self.resume_stat(var)
if graphique:
return_function = lambda var: self.representation_graphique(var)
choix_critere = {}
choix_critere["question"] = "Choisissez un critère."
choix_critere["individu"] = contenu["individu"]
choix_critere['pseudo'] = contenu['pseudo']
choix_critere["options"] = criteres
choix_critere['options basiques'] = [['RETOUR', 'R'],
[
"RETOUR AU MENU DE L'ACTEUR",
'RMA'
], ["QUITTER", 'Q']]
choix_critere["actions"] = [
lambda var: fonction_a_appliquer(contenu, 'superficie'),
lambda var: fonction_a_appliquer(contenu, 'population'), lambda
var: fonction_a_appliquer(contenu, 'croissance démographique'),
lambda var: fonction_a_appliquer(contenu, 'inflation'),
lambda var: fonction_a_appliquer(contenu, 'dette'),
lambda var: fonction_a_appliquer(contenu, 'chômage'),
lambda var: fonction_a_appliquer(contenu, 'dépenses santé'),
lambda var: fonction_a_appliquer(contenu, 'dépenses éducation'),
lambda var: fonction_a_appliquer(contenu, 'dépenses militaires'),
return_function, lambda var: Menu_Ouvert(self.contenu_initial),
self.quitter
]
return Menu_Ouvert(choix_critere)
def _afficher_liste_des_comptes(self, contenu):
"""Cette méthode permet d'afficher la liste des différents comptes présents dans le gestionnaire"""
gestionnaire = Gestionnaire()
liste_des_comptes = gestionnaire.read(Compte().get_chemin_fichier())
print('\n--------------------------------')
for compte in liste_des_comptes:
print(compte)
print('\n--------------------------------')
input('\nAppuyez sur entrer pour continuer.')
return Menu_Ouvert(contenu)
def resume_stat(self, contenu):
"""Cette méthode est la tâche résumé d'informations. Elle affiche plusieurs tâches que peut effectuer
le data scientist et renverra le résultat par la méthode correspondante au choix de la tâche.
Elle prend en compte le contenu selon ce que souhaite l'administrateur."""
if self.verification_connexion():
if self.contenu_initial == {}:
self.contenu_initial = contenu
choix_resume = {}
choix_resume["question"] = "Choisissez une option d'affichage."
choix_resume["individu"] = contenu["individu"]
choix_resume["pseudo"] = contenu["pseudo"]
choix_resume["options"] = [
"Afficher les critères usuels d'un ou plusieurs pays",
"Afficher les premiers/derniers pays selon un certain critère",
"Afficher les pays dont un critère dépasse un certain seuil",
"Afficher le tableau des classes d'âge pour certains pays",
"Afficher la somme des critères cumulables",
"Afficher le summary d'un critère",
"Afficher les différents profils de pays"
]
choix_resume['options basiques'] = [[
"RETOUR AU MENU DE L'ACTEUR", 'R'
], ["QUITTER", 'Q']]
choix_resume["actions"] = [
lambda var: self.criteres_usuels(contenu),
lambda var: self.top_flop(contenu),
lambda var: self.resume_seuil(contenu),
lambda var: self.classes_age(contenu),
lambda var: self.somme(contenu),
lambda var: self.summary(contenu),
lambda var: self.profils_pays(contenu),
lambda var: Menu_Ouvert(self.contenu_initial), self.quitter
]
return Menu_Ouvert(choix_resume)
else:
return Menu_Ouvert(contenu)
def _supprimer_compte(self, contenu):
"""A l'inverse de la création d'un compte, cette méthode permet de supprimer un compte.
L'administrateur n'a besoin que de choisir dans une liste des pseudos des comptes. Cela ne requiert pas le mot de passe
de l'acteur en question. Une fois effectué, le compte sera supprimé du gestionnaire."""
gestionnaire = Gestionnaire()
liste_des_comptes = gestionnaire.read(Compte().get_chemin_fichier())
liste_des_pseudos = [
compte.get_pseudo() for compte in liste_des_comptes
]
pseudo_compte_a_supprimer = input(
'\nEntrez le pseudo du compte à supprimer\n> ')
if pseudo_compte_a_supprimer not in liste_des_pseudos:
input(
"\nCe compte n'existe pas.\nAppuyez sur entrer pour continuer.\n"
)
return Menu_Ouvert(contenu)
if pseudo_compte_a_supprimer != contenu['pseudo']:
confirmation = input(
'\nConfirmation de la suppression du compte (O/N) ?\n> ')
if confirmation in ['o', 'O']:
gestionnaire.suppr_elm(Compte(pseudo_compte_a_supprimer))
input(
"\nLe compte de {} a bien été supprimé.\nAppuyez sur entrer pour continuer."
.format(pseudo_compte_a_supprimer))
else:
input(
"\nLa tentative de suppression de compte n'a pas abouti\nAppuyez sur entrer pour continuer.\n"
)
else:
input(
'\nVous ne pouvez pas supprimer votre propre compte.\nAppuyez sur entrer pour continuer.'
)
return Menu_Ouvert(contenu)
def _ajout_pays_table_criteres(self, contenu, liste_pays_a_afficher,
fonction_a_appliquer):
"""Cette méthode permet d'ajouter un pays à une liste afin d'appliquer une autre méthode
en fonction d'un certain critère. Cette méthode est utilisée par la fonction critere_usuel."""
donnees = Data_Base().donnees
nb_pays = len(donnees)
if len(liste_pays_a_afficher) >= 10:
input(
"\nVous ne pouvez pas afficher plus de 10 pays à la fois.\nAppuyez sur entrer pour continuer."
)
return fonction_a_appliquer(contenu, liste_pays_a_afficher)
choix_pays = {}
choix_pays['question'] = 'Choisissez un pays.'
choix_pays['individu'] = contenu['individu']
choix_pays['pseudo'] = contenu['pseudo']
liste_des_pays = []
liste_des_nums_pays_a_afficher = [
pays.num_pays for pays in liste_pays_a_afficher
]
liste_des_noms_pays_a_afficher = [
pays.get_name() for pays in liste_pays_a_afficher
]
for num_pays in range(nb_pays):
nom_pays = Pays(num_pays, donnees).get_name()
if nom_pays and nom_pays not in liste_des_noms_pays_a_afficher:
liste_des_pays.append((nom_pays, num_pays))
liste_des_pays.sort()
liste_des_noms = [pays[0] for pays in liste_des_pays]
liste_des_nums = [pays[1] for pays in liste_des_pays]
choix_pays['options'] = liste_des_noms
choix_pays['options basiques'] = []
choix_pays['actions'] = [
lambda var, num=num: fonction_a_appliquer(
contenu, liste_pays_a_afficher + [Pays(num, donnees)])
for num in liste_des_nums
if num not in liste_des_nums_pays_a_afficher
]
return Menu_Ouvert(choix_pays)