You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1227 lines
33 KiB
1227 lines
33 KiB
#include "SAE.h"
|
|
//#include "SAEl.h"
|
|
|
|
bool motdepasseVerif(void)
|
|
{
|
|
char mdp[10];
|
|
int i=4;
|
|
while(i > 0)
|
|
{
|
|
printf("entrer le mot de passe administrateur : ");
|
|
system("stty -echo");
|
|
scanf("%s",mdp);
|
|
system("stty echo");
|
|
if (strcmp(mdp,"123456") == 0)
|
|
{
|
|
system("clear");
|
|
return true;
|
|
}
|
|
system("clear");
|
|
printf("\n! mots de passe faux !\n");
|
|
i = i - 1;
|
|
printf("\n! il vous reste %d tentative/s !\n",i);
|
|
}
|
|
printf("Vous avez effectuer trop de tentative retour au menu Utilisateur !\n");
|
|
return false;
|
|
}
|
|
|
|
bool verifQuit(void)
|
|
{
|
|
char choix[4];
|
|
while(1)
|
|
{
|
|
system("clear");
|
|
printf("Êtes-vous sûr de vouloir quitter ? (oui|non) : ");
|
|
scanf("%s",choix);
|
|
if (strcmp(choix,"oui")==0)
|
|
return true;
|
|
if (strcmp(choix,"non")==0)
|
|
return false;
|
|
printf("Erreur de sélection ! Veuillez réessayer \n");
|
|
}
|
|
}
|
|
|
|
bool verifSelection(void)
|
|
{
|
|
char choix[4];
|
|
while(1)
|
|
{
|
|
printf("Voulez-vous continué la sélection (oui|non) : ");
|
|
scanf("%s",choix);
|
|
if (strcmp(choix,"oui")==0)
|
|
return true;
|
|
if (strcmp(choix,"non")==0)
|
|
return false;
|
|
printf("Erreur de sélection ! Veuillez réessayer \n");
|
|
}
|
|
}
|
|
|
|
bool confirmationSup(void)
|
|
{
|
|
char choix[4];
|
|
while(1)
|
|
{
|
|
printf("Êtes-vous sûr de vouloir supprimer/moddifié : ");
|
|
scanf("%s", choix);
|
|
if (strcmp(choix,"oui")==0)
|
|
return true;
|
|
if (strcmp(choix,"non")==0)
|
|
return false;
|
|
printf("Erreur de sélection ! Veuillez réessayer \n");
|
|
}
|
|
|
|
}
|
|
|
|
int menuUtilisateurAffiche(void)
|
|
{
|
|
int choix;
|
|
printf("####################################################\n");
|
|
printf("\t\t|Menu Utilisateur|\n");
|
|
printf("\t\t------------------\n\n");
|
|
printf("1 - Consultation des IUT\n");
|
|
printf("2 - Consultation des département global par IUT\n");
|
|
printf("3 - Consultation du nombre de places pour un Département par IUT\n");
|
|
printf("4 - Consultation du nombre de places pour un Département dans un IUT\n");
|
|
printf("5 - Consultation des départements dans un IUT\n");
|
|
printf("6 - Consultation de tout les IUT ayant un département choisi\n");
|
|
printf("7 - Consultation de toute les informations des Département par IUT");
|
|
printf("\n\n9 - Connexion mode Administrateur\n");
|
|
printf("\n\n10 - Quitter\n");
|
|
printf("####################################################\n");
|
|
printf("\nSelection : ");
|
|
scanf("%d",&choix);
|
|
return choix;
|
|
}
|
|
|
|
int menuAdminAffiche(void)
|
|
{
|
|
int choix;
|
|
printf("####################################################\n");
|
|
printf("\t\t|Menu Administrateur|\n\n");
|
|
printf("\t\t---------------------\n\n");
|
|
printf("1 - Mise à jour nombre de Places d'un Département d'un IUT\n");
|
|
printf("2 - Création d'un département dans un IUT\n");
|
|
printf("3 - Suppression d'un département dans un IUT\n");
|
|
printf("4 - Gestion des phases de candidature\n");
|
|
printf("5 - Changement d'un responsable de département\n");
|
|
printf("\n\n9 - Repasser en mode Utilisateur");
|
|
printf("\n\n10 - Quitter\n");
|
|
printf("####################################################\n");
|
|
printf("\nSelection : ");
|
|
scanf("%d",&choix);
|
|
return choix;
|
|
}
|
|
|
|
void gestionMenu(VilleIUT **tiut, int nbEle)
|
|
{
|
|
int choix;
|
|
while(1)
|
|
{
|
|
choix = menuUtilisateurAffiche();
|
|
system("clear");
|
|
switch(choix) {
|
|
case 1:
|
|
AffichageVille(tiut,nbEle);
|
|
clearpage();
|
|
break;
|
|
case 2:
|
|
AffichageGlobalDepVille(tiut, nbEle);
|
|
clearpage();
|
|
break;
|
|
case 3:
|
|
AffichageNbplaceDept(tiut, nbEle);
|
|
clearpage();
|
|
break;
|
|
case 4:
|
|
AffichageNbplaceDeptVille(tiut, nbEle);
|
|
clearpage();
|
|
break;
|
|
case 5:
|
|
AffichageDepVille(tiut, nbEle);
|
|
clearpage();
|
|
break;
|
|
case 6:
|
|
AffichageDeptVille(tiut, nbEle);
|
|
clearpage();
|
|
break;
|
|
case 7:
|
|
AffichageGlobalIUT(tiut, nbEle);
|
|
clearpage();
|
|
break;
|
|
case 9:
|
|
choix = gestionMenuAdmin(tiut, nbEle);
|
|
if (choix == -1)
|
|
if (verifQuit()) return;
|
|
break;
|
|
case 10:
|
|
if (verifQuit()) return;
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
int gestionMenuAdmin(VilleIUT **tiut, int nbEle)
|
|
{
|
|
int choix;
|
|
if (!motdepasseVerif())
|
|
return 0;
|
|
while(1)
|
|
{
|
|
choix = menuAdminAffiche();
|
|
system("clear");
|
|
switch(choix){
|
|
case 1:
|
|
MiseAJourNbPlace(tiut, nbEle);
|
|
system("clear");
|
|
break;
|
|
case 2:
|
|
creationDept(tiut, nbEle);
|
|
system("clear");
|
|
break;
|
|
case 3:
|
|
suppressionDept(tiut, nbEle);
|
|
system("clear");
|
|
break;
|
|
case 4:
|
|
//affichage du nombres de places par département d'un iut
|
|
clearpage();
|
|
break;
|
|
case 5:
|
|
modifChefDept(tiut, nbEle);
|
|
system("clear");
|
|
break;
|
|
case 9:
|
|
return 0;
|
|
case 10:
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
void global(void)
|
|
{
|
|
/*int tailleL, i;
|
|
VilleIUT** tab;
|
|
char nomFich[20];
|
|
strcpy(nomFich,"iut.txt");
|
|
printf("charg\n");
|
|
tab = chargementVille(nomFich,30,&tailleL);
|
|
printf("\n");
|
|
gestionMenu(tab, tailleL);
|
|
SauvegardeIUT(tab, tailleL)
|
|
*/
|
|
int tphys, nb;
|
|
Candidat **tab;
|
|
tab = chargmentCandid("candidature.txt", &tphys, &nb);
|
|
system("clear");
|
|
afficherCandid(tab, nb);
|
|
supprimerCandid(tab, &nb);
|
|
afficherCandid(tab, nb);
|
|
creationCandid(tab, &nb, &tphys);
|
|
afficherCandid(tab, nb);
|
|
|
|
}
|
|
|
|
void AffichageVille(VilleIUT **tiut, int nbEle)
|
|
{
|
|
int i;
|
|
printf("\tIUT par ville :\n");
|
|
for(i=0;i<nbEle;i++)
|
|
{
|
|
printf("- %s\n\t",tiut[i]->ville);
|
|
}
|
|
}
|
|
|
|
void AffichageGlobalDepVille(VilleIUT **tiut, int nbEle)
|
|
{
|
|
int i;
|
|
MaillonDept *aux;
|
|
printf("\tDépartement par IUT :\n");
|
|
for(i=0;i<nbEle;i++)
|
|
{
|
|
printf("%s :\n", tiut[i]->ville);
|
|
aux = tiut[i]->idDept;
|
|
while(aux != NULL)
|
|
{
|
|
printf("|%s|\n",aux->departement);
|
|
aux = aux->suiv;
|
|
}
|
|
}
|
|
}
|
|
|
|
void AffichageNbplaceDept(VilleIUT **tiut, int nbEle)
|
|
{
|
|
int pos;
|
|
MaillonDept *aux;
|
|
for (pos = 0; pos < nbEle; pos++)
|
|
{
|
|
printf("%s -> \t", tiut[pos]->ville);
|
|
aux = tiut[pos]->idDept;
|
|
while(aux->suiv != NULL && pos < nbEle)
|
|
{
|
|
printf("|%s, %d places|\n\t",aux->departement, aux->nbPers);
|
|
aux = aux->suiv;
|
|
}
|
|
printf("\n");
|
|
}
|
|
}
|
|
|
|
int rechVille(VilleIUT **tiut, int nbEle, char code[], int *trouve)
|
|
{
|
|
int inf = 0, sup = nbEle - 1, m;
|
|
while(inf <= sup)
|
|
{
|
|
m = (inf + sup)/2;
|
|
if (strcmp(tiut[m]->ville, code)==0)
|
|
{
|
|
*trouve = 1;
|
|
return m;
|
|
}
|
|
if (strcmp(tiut[m]->ville, code)>0)
|
|
sup = m - 1;
|
|
else inf = m + 1;
|
|
}
|
|
*trouve = 0;
|
|
return inf;
|
|
}
|
|
|
|
void AffichageNbplaceDeptVille(VilleIUT **tiut, int nbEle)
|
|
{
|
|
MaillonDept *aux;
|
|
char code[30];
|
|
int pos,trouve = 0;
|
|
while(1)
|
|
{
|
|
printf("IUT : ");
|
|
scanf("%s",code);
|
|
pos = rechVille(tiut, nbEle, code,&trouve);
|
|
if (trouve == 1)
|
|
|
|
{
|
|
while(1)
|
|
{
|
|
printf("Département : ");
|
|
scanf("%s",code);
|
|
trouve = 0;
|
|
aux = rechercheDept(tiut[pos]->idDept, code);
|
|
if (aux == NULL)
|
|
printf("Département non présent à l'iut de %s",tiut[pos]->ville);
|
|
if (aux != NULL)
|
|
printf("%s -> |%s, %d places|\n",tiut[pos]->ville,aux->departement, aux->nbPers);
|
|
printf("Saisi Département :\n");
|
|
if(!verifSelection())
|
|
break;
|
|
}
|
|
}
|
|
if (trouve == 0) printf("%s n'a pas d'IUT\n",code);
|
|
printf("Saisi Département :\n");
|
|
if(!verifSelection())
|
|
break;
|
|
}
|
|
}
|
|
|
|
void AffichageDepVille(VilleIUT **tiut, int nbEle)
|
|
{
|
|
char code[30];
|
|
int pos,trouve = 0;
|
|
while(1)
|
|
{
|
|
printf("IUT : ");
|
|
scanf("%s",code);
|
|
pos = rechVille(tiut, nbEle, code,&trouve);
|
|
if (trouve == 1)
|
|
{
|
|
printf("%s :\n\t",tiut[pos]->ville);
|
|
affichageListeDept(tiut[pos]->idDept);
|
|
}
|
|
if (trouve == 0)
|
|
printf("%s n'a pas d'IUT\n",code);
|
|
printf("Saisi Ville :\n");
|
|
if(!verifSelection())
|
|
break;
|
|
}
|
|
}
|
|
|
|
void AffichageDeptVille(VilleIUT **tiut, int nbEle)
|
|
{
|
|
MaillonDept *aux;
|
|
char code[30];
|
|
int pos = 0, nbocc = 0;
|
|
while(1)
|
|
{
|
|
printf("département : ");
|
|
scanf("%s",code);
|
|
printf("\nIUT ayant un département %s : \n",code);
|
|
for(pos = 0; pos < nbEle; pos++)
|
|
{
|
|
aux = rechercheDept(tiut[pos]->idDept, code);
|
|
if(aux != NULL)
|
|
{
|
|
printf("- %s\n", tiut[pos]->ville);
|
|
nbocc = nbocc + 1;
|
|
}
|
|
}
|
|
if (nbocc == 0)
|
|
printf("aucun département %s est présent en France\n", code);
|
|
printf("Saisi Département :\n");
|
|
if(!verifSelection())
|
|
break;
|
|
}
|
|
}
|
|
|
|
void AffichageGlobalIUT(VilleIUT **tiut, int nbEle)
|
|
{
|
|
int pos = 0;
|
|
printf("Ville : \t");
|
|
while(pos < nbEle)
|
|
{
|
|
printf("-%s \n", tiut[pos]->ville);
|
|
printf("Département:\tNombre de places:\tNom du Responsable:\n");
|
|
affichageListeDept(tiut[pos]->idDept);
|
|
pos = pos + 1;
|
|
printf("\n");
|
|
}
|
|
}
|
|
|
|
void MiseAJourNbPlace(VilleIUT **tiut, int nbEle)
|
|
{
|
|
MaillonDept *aux;
|
|
int nouvNbPlace, pos, trouve;
|
|
char code[30];
|
|
while(1)
|
|
{
|
|
printf("IUT : ");
|
|
scanf("%s",code);
|
|
pos = rechVille(tiut, nbEle, code,&trouve);
|
|
if (trouve == 1)
|
|
{
|
|
while(1)
|
|
{
|
|
printf("Département : ");
|
|
scanf("%s",code);
|
|
aux = rechercheDept(tiut[pos]->idDept, code);
|
|
if (aux != NULL)
|
|
{
|
|
printf("Ancien nombre de places : %d\n",aux->nbPers);
|
|
printf("Nouveau nombre de places : ");
|
|
scanf("%d", &nouvNbPlace);
|
|
aux->nbPers = nouvNbPlace;
|
|
printf("Mise à jour effectuer avec succès !");
|
|
break;
|
|
}
|
|
if (aux == NULL)
|
|
printf("Département non présent à l'iut de %s",tiut[pos]->ville);
|
|
printf("Saisi Département :\n");
|
|
if(!verifSelection())
|
|
break;
|
|
}
|
|
}
|
|
if (trouve == 0)
|
|
printf("Cet ville n'a pas d'IUT\n");
|
|
printf("Saisi Ville :\n");
|
|
if(!verifSelection())
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
void creationDept(VilleIUT **tiut, int nbEle)
|
|
{
|
|
MaillonDept *aux;
|
|
char code[30], nom[30];
|
|
int trouve, pos, nbP;
|
|
while(1)
|
|
{
|
|
printf("Dans quel IUT voulez-vous créer un département : ");
|
|
scanf("%s", code);
|
|
pos = rechVille(tiut, nbEle, code, &trouve);
|
|
if (trouve == 1)
|
|
{
|
|
while(1)
|
|
{
|
|
printf("Nom du Département : ");
|
|
scanf("%s", code);
|
|
aux = rechercheDept(tiut[pos]->idDept, code);
|
|
if (aux != NULL)
|
|
printf("Département déjà existant\n");
|
|
if (aux == NULL)
|
|
{
|
|
printf("Nom du Responsable du Département de %s : ",code);
|
|
fgets(nom,30,stdin);
|
|
nom[strlen(nom)-1] = '\0';
|
|
printf("Nombre de place du Département %s : ",code);
|
|
scanf("%d", &nbP);
|
|
tiut[pos]->idDept = insererDept(tiut[pos]->idDept,code,nom,nbP);
|
|
printf("insertion du département %s effectuer \n", code);
|
|
}
|
|
printf("Saisi Département :\n");
|
|
if (!verifSelection())
|
|
break;
|
|
}
|
|
}
|
|
if (trouve == 0)
|
|
printf("Cet ville n'a pas d'IUT\n");
|
|
printf("Saisi Ville :\n");
|
|
if(!verifSelection())
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void suppressionDept(VilleIUT **tiut, int nbEle)
|
|
{
|
|
MaillonDept *aux;
|
|
char code[30];
|
|
int trouve, pos;
|
|
while(1)
|
|
{
|
|
printf("Dans quel IUT voulez-vous supprimer un département : ");
|
|
scanf("%s", code);
|
|
pos = rechVille(tiut, nbEle, code, &trouve);
|
|
if (trouve == 1)
|
|
{
|
|
printf("Nom du Département : ");
|
|
scanf("%s", code);
|
|
aux = rechercheDept(tiut[pos]->idDept, code);
|
|
if (aux != NULL)
|
|
if (confirmationSup())
|
|
tiut[pos]->idDept = supprimerDept(tiut[pos]->idDept, code);
|
|
if (aux == NULL)
|
|
printf("Ce Département n'existe pas dans l'IUT de %s \n",tiut[pos]->ville);
|
|
printf("Saisi Département :\n");
|
|
if (!verifSelection())
|
|
break;
|
|
}
|
|
if (trouve == 0)
|
|
printf("Cet ville n'a pas d'IUT\n");
|
|
printf("Saisi Ville :\n");
|
|
if (!verifSelection())
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
void modifChefDept(VilleIUT **tiut, int nbEle)
|
|
{
|
|
MaillonDept *aux;
|
|
char code[30];
|
|
int trouve, pos;
|
|
while(1)
|
|
{
|
|
printf("Dans quel IUT voulez-vous modifier le chef de département : ");
|
|
scanf("%s", code);
|
|
pos = rechVille(tiut, nbEle, code, &trouve);
|
|
if (trouve == 1)
|
|
{
|
|
printf("Nom du Département : ");
|
|
scanf("%s%*c", code);
|
|
aux = rechercheDept(tiut[pos]->idDept, code);
|
|
if (aux != NULL)
|
|
{
|
|
printf("Nom de l'ancien chef de département %s de %s : %s\n",aux->departement, tiut[pos]->ville,aux->responsable);
|
|
printf("Nom du nouveau chef de département %s de %s :",aux->departement, tiut[pos]->ville);
|
|
fgets(code,30,stdin);
|
|
code[strlen(code)-1] = '\0';
|
|
strcpy(aux->responsable, code);
|
|
printf("Chef de département : %s\n",aux->responsable);
|
|
}
|
|
if (aux == NULL)
|
|
printf("Ce Département n'existe pas dans l'IUT de %s \n",tiut[pos]->ville);
|
|
printf("Saisi Département :\n");
|
|
if (!verifSelection())
|
|
break;
|
|
}
|
|
if (trouve == 0)
|
|
printf("Cet ville n'a pas d'IUT\n");
|
|
printf("Saisi Ville :\n");
|
|
if (!verifSelection())
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
void triEchange(VilleIUT **tiut, int nbEle)
|
|
{
|
|
int pge;
|
|
while(nbEle>1)
|
|
{
|
|
pge = plusGrand(tiut, nbEle);
|
|
echanger(tiut,pge,nbEle-1);
|
|
nbEle = nbEle - 1;
|
|
}
|
|
}
|
|
|
|
int plusGrand(VilleIUT **tiut, int nbEle)
|
|
{
|
|
int pge = 0, i;
|
|
for (i = 1; i < nbEle; i++)
|
|
if (strcmp(tiut[i]->ville,tiut[pge]->ville)>0)
|
|
pge = i;
|
|
return pge;
|
|
}
|
|
|
|
void echanger(VilleIUT **tiut, int i, int j)
|
|
{
|
|
VilleIUT *aux;
|
|
aux = tiut[i];
|
|
tiut[i] = tiut[j];
|
|
tiut[j] = aux;
|
|
}
|
|
|
|
|
|
void clearpage(void)
|
|
{
|
|
char entre;
|
|
printf("\nappuyé sur la touche [ENTREE] pour continuer");
|
|
scanf("%*c%c", &entre);
|
|
system("clear");
|
|
}
|
|
|
|
ListeCandid ListeCandidvide(void)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
ListeCandid insererEnTeteCandid(ListeCandid l, char *ville, ChoixDept **tDept, int nbEle)
|
|
{
|
|
MaillonCandid *m;
|
|
m = (MaillonCandid *)malloc(sizeof(MaillonCandid));
|
|
if (m == NULL)
|
|
{
|
|
printf("Pb maillon");
|
|
exit(1);
|
|
}
|
|
strcpy(m->iutCandid, ville);
|
|
m->nbChoix = nbEle;
|
|
m->tabDept = tDept;
|
|
m->suiv = l;
|
|
return m;
|
|
}
|
|
|
|
ListeCandid insererCandid(ListeCandid l, char *ville, ChoixDept **tDept, int nbEle)
|
|
{
|
|
if (l == NULL)
|
|
return insererEnTeteCandid(l, ville, tDept, nbEle);
|
|
if (strcmp(ville, l->iutCandid) < 0)
|
|
return insererEnTeteCandid(l, ville, tDept, nbEle);
|
|
if (strcmp(ville, l->iutCandid) == 0)
|
|
return l;
|
|
l->suiv = insererCandid(l->suiv, ville, tDept, nbEle);
|
|
return l;
|
|
}
|
|
|
|
int rechCandiDept(ChoixDept **tDept, int tailleL, char dept[], int *trouve)
|
|
{
|
|
int inf = 0, sup = tailleL + 1, m;
|
|
while(inf <= sup)
|
|
{
|
|
m = (inf + sup)/2;
|
|
if (strcmp(tDept[m]->departement, dept)==0)
|
|
{
|
|
*trouve = 1;
|
|
return m;
|
|
}
|
|
if (strcmp(tDept[m]->departement, dept)<0)
|
|
sup = m-1;
|
|
else inf = m+1;
|
|
}
|
|
*trouve = 0;
|
|
return inf;
|
|
}
|
|
|
|
int plusGrandCandidDept(ChoixDept **tDept, int tailleL)
|
|
{
|
|
int pge = 0, i;
|
|
for (i = 1; i < tailleL; i++)
|
|
{
|
|
if(strcmp(tDept[i]->departement, tDept[pge]->departement)>0)
|
|
pge = i;
|
|
return pge;
|
|
}
|
|
}
|
|
|
|
void echangerCandidDept(ChoixDept **tDept, int i, int j)
|
|
{
|
|
ChoixDept *aux;
|
|
aux = tDept[i];
|
|
tDept[i] = tDept[j];
|
|
tDept[j] = aux;
|
|
}
|
|
|
|
void triEchangeCandidDept(ChoixDept **tDept, int tailleL)
|
|
{
|
|
int pge;
|
|
while(tailleL > 1)
|
|
{
|
|
pge = plusGrandCandidDept(tDept, tailleL);
|
|
echangerCandidDept(tDept, pge, tailleL - 1);
|
|
tailleL = tailleL - 1;
|
|
}
|
|
}
|
|
|
|
void videTabDept(ChoixDept **tDept, int tailleP)
|
|
{
|
|
ChoixDept *aux;
|
|
int i;
|
|
for (i=tailleP - 1; i >= 0; i--)
|
|
{
|
|
aux = tDept[i];
|
|
free(aux);
|
|
}
|
|
}
|
|
|
|
ListeCandid suppressionEnTeteCandid(ListeCandid l , ChoixDept **tDept, int tailleP)
|
|
{
|
|
MaillonCandid *aux;
|
|
if(l == NULL)
|
|
{
|
|
printf("opération interdite !\n");
|
|
exit(1);
|
|
}
|
|
aux = l;
|
|
videTabDept(tDept, tailleP);
|
|
l = l->suiv;
|
|
free(aux);
|
|
return l;
|
|
}
|
|
|
|
ListeCandid suppressionCandid(ListeCandid l, char *ville, ChoixDept **tDept, int tailleP)
|
|
{
|
|
if (l == NULL)
|
|
return l;
|
|
if (strcmp(ville, l->iutCandid) < 0)
|
|
return l;
|
|
if (strcmp(ville, l->iutCandid) == 0)
|
|
return suppressionEnTeteCandid(l, tDept, tailleP);
|
|
l->suiv = suppressionCandid(l->suiv, ville, tDept, tailleP);
|
|
return l;
|
|
}
|
|
|
|
void afficherCandid(Candidat **tab, int nbEle)
|
|
{
|
|
int i;
|
|
for (i=0; i < nbEle; i++)
|
|
{
|
|
printf("%d %s %s |%.1f %.1f %.1f %.1f|\n", tab[i]->id, tab[i]->nom, tab[i]->prenom, tab[i]->note[0], tab[i]->note[1], tab[i]->note[2], tab[i]->note[3]);
|
|
afficherCandidIUT(tab[i]->idCandIUT);
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
void afficherCandidIUT(ListeCandid l)
|
|
{
|
|
if (l == NULL)
|
|
return;
|
|
printf("%s : %d\n", l->iutCandid,l->nbChoix);
|
|
afficherCandidDept(l->tabDept, l->nbChoix);
|
|
l=l->suiv;
|
|
return afficherCandidIUT(l);
|
|
}
|
|
|
|
void afficherCandidDept(ChoixDept **tab, int nbChoix)
|
|
{
|
|
int i;
|
|
for (i=0; i < nbChoix; i++)
|
|
{
|
|
printf("|%s %d %d|\n", tab[i]->departement, tab[i]->decisionDept, tab[i]->decisionCandid);
|
|
}
|
|
}
|
|
int longueur(ListeCandid l)
|
|
{
|
|
if(l==NULL)
|
|
return 0;
|
|
return 1 + longueur(l->suiv);
|
|
}
|
|
|
|
Candidat **chargmentCandid(char *nomFich, int *tphys, int *tailleL)
|
|
{
|
|
int i = 0, j = 0, nbIUT, nbDept;
|
|
FILE *flot;
|
|
Candidat **tcandid;
|
|
flot = fopen(nomFich, "r");
|
|
if (flot == NULL)
|
|
{
|
|
printf("Problèmes d'ouverture de fichier !\n");
|
|
exit(1);
|
|
}
|
|
fscanf(flot,"%d",tphys);
|
|
*tphys = *tphys + 10;
|
|
tcandid = (Candidat **)malloc(sizeof(Candidat *) * *tphys);
|
|
if (tcandid == NULL)
|
|
{
|
|
printf("Erreur malloc tcandid !\n");
|
|
exit(1);
|
|
}
|
|
*tailleL = 0;
|
|
tcandid[*tailleL] = (Candidat *)malloc(sizeof(Candidat));
|
|
if (tcandid[*tailleL] == NULL)
|
|
{
|
|
printf("Erreur malloc candidat !\n");
|
|
fclose(flot);
|
|
exit(1);
|
|
}
|
|
*(tcandid[*tailleL]) = lireCandidat(flot);
|
|
while(!feof(flot))
|
|
{
|
|
fscanf(flot, "%d", &nbIUT);
|
|
printf("%d\n", nbIUT);
|
|
tcandid[*tailleL]->idCandIUT = ListeCandidvide();
|
|
while(i < nbIUT)
|
|
{
|
|
tcandid[*tailleL]->idCandIUT = traiterCandidIUT(tcandid[*tailleL]->idCandIUT, flot);
|
|
i = i + 1;
|
|
}
|
|
i = 0;
|
|
*tailleL = *tailleL + 1;
|
|
tcandid[*tailleL] = (Candidat *)malloc(sizeof(Candidat));
|
|
if (tcandid[*tailleL] == NULL)
|
|
{
|
|
printf("Erreur malloc candidat !\n");
|
|
fclose(flot);
|
|
exit(1);
|
|
}
|
|
printf("\n\n");
|
|
*(tcandid[*tailleL]) = lireCandidat(flot);
|
|
}
|
|
if (tailleL == 0)
|
|
printf("Fichier vide !\n");
|
|
fclose(flot);
|
|
return tcandid;
|
|
}
|
|
|
|
Candidat lireCandidat(FILE *flot)
|
|
{
|
|
Candidat c;
|
|
fscanf(flot,"%d",&c.id);
|
|
fscanf(flot,"%s%*c",c.nom);
|
|
fgets(c.prenom,30,flot);
|
|
c.prenom[strlen(c.prenom) - 1] = '\0';
|
|
fscanf(flot, "%f %f %f %f", &c.note[0], &c.note[1], &c.note[2], &c.note[3]);
|
|
printf("%d %s %s %.1f %.1f %.1f %.1f\n", c.id, c.nom, c.prenom, c.note[0], c.note[1], c.note[2], c.note[3]);
|
|
return c;
|
|
}
|
|
|
|
ListeCandid traiterCandidIUT(ListeCandid l, FILE *flot)
|
|
{
|
|
char ville[30];
|
|
int nbDept, i=0;
|
|
ChoixDept **tDept;
|
|
fscanf(flot,"%s",ville);
|
|
fscanf(flot, "%d", &nbDept);
|
|
printf("%s |%d|\n", ville, nbDept);
|
|
tDept = (ChoixDept **)malloc(sizeof(ChoixDept *)*(nbDept + 10));
|
|
if(tDept == NULL)
|
|
{
|
|
printf("Pb malloc candidIUt\n");
|
|
exit(1);
|
|
}
|
|
while (i < nbDept)
|
|
{
|
|
tDept[i] = traiterCandidDept(i, nbDept, flot);
|
|
i = i + 1;
|
|
}
|
|
l = insererCandid(l , ville , tDept, nbDept);
|
|
return l;
|
|
}
|
|
|
|
ChoixDept *traiterCandidDept(int tailleL, int tailleP, FILE *flot)
|
|
{
|
|
ChoixDept *cD;
|
|
char dept[30];
|
|
int deciDept, deciCandid;
|
|
cD = (ChoixDept *)malloc(sizeof(ChoixDept));
|
|
if (cD == NULL)
|
|
{
|
|
printf("Pb malloc");
|
|
exit(1);
|
|
}
|
|
fscanf(flot,"%s", dept);
|
|
fscanf(flot,"%d", &deciDept);
|
|
fscanf(flot,"%d",&deciCandid);
|
|
strcpy(cD->departement, dept);
|
|
cD->decisionDept = deciDept;
|
|
cD->decisionCandid = deciCandid;
|
|
printf("|%s %d %d|\n", cD->departement, cD->decisionDept, cD->decisionCandid);
|
|
return cD;
|
|
}
|
|
|
|
int rechCandid(Candidat **tab, int nbEle, int id, int *trouve)
|
|
{
|
|
int i;
|
|
for (i=0; i < nbEle; i++)
|
|
{
|
|
if (tab[i]->id == id)
|
|
{
|
|
*trouve = 1;
|
|
return i;
|
|
}
|
|
if (tab[i]->id > id)
|
|
{
|
|
*trouve = 0;
|
|
return i;
|
|
}
|
|
}
|
|
*trouve = 0;
|
|
return nbEle - 1;
|
|
}
|
|
|
|
void triEchangecandid(Candidat **tab, int nbEle)
|
|
{
|
|
int pge;
|
|
while(nbEle > 1)
|
|
{
|
|
pge = plusGrandCandid(tab, nbEle);
|
|
echangerCandid(tab, pge, nbEle - 1);
|
|
nbEle = nbEle - 1;
|
|
}
|
|
}
|
|
|
|
int plusGrandCandid(Candidat **tab, int nbEle)
|
|
{
|
|
int pge = 0, i;
|
|
for (i = 1; i < nbEle; i++)
|
|
{
|
|
if(tab[i]->id > tab[pge]->id)
|
|
{
|
|
pge = i;
|
|
}
|
|
return pge;
|
|
}
|
|
}
|
|
|
|
void echangerCandid(Candidat **tab, int i, int j)
|
|
{
|
|
Candidat *aux;
|
|
aux = tab[i];
|
|
tab[i] = tab[j];
|
|
tab[j] = aux;
|
|
}
|
|
|
|
ListeCandid rechCandidIUT(ListeCandid l, char *code)
|
|
{
|
|
if (l == NULL)
|
|
return NULL;
|
|
if ((strcmp(code, l->iutCandid)) < 0)
|
|
return NULL;
|
|
if ((strcmp(code, l->iutCandid)) == 0)
|
|
return l;
|
|
return rechCandidIUT(l->suiv, code);
|
|
}
|
|
|
|
void supprimerCandid(Candidat **tab, int *nbEle)
|
|
{
|
|
int idSup, pos, trouve;
|
|
while(1)
|
|
{
|
|
printf("Identifiant de la candidiature à supprimer : ");
|
|
scanf("%d", &idSup);
|
|
pos = rechCandid(tab, *nbEle, idSup, &trouve);
|
|
if (trouve == 0)
|
|
{
|
|
printf("Candidature non présente dans la base de donnée\n");
|
|
break;
|
|
}
|
|
if (trouve == 1)
|
|
if (!confirmationSup())
|
|
return;
|
|
while(tab[pos]->idCandIUT != NULL)
|
|
{
|
|
suppressionCandid(tab[pos]->idCandIUT, tab[pos]->idCandIUT->iutCandid, tab[pos]->idCandIUT->tabDept, tab[pos]->idCandIUT->nbChoix);
|
|
tab[pos]->idCandIUT = tab[pos]->idCandIUT->suiv;
|
|
}
|
|
*nbEle = *nbEle - 1;
|
|
free(tab[pos]);
|
|
triEchangecandid(tab, *nbEle + 1);
|
|
return;
|
|
|
|
if(!verifSelection())
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
|
|
Candidat **reallocTCandid(Candidat **tab, int *tailleP)
|
|
{
|
|
Candidat **aux;
|
|
*tailleP = *tailleP + 1;
|
|
aux = (Candidat **)realloc(tab, *tailleP * sizeof(Candidat *));
|
|
if (aux == NULL)
|
|
{
|
|
printf("Erreur realloc\n");
|
|
exit(1);
|
|
}
|
|
return aux;
|
|
}
|
|
|
|
void creationCandid(Candidat **tab, int *nbEle, int *tailleP)
|
|
{
|
|
char nom[30], prenom[30], choix[4];
|
|
int idAdd, i;
|
|
Candidat c;
|
|
if (*nbEle == *tailleP)
|
|
tab = reallocTCandid(tab, tailleP);
|
|
while(1)
|
|
{
|
|
idAdd = tab[*nbEle - 1]->id + 1;
|
|
printf("Votre prénom : ");
|
|
scanf("%s%*c", prenom);
|
|
printf("Votre nom : ");
|
|
fgets(nom,30, stdin);
|
|
nom[strlen(nom) - 1] = '\0';
|
|
printf("%s %s\n", prenom, nom);
|
|
printf("vos 4 notes : ");
|
|
scanf("%f %f %f %f", &c.note[0], &c.note[1], &c.note[2], &c.note[3]);
|
|
printf("note : |%.1f|%.1f|%.1f|%.1f|\n",c.note[0], c.note[1], c.note[2], c.note[3]);
|
|
while(1)
|
|
{
|
|
printf("vous valider votre candidature (oui|non) : ");
|
|
scanf("%s", choix);
|
|
if (strcmp(choix, "oui")==0)
|
|
{
|
|
c.id = idAdd;
|
|
strcpy(c.nom, nom);
|
|
strcpy(c.prenom, prenom);
|
|
c.idCandIUT = ListeCandidvide();
|
|
*(tab[*nbEle]) = c;
|
|
*nbEle = *nbEle + 1;
|
|
printf("création terminer \n");
|
|
break;
|
|
}
|
|
if (strcmp(choix, "non")==0)
|
|
break;
|
|
}
|
|
while(1)
|
|
{
|
|
printf("voulez vous faire votre choix maintenant (oui|non) : ");
|
|
scanf("%s", choix);
|
|
if (strcmp(choix, "oui")==0)
|
|
{
|
|
printf("en construction\n");
|
|
}
|
|
if (strcmp(choix, "non")==0)
|
|
break;
|
|
}
|
|
if(!verifSelection())
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
int menuCandid(void)
|
|
{
|
|
int choix;
|
|
printf("####################################################\n");
|
|
printf("\t\t|Menu Candidature|\n");
|
|
printf("\t\t------------------\n\n");
|
|
printf("1 - Créer une Candidature\n");
|
|
printf("2 - Supprimer une Candidature\n");
|
|
printf("3 - Modifier une Candidature\n");
|
|
printf("4 - Afficher une Candidature\n");
|
|
printf("5 - Afficher toute les Candidatures\n");
|
|
printf("\n\n9 - Connexion mode Administrateur\n");
|
|
printf("\n\n10 - Quitter\n");
|
|
printf("####################################################\n");
|
|
printf("\nSelection : ");
|
|
scanf("%d",&choix);
|
|
return choix;
|
|
}
|
|
|
|
void gestionCandid(VilleIUT **tiut, int nbIUT, Candidat **tcandid, int *nbCandid, int *taillePCandid)
|
|
{
|
|
int choix;
|
|
while(1)
|
|
{
|
|
choix = menuCandid();
|
|
system("clear");
|
|
switch(choix) {
|
|
case 1:
|
|
creationCandid(tcandid, nbCandid, taillePCandid);
|
|
system("clear");
|
|
break;
|
|
case 2:
|
|
suppressionCandid(tab, nbCandid);
|
|
system("clear");
|
|
break;
|
|
case 3:
|
|
modifCandid(tiut, nbEle);
|
|
system("clear");
|
|
break;
|
|
case 4:
|
|
AffichageNbplaceDeptVille(tiut, nbEle);
|
|
clearpage();
|
|
break;
|
|
case 5:
|
|
//modif candid;
|
|
clearpage();
|
|
break;
|
|
case 9:
|
|
choix = gestionMenuAdmin(tiut, nbEle);
|
|
if (choix == -1)
|
|
if (verifQuit()) return;
|
|
break;
|
|
case 10:
|
|
if (verifQuit()) return;
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
int menuGestionCandid(void)
|
|
{
|
|
int choix;
|
|
printf("####################################################\n");
|
|
printf("\t\t|Gestion Candidature|\n");
|
|
printf("\t\t---------------------\n\n");
|
|
printf("1 - Ajouter un voeux\n");
|
|
printf("2 - Supprimer un voeux\n");
|
|
printf("\n\n9 - Retour Menu Candidature\n");
|
|
printf("####################################################\n");
|
|
printf("\nSelection : ");
|
|
scanf("%d",&choix);
|
|
return choix;
|
|
}
|
|
|
|
ListeCandid recherchecandidIUT(ListeCandid l, char code[])
|
|
{
|
|
if (l == NULL)
|
|
return NULL;
|
|
if ((strcmp(code,l->iutCandid)) < 0)
|
|
return NULL;
|
|
if (strcmp(code,l->iutCandid)==0)
|
|
return l;
|
|
return recherchecandidIUT(l->suiv, code);
|
|
}
|
|
|
|
int recherchecandidDept(ChoixDept **tab,int nbEle, char code[],int *trouve)
|
|
{
|
|
int i=0;
|
|
while(i < nbEle)
|
|
{
|
|
if ((strcmp(code,tab[i]->departement)) < 0)
|
|
{
|
|
*trouve = 0;
|
|
return -1;
|
|
}
|
|
if (strcmp(code,tab[i]->departement)==0)
|
|
{
|
|
*trouve = 1;
|
|
return i;
|
|
}
|
|
}
|
|
*trouve = 0;
|
|
return -1;
|
|
|
|
}
|
|
|
|
ChoixDept RempTabCandid(char dept[],int deciCandid ,int deciDept)
|
|
{
|
|
ChoixDept d;
|
|
strcpy(d.departement, dept);
|
|
d.decisionDept = deciDept;
|
|
d.decisionCandid = deciCandid;
|
|
return d;
|
|
|
|
}
|
|
|
|
void ajouterDept(Candidat **tcandid, int nbCandid, VilleIUT **tiut, int nbIUT, int iCandid)
|
|
{
|
|
char ville[30], departement[30];
|
|
int pos,irech, trouve;
|
|
MaillonCandid *aux;
|
|
ChoixDept **tDept;
|
|
while(1)
|
|
{
|
|
printf("Dans quel IUT voulez vous candidater : ");
|
|
scanf("%s%*c", ville);
|
|
pos = rechVille(tiut, nbIUT, ville, &trouve);
|
|
if (trouve == 0)
|
|
printf("Erreur ! IUT non référencé\n");
|
|
if(trouve == 1)
|
|
{
|
|
while(1)
|
|
{
|
|
printf("Dans quel Département voulez-vous candidater : ");
|
|
scanf("%s%*c", departement);
|
|
pos = recherchecandidDept(tiut[pos]->idDept, departement)
|
|
if (trouve == 0)
|
|
printf("Erreur ! Département non référencé\n");
|
|
if (trouve == 1)
|
|
{
|
|
aux = recherchecandidIUT(tcandid[iCandid]->idCandIUT, ville) == NULL)
|
|
{
|
|
tDept = (ChoixDept **)malloc(sizeof(ChoixDept *)*(nbDept + 5));
|
|
if(tDept == NULL)
|
|
{
|
|
printf("Pb malloc candidIUt\n");
|
|
exit(1);
|
|
}
|
|
*(tDept[0]) = RempTabCandid(departement, 0, 0);
|
|
tcandid[iCandid]->idCandIUT = insererCandid(tcandid[iCandid]->idCandIUT, ville, tDept, 1);
|
|
}
|
|
else
|
|
{
|
|
irech = recherchecandidDept(tcandid[iCandid]->idCandIUT->tabDept, tcandid[iCandid]->nbChoix, departement, &trouve);
|
|
if (trouve == 0)
|
|
{
|
|
*(tcandid[iCandid]->idCandIUT->tabDept[tcandid[iCandid]->idCandIUT->nbChoix]) = RempTabCandid(departement, 0, 0);
|
|
tcandid[iCandid]->idCandIUT->nbChoix = tcandid[iCandid]->idCandIUT->nbChoix + 1;
|
|
printf("Candidature validée !\n");
|
|
}
|
|
else
|
|
printf("vous avez déjà postuler au département %s de cette %s", departement, ville);
|
|
}
|
|
}
|
|
printf("saisie Département\n")
|
|
if(verifSelection())
|
|
break
|
|
}
|
|
}
|
|
printf("Saisie IUT\n")
|
|
if(!verifSelection())
|
|
break;
|
|
}
|
|
}
|
|
|
|
void supprimerCandidDept(Candidat **tcandid, int nbCandid, VilleIUT **tiut, int nbIUT, int iCandid)
|
|
{
|
|
char ville[30], departement[30];
|
|
int pos, trouve;
|
|
MaillonCandid *aux;
|
|
while(1)
|
|
{
|
|
printf("Dans quel IUT voulez-vous supprimer votre candidature : ");
|
|
scanf("%s%*c", ville);
|
|
aux = rechCandidIUT(tcandid[iCandid]->idCandIUT, ville);
|
|
if(aux== NULL)
|
|
printf("Aucun voeux formuler dans cette IUT\n");
|
|
else
|
|
while(1)
|
|
{
|
|
printf("Dans quel Département voulez-vous supprimer votre candidature\n");
|
|
scanf("%s%*c", departement);
|
|
pos = recherchecandidDept(aux->tabDept, aux->nbChoix, departement, &trouve);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void modifCandid(Candidat **tcandid, int nbCandid, VilleIUT **tiut, int nbIUT, int iCandid)
|
|
{
|
|
int choix, iCandid;
|
|
while(1)
|
|
{
|
|
choix = menuGestionCandid();
|
|
system("clear");
|
|
switch(choix){
|
|
case 1:
|
|
ajouterDept(tcandid, nbCandid, tiut, nbIUT, iCandid);
|
|
case 2:
|
|
supprimerCandidDept(tcandid, nbCandid, tiut, nbIUT, iCandid);
|
|
case 9:
|
|
return;
|
|
}
|
|
}
|
|
} |