ajout des fonctions de la partie 1

donneesIUT.don

@@ -0,0 +1,17 @@
+Grenoble			1
+Informatique		112 Dupont Jean
+
+Clermont-Ferrand	2
+Informatique		136 Simon Carine
+Biologie			120 Giroud Olivier
+
+Aurillac			1
+Bio-informatique	120 Mbappe Kylian
+
+Valence				2
+Chimie				97	Pogba Paul
+Physique			130 Depay Memphis
+
+Lyon				2
+Géosciences			122	Santan Dave
+Economie			135	Jean-Michel Aulas

sae1-02.c

@@ -3,157 +3,880 @@
 #include <stdlib.h>
 #include "sae1-02.h"
 
-// général 
+// Partie 1
 
-// f enregistrement 
+// PARTIE ENREGISTREMENT
+Listdept initialisation(void) {
+    return NULL;
+}
 
+VilleIUT lireVille(FILE *fe) {
+		VilleIUT v;
+		fscanf(fe, "%s %d", v.Ville, &v.nbIUT);
+		return v;
+}
 
-// Partie 1
+Listdept lireDept(FILE *fe, int nbIUT) {
+	if(nbIUT == 0) return NULL;
+	MaillonDept* d;
+	d = (MaillonDept*)malloc(sizeof(MaillonDept));
+	fscanf(fe, "%s %d", d->departement, &d->nbplace);
+	fgets(d->responsable, 31, fe);
+	d->responsable[strlen(d->responsable)-1] = '\0';
+	d->suivant = lireDept(fe, nbIUT - 1);
+	return d;
+}
+
+int chargeIUT(VilleIUT* tIUT[], int taillemax) {
+	FILE * fe = fopen("donneesIUT.don", "r");
+	int i = 0;
+	VilleIUT v;
+	Listdept d = initialisation();
+
+	if(fe == NULL) { printf("Erreur ouverture fichier \n"); return -1; }
 
+	v = lireVille(fe);
+	while(!feof(fe)) {
+		if (i == taillemax) { printf("erreur taille tableau \n"); return -1; }
+		tIUT[i] = (VilleIUT*) malloc(sizeof(VilleIUT));
+		if(tIUT[i] == NULL) { printf("erreur tab\n"); return -1; }
+		d = lireDept(fe, v.nbIUT);
+		v.ldept = d;
+		*tIUT[i] = v;
 
-void affichageVilleIUT() {
+		v = lireVille(fe);
-	printf("%s\t%s\t%d\t%s")
+		i++;
+	}
+	fclose(fe);
+	return i;
 }
 
-int rechercheVille() {
+// PARTIE UTILISATEUR //////////
 
+// villes contenant un IUT
+void afficheVilleIUT(VilleIUT *tville[], int nbville) {
+	printf("Villes contenant un IUT : \n");
+	for(int i = 0; i < nbville; i++) {
+		printf(" - %s\n", tville[i]->Ville);
+	}
 }
 
-VilleIUT lire(FILE * fe) {
+// départements de chaques IUT
-	VilleIUT v;
+void afficheDepartementsIUT(VilleIUT *tville[], int nbville) {
-	fscanf(fe, "%s", V.ville);
+	Listdept d;
-	fscanf(fe, "%s", v.Idept->departement);
+
-	fscanf(fe, "%d", v.Idept->nbplace);
+	int i = rechercheVille(tville, nbville);
-	fgets(v.Idept->responsable, 31, fe);
+	if (i == -1) return;// cas où rien est trouvé en parcourant le tableau
-	v.Idept->responsable[strlen(v.Idept->responsable)-1] = '\0';
+
-	return v;
+	d = tville[i]->ldept;
+	printf("Département(s) : \n");
+	affichageDep(d);
 }
 
-// Partie 2
+// nombre de place 
+void afficheDepNbPlace(VilleIUT *tville[], int nbville) {
+	printf("Voici le nombre de place pour chaques départements de chaques IUT : \n");
+	affichageville(tville, nbville);
+}
 
-/*
+// IUT avec un département particulier
-	( beaucoup de donnée a traité n(min 10 ; max ?)*nb candidat donc faire attention )
+void afficheIUTdepParticulier(VilleIUT *tville[], int nbville) {
-	possibilité pour le candidat pouvoir  <! table = (modifier - ajouter - supp) !>
+	char rechercheDep[31];
+	Listdept d;
+	int cpt = 0;
+	printf("Quelle département recherchez vous en particulier ? : ");
+	scanf("%s", rechercheDep);
+
+	printf("Voici les villes avec le département %s : \n", rechercheDep);
+	for (int i = 0; i < nbville; i++) {
+		d = tville[i]->ldept;
+		if(strcmp(rechercheDep, d->departement) == 0) {
+			printf(" - %s\n", tville[i]->Ville);
+			cpt++;
+		}
+	}
+	if(cpt == 0) printf("Aucun IUT avec ce département n'a été trouvé\n");
+}
 
+// PARTIE ADMINISTRATEUR /////////
+
+// modif nombre place département
+void modifPlace(VilleIUT *tville[], int nbville) {
+	Listdept d;
+	char rechercheDep[31];
+	int i = rechercheVille(tville, nbville);
+	if (i == -1) return;// cas où rien est trouvé en parcourant le tableau
+	d = tville[i]->ldept;
+	printf("Et quel département pour %s ? : ", tville[i]->Ville);
+	scanf("%s", rechercheDep);
+	int cpt = chercheDepModif(d, rechercheDep);
+	if(cpt == 0) printf("Aucun département de ce nom\n");
+}
 
-	- nb candidats (général en haut du doss)
+int chercheDepModif(Listdept d, char rechercheDep[30]) {
+	int cpt = 0;
+	if (d == NULL) return cpt;
+	if(strcmp(d->departement, rechercheDep) == 0) {
+		printf("Nombre de place actuellement : %d\nNouveau nombre de place : ", d->nbplace);
+		scanf("%d", &d->nbplace);
+		cpt++;
+	}
+	else return chercheDepModif(d->suivant, rechercheDep);
+}
 
-	- num candidat
+// recherche ville
-	- nom candidat
+int rechercheVille(VilleIUT *tville[], int nbville) {
-	- prénom candidat
+	char recherche[31];
-	- liste des notes (moyenne dans le sens précis -- math francais anglais et matière spé)
+	printf("Quelle IUT recherchez vous ? : ");
-	|<= nb choix
+	scanf("%s", recherche);
-	|=>recurrence :
+	for(int i = 0; i < nbville; i++) {
-	|- ville
+		if(strcmp(recherche, tville[i]->Ville) == 0) return i;
-	|- département
+	}
-	|- décision ( admis - 1 /attente 0 default /refusé -2 )
+	printf("L'IUT n'a pas été trouvé !\n");
-	|- validation candidat ( 0 default / -1 refus de ce choix / 2 accepte )
+	return -1;
+}
 
-doit venir du menu car sinon pas de transport pour la part 3,
-le tableau de pointeur qui contient listcandinfo et listcand,
 
+// ajouter un département IUT
+Listdept ajoutDept(int posOptionnel, VilleIUT *tville[], int nbville) {
+	int i;
+	MaillonDept* m;
+	Listdept d;
+	m = (MaillonDept*)malloc(sizeof(MaillonDept));
+	if (m == NULL) { printf("Problème malloc"); exit(1);}
+
+	if(posOptionnel == -1) i = rechercheVille(tville, nbville); // Demande dans quelle IUT on souhaite ajouter le département
+	else i = posOptionnel;
+	if (i == -1) return m;
+	
+	d = tville[i]->ldept;
+
+	printf("Veuillez entrer le nom du nouveau département : ");
+	scanf("%s", m->departement);
+	printf("Entrez le nombre de place pour le département %s de %s : ", m->departement, tville[i]->Ville);
+	scanf("%d ", &m->nbplace);
+	printf("Entrez le nom du responsable : ");
+	fgets(m->responsable, 31, stdin);
+	m->responsable[strlen(m->responsable)-1]='\0';
+	m->suivant = d;
+	tville[i]->nbIUT++; // augmente le nombre d'IUT enregistré
+	if(posOptionnel == -1) tville[i]->ldept = m;
+	return m;
+}
 
+// ajouter un IUT 
+void ajoutIUT(VilleIUT *tIUT[], int *nbville, int taillemax) {
+	Listdept d;
 
+	if (*nbville == taillemax) { printf("erreur taille tableau \n"); return; }
+	tIUT[*nbville] = (VilleIUT*) malloc(sizeof(VilleIUT));
+	if(tIUT[*nbville] == NULL) { printf("erreur tab\n"); return; }
 
-combien de fonctionnalité en combien de fonction ...
+	printf("Entrez le nom de la ville à ajouter: ");
+	scanf("%s", tIUT[*nbville]->Ville);
+	tIUT[*nbville]->nbIUT = 0;
 
-	-charger fichier 
+	d = ajoutDept(*nbville, tIUT, *nbville);
-	-modifier choix
+	tIUT[*nbville]->ldept = d;
-	-ajouter choix
+	*nbville = *nbville + 1;
-	-supp choix
+}
-	-afficher les infos d'un cand
-	-tout cand d'un dep (ordre alphabétique)
-	-enregistrer fichier 
 
+// supprimer un département
 
-charger -- recup :
-	-nb candi
-	-listcandinfo
-	-nb choix
-	-listcand
 
-j'ai deux tableau 1 avec infoetu et l'autre les choix de l'etu au meme niveau que lui 
-tinfoetu est tableau de pointeur sur structure 
-tcarteetu est tableau de pointeur sur files 
 
+Listdept suppressionDept(Listdept d, char rechercheDep[31]){
+	Listdept tmp;
+	if(d == NULL){ exit(1); }
+	if(strcmp(d->departement, rechercheDep) == 0){
+		tmp = d->suivant;
+		free(d);
+		return tmp;
+	}
+	d = suppressionDept(d->suivant, rechercheDep);
+}
+
+void supprDepartement(VilleIUT *tville[], int *nbville) {
+	int i = rechercheVille(tville, *nbville);
+	if (i == -1) return;
+	Listdept d = tville[i]->ldept;
+
+
+	char rech[31];
+	printf("Quel département à supprimer pour la ville de %s : ", tville[i]->Ville);
+	scanf("%s", rech);
+
+	tville[i]->ldept = suppressionDept(d, rech);
+	tville[i]->nbIUT = tville[i]->nbIUT - 1;
+
+	if (tville[i]->nbIUT == 0) {
+		for (i; i < *nbville - 1; i++) {
+			strcpy(tville[i]->Ville, tville[i + 1]->Ville);
+			tville[i]->nbIUT = tville[i + 1]->nbIUT;
+			tville[i]->ldept = tville[i + 1]->ldept;
+		}
+		*nbville = *nbville - 1;
+	}
+}
+
+void modifNomResponsable(VilleIUT *tville[], int nbville) {
+	int i = rechercheVille(tville, nbville);
+	if (i == -1) return;
+	Listdept d = tville[i]->ldept;
+
+	char rech[31];
+	printf("Modifier le nom du responsable de quel département pour %s ? : ", tville[i]->Ville);
+	scanf("%s", rech);
+
+// bug a corriger
+	fgets(d->responsable, 31, stdin);
+	d->responsable[strlen(d->responsable)-1]='\0';
+
+	fgets(d->responsable, 31, stdin);
+	d->responsable[strlen(d->responsable)-1]='\0';
+
+	tville[i]->ldept = d;
+}
+
+// PARTIE AFFICHAGE
+
+void affichageDep(Listdept d) {
+	if(d == NULL) { return; }
+	printf(" - %s\n", d->departement);
+	affichageDep(d->suivant);
+}
+
+void affichageAllDep(Listdept d){
+	if(d == NULL) { return; }
+	printf("Département : %s\nNombre place : %d\nResponsable : %s\n\n", d->departement, d->nbplace, d->responsable);
+	affichageAllDep(d->suivant);
+}
+
+void affichageville(VilleIUT *tville[], int nbville){
+	int i;
+	Listdept d;
+	for(i = 0; i < nbville; i++) {
+		d = tville[i]->ldept;
+		printf("%s -\n", tville[i]->Ville);
+		affichageAllDep(d);
+		printf("\n");
+	}
+}
+
+void sauvegardeDep(Listdept d, FILE *fs) {
+	if(d == NULL) return;
+	fprintf(fs, "%s\t%d%s\n\n", d->departement, d->nbplace, d->responsable);
+	sauvegardeDep(d->suivant, fs);
+}
+
+void sauvegarde(VilleIUT *tville[], int nbville) {
+	FILE *fs;
+    fs = fopen ("donneesIUT.don", "w");
+    if (fs == NULL) { printf ("Erreur, ouverture fichier"); return; }
 
-quand on quitte il vide tout avec free
+    for (int i = 0; i < nbville; i++) {
+    	fprintf(fs, "%s\t%d\n", tville[i]->Ville, tville[i]->nbIUT);
+    	sauvegardeDep(tville[i]->ldept, fs);
+    }
+    fclose(fs);
+}
+
+// MENU PARTIE 1
+
+void menuP1Utilisateur(VilleIUT *v[], int nb) {
+	int choixP1U = 0;
+	printf("---------------------- MENU UTILISATEUR -----------------------\n\n");
+
+	printf("   1 - Consulter les villes avec un IUT\n");
+	printf("   2 - Consulter les départements d'un IUT\n");
+	printf("   3 - Consulter le nombre de place des départements\n");
+	printf("   4 - Consulter les IUT possédant un certain département\n\n");
+	
+	printf("   9 - Retour\n");
+
+	while (choixP1U >= 1 || choixP1U <= 4) {
+		switch (choixP1U) {
+			case 1:
+				afficheVilleIUT(v, nb);
+			case 2:
+				afficheDepartementsIUT(v, nb);
+			case 3:
+				affichageville(v, nb);
+			case 4:
+				afficheIUTdepParticulier(v, nb);
+			case 9:
+				sauvegarde(v, nb);// mettre menu général
+		}
+	}
+}
+
+void menuP1Administrateur(VilleIUT *v[], int nb) {
+	int choixP1A = 0;
+	printf("---------------------- MENU UTILISATEUR -----------------------\n\n");
+
+	printf("   1 - Modifier le nombre de place d'un département\n");
+	printf("   2 - Créer un département\n");
+	printf("   3 - Créer un IUT\n");
+	printf("   4 - Supprimer un département\n\n");
+	printf("   5 - Modifier le nom d'un responsable\n\n");
+	
+	printf("   9 - Retour\n");
+
+	while (choixP1A >= 1 || choixP1A <= 4) {
+		switch (choixP1A) {
+			case 1:
+				modifPlace(v, nb);
+			case 2:
+				ajoutDept(-1, v, nb);
+			case 3:
+				ajoutIUT(v, &nb, 100);
+			case 4:
+				supprDepartement(v, &nb);
+			case 5:
+				modifNomResponsable(v, nb);
+			case 9:
+				sauvegarde(v, nb);// mettre menu général
+		}
+	}
+}
+
+/*
+void test(void){
+	VilleIUT *v[100];
+	int nb = chargeIUT(v, 100);
+	affichageville(v, nb);
+	affichageville(v, nb);
+
+	sauvegarde(v, nb);
+	
+	afficheVilleIUT(v, nb);
+	afficheDepartementsIUT(v, nb);
+	afficheIUTdepParticulier(v, nb);
+	modifPlace(v, nb);
+	affichageville(v, nb);
+	ajoutIUT(v, &nb, 100);
+	ajoutDept(-1, v, nb);
+	supprDepartement(v, &nb);
+	affichageville(v, nb);
+	
+}
 */
 
-booleen listevide(Filecartecand f){
+// Partie 2
-	if(f.tete==NULL){return True;}
+
-	return False; 
+//chargement ======================================================================================================================================================================
+/*
+Listchoixdept listvide(void){return NULL;}
+
+Listchoixdept lireCarte(FILE *fe, int nbchoix){
+	if(nbchoix==0){return NULL;}
+	Maillonchoix* cc;
+	cc = (Maillonchoix*)malloc(sizeof(Maillonchoix));
+	fscanf(fe, "%s %s %d %d", cc->Ville, cc->dep, &cc->decision, &cc->validation);
+	cc->suivant = lireCarte(fe, nbchoix-1);
+	return cc;
 }
 
-Filecartecand initial(void){
+listetuinfo lireEtu(FILE *fe){
-	Filecartecand f; f.queue=NULL; f.tete=NULL; return f;
+ 	listetuinfo b;
+	int i;
+	fscanf(fe, "%d %s %s %d %d %d %d %d", &b.numeroetu, b.nometu, b.prenometu, &b.notes[0], &b.notes[1], &b.notes[2], &b.notes[3], &b.nbchoix);
+	return b;
 }
 
-Filecartecand enfiler(Filecartecand f, char Ville[], char dep[], int decision, int validation){
+int chargeretudiant(char nomFich[], listetuinfo *tetu[], int tmax){
-	Mailloncartecand*m;
+	int i=0, nbetu;
-	m=(Mailloncartecand*)malloc(sizeof(Mailloncartecand*));
+	listetuinfo a;
-	if(m==NULL){printf("<! pb malloc in enfiler !>");exit(1);}
+	Listchoixdept b;
-	strcpy(m->Ville,Ville);
+	FILE *fe;
-	strcpy(m->dep,dep);
+	fe = fopen( nomFich, "r");
-	m->decision=decision;
+	if(fe==NULL){printf("<! pb ouverture fichier in chargeretudiant !>\n");return-1;}
-	m->validation=validation;
+	fscanf(fe, "%d", &nbetu);
-	m->suivant=NULL;
+	b = listvide();
-	if(listevide(f)){
+	for(i=0; i<nbetu; i++){
-		f.tete=m;
+		if(i==tmax){printf("<! erreur fichier in chargeetudiant !>");fclose(fe);return-1;}
-		f.queue=m;
+		tetu[i] = (listetuinfo*)malloc(sizeof(listetuinfo));
-	}else{
+		if(tetu[i]==NULL){printf("<! pb malloc in chargeretudiant !>\n");fclose(fe);return-1;}
-		f.queue->suivant=m;
+		a = lireEtu(fe);
-		f.queue=m;
+		b = lireCarte(fe, a.nbchoix);
+		a.carte = b;
+		*tetu[i] = a;
 	}
-	return f;
+	fclose(fe);
+	return nbetu;
 }
 
+//enregistrement ========================================================================================================================================================
 
-listcandinfo lireMat(FILE *fe){
+void enregistrementcarte(FILE *fe, Maillonchoix* carte, int nb){
-	listcandinfo etu;
+	if(carte==NULL){return;}
-	fscanf(fe ,"%d", &etu.numetu);
+	fprintf(fe, "%s\n%s\n%d\n%d\n", carte->Ville, carte->dep, carte->decision, carte->validation);
-	fgets(etu.numetu, 31, fe);
+	enregistrementcarte(fe, carte->suivant, nb-1);
-	*(etu.numetu +(strlen(etu.numetu) - 1)) = '\0';
+	free(carte);
-	fgets(etu.prenometu, 31, fe);
+}
-	*(etu.prenometu +(strlen(etu.prenometu) - 1)) = '\0';
+
-	fscanf(fe ,"%d %d %d %d %d", &etu.note[1], &etu.note[2], &etu.note[3], &etu.[4], &etu.choix);
+void enregistrementinfo(FILE *fe, listetuinfo etu){
-	return etu;
+	Listchoixdept b;
+	int i=0;
+	b = etu.carte;
+	fprintf(fe, "%d\n%s\n%s\n%d %d %d %d\n%d\n", etu.numeroetu, etu.nometu, etu.prenometu, etu.notes, etu.nbchoix);
+	enregistrementcarte(fe, b, etu.nbchoix);
 }
 
-int chargetableaux(char nomFich[], listcandinfo *tinfoetu[], listcanddept *tcarteetu[], int Tmax){
+int enregistrementetudiants(char nomFich[], listetuinfo *tetu[], int nb){
-	listcandinfo a;
-	listcand b;
 	int i=0;
 	FILE *fe;
-	fe = fopen( nomFich , "r");
+	listetuinfo etu;
-	if(fe==NULL){printf("<! pb in chargeFmatieres to open file !>\n");return-1;}
+	fe = fopen( nomFich, "w");
-	a = lireMat(fe);
+	if(fe==NULL){printf("<! pb fichier in enregistrementetudiant !>\n");return-1;}
-	while(!feof(fe)){
+	fprintf(fe, "%d\n", nb);
-		if(i==Tmax){printf("<! pb in chargeFmatieres with tMat capacity !>\n");fclose(fe);return-1;}
+	for(i=0; i<nb; i++){
-		tinfoetu[i] = (listcandinfo*)malloc(sizeof(listcandinfo));
+		etu = tetu[i];
-		if(table[i]==NULL){printf("<! pb in chargeFmatieres with tMat malloc !>\n");fclose(fe);return-1;}
+		enregistrementinfo(fe, etu);
-		*tinfoetu[i]= a;
+		free(tetu[i]);
-		a = lireMat(fe);
-		i++;
 	}
 	fclose(fe);
-	return i;
 }
 
 
+//général fonction for ajouter modifier et supprimer ========================================================================================
+
+void affichagedep(MaillonDept* carte){
+	if(carte==NULL){return;}
+	printf("%s", carte->departement);
+	affichagedep(carte->suivant);
+}
+
+void affichagecarte(Maillonchoix* carte){
+	if(carte==NULL){return;}
+	printf("%s - %s\n", carte->Ville, carte->dep);
+	afficherchoix(carte->suivant);
+}
+
+void affichageville(Maillon *tville[], int nbville){
+	int i;
+	Listdept b;
+	for(i=0; i<nbville; i++){
+		b = tville[i]->ldept;
+		printf("%s :\n", tville[i]->Ville);
+		affichagedep(b);
+		printf("\n");
+	}
+}
+
+void affichervillechoix(Maillon villechoix){
+	int i;
+	Listdept ldep;
+	ldep = villechoix.ldept;
+	printf("%s :\n", villechoix.Ville);
+	affichagedep(ldep);
+	printf("\n");
+}
+
+int cherchelistcorrespond(MaillonDept* dep, char choixdep[]){
+	if(dep==NULL){return -1;}
+	if(strcmp(dep->departement,choixdep)==0){return 1;}
+	return cherchelistcorrespond(dep->suivant, choixdep);
+}
+
+int correspondville(char choixville[], char choixdep[], Maillon *tville[], int nbville){
+	int i, ok;
+	Listdept b;
+	for(i=0; i<nbville; i++){
+		if(strcmp(tville[i]->Ville,choixville)==0){
+			b = tville[i].ldept;
+			ok = cherchelistcorrespond(b, choixdep);
+			if(ok==1){return 1;}
+		}
+	}
+	return -1;
+}
+
+int correspondcarte(char choixville[], char choixdep[], Maillonchoix* carte){
+	if(carte==NULL){return 0;}
+	if(strcmp(choixville,carte->Ville)==0){
+		if(strcmp(choixdep,carte->dep)==0){
+			return 1;
+		}
+	}
+	correspondcarte(choixville, choixdep, carte->suivant);
+}
 
+//ajouter =============================================================================================================================================
+
+void choix(Maillon *tville[], int nbville, char choixville[], char choixdep[]){
+	int i, ok;
+	printf("ville : \n");
+	fgets(choixville, 31, stdin);
+	choixville[strlen(choixville)-1]='\0';
+	printf("departement : \n");
+	fgets(choixdep, 31, stdin);
+	choixdep[strlen(choixdep)-1]='\0';
+	ok = correspondville(choixville, choixdep, tville, nbville);
+	while(ok!=1){
+		printf("ville : \n");
+		fgets(choixville, 31, stdin);
+		choixville[strlen(choixville)-1]='\0';
+		printf("departement : \n");
+		fgets(choixdep, 31, stdin);
+		choixdep[strlen(choixdep)-1]='\0';
+		ok = correspondville(choixville, choixdep, tville, nbville);
+	}
+}
 
+Listchoixdept ajoutercarte(Maillonchoix* a, char choixville[], char choixdep[]){
+	Maillonchoix* carte;
+	carte = (Maillonchoix*)malloc(sizeof(Maillonchoix));
+	if(carte==NULL){printf("<! erreur malloc in ajoutercarte !>\n");exit(1);}
+	strcpy(carte->Ville,choixville);
+	strcpy(carte->dep,choixdep);
+	carte->decision=0;
+	carte->validation=0;
+	carte->suivant=a;
+	return carte;
+}
 
+int allajoutprocess(Maillon *tville[], listetuinfo etu, int nbville){
+	int i, ok;
+	Listchoixdept b;
+	b = etu.carte;
+	char choixville[31], choixdep[31];
+	affichageville(tville, nbville);
+	choix(tville, nbville, choixville, choixdep);
+	ok = correspondcarte(choixville, choixdep, b);
+	if(ok==0){b = ajoutercarte(b, choixville, choixdep);}
+	else{printf("\t< choix deja existant >\n");}
+}
 
+//modifier ==============================================================================================================================================================
+
+void choix2(Listchoixdept lcarte, char choixville[], char choixdep[]){
+	int ok;
+	printf("ville : \n");
+	fgets(choixville, 31, stdin);
+	choixville[strlen(choixville)-1]='\0';
+	printf("departement : \n");
+	fgets(choixdep, 31, stdin);
+	choixdep[strlen(choixdep)-1]='\0';
+	ok = correspondcarte(choixville, choixdep, lcarte);
+	while(ok!=1){
+		printf("ville : \n");
+		fgets(choixville, 31, stdin);
+		choixville[strlen(choixville)-1]='\0';
+		printf("departement : \n");
+		fgets(choixdep, 31, stdin);
+		choixdep[strlen(choixdep)-1]='\0';
+		ok = correspondcarte(choixville, choixdep, lcarte);
+	}
+}
 
+void fchoixdep(char choixville[], char choixdep[], Maillon *tville[], int nbville){
+	int ok;
+	printf("\n< quel departement voulez vous choisir ? >\n==>");
+	fgets(choixdep, 31, stdin);
+	choixdep[strlen(choixdep)-1]='\0';
+	ok = correspondville(choixville, choixdep, tville[i], nbville);
+	while(ok!=1){
+		printf("\n< quel departement voulez vous choisir ? >\n==>");
+		fgets(choixdep, 31, stdin);
+		choixdep[strlen(choixdep)-1]='\0';
+		ok = correspondville(choixville, choixdep, tville[i], nbville);
+	}
+}
 
+Maillonchoix choixmodifcarte(Maillonchoix dep, char choixville[], char choixdep[]){
+	Maillonchoix dep;
+	if(dep==NULL){exit(1);}
+	if(strcmp(dep->Ville,choixville)==0){
+		if(strcmp(dep->dep,choixdep)==0){
+			fchoixdep(choixville, choixdep, tville, nbville);
+			dep->dep=choixville;
+			return dep;
+		}
+	}
+	dep->suivant = choixmodifcarte(dep.suivant, choixville, choixdep);
+}
+
+int correspondvilleonly(char choixville[], Maillon ville){
+	Listdept b;
+	if(strcmp(ville.Ville,choixville)==0){
+		affichervillechoix(ville);
+		return 1;
+	}
+}
+
+void modificationcarte(listetuinfo etu, Maillon *tville[], int nbville){
+	int i, ok;
+	char choixville[31], choixdep[31];
+	Listchoixdept lcarte;
+	lcarte=etu.carte;
+	affichagecarte(lcarte);
+	choix2(lcarte, choixville, choixdep);
+	for(i=0; i<nbville; i++){
+		ok = correspondvilleonly(choixville, tville[i]);
+		if(ok==1){
+			fchoixdep(choixville, choixdep, tville, nbville);
+			lcarte = choixmodifcarte(choixville, choixdep, tville, nbville);
+			etu.carte=lcarte;
+		}
+		else{printf("\t< choix deja existant >\n");}
+	}
+}
+
+//supprimer ==========================================================================================================================================
+
+Maillonchoix suppressioncartechoix(char choixville[], char choixdep[], Maillonchoix* carte){
+	Maillonchoix* premier, tmp;
+	if(carte==NULL){exit(1);}
+	if(strcmp(carte.Ville,choixville)==0){
+		if(strcmp(choixdep,carte.dep)==0){
+			tmp=carte.suivant;
+			free(carte);
+			return tmp;
+		}
+	}
+	carte = suppressioncartechoix(choixville, choixdep, carte.suivant);
+}
+
+void suppcarte(listetuinfo etu){
+	int i, ok;
+	char choixville[31], choixdep[31];
+	Listchoixdept lcarte;
+	lcarte=etu.carte;
+	affichagecarte(lcarte);
+	choix2(lcarte, choixville, choixdep);
+	lcarte = suppressioncartechoix(choixville, choixdep, lcarte);
+}
+
+//affichage =======================================================================================================================================================
+
+void affichagecarteall(Maillonchoix* carte){
+	if(carte==NULL){return;}
+	printf("%s - %s\n décision : %d\nvalidation : %d\n", carte->Ville, carte->dep, carte->decision, carte->validation);
+	afficherchoix(carte->suivant);
+}
+
+void affichageetu(listetuinfo etu){
+	Listchoixdept lcarte;
+	lcarte=etu.carte;
+	printf(" %d\n %s %s\n", a.numeroetu, a.nometu, a.prenometu);
+	printf(" mathématique : %d\n", a.notes[0]);
+	printf(" français : %d\n", a.notes[1]);
+	printf(" anglais : %d\n", a.notes[2]);
+	printf(" matière spé : %d\n", a.notes[3]);
+	affichagecarteall(lcarte);
+}
+
+void affichage(Listchoixdept c){
+	if(c==NULL){printf("\n");return;}
+	printf("%s %s %d %d", c->Ville, c->dep, c->decision, c->validation);
+	if(c->suivant==NULL){affichage(c->suivant);}
+	else{
+		printf("\n - ");
+		affichage(c->suivant);
+	}
+}
+
+//affiche que la personne
+void affichageetu(listetuinfo a){
+	printf(" %d\n %s %s\n", a.numeroetu, a.nometu, a.prenometu);
+	printf(" mathématique : %d -", a.notes[0]);
+	printf(" français : %d -", a.notes[1]);
+	printf(" anglais : %d -", a.notes[2]);
+	printf(" matière spé : %d\n", a.notes[3]);
+}
+
+//affichage general
+void affichealletu(listetuinfo *tetu[], int nb){
+	int j=0;
+	Listchoixdept b;
+	b = listvide();
+	for(j=0; j<nb; j++){
+		affichageetu(*tetu[j]);
+		printf("tout les choix :\n - ");
+		b = tetu[j]->carte;
+		affichage(b);
+		printf("\n\n");
+	}
+}
+
+//=========================================================================================================================================================
+
+// zone de test =========================================================================================
+/*
+void test1(void){
+	listetuinfo *tetu[5000];
+	int nb;
+	char nomFich[20];
+	strcpy( nomFich, "candidature.txt");
+	nb = chargeretudiant(nomFich, tetu, 5000);
+	affichealletu(tetu, nb);
+}
+*/
+//==========================================================================================================
 
 // Partie 3
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 // Partie 4
 
-// Général (menu et ce qui en ai relié)
+/*
+	V affichage coté candidat de ces infos admis ou pas
+	- valdier ça candidature refuse les autres
+	- valider met a jour le dossier candidature
+	- chaque departement peut consulter ça liste d'attente
+	- metre a jour la liste 
+	-
+	-
+	-
+	-
+	-
+
+*/
+*/
+
+// coté etu=========================================================================================================
+// affichage
+/*
+void affichagedepresultat(Maillonchoix* carte){
+	if(carte==NULL){return;}
+	if(carte->decision==1){
+		printf("%s %s - admis \n", carte.Ville, carte.dep);
+	}
+	if(carte->decision==1){
+		printf("%s %s - refusé \n", carte.Ville, carte.dep);
+	}
+	if(carte->decision==1){
+		printf("%s %s - lsite d'attente \n", carte.Ville, carte.dep);
+	}
+	affichagedepresultat(carte.suivant);
+}
+
+// validation 
+
+void validation(char choixville[], char choixdep[], Maillonchoix* carte, int *ok, Maillonatt lplace, int nbplace, listetuinfo etu){
+	if(carte==NULL){return;}
+	if(strcmp(carte.Ville,choixville)==0){
+		if(strcmp(carte.dep,choixdep)==0){
+			if(carte.decision==1){
+				carte.validation=1;
+				*ok=1;
+			}else{printf("vous netes pas admis dans cette iut\n");*ok=-1;return;}
+		}
+	}
+	validation(choixville, choixdep, carte.suivant, ok);
+	if(ok==1){
+		if(carte.decision==1){
+			carte.validation=-1;
+			miseajourindep( lplace, nbplace, etu);
+		}
+	}
+}
 
+void enregistrementvalidation(char choixville[], char choixdep[], Maillonchoix* carte, int *ok, char nomFich[], listetuinfo *tetu[], int nb){
+	int ok;
+	validation( choixville, choixdep, carte, &ok);
+	enregistrementetudiants( nomFich, tetu, nb);
+}
+
+// -> mise a jour 
+
+Maillonatt miseajourfile(Maillonatt place, int nbplace, listetuinfo etu){
+	if(place==NULL){exit(1);}
+	if(place.munc==etu.numeroetu){
+		Maillonatt temp;
+		temp=place.suivant;
+		free(place);
+		return temp;
+	}
+	miseajourfile(place.suivant, nbplace-1);
+}
+
+int miseajouratt(Maillonatt place, int nbplace){
+	if(place==NULL){return;}
+	if(nbplace==0){return;}
+	if(place.decision==2){
+		place.decision==1;
+	}
+	miseajouratt(place.suivant, nbplace-1);
+}
+
+void miseajourindep(Maillonatt lplace, int nbplace, listetuinfo etu){
+	lpace = miseajourfile(lplace, nbplace, etu);
+	miseajouratt(lplace, nbplace);
+}
+
+
+
+// coté dep=============================================================================================================
+// affichage dep 
+
+void affichageonlyadmis(Maillonatt etuatt){
+	if(etuatt==NULL){return;}
+	if(etuatt.decision==1){
+		printf("%d %s %s\n" etuatt.numc, etuatt.nom, etuatt.prenom);
+	}
+	affichageonlyadmis(etuatt.suivant);
+}
+
+void affichageonlyatt(Maillonatt etuatt){
+	if(etuatt==NULL){return;}
+	if(etuatt.decision==1){
+		printf("%d %s %s\n" etuatt.numc, etuatt.nom, etuatt.prenom);
+	}
+	affichageonlyatt(etuatt.suivant);
+}
+
+//chercher present en admission ========================================================================================
+
+void chercheretuadmisindep(char choixnom[], char nomprenom[], Maillonatt etuatt){
+	if(etuatt==NULL){printf("erreur de recherche\n");return;}
+	if(strcmp(etuatt.nom,choixnom)==0){
+		if(strcmp(etuatt.prenom,choixprenom)==0){
+			if(etuatt.decision==1){printf("%s %s est admis\n", etuatt.nom, etuatt.prenom);return;}
+			if(etuatt.decision==2){printf("%s %s est en attente\n", etuatt.nom, etuatt.prenom);return;}
+			if(etuatt.decision==-1){printf("%s %s est refusé\n", etuatt.nom, etuatt.prenom);return;}
+		}
+	}
+	chercheretuadmisindep(choixnom, choixprenom, etuatt.suivant);
+}
+*/
+// Général (menu et ce qui en ai relié)
+/*
 questionadmin(){
 	printf("\nQuel numéro détudiant ?\n==>");	
 	scanf("%d%*c", &choix);
@@ -190,3 +913,4 @@ int menu(void){
 
 	return 1;
 }
+*/

sae1-02.h

@@ -12,43 +12,72 @@
 
 
 // Partie 1
-typedef struct listville{
+typedef struct listville {
 	char departement[31];
 	int nbplace;
 	char responsable[31];
 	struct listville* suivant;
-}MaillonDept, *Listdept;
+} MaillonDept, *Listdept;
 
-typedef struct VilleIUT{
+typedef struct {
 	char Ville[31];
+	int nbIUT;
 	Listdept ldept;
-}Maillon;
+} VilleIUT;
 
+//chargement
+Listdept initialisation(void);
+VilleIUT lireVille(FILE *fe);
+Listdept lireDept(FILE *fe, int nbIUT);
+int chargeIUT(VilleIUT* tIUT[], int taillemax);
 
-// Partie 2
+//affichage
+void affichageDep(Listdept d);
+void affichageAllDep(Listdept d);
+void affichageville(VilleIUT *tville[], int nbville);
+void afficheVilleIUT(VilleIUT *tville[], int nbville);
+void afficheDepartementsIUT(VilleIUT *tville[], int nbville);
+void afficheDepNbPlace(VilleIUT *tville[], int nbville);
+void afficheIUTdepParticulier(VilleIUT *tville[], int nbville);
 
-typedef struct{
+//modif
-	int numetu;
+int rechercheVille(VilleIUT *tville[], int nbville);
-	char nometu[31];
+void modifPlace(VilleIUT *tville[], int nbville);
-	char prenometu[31];
+int chercheDepModif(Listdept d, char rechercheDep[31]);
-	int notes[4];
+void modifNomResponsable(VilleIUT *tville[], int nbville);
-	int nbchoix;
+
-}listcandinfo;
+//ajout / suppressions
+Listdept ajoutDept(int posOptionnel, VilleIUT *tville[], int nbville);
+void ajoutIUT(VilleIUT *tIUT[], int *nbville, int taillemax);
+Listdept suppressionDept(Listdept d, char rechercheDep[31]);
+void supprDepartement(VilleIUT *tville[], int* nbville);
+void suppcarte(VilleIUT *tville[], int nbville);
+
+
+void menuP1Utilisateur(VilleIUT *v[], int nb);
+void menuP1Administrateur(VilleIUT *v[], int nb);
 
-typedef struct listcand{
+void sauvegardeDep(Listdept d, FILE *fs);
+void sauvegarde(VilleIUT *tville[], int nbville);
+
+// Partie 2
+
+typedef struct listchoix{
 	char Ville[31];
 	char dep[31];
 	int decision;
 	int validation;
-	struct listcand* suivant;
+	struct listchoix* suivant;
-}Mailloncartecand, listcanddept;
+}Maillonchoix, *Listchoixdept;
 
 typedef struct{
-	Mailloncartecand* tete;
+	int numeroetu;
-	Mailloncartecand* queue;
+	char nometu[21];
-}Filecartecand;
+	char prenometu[21];
-
+	int notes[4];
-typedef enum {False,True}booleen;
+	int nbchoix;
+	Listchoixdept carte;
+}listetuinfo;
 
 // Partie 3
 typedef struct listresp{
@@ -63,6 +92,10 @@ typedef struct listresp{
 // Partie 4
 typedef struct listatt{
 	int numc;
+	char nom[21];
+	char prenom[21];
+	int decision;
 	struct listatt* suivant;
-}maillonatt;
+}Maillonatt;
 
+void test1(void);