@ -699,24 +699,91 @@ void menuAdmin(VilleIUT *tiut[], int *tLog, int tMax) /* Affiche un menu de choi
}
}
voidmenuCandidat(VilleIUT*tiut[],int*tLog,inttMax)/* Affiche un menu adapté pour un candidat et appelle les fonctions nécessaires pour effectuer les actions souhaitées */
ListeDeptlisteDeptNouv(void)/*Permet de créer un liste vide puis la retourne à la fonction appelante.*/
{
ListeDeptlDept;
lDept=NULL;
returnlDept;
}
ListeDeptinsererEntete(ListeDeptlDept,Departementd)/*Permet d'insérer un MaillonDept en début d'une liste passée en paramètre puis renvoie cette même liste*/
{
MaillonDept*m;/* Création d'un pointeur vers une structure MaillonDept */
m=(MaillonDept*)malloc(sizeof(MaillonDept));/* Allocation d'un espace mémoire pour le nouveau maillon */
if(m==NULL)
{
printf("Problème d'allocation mémoire lors de l'insertion\n");/* Message d'erreur en cas de problème de malloc */
exit(1);
}
m->d=d;/* Affecte le département passé en paramètre à l'attribut d du nouveau maillon */
m->suiv=lDept;
returnm;
}
ListeDeptinsererDept(ListeDeptlDept,Departementd)/* Permet d'insérer un maillon dans une liste donnée en paramètre dans l'ordre alpĥabétique/croissant et retourne cette liste */
{
if(lDept==NULL)/* Si la liste est vide, insère le nouveau maillon en tête */
{
returninsererEntete(lDept,d);
}
if(strcmp(d.dept,lDept->d.dept)<0)/* Si le nom du département est inférieur à celui de la liste testé, le maillon est inséré en tête*/
{
returninsererEntete(lDept,d);
}
if(strcmp(d.dept,lDept->d.dept)==0)/* Si le maillon existe déjà, retourne la liste sans changement */
{
printf("Département déjà présent dans cet IUT\n");
returnlDept;
}
lDept->suiv=insererDept(lDept->suiv,d);/* Si aucun cas précédent n'est respecté, recommence avec le maillon suivant de la liste */
returnlDept;
}
ListeDeptsupprimerEntete(ListeDeptlDept)/* Permet de supprimer un maillon en tête de la liste donnée en paramètre et retourne cette liste */
{
ListeDeptaux;
if(lDept==NULL)/* Si la liste est vide, quitte le programme car cela provoquerait une erreur */
{
printf("Opération interdite\n");
exit(1);
}
aux=lDept;/* On affecte l'adresse de la liste actuelle à une variable temporaire */
lDept=lDept->suiv;/* On supprime le maillon */
free(aux);/* On libère l'espace mémoire du maillon supprimer*/
returnlDept;
}
ListeDeptsupprimerDept(ListeDeptlDept,char*dep)/* Permet de supprimer un maillon d'une liste lDept passée en paramètre à partir de son attribut nom de département (dept) et retourne cette liste */
{
if(lDept==NULL)/* La liste est vide, on la retourne sans changements */
{
returnlDept;
}
if(strcmp(dep,lDept->d.dept)<0)/* Le maillon à supprimer n'existe pas, on retourne la liste sans changement */
{
returnlDept;
}
if(strcmp(dep,lDept->d.dept)==0)/* Le maillon à supprimer est trouvé, on le supprime */
{
returnsupprimerEntete(lDept);
}
lDept->suiv=supprimerDept(lDept->suiv,dep);/* Aucune des conditions précédentes n'a été respectée, on recommence avec le maillon suivant */
returnlDept;
}
intlongueur(ListeDeptlDept)/* Permet d'obtenir la longueur d'une liste passée en paramètre et retourne le nombre de maillons */
{
intcompt=0;/* On déclare un compteur pour compter le nombre de maillons */
while(lDept!=NULL)/* Tant que la liste n'est pas vide, on incrémente le compteur de 1 et on passe au maillon suivant */
{
compt=compt+1;
lDept=lDept->suiv;
}
returncompt;
}
boolvide(ListeDeptlDept)/* Permet de savoir si une liste est vide et retourne un booléen */
{
if(lDept==NULL)
returntrue;
returnfalse;
}
/*int tete(Liste l){
if(l==NULL){
printf("Opération interdite\n");
exit(1)
}
returnl->v;
}*/
ListeDeptrechercherDept(ListeDeptlDept,chardept[],int*trouve)/* Permet de recherche un maillon dans une liste de départements passée en paramètre pour ensuite renvoyer son adresse*/
{
if(vide(lDept))/* Si la liste est vide, la variable trouve passée en pointeur prend la valeur 0 et on retourne la liste */
{
*trouve=0;
returnlDept;
}
if(strcmp(dept,lDept->d.dept)<0)/* Même procédé que la condition précédente si le département recherché n'est pas trouvé*/
{
*trouve=0;
returnlDept;
}
if(strcmp(dept,lDept->d.dept)==0)/* Si le département recherché est trouvé, trouve prend la valeur 1 et on retourne la liste */
{
*trouve=1;
returnlDept;
}
returnrechercherDept(lDept->suiv,dept,trouve);/* Si aucune condition n'est respectée, renvoie la même recherche pour le maillon suivant */
voidafficherVille(VilleIUTv)/* Permet d'afficher le nom d'une variable de type structure villeIUT passée en paramètre de façon esthétique */
{
printf("|----------------------------------|\n");
printf("| %-32s |\n",v.nom);
printf("|----------------------------------|\n");
}
voidafficherTIUT(VilleIUT*tiut[],inttLog)/* Permet d'afficher le nom de toute les villes présentes dans le tableau tiut de façon esthétique*/
{
inti=0;
printf("____________________________________\n");
printf("| Ville |\n");
for(i=0;i<tLog;i++)
{
afficherVille(*tiut[i]);
}
printf("\n");
}
voidafficherVilleDep(VilleIUTv)/* Permet d'afficher une ville passée en paramètre ainsi que tous les départements qui y sont présent de manière esthétique*/
intchargement(VilleIUT*tiut[],inttMax)/* Permet de charger le contenu du fichier IUT.don dans des structures MaillonDept et VilleIUT pour remplir le tableau tiut */
{
FILE*flot;/* Déclaration de la variable pour lire le fichier */
inttLog=0,pos,trouve;/* tLog, la taille logique que l'on incrémente à chaque nouvelle ville insérée dan le tableau */
charnomV[31];
Departementd;
flot=fopen("IUT.don","r");/* Ouverture du fichier */
if(flot==NULL)/* En cas de problème avec l'ouverture du fichier, on affiche un message d'erreur, on ferme le fichier et on quitte la fonction */
{
printf("Erreur lors de l'ouverture du fichier\n");
fclose(flot);
return-1;
}
fscanf(flot,"%s",nomV);/* On commence par lire le nom de la première ville dans le fichier */
while(!feof(flot))
{
if(tLog==tMax)/* Si le tableau est plein, on affiche un message d'erreur, on ferme le fichier et on arrête la fonction */
{
printf("Tableau tiut plein\n");
fclose(flot);
return-3;
}
d=lireDep(flot);/* On appelle la fonction lireDep pour remplir une structure Département à partir du fichier */
pos=rechercheIUT(tiut,tLog,nomV,&trouve);/* On recherche la ville lue dans le tableau et on récupère sa position si elle est présente ou sa position d'insertion dans le cas contraire*/
if(trouve==1)/* Si la ville a été trouvée, on insère le département d lu dans la liste des départements de la ville en question*/
{
tiut[pos]->lDept=insererDept(tiut[pos]->lDept,d);
}
else/* Si la ville n'existe pas, on l'insère dans le tableau et on insère dans sa liste le département d */
{
insererVille(tiut,nomV,&tLog,tMax,pos);
tiut[pos]->lDept=insererDept(tiut[pos]->lDept,d);
}
fscanf(flot,"%s",nomV);/* On lit le nom de la ville suivante pour continuer le remplissage du tableau */
}
fclose(flot);/* On ferme le fichier avant de retourner la taille logique du tableau */
returntLog;
}
DepartementlireDep(FILE*flot)/* Permet de lire à partir d'un flot passé en paramètre les informations relatives à un département pour les insérer dans une structure Département*/
{
Departementd;
fscanf(flot,"%s%d",d.dept,&d.nbP);
fgets(d.respAd,31,flot);
d.respAd[strlen(d.respAd)-1]='\0';
returnd;
}
/************************************************************** Fonctions de Villes ***********************************************************/
intinsererVille(VilleIUT*tiut[],charnomV[],int*tLog,inttMax,intpos)/* Permet d'insérer une ville dans le tableau tiut et renvoie un entier dépendant du déroulement de l'insertion */
{
inti;
if(*tLog==tMax)/* Si le tableau est plein, l'insertion est impossible, on affiche un message d'erreur et on retourne -1 */
{
printf("Tableau plein, insertion impossible\n");
return-1;
}
for(i=*tLog-1;i>=pos;i--)/* On décale tous les éléments vers la droite depuis le dernier élément du tableau jusqu'à la position d'insertion passée en paramètre */
{
tiut[i+1]=tiut[i];
}
tiut[pos]=(VilleIUT*)malloc(sizeof(VilleIUT));/* On alloue un espace mémoire pour la nouvelle ville à insérer */
if(tiut[pos]==NULL)/* Si l'allocation se passe mal, on affiche un message d'erreur et on retourne -1 */
{
printf("Problème d'allocation mémoire lors de l'insertion de la ville\n");
return-1;
}
strcpy(tiut[pos]->nom,nomV);/* On copie le nom de la ville à insérer passé en paramètre dans le nom de la structure VilleIUT allouée précédemment*/
tiut[pos]->lDept=listeDeptNouv();/* On créer une liste de départements vide pour la nouvelle ville */
*tLog=*tLog+1;/* On incrémente de 1 la taille logique après insertion de la nouvelle ville */
return0;
}
intsupprimerVille(VilleIUT*tiut[],charnomV[],int*tLog,intpos)/* Permet de supprimer une ville du tableau tiut dont le nom est passé en paramètre*/
{
VilleIUT*aux;/* Création d'un pointeur auxiliaire vers une structure villeIUT */
aux=tiut[pos];/* Attribution de la ville à supprimer à la variable auxiliaire */
while(pos<*tLog-1)/* Décalage à gauche de tous les éléments du tableau à partir de la position de la villeà supprimer passée en paramètre */
{
tiut[pos]=tiut[pos+1];
pos++;
}
while(aux->lDept!=NULL)/* Suppression de tous les départements dans la liste de la ville supprimée */
{
aux->lDept=supprimerEntete(aux->lDept);
}
free(aux);/* Libération de la mémoire occupée par la ville supprimée*/
*tLog=*tLog-1;/* Diminution de la taille logique de 1 après la suppression de la ville */
return0;
}
intrechercheIUT(VilleIUT*tiut[],inttLog,charville[],int*trouve)/* Permet d'effectuer une recherche dichotomique dans le tableau tiut d'une ville passée en paramètre */
{
intinf,sup,t;/* Déclarations des variables permettant la navigarion dans le tableau */
inf=0;
sup=tLog-1;
while(inf<=sup)
{
t=(inf+sup)/2;/* Calcul de l'indice de position central du tableau*/
if(strcmp(ville,tiut[t]->nom)==0)/* Si la ville est trouvée, on donne la valeur 1 à la variable trouve passée par pointeur et on retourne sa position */
{
*trouve=1;
returnt;
}
if(strcmp(ville,tiut[t]->nom)<0)
sup=t-1;
elseinf=t+1;
if(strcmp(ville,tiut[t]->nom)<0)/* Si la ville recherchée est inférieure à la ville à la position t (centrale), on continue la recherche dans la partie gauche du tableau */
{
sup=t-1;
}
else/* Dans le cas contraire, on continue la recherche dans la partie droite du tableau */
{
inf=t+1;
}
}
*trouve=0;/* Si la ville n'a pas été trouvée, on donne la valeur 0 à trouve et on retourne sa position d'insertion inf */
returninf;
}
/******************************************************* Fonctions de départements ************************************************************/
voidcreerDept(VilleIUT*tiut[],inttLog)/* Permet de demander à l'administrateur toutes les informations nécessaires pour la création d'un nouveau département et exécute cette création */
{
Departementd;
intpos,trouve;
charville[31];
printf("Dans quelle ville souhaitez-vous créer un nouveau département ?\nSaisie : ");/* Recueil du nom de la ville dans laquelle insérer le département */
scanf("%s%*c",ville);
printf("\n");
pos=rechercheIUT(tiut,tLog,ville,&trouve);/* Vérification que la ville est bien existante, si ce n'est pas le cas, on re-demande de saisir le nom tant que ce n'est pas bon */
while(trouve==0)
{
printf("Cette ville n'existe pas, veuillez re-saisir : ");
scanf("%s%*c",ville);
printf("\n");
pos=rechercheIUT(tiut,tLog,ville,&trouve);
}
printf("Quel est le nom du département à insérer ?\nSaisie : ");/* Demande le nom du département à insérer */
scanf("%s%*c",d.dept);
rechercherDept(tiut[pos]->lDept,d.dept,&trouve);/* Vérification que le département n'existe pas déjà */
if(trouve==1)/* Si le département existe déjà, on affiche un message d'erreur et on arrête la fonction */
{
printf("Erreur, le département %s existe déjà dans cet IUT\n",d.dept);
return;
}
printf("Combien de place y a-t-il pour dans ce département ?\nSaisie : ");/* On continue de demander les informations nécessaires sur le département à insérer */
scanf("%d%*c",&d.nbP);
printf("\n");
printf("Quel est le nom du responsable du département ?\nSaisie : ");
fgets(d.respAd,31,stdin);
d.respAd[strlen(d.respAd)-1]='\0';
afficherDep(d);/* On affiche le département qui va être inséré */
tiut[pos]->lDept=insererDept(tiut[pos]->lDept,d);/* On insère le département dans la liste de la ville correspondante */
return;
}
voidafficherVille(VilleIUTv){
printf("%s",v.nom);
voidretirerDept(VilleIUT*tiut[],inttLog)/* Permet de gérer la suppression d'un département dans une ville saisie dans la fonction */
{
inttrouve,pos;
charville[31],dep[31],choix;
printf("Dans quelle ville souhaitez-vous supprimer un département ?\nSaisie : ");/* Demande dans quelle ville on souhaite supprimer un département */
scanf("%s%*c",ville);
printf("\n");
pos=rechercheIUT(tiut,tLog,ville,&trouve);/* On vérifie que la ville existe */
while(trouve==0)/* Si la ville n'existepas, on effectue une saisie contrôlée tant que ce n'est pas bon */
{
printf("Cette ville n'existe pas, veuillez re-saisir : ");
scanf("%s%*c",ville);
printf("\n");
pos=rechercheIUT(tiut,tLog,ville,&trouve);
}
printf("Quel est le nom du département à supprimer ?\nSaisie : ");/* Demande le nom du département à supprimer */
scanf("%s%*c",dep);
rechercherDept(tiut[pos]->lDept,dep,&trouve);/* Vérifie que le département en question existe */
if(trouve==0)/* S'il n'existe pas, affiche un message d'erreur et arrête la fonction */
{
printf("Erreur, le département %s n'existe pas dans cet IUT\n",dep);
return;
}
printf("Êtes-vous sur de vouloir supprimer ce département ? (O/n)\nSaisie : ");/* Demande confirmation de la suppression */
scanf("%c%*c",&choix);
printf("\n");
if(choix=='N'||choix=='n')/* Si le choix et non, annule la supression */
{
printf("Suppression annulée\n");
return;
}
tiut[pos]->lDept=supprimerDept(tiut[pos]->lDept,dep);/* Supprime le département */
return;
}
/*********************************************** Fonctions de login, menus, globale et clearpage **********************************************/
intlogin(void)/* Affiche un menu de connexion pour ensuite adapter l'affichage et les fonctionnalités au type d'utilisateur */
{
inti=3;
charid,mdp[31]="mettez20svp",mdpatrouve[31];/* Déclaration d'un motdepasse administrateur */
system("clear");
printf("\t################################ Bienvenue! ################################\nSouhaitez-vous vous connecter en tant qu'utilisateur ou administeur ? (C/A)\nSaisie : ");
scanf("%c%*c",&id);
if(id=='q')/* Si l'utilisateur saisie la lettre 'q', le programme s'arrête */
{
return-1;
}
while(id!='A'&&id!='a'&&id!='C'&&id!='c')/* Effectue une saisie contrôlée si la saisie ne correspond à aucune option */
{
system("clear");
printf("\t#################### Mauvaise saisie ('q' pour quitter) ####################\nSouhaitez-vous vous connecter en tant qu'utilisateur ou administeur? (C/A)\nSaisie : ");
scanf("%c%*c",&id);
if(id=='q')
{
return-1;
}
}
if(id=='A'||id=='a')/* Si l'utilisateur sélectionne administrateur, il doit ensuit taper le mot de passe */
{
while(i!=0)
{
printf("\n\nMot de passe : ");
system("stty -echo");/* On masque la saisie pour saisir le mot de passe */
fgets(mdpatrouve,31,stdin);
mdpatrouve[strlen(mdpatrouve)-1]='\0';
printf("\n");
if(strcmp(mdpatrouve,mdp)==0)/* Si le mot de passe est bon, la fonction retourne 1 */
{
system("stty echo");
system("clear");
return1;
}
else/* Si le mot de passe est faux, l'utilisateur dispose de 2 essais supplémentaire */
{
i--;
printf("Mot de passe incorrect, il vous reste %d chances\n",i);
}
system("stty echo");
}
return-1;
}
else/* Si l'utilisateur sélectionne candidat, la fonction retourne 0 */
{
system("clear");
return0;
}
}
voidmenuAdmin(VilleIUT*tiut[],int*tLog,inttMax)/* Affiche un menu de choix adaptés pour un administrateur et appelle les fonctions en conséquence */
voidglobale(void)/* Permet l'initialisation du tableau, le chargement de celui-ci et l'appel des fonctions login, menus et enregistrement */
{
inttLog,retour;
VilleIUT*tiut[100];/* Déclaration du tableau de pointeurs tiut */
if(tiut==NULL)/* En cas de problème de mémoire, affiche un message d'erreur et quitte le programme */
{
printf("Problème d'allocation mémoire du tableau tiut\n");
exit(1);
}
tLog=chargement(tiut,100);/* Effectue le chargement du tableau tiut */
if(tLog<0)/* En cas de problème avec le chargement, affiche un message d'erreur et quitte le programme */
{
printf("Le programme ne peut pas fonctionner\n");
exit(1);
}
retour=login();/* Appelle la fonction login */
while(retour!=-1)/* Tant que login ne retourne pas -1, la fonction appelle le menu adaptée en fonction du retour de login puis appelle de nouveau login */
{
if(retour==1)
{
menuAdmin(tiut,&tLog,100);
}
if(retour==0)
{
menuCandidat(tiut,&tLog,100);
}
retour=login();
}
enregistrement(tiut,tLog);
}
voidenregistrement(VilleIUT*tiut[],inttLog)/* Permet l'enregistrement du tableau tiut dans le fichier IUT.don */
{
inti;
FILE*flot;
flot=fopen("IUT.don","w");/* Ouverture du fichier IUT.don dans la variable flot */
if(flot==NULL)/* En cas d'erreur de l'ouverture du fichier, affiche un message d'erreur, ferme le fichier et quitte la fonction */
{
printf("Erreur de l'enregistrement du fichier\n");
fclose(flot);
return;
}
while(i<tLog)/* Boucle allant jusqu'à la dernière ville du tableau */
{
while(tiut[i]->lDept!=NULL)/* Boucle allant jusqu'au dernier département de la ville */
{
fprintf(flot,"%s\t%s\t%d\t%s\n",tiut[i]->nom,tiut[i]->lDept->d.dept,tiut[i]->lDept->d.nbP,tiut[i]->lDept->d.respAd);/* Écriture dans le fichier */
tiut[i]->lDept=tiut[i]->lDept->suiv;
}
i++;/* Incrémentation de l'indice i pour passer à la ville suivante */
Sami GHEBRID
2 years ago