Skip to content
Snippets Groups Projects
Commit c2119c1c authored by SBAIHI Dylan's avatar SBAIHI Dylan
Browse files

Application kivy

parent 84937f4d
No related branches found
No related tags found
No related merge requests found
Show whitespace changes
Inline Side-by-side
Showing
with 982 additions and 0 deletions
python file/main_1_.py 0 → 100644
+ 982
− 0
View file @ c2119c1c
from kivy.app import App
from kivymd.app import MDApp
from kivymd.uix.screen import MDScreen
from kivymd.uix.responsivelayout import MDResponsiveLayout
from kivymd.uix.card import MDCard
from kivy.uix.screenmanager import ScreenManager, Screen
from kivy.properties import ListProperty
import mysql.connector
import requests
import json
from kivymd.uix.menu import MDDropdownMenu
from kivy.lang import Builder
#from personne import Personne
#from etudiant import Etudiant
import hashlib
import socket
from clientTCP import TCPClient
# Charger le fichier KV
Builder.load_file('scmMD.kv')
sql_query={}
class UserChoiceScreen(Screen):
'''1ere ecran de choix :eleve, professeur, administrateur'''
def on_user_selected(self, instance):
'''methode qui fait reference au choix de l'utilisateur : eleve, professeur, administrateur'''
app = App.get_running_app()
app.user_role = instance.text.lower() # user_role est maintenant le choix fait pas user
app.login_screen.ids.conn_role.text=f"Espace {app.user_role}"
if instance.text.lower() == 'admin':
app.root.current = 'adminlogin'
else:
app.root.current = 'login' # passage a l'écran suivant nommée 'login'
def quit(self,instance):
App.get_running_app().stop()
class LoginScreen(Screen):
'''2eme ecran de login: username, passwd, ajouter try except finally ...'''
def on_create(self,instance):
app=App.get_running_app()
if app.user_role=="élève":
app.root.current = 'etuaccount'
else:
app.root.current = 'profaccount'
def on_login(self, instance):
'''Doit verifier si le login utilsier correpsond a un nom dans la tables Utilisateurs(username,password)'''
app = App.get_running_app()
username = self.ids.username_input.text
password = self.ids.password_input.text
self.ids.username_input.text=""
self.ids.password_input.text=""
nom = [username[1:-2]]
app.username_text=username
if username and password != "":
try:
sql_query2=None
#changement de la méthode client server ( TCP ) :
# Créer une instance du client TCP
# Utilisation de la classe TCPClient
client_instance=TCPClient('127.0.0.1', 50000)
client_instance2=TCPClient('127.0.0.1', 50000)
sql_query = {
'request': 'get_user_by_username_password',
'params': (username, password)
}
if app.user_role == 'professeur':
sql_query2 = {
'request': 'get_nom_prof',
'params': (nom)
}
# Convertir la requête en JSON et l'envoyer au serveur
message = json.dumps(sql_query)
req=json.loads(client_instance.send_request(message))
if sql_query2 != None:
message2 = json.dumps(sql_query2)
req2=json.loads(client_instance.send_request(message2))
client_instance2.close()
print(f"Response from server: {req2}")
if 'invalid_request' in req2:
print("requete invalide, non reconnue par le server")
# Gérer l'erreur comme vous le souhaitez
else:
if req2["success"] == False:
print('ok success false')
else:
print('ok success true')
if app.user_role=="professeur":
app.prof_screen.ids.mat_charge_prof.text=f"Matière en charge : {req2['data'][0][3]}"
client_instance.close()
print(f"Response from server: {req}")
if 'invalid_request' in req:
print("requete invalide, non reconnue par le server")
# Gérer l'erreur comme vous le souhaitez
else:
if req["success"] == False:
username = self.ids.username_input
password = self.ids.password_input
print('ok success false')
else:
print('ok success true')
if app.user_role=="élève":
app.root.current='student'
app.etu_screen.ids.user_label_etu.text=f"Bonjour {app.username_text} {app.user_role}"
else:
app.root.current='prof'
app.prof_screen.ids.user_label_prof.text=f"Bonjour {app.user_role} {app.username_text[1:-2]} "
except Exception as e:
print(f"Erreur reponse du server : {e}")
# Gérez l'erreur comme vous le souhaitez
else:
username = self.ids.username_input
password = self.ids.password_input
def hasher_password(self,password):
# Créer un objet de hachage MD5
hachage_md5 = hashlib.md5()
# Mettre à jour le hachage avec le mot de passe encodé en UTF-8
hachage_md5.update(password.encode('utf-8'))
# Récupérer la représentation hexadécimale du hachage
hachage_hexadecimal = hachage_md5.hexdigest()
return hachage_hexadecimal
def back_home(self,instance):
app = App.get_running_app()
self.ids.username_input.text=""
self.ids.password_input.text=""
app.root.current='user_choice'
def quit(self,instance):
App.get_running_app().stop()
class LoginAdminScreen(Screen):
def on_admlogin(self,instance):
'''Doit verifier si le login utilsier correpsond a un nom dans la tables Utilisateurs(username,password)'''
app=App.get_running_app()
app.root.current='adminlogin'
username = self.ids.username_input.text
password = self.ids.password_input.text
self.ids.username_input.text=""
self.ids.password_input.text=""
if username and password != "":
try:
# Créer une instance du client TCP
# Utilisation de la classe TCPClient
client_instance=TCPClient('127.0.0.1', 50000)
sql_query = {
'request': 'get_user_by_username_password',
'params': (username, password)
}
# Convertir la requête en JSON et l'envoyer au serveur
message = json.dumps(sql_query)
# envoie du message avec la methode send_message
req=json.loads(client_instance.send_request(message))
client_instance.close()
print(f"Response from server: {req}")
if 'invalid_request' in req:
print("requete invalide, non reconnue par le server")
# Gérer l'erreur comme vous le souhaitez
else:
if req["success"] == False:
username = self.ids.username_input
password = self.ids.password_input
print('ok success false')
else:
print('ok success true')
if app.user_role=="admin":
app.root.current='admin'
app.etu_screen.ids.user_label_etu.text=f"Bonjour {app.username_text} {app.user_role}"
except Exception as e:
print(f"Erreur lors de la connexion : {e}")
# Gérez l'erreur comme vous le souhaitez
else:
username = self.ids.username_input
password = self.ids.password_input
def back_home(self,instance):
app = App.get_running_app()
app.root.current='user_choice'
class CreateEtuAccountScreen(Screen):
# Variable de classe pour stocker la valeur de la checkbox active
active_checkbox_value_year= None
active_checkbox_value_grp= None
def register(self,instance):
'''Boutton enregistrer lors de la creation du compte, ajoute a la BD
Peut etre enregistrer les info du comtpe dans un fihcier ou executer directement les commande pour l'ajuoter dans la bd'''
name=self.ids.name_input.text
pname=self.ids.pname_input.text
mail=self.ids.mail_input.text
year=self.active_checkbox_value_year
group=self.active_checkbox_value_grp
password = self.ids.create_password_input.text
if year is not None:
print(f"Enregistrer avec la checkbox active : {year}")
print([name,pname,int(year),mail,group])
else:
print("Aucune checkbox activée")
save=self.user_login(name,pname,year,password)
self.ids.login_label_register.text=save[0]
info={'user_login': save, 'stud_data': [pname,name,year,mail,group]}
print(info)
if self.check_user_exist(save[0]) == True:
print("utilsateur existe déja, contacter l'aide")
else:
self.db_register_acc(info)
def check_user_exist(self,username):
exist=True
user=[username]
try:
client_instance=TCPClient('127.0.0.1', 50000)
sql_query = {
'request': ('check_user_exist'),
'params': user
}
message = json.dumps(sql_query)
req = json.loads(client_instance.send_request(message))
print(f"Response from server: {req}")
if 'invalid_request' in req:
print("requete invalide, non reconnue par le server")
# Gérer l'erreur comme vous le souhaitez
else:
if req["success"] == False:
print('ok success false')
exist=False
else:
print('ok success true')
client_instance.close()
except Exception as e:
print(f"Erreur lors de la connexion : {e}")
# Gérez l'erreur comme vous le souhaitez
return exist
def db_register_acc(self,info):
"""Cette fonction va envoyer les données nécéssaire au server pour ajouter un compte concernat etudaint, un login et mdp puis les données associés"""
#info utilisateur :
user=info['user_login']
print(user,"qzdqzdqzd",user[0],user[1])
#info etudiant :
stud=info['stud_data']
try:
# Créer une instance du client TCP
# Utilisation de la classe TCPClient
client_instance=TCPClient('127.0.0.1', 50000)
client_instance2=TCPClient('127.0.0.1', 50000)
sql_query = {
'request': ('add_new_student'),
'params': stud
}
sql_query2 = {
'request': ('insert_user'),
'params': (user[0],user[1])
}
# Convertir la requête en JSON et l'envoyer au serveur
message = json.dumps(sql_query)
message2 = json.dumps(sql_query2)
# envoie du message avec la methode send_message
req = json.loads(client_instance.send_request(message))
req2=json.loads(client_instance.send_request(message2))
print(f"Response from server: {req}")
if 'invalid_request' in req:
print("requete invalide, non reconnue par le server")
# Gérer l'erreur comme vous le souhaitez
else:
if req["success"] == False:
print('ok success false')
else:
print('ok success true')
# envoie du message avec la methode send_message
print(f"Response from server 2: {req2}")
if 'invalid_request' in req2:
print("requete invalide, non reconnue par le server 2")
# Gérer l'erreur comme vous le souhaitez
else:
if req2["success"] == False:
print('ok success false 2')
else:
print('ok success true 2')
client_instance.close()
client_instance2.close()
except Exception as e:
print(f"Erreur lors de la connexion : {e}")
# Gérez l'erreur comme vous le souhaitez
def user_login(self,name,pname,year,password):
userlog=pname[0].upper()+name+year
#mdp=self.hasher_password(password)
#mdp=self.encrypt_password(password)
print(f"login : '{userlog}' | mdp non chiffré : '{password}'")
return [userlog,password]
def on_checkbox_active_year(self, instance, value):
if value is True:
self.active_checkbox_value_year=instance.data
print(f"Checkbox Checked {value} {instance.data}") #instance.data fait réf a l'id de la checkbox, liaison pour connaitre l'ID
else:
self.active_checkbox_value_year=None
print(f"Checkbox Unchecked {value} {instance.data}")
def on_checkbox_active_grp(self, instance, value):
if value is True:
self.active_checkbox_value_grp=instance.data
print(f"Checkbox Checked {value} {instance.data}") #instance.data fait réf a l'id de la checkbox, liaison pour connaitre l'ID
else:
self.active_checkbox_value_grp=None
print(f"Checkbox Unchecked {value} {instance.data}")
def hasher_password(self,password):
# Créer un objet de hachage MD5
hachage_md5 = hashlib.md5()
# Mettre à jour le hachage avec le mot de passe encodé en UTF-8
hachage_md5.update(password.encode('utf-8'))
# Récupérer la représentation hexadécimale du hachage
hachage_hexadecimal = hachage_md5.hexdigest()
return hachage_hexadecimal
def encrypt_password(self,password):
# Inverser l'ordre des caractères
reversed_password = password[::-1]
# Ajouter une chaîne spéciale (vous pouvez choisir celle que vous préférez)
encrypted_password = reversed_password + "_special_string"
return encrypted_password
def quit(self,instance):
App.get_running_app().stop()
def back_home(self,instance):
app = App.get_running_app()
self.ids.username_input.text=""
self.ids.password_input.text=""
app.root.current='user_choice'
class CreateProfAccountScreen(Screen):
def user_prof_login(self,name,pname,bureau,matiere,password):
userlog=pname[0].upper()+name+bureau+matiere[0].upper()
#mdp=self.hasher_password(password)
#mdp=self.encrypt_password(password)
print(f"login : '{userlog}' | mdp non chiffré : '{password}'")
return [userlog,password]
def spinner_desk(self,value):
print("Bureau sélectionné :",value)
return value
def spinner_mat(self,value):
print("Matière sélectionnée :",value)
return value
def register(self,instance):
'''Boutton enregistrer lors de la creation du compte, ajoute a la BD'''
name = self.ids.name_input.text
pname = self.ids.pname_input.text
bureau = self.ids.drop_item_desk.text
matiere = self.ids.drop_item_mat.text
password = self.ids.create_password_input_prof.text
save=self.user_prof_login(name,pname,bureau,matiere,password)
self.ids.login_label_register.text=save[0]
info={'user_login': save, 'prof_data': [name,bureau,matiere]}
print(info)
if self.check_user_exist(save[0]) == True:
print("utilsateur existe déja, contacter l'aide")
else:
self.db_register_acc(info)
def check_user_exist(self,username):
exist=True
user=[username]
try:
client_instance=TCPClient('127.0.0.1', 50000)
sql_query = {
'request': ('check_user_exist'),
'params': user
}
message = json.dumps(sql_query)
req = json.loads(client_instance.send_request(message))
print(f"Response from server: {req}")
if 'invalid_request' in req:
print("requete invalide, non reconnue par le server")
# Gérer l'erreur comme vous le souhaitez
else:
if req["success"] == False:
print('ok success false')
exist=False
else:
print('ok success true')
client_instance.close()
except Exception as e:
print(f"Erreur lors de la connexion : {e}")
# Gérez l'erreur comme vous le souhaitez
return exist
def db_register_acc(self,info):
"""Cette fonction va envoyer les données nécéssaire au server pour ajouter un compte concernant professeur, un login et mdp puis les données associés"""
#info utilisateur :
user=info['user_login']
print(user,"qzdqzdqzd",user[0],user[1])
#info etudiant :
prof=info['prof_data']
try:
# Créer une instance du client TCP
# Utilisation de la classe TCPClient
client_instance=TCPClient('127.0.0.1', 50000)
client_instance2=TCPClient('127.0.0.1', 50000)
sql_query = {
'request': ('add_new_prof'),
'params': prof
}
sql_query2 = {
'request': ('insert_user'),
'params': (user[0],user[1])
}
# Convertir la requête en JSON et l'envoyer au serveur
message = json.dumps(sql_query)
message2 = json.dumps(sql_query2)
# envoie du message avec la methode send_message
req = json.loads(client_instance.send_request(message))
req2=json.loads(client_instance.send_request(message2))
print(f"Response from server: {req}")
if 'invalid_request' in req:
print("requete invalide, non reconnue par le server")
# Gérer l'erreur comme vous le souhaitez
else:
if req["success"] == False:
print('ok success false')
else:
print('ok success true')
# envoie du message avec la methode send_message
print(f"Response from server 2: {req2}")
if 'invalid_request' in req2:
print("requete invalide, non reconnue par le server 2")
# Gérer l'erreur comme vous le souhaitez
else:
if req2["success"] == False:
print('ok success false 2')
else:
print('ok success true 2')
client_instance.close()
client_instance2.close()
except Exception as e:
print(f"Erreur lors de la connexion : {e}")
# Gérez l'erreur comme vous le souhaitez
def open_menu_desk(self,items):
app = App.get_running_app()
# Créez une liste de toutes les matières
#all_subjects = self.liste_etudiant(year)
all_subjects = ["1","2","3","4","5","6","7"]
# Créer les éléments du menu en fonction de la liste de matières
menu_items = [
{
"text": subject,
"viewclass": "OneLineListItem",
"on_release": lambda x=subject: self.menu_callback_desk(x),
} for subject in all_subjects
]
self.menu = MDDropdownMenu(
caller=app.create_prof_account.ids.drop_item_desk,
items=menu_items,
width_mult=4,
)
self.menu.open()
def menu_callback_desk(self, text_item):
app = App.get_running_app()
app.create_prof_account.ids.drop_item_desk.text = text_item
print(text_item)
self.menu.dismiss()
def open_menu_mat(self,items):
app = App.get_running_app()
# Créez une liste de toutes les matières
#all_subjects = self.liste_etudiant(year)
all_subjects = ["Reseau","Math","Anglais","Progra"]
# Créer les éléments du menu en fonction de la liste de matières
menu_items = [
{
"text": subject,
"viewclass": "OneLineListItem",
"on_release": lambda x=subject: self.menu_callback_mat(x),
} for subject in all_subjects
]
self.menu = MDDropdownMenu(
caller=app.create_prof_account.ids.drop_item_mat,
items=menu_items,
width_mult=4,
)
self.menu.open()
def menu_callback_mat(self, text_item):
app = App.get_running_app()
app.create_prof_account.ids.drop_item_mat.text = text_item
print(text_item)
self.menu.dismiss()
def quit(self,instance):
App.get_running_app().stop()
def back_home(self,instance):
app = App.get_running_app()
self.ids.username_input.text=""
self.ids.password_input.text=""
app.root.current='user_choice'
class FinishAccountScreen(Screen):
pass
class EtuScreen(Screen):
def abscence_button(self, instance):
pass
def note_button(self, instance):
pass
def back_home(self,instance):
app = App.get_running_app()
app.root.current='user_choice'
def quit(self,instance):
App.get_running_app().stop()
class ProfScreen(Screen):
def on_checkbox_active_year_stud(self, instance, value):
app = App.get_running_app()
if value is True:
print(f"Checkbox Checked {value} {instance.data}") #instance.data fait réf a l'id de la checkbox, liaison pour connaitre l'ID
if int(instance.data)== 1:
app.root.current='1ascreen'
elif int(instance.data)== 2:
app.root.current='2ascreen'
else:
app.root.current='3ascreen'
else:
print(f"Checkbox Unchecked {value} {instance.data}")
def back_home(self,instance):
app = App.get_running_app()
app.root.current='user_choice'
def quit(self,instance):
App.get_running_app().stop()
class ProfFirstYearScreen(Screen):
def liste_etudiant(self,params):
try:
# Créer une instance du client TCP
# Utilisation de la classe TCPClient
client_instance=TCPClient('127.0.0.1', 50000)
sql_query = {
'request': ('get_list_student_year'),
'params': params
}
# Convertir la requête en JSON et l'envoyer au serveur
message = json.dumps(sql_query)
# envoie du message avec la methode send_message
req = json.loads(client_instance.send_request(message))
print(f"Response from server: {req['data']}")
if 'invalid_request' in req:
print("requete invalide, non reconnue par le server")
# Gérer l'erreur comme vous le souhaitez
else:
if req["success"] == False:
print('ok success false')
else:
print('ok success true')
return req['data']
client_instance.close()
except Exception as e:
print(f"Erreur lors de la connexion : {e}")
# Gérez l'erreur comme vous le souhaitez
def add_note(self, instance):
pass
def add_abs(self, instance):
pass
def open_menu(self,items):
app = App.get_running_app()
# Créez une liste de toutes les étudiant correspondant a leur année
if app.root.current=='1ascreen':
nouvelle_liste = [f"{element[0]} {element[1]}" for element in self.liste_etudiant([1])]
elif app.root.current=='2ascreen':
nouvelle_liste = [f"{element[0]} {element[1]}" for element in self.liste_etudiant([2])]
else:
nouvelle_liste = [f"{element[0]} {element[1]}" for element in self.liste_etudiant([3])]
all_subjects = nouvelle_liste
# Créer les éléments du menu en fonction de la liste de matières
menu_items = [
{
"text": subject,
"viewclass": "OneLineListItem",
"on_release": lambda x=subject: self.menu_callback(x),
} for subject in all_subjects
]
self.menu = MDDropdownMenu(
caller=app.prof_1a_screen.ids.drop_item,
items=menu_items,
width_mult=4,
)
self.menu.open()
def menu_callback(self, text_item):
app = App.get_running_app()
app.prof_1a_screen.ids.drop_item.text = text_item
app.prof_1a_screen.ids.selected_year_label.text = text_item
self.update_student_details(text_item)
self.menu.dismiss()
def update_student_details(self, student_name):
app = App.get_running_app()
app.prof_1a_screen.ids.note_label.text = str(14.5)
app.prof_1a_screen.ids.moyenne_label.text = f"{float(app.prof_1a_screen.ids.note_label.text) * 2 / 2}"
app.prof_1a_screen.ids.abs_label.text = "3 (6 heures)"
app.prof_1a_screen.ids.image_student.source = "image_stud.jpg"
def show_grade_dialog(self):
pass
def edit_student_details(self):
pass
def update_dropdown_items(self):
# Créer les éléments du menu en fonction des étudiants affichés
menu_items = [
{
"text": f"{student['name']} - Year {student['year']}",
"viewclass": "OneLineListItem",
"on_release": lambda x=student['name']: self.menu_callback(x),
} for student in self.displayed_students
]
# Mettre à jour les éléments dans MDDropDownItem
self.ids.drop_item.set_items(menu_items)
def back_home(self,instance):
app = App.get_running_app()
app.root.current='prof'
def quit(self,instance):
App.get_running_app().stop()
pass
class ProfSecondYearScreen(Screen):
def liste_etudiant(self,params):
try:
# Créer une instance du client TCP
# Utilisation de la classe TCPClient
client_instance=TCPClient('127.0.0.1', 50000)
sql_query = {
'request': ('get_list_student_year'),
'params': params
}
# Convertir la requête en JSON et l'envoyer au serveur
message = json.dumps(sql_query)
# envoie du message avec la methode send_message
req = json.loads(client_instance.send_request(message))
print(f"Response from server: {req['data']}")
if 'invalid_request' in req:
print("requete invalide, non reconnue par le server")
# Gérer l'erreur comme vous le souhaitez
else:
if req["success"] == False:
print('ok success false')
else:
print('ok success true')
return req['data']
client_instance.close()
except Exception as e:
print(f"Erreur lors de la connexion : {e}")
# Gérez l'erreur comme vous le souhaitez
def open_menu(self,items):
app = App.get_running_app()
# Créez une liste de toutes les étudiant correspondant a leur année
if app.root.current=='1ascreen':
nouvelle_liste = [f"{element[0]} {element[1]}" for element in self.liste_etudiant([1])]
elif app.root.current=='2ascreen':
nouvelle_liste = [f"{element[0]} {element[1]}" for element in self.liste_etudiant([2])]
else:
nouvelle_liste = [f"{element[0]} {element[1]}" for element in self.liste_etudiant([3])]
all_subjects = nouvelle_liste
# Créer les éléments du menu en fonction de la liste de matières
menu_items = [
{
"text": subject,
"viewclass": "OneLineListItem",
"on_release": lambda x=subject: self.menu_callback(x),
} for subject in all_subjects
]
self.menu = MDDropdownMenu(
caller=app.prof_1a_screen.ids.drop_item,
items=menu_items,
width_mult=4,
)
self.menu.open()
def menu_callback(self, text_item):
app = App.get_running_app()
app.prof_1a_screen.ids.drop_item.text = text_item
app.prof_1a_screen.ids.selected_year_label.text = text_item
self.update_student_details(text_item)
self.menu.dismiss()
def update_student_details(self, student_name):
app = App.get_running_app()
app.prof_1a_screen.ids.note_label.text = str(14.5)
app.prof_1a_screen.ids.moyenne_label.text = f"{float(app.prof_1a_screen.ids.note_label.text) * 2 / 2}"
app.prof_1a_screen.ids.abs_label.text = "3 (6 heures)"
app.prof_1a_screen.ids.image_student.source = "image_stud.jpg"
def show_grade_dialog(self):
pass
def edit_student_details(self):
pass
def update_dropdown_items(self):
# Créer les éléments du menu en fonction des étudiants affichés
menu_items = [
{
"text": f"{student['name']} - Year {student['year']}",
"viewclass": "OneLineListItem",
"on_release": lambda x=student['name']: self.menu_callback(x),
} for student in self.displayed_students
]
# Mettre à jour les éléments dans MDDropDownItem
self.ids.drop_item.set_items(menu_items)
def back_home(self,instance):
app = App.get_running_app()
app.root.current='prof'
def quit(self,instance):
App.get_running_app().stop()
pass
class ProfThirdYearScreen(Screen):
def liste_etudiant(self,params):
try:
# Créer une instance du client TCP
# Utilisation de la classe TCPClient
client_instance=TCPClient('127.0.0.1', 50000)
sql_query = {
'request': ('get_list_student_year'),
'params': params
}
# Convertir la requête en JSON et l'envoyer au serveur
message = json.dumps(sql_query)
# envoie du message avec la methode send_message
req = json.loads(client_instance.send_request(message))
print(f"Response from server: {req['data']}")
if 'invalid_request' in req:
print("requete invalide, non reconnue par le server")
# Gérer l'erreur comme vous le souhaitez
else:
if req["success"] == False:
print('ok success false')
else:
print('ok success true')
return req['data']
client_instance.close()
except Exception as e:
print(f"Erreur lors de la connexion : {e}")
# Gérez l'erreur comme vous le souhaitez
def open_menu(self,items):
app = App.get_running_app()
# Créez une liste de toutes les étudiant correspondant a leur année
if app.root.current=='1ascreen':
nouvelle_liste = [f"{element[0]} {element[1]}" for element in self.liste_etudiant([1])]
elif app.root.current=='2ascreen':
nouvelle_liste = [f"{element[0]} {element[1]}" for element in self.liste_etudiant([2])]
else:
nouvelle_liste = [f"{element[0]} {element[1]}" for element in self.liste_etudiant([3])]
all_subjects = nouvelle_liste
# Créer les éléments du menu en fonction de la liste de matières
menu_items = [
{
"text": subject,
"viewclass": "OneLineListItem",
"on_release": lambda x=subject: self.menu_callback(x),
} for subject in all_subjects
]
self.menu = MDDropdownMenu(
caller=app.prof_1a_screen.ids.drop_item,
items=menu_items,
width_mult=4,
)
self.menu.open()
def menu_callback(self, text_item):
app = App.get_running_app()
app.prof_1a_screen.ids.drop_item.text = text_item
app.prof_1a_screen.ids.selected_year_label.text = text_item
self.update_student_details(text_item)
self.menu.dismiss()
def update_student_details(self, student_name):
app = App.get_running_app()
app.prof_1a_screen.ids.note_label.text = str(14.5)
app.prof_1a_screen.ids.moyenne_label.text = f"{float(app.prof_1a_screen.ids.note_label.text) * 2 / 2}"
app.prof_1a_screen.ids.abs_label.text = "3 (6 heures)"
app.prof_1a_screen.ids.image_student.source = "image_stud.jpg"
def show_grade_dialog(self):
pass
def edit_student_details(self):
pass
def update_dropdown_items(self):
# Créer les éléments du menu en fonction des étudiants affichés
menu_items = [
{
"text": f"{student['name']} - Year {student['year']}",
"viewclass": "OneLineListItem",
"on_release": lambda x=student['name']: self.menu_callback(x),
} for student in self.displayed_students
]
# Mettre à jour les éléments dans MDDropDownItem
self.ids.drop_item.set_items(menu_items)
def back_home(self,instance):
app = App.get_running_app()
app.root.current='prof'
def quit(self,instance):
App.get_running_app().stop()
pass
class AdminScreen(Screen):
def back_home(self,instance):
app = App.get_running_app()
self.ids.username_input.text=""
self.ids.password_input.text=""
app.root.current='user_choice'
def quit(self,instance):
App.get_running_app().stop()
class MyApp(MDApp):
def build(self):
self.user_role = None
self.username_text=""
self.user_choice=UserChoiceScreen(name='user_choice')
self.login_screen = LoginScreen(name='login')
self.adminlogin_screen = LoginAdminScreen(name='adminlogin')
self.create_etu_account = CreateEtuAccountScreen(name='etuaccount')
self.create_prof_account = CreateProfAccountScreen(name='profaccount')
self.finish_account = FinishAccountScreen(name='final')
self.etu_screen = EtuScreen(name='student')
self.prof_screen = ProfScreen(name='prof')
self.admin_screen = AdminScreen(name='admin')
self.prof_1a_screen = ProfFirstYearScreen(name='1ascreen')
self.prof_2a_screen = ProfSecondYearScreen(name='2ascreen')
self.prof_3a_screen = ProfThirdYearScreen(name='3ascreen')
root = ScreenManager()
self.theme_cls.primary_palette = "Orange"
self.theme_cls.theme_style = "Dark"
# Ajout des différents ecrans de l'application :
root.add_widget(self.user_choice) # choix du role (etudiant,prof,admin) --\
root.add_widget(self.login_screen) # connection, si l'utilisateur a un compte, \
root.add_widget(self.create_etu_account) # Sinon création de compte etu, \ <--|
root.add_widget(self.create_prof_account) # Sinon création de compte prof,
root.add_widget(self.finish_account) # finalisation inscription --\
root.add_widget(self.etu_screen) # interface etudiant <--|
root.add_widget(self.prof_screen) # interface prof <--|
root.add_widget(self.admin_screen) # interface admin <--|
root.add_widget(self.adminlogin_screen) # login admin (pas de creation de comtpe)
root.add_widget(self.prof_1a_screen)
root.add_widget(self.prof_2a_screen)
root.add_widget(self.prof_3a_screen)
return root
if __name__ == '__main__':
MyApp().run()
\ No newline at end of file
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment