ajout de types opaques et correction des problèmes de compilation dues à la mise en place de l'encapsulation
continuous-integration/drone/push Build is failing
Details
continuous-integration/drone/push Build is failing
Details
parent
dba9b7513a
commit
9a8f97899b
@ -1,12 +1,22 @@
|
||||
#ifndef app_bundle_h
|
||||
#define app_bundle_h
|
||||
#ifndef app_env_h
|
||||
#define app_env_h
|
||||
|
||||
#include "src/logique/candidature/candidature.h"
|
||||
#include "src/logique/candidature/liste_candidature.h"
|
||||
#include "src/logique/compte/compte.h"
|
||||
#include "src/logique/formation/ville_iut.h"
|
||||
|
||||
#define NB_MAX_FORMATIONS 100
|
||||
|
||||
#define EMPLACEMENT_FICHIER_COMPTES "stockage/comptes.bin"
|
||||
#define EMPLACEMENT_FICHIER_CANDIDATURES "stockage/candidatures.txt"
|
||||
#define EMPLACEMENT_FICHIER_FORMATIONS "stockage/formations.txt"
|
||||
#define EMPLACEMENT_FICHIER_PHASE "stockage/phase.txt"
|
||||
|
||||
#define EMPLACEMENT_DOSSIER_RESULTATS "stockage/resultats"
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Enum représentant la phase.txt actuelle.
|
||||
* Chaque phase.txt permet d'influencer les actions faisables sur une IUT.
|
||||
@ -1,11 +1,18 @@
|
||||
#include "src/logique/recrutement/profil.h"
|
||||
#include "src/logique/recrutement/liste_profil.h"
|
||||
#include "src/application/app_utils.h"
|
||||
#include "src/application/app_env.h"
|
||||
|
||||
|
||||
/**
|
||||
* Affiche l'outil permettant au recruteur d'examiner les différents profils et de leurs attribuer une note
|
||||
* \param[in] compte le compte du recruteur
|
||||
* \param[in] profils liste des différents profils que le recruteur devra examiner.
|
||||
* */
|
||||
void afficherOutilExamen(Compte* compte, ListeProfil* profils);
|
||||
void examinationDesProfils(Compte* compte, ListeProfil* profils);
|
||||
|
||||
void examinationDesProfils(Compte* compte, ListeCandidature* candidatures);
|
||||
/**
|
||||
* Demarre une session d'examen et met à jour les resultats d'admissions du département du recruteur.
|
||||
* \param[in] compte le compte du recruteur
|
||||
* \param[in] candidatures liste des différentes candidatures dont le recruteur examinera les voeuxs faits par apport à son département.
|
||||
* */
|
||||
void demarrerSessionExamen(Compte* compte, ListeCandidature* candidatures);
|
||||
@ -1,83 +1,32 @@
|
||||
#ifndef candidature_h
|
||||
#define candidature_h
|
||||
|
||||
#include "src/logique/compte/compte.h"
|
||||
#include "src/logique/compte/liste_compte.h"
|
||||
#include "src/logique/candidature/voeux.h"
|
||||
#include "src/logique/candidature/liste_voeux.h"
|
||||
#include "src/logique/candidature/dossier.h"
|
||||
|
||||
/**
|
||||
* Dossier scolaire d'un candidat.
|
||||
* Contient les moyennes en mathématiques, français, anglais et la spécialité du candidat.
|
||||
* */
|
||||
typedef struct {
|
||||
float maths;
|
||||
float francais;
|
||||
float anglais;
|
||||
float specialite;
|
||||
} Dossier;
|
||||
|
||||
bool dossierEgal(Dossier* a, Dossier* b);
|
||||
|
||||
/**
|
||||
* Structure représentant la candidature d'un candidat.
|
||||
* */
|
||||
typedef struct {
|
||||
/**
|
||||
* Le compte du candidat
|
||||
* */
|
||||
Compte* candidat;
|
||||
/**
|
||||
* Le dossier du candidat, utilisé pendant la phase d'examination des voeuxs
|
||||
* */
|
||||
Dossier* dossier;
|
||||
/**
|
||||
* La liste des voeux de la candidature.
|
||||
* Le candidat remplit cette liste pendant la phase de candidature,
|
||||
* puis pendant la phase de consultation des resultats, la liste de voeuxs évolue
|
||||
* selon les choix du jury et du candidat.
|
||||
* */
|
||||
ListeVoeux voeuxs;
|
||||
/**
|
||||
* l'unique voeux accepté par le jury et le candidat.
|
||||
* (est NULL pendant la phase de candidature/examination des voeux, et tant que le candidat n'a pas accepté de voeux).
|
||||
* NOTE: le voeux accepté ne devrait donc pas figurer dans la liste de voeuxs.
|
||||
* */
|
||||
Voeux* voeuxAccepte;
|
||||
} Candidature;
|
||||
|
||||
float moyenneGenerale(Dossier* dossier);
|
||||
|
||||
void freeCandidature(Candidature* c);
|
||||
|
||||
/**
|
||||
* Definit une liste chainée triée sur le nom / prenom des candidats et leurs identifiants
|
||||
* */
|
||||
typedef struct maillonCandidature {
|
||||
Candidature* candidature;
|
||||
struct maillonCandidature* suiv;
|
||||
} MaillonCandidature, * ListeCandidature;
|
||||
|
||||
ListeCandidature chargerCandidatures(char* nomFichier, ListeCompte* lc);
|
||||
void sauvegarderCandidatures(char* nomFichier, ListeCandidature* l);
|
||||
|
||||
|
||||
ListeCandidature nouvListeCandidature(void);
|
||||
struct candidature;
|
||||
typedef struct candidature Candidature;
|
||||
|
||||
void freeListeCandidature(ListeCandidature* l);
|
||||
|
||||
|
||||
void ajouterCandidature(ListeCandidature* l, Candidature* v);
|
||||
Candidature* nouvCandidature(Compte* candidat, Dossier* dossier);
|
||||
|
||||
bool supprimerCandidature(ListeCandidature* l, Candidature* v);
|
||||
Compte* getCompteCandidat(Candidature* c);
|
||||
Dossier* getDossierCandidat(Candidature* c);
|
||||
ListeVoeux* getVoeuxs(Candidature* c);
|
||||
Voeux* getVoeuxAccepte(Candidature* c);
|
||||
void accepterVoeux(Candidature* c, Voeux* v);
|
||||
|
||||
ListeCandidature* queueLCa(ListeCandidature* l);
|
||||
Candidature* lireCandidature(ListeCompte* lc, FILE* f);
|
||||
void ecrireCandidature(Candidature* c, FILE* f);
|
||||
|
||||
Candidature* teteLCa(ListeCandidature* l);
|
||||
|
||||
int longueurLCa(ListeCandidature* l);
|
||||
|
||||
bool videLCa(ListeCandidature* l);
|
||||
|
||||
ListeCandidature filtrerLCPourDept(ListeCandidature* lc, VilleIUT* iut, Dep* dept);
|
||||
void freeCandidature(Candidature* c);
|
||||
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,54 @@
|
||||
#include "src/logique/candidature/dossier.h"
|
||||
|
||||
|
||||
struct dossier {
|
||||
float maths;
|
||||
float francais;
|
||||
float anglais;
|
||||
float specialite;
|
||||
};
|
||||
|
||||
float ensureNote(float note) {
|
||||
if (note < 0 || note > 20)
|
||||
fatal(ARGUMENT_INVALIDE, "la note n'est pas comprise entre 0 et 20.");
|
||||
return note;
|
||||
}
|
||||
|
||||
Dossier* nouvDossier(float maths, float anglais, float francais, float specialite) {
|
||||
Dossier* d = (Dossier*) malloc(sizeof(Dossier));
|
||||
if (d == NULL) {
|
||||
fclose(f);
|
||||
fatal(ERREUR_MEMOIRE, "impossible de malloc un nouveau dossier.");
|
||||
}
|
||||
d->maths = ensureNote(maths);
|
||||
d->anglais = ensureNote(anglais);
|
||||
d->francais = ensureNote(francais);
|
||||
d->specialite = ensureNote(specialite);
|
||||
}
|
||||
|
||||
float moyenneGenerale(Dossier* dossier) {
|
||||
return (dossier->maths + dossier->anglais + dossier->francais + (dossier->specialite * 2)) / 5;
|
||||
}
|
||||
|
||||
float getNoteMaths(Dossier* d) {
|
||||
return d->maths;
|
||||
}
|
||||
float getNoteFrancais(Dossier* d) {
|
||||
return d->fracais;
|
||||
}
|
||||
float getNoteAnglais(Dossier* d) {
|
||||
return d->anglais;
|
||||
}
|
||||
float getNoteSpecialite(Dossier* d) {
|
||||
return d->specialite;
|
||||
}
|
||||
|
||||
void ecrireDossier(Dossier* d, FILE* f) {
|
||||
fprintf(f, "%.2f %.2f %.2f %.2f\n", d->francais, d->maths, d->anglais, d->specialite);
|
||||
}
|
||||
|
||||
Dossier* lireDossier(FILE* f) {
|
||||
float fr, maths, anglais, spe;
|
||||
fscanf(f, "%f %f %f %f", &maths, &anglais, fr, &spe);
|
||||
return nouvDossier(maths, anglais, fr, spe);
|
||||
}
|
||||
@ -0,0 +1,18 @@
|
||||
|
||||
/**
|
||||
* Dossier scolaire d'un candidat.
|
||||
* Contient les moyennes en mathématiques, français, anglais et la spécialité du candidat.
|
||||
* */
|
||||
struct dossier;
|
||||
typedef struct dossier Dossier;
|
||||
|
||||
Dossier* nouvDossier(float math, float anglais, float francais, float specialite);
|
||||
|
||||
float moyenneGenerale(Dossier* dossier);
|
||||
float getNoteMaths(Dossier* d);
|
||||
float getNoteFrancais(Dossier* d);
|
||||
float getNoteAnglais(Dossier* d);
|
||||
float getNoteSpecialite(Dossier* d);
|
||||
|
||||
void ecrireDossier(Dossier* d, FILE* f);
|
||||
Dossier* lireDossier(FILE* f);
|
||||
@ -0,0 +1,149 @@
|
||||
#include "src/logique/candidature/liste_candidature.h"
|
||||
|
||||
struct maillonCandidature {
|
||||
Candidature* candidature;
|
||||
struct maillonCandidature* suiv;
|
||||
};
|
||||
|
||||
ListeCandidature nouvListeCandidature(void) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void ajouterCandidature(ListeCandidature* l, Candidature* c) {
|
||||
char* nom = getNom(c->candidat);
|
||||
char* prenom = getPrenom(c->candidat);
|
||||
int id = getIDCompte(c->candidat);
|
||||
|
||||
|
||||
MaillonCandidature** m = l;
|
||||
//on cherche le bon emplacement où insérer la candidature
|
||||
while (*m != NULL) {
|
||||
Compte* it = (*m)->candidature->candidat;
|
||||
int cmpNom = strcmp(nom, it->nom);
|
||||
int cmpPrenom = strcmp(prenom, it->prenom);
|
||||
int cmpId = id - it->identifiant;
|
||||
if (cmpNom < 0 || (cmpNom == 0 && cmpPrenom < 0) || (cmpNom == 0 && cmpPrenom == 0 && cmpId < 0))
|
||||
break; //emplacement trouvé
|
||||
m = &(*m)->suiv;
|
||||
}
|
||||
|
||||
MaillonCandidature* nouv = (MaillonCandidature*) malloc(sizeof(MaillonCandidature));
|
||||
if (nouv == NULL)
|
||||
fatal(ERREUR_MEMOIRE, "impossible d'allouer un nouveau compte.");
|
||||
nouv->candidature = c;
|
||||
nouv->suiv = *m; //Le nouveau maillon pointe vers le maillon remplacé
|
||||
*m = nouv; //le pointeur du maillon remplacé devient le nouveau maillon
|
||||
|
||||
}
|
||||
|
||||
bool supprimerCandidature(ListeCandidature* l, Candidature* c) {
|
||||
if (videLCa(l))
|
||||
return false;
|
||||
|
||||
char* nom = c->candidat->nom;
|
||||
char* prenom = c->candidat->prenom;
|
||||
int id = c->candidat->identifiant;
|
||||
|
||||
MaillonCandidature** m = l;
|
||||
//on cherche le maillon qui contient la candidature.
|
||||
// Si on trouve pas on retourne false
|
||||
while (*m != NULL) {
|
||||
Compte* it = (*m)->candidature->candidat;
|
||||
int cmpNom = strcmp(nom, it->nom);
|
||||
int cmpPrenom = strcmp(prenom, it->prenom);
|
||||
int cmpId = id - it->identifiant;
|
||||
if (cmpNom > 0 || (cmpNom == 0 && cmpPrenom > 0) || (cmpNom == 0 && cmpPrenom == 0 && cmpId > 0))
|
||||
return false; //on a pas trouvé
|
||||
if (cmpNom == 0 && cmpPrenom == 0 && cmpId == 0)
|
||||
break; // on a trouvé
|
||||
m = &(*m)->suiv;
|
||||
}
|
||||
if (*m == NULL) return false; // on a pas trouvé
|
||||
MaillonCandidature* aux = *m;
|
||||
*m = aux->suiv;
|
||||
free(aux);
|
||||
return true;
|
||||
}
|
||||
|
||||
ListeCandidature* queueLCa(ListeCandidature* l) {
|
||||
if (videLCa(l))
|
||||
fatal(LISTE_VIDE, "tentative de récupérer la teteLD d'une liste videLD");
|
||||
return &(*l)->suiv;
|
||||
}
|
||||
|
||||
Candidature* teteLCa(ListeCandidature* l) {
|
||||
if (videLCa(l))
|
||||
fatal(LISTE_VIDE, "tentative de récupérer la teteLD d'une liste videLD");
|
||||
return (*l)->candidature;
|
||||
}
|
||||
|
||||
bool videLCa(ListeCandidature* l) {
|
||||
return *l == NULL;
|
||||
}
|
||||
|
||||
int longueurLCa(ListeCandidature* l) {
|
||||
MaillonCandidature* m = *l;
|
||||
int i = 0;
|
||||
while (!videLCa(&m)) {
|
||||
i++;
|
||||
m = m->suiv;
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
void freeListeCandidature(ListeCandidature* l) {
|
||||
MaillonCandidature* mv = *l, * aux;
|
||||
while (mv != NULL) {
|
||||
aux = mv;
|
||||
mv = mv->suiv;
|
||||
free(aux);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
ListeCandidature filtrerLCPourDept(ListeCandidature* lc, VilleIUT* iut, Dep* dept) {
|
||||
ListeCandidature filtre = nouvListeCandidature(); //contient toutes les candidatures qui ont un voeux pour le departement
|
||||
while (!videLCa(lc)) {
|
||||
Candidature* c = teteLCa(lc);
|
||||
ListeVoeux* voeuxs = &c->voeuxs;
|
||||
while (!videLV(voeuxs)) {
|
||||
Voeux* voeux = teteLV(voeuxs);
|
||||
if (strcmp(voeux->nomVille, iut->ville) == 0 && strcmp(voeux->departement, dept->departement) == 0) {
|
||||
ajouterCandidature(&filtre, c);
|
||||
break;
|
||||
}
|
||||
voeuxs = queueLV(voeuxs);
|
||||
}
|
||||
lc = queueLCa(lc);
|
||||
}
|
||||
return filtre;
|
||||
}
|
||||
|
||||
ListeCandidature chargerCandidatures(char* nomFichier, ListeCompte* lc) {
|
||||
FILE* f = fopen(nomFichier, "r");
|
||||
if (f == NULL)
|
||||
fatal(OUVERTURE_FICHIER, "impossible de lire le fichier des candidatures");
|
||||
int nbCandidat = 0;
|
||||
ListeCandidature candids = nouvListeCandidature();
|
||||
fscanf(f, "%d", &nbCandidat);
|
||||
for (int i = 0; i < nbCandidat; i++)
|
||||
ajouterCandidature(&candids, lireCandidature(lc, f));
|
||||
|
||||
fclose(f);
|
||||
return candids;
|
||||
}
|
||||
|
||||
|
||||
void sauvegarderCandidatures(char* nomFichier, ListeCandidature* l) {
|
||||
FILE* f = fopen(nomFichier, "w");
|
||||
if (f == NULL)
|
||||
fatal(OUVERTURE_FICHIER, "impossible d'ecrire dans le fichier des candidatures");
|
||||
int nb = longueurLCa(l);
|
||||
fprintf(f, "%d\n", nb);
|
||||
MaillonCandidature* mc = *l;
|
||||
for (int i = 0; i < nb; i++) {
|
||||
ecrireCandidature(mc->candidature, f);
|
||||
mc = mc->suiv;
|
||||
}
|
||||
fclose(f);
|
||||
}
|
||||
@ -0,0 +1,35 @@
|
||||
#ifndef liste_candidature_h
|
||||
#define liste_candidature_h
|
||||
|
||||
#include "src/logique/candidature/candidature.h"
|
||||
#include "src/logique/formation/departement.h"
|
||||
#include "src/logique/compte/liste_compte.h"
|
||||
|
||||
typedef struct candidature Candidature;
|
||||
|
||||
/**
|
||||
* Definit une liste chainée triée sur le nom / prenom des candidats et leurs identifiants
|
||||
* */
|
||||
struct maillonCandidature;
|
||||
typedef struct maillonCandidature MaillonCandidature, * ListeCandidature;
|
||||
|
||||
|
||||
ListeCandidature nouvListeCandidature(void);
|
||||
void freeListeCandidature(ListeCandidature* l);
|
||||
|
||||
|
||||
void ajouterCandidature(ListeCandidature* l, Candidature* v);
|
||||
bool supprimerCandidature(ListeCandidature* l, Candidature* v);
|
||||
ListeCandidature* queueLCa(ListeCandidature* l);
|
||||
Candidature* teteLCa(ListeCandidature* l);
|
||||
int longueurLCa(ListeCandidature* l);
|
||||
bool videLCa(ListeCandidature* l);
|
||||
|
||||
ListeCandidature filtrerLCPourDept(ListeCandidature* lc, VilleIUT* iut, Dep* dept);
|
||||
|
||||
|
||||
ListeCandidature chargerCandidatures(char* nomFichier, ListeCompte* lc);
|
||||
void sauvegarderCandidatures(char* nomFichier, ListeCandidature* l);
|
||||
|
||||
#endif
|
||||
|
||||
@ -0,0 +1,95 @@
|
||||
#include "src/logique/candidature/liste_voeux.h"
|
||||
|
||||
|
||||
|
||||
ListeVoeux nouvListeVoeux(void) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void ajouterVoeux(ListeVoeux* l, Voeux* v) {
|
||||
if (!videLV(l)) {
|
||||
ajouterVoeux(&(*l)->suiv, v);
|
||||
return;
|
||||
}
|
||||
MaillonVoeux* m = (MaillonVoeux*) malloc(sizeof(MaillonVoeux));
|
||||
if (m == NULL)
|
||||
fatal(ERREUR_MEMOIRE, "impossible de malloc un maillon voeux\n");
|
||||
|
||||
m->suiv = NULL;
|
||||
m->voeux = v;
|
||||
*l = m;
|
||||
}
|
||||
|
||||
void supprimerVoeux(ListeVoeux* l, Voeux* v) {
|
||||
if (videLV(l))
|
||||
return;
|
||||
|
||||
if (voeuxEgal(teteLV(l), v)) {
|
||||
ListeVoeux queue = (*l)->suiv;
|
||||
MaillonVoeux* tete = *l;
|
||||
free(tete);
|
||||
*l = queue;
|
||||
return;
|
||||
}
|
||||
supprimerVoeux(queueLV(l), v);
|
||||
}
|
||||
|
||||
ListeVoeux* queueLV(ListeVoeux* l) {
|
||||
if (videLV(l))
|
||||
fatal(LISTE_VIDE, "tentative de récupérer la teteLD d'une liste videLD");
|
||||
return &(*l)->suiv;
|
||||
}
|
||||
|
||||
Voeux* teteLV(ListeVoeux* l) {
|
||||
if (videLV(l))
|
||||
fatal(LISTE_VIDE, "tentative de récupérer la teteLD d'une liste videLD");
|
||||
return (*l)->voeux;
|
||||
}
|
||||
|
||||
bool videLV(ListeVoeux* l) {
|
||||
return *l == NULL;
|
||||
}
|
||||
|
||||
int longueurLV(ListeVoeux* l) {
|
||||
MaillonVoeux* m = *l;
|
||||
int i = 0;
|
||||
while (!videLV(&m)) {
|
||||
i++;
|
||||
m = m->suiv;
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
void freeListeVoeux(ListeVoeux* l) {
|
||||
MaillonVoeux* mv = *l, *aux;
|
||||
while (mv != NULL) {
|
||||
aux = mv;
|
||||
mv = mv->suiv;
|
||||
free(aux);
|
||||
}
|
||||
}
|
||||
|
||||
bool contientVoeux(ListeVoeux* lv, Voeux* v) {
|
||||
MaillonVoeux* mv = *lv;
|
||||
while (!videLV(&mv)) {
|
||||
if (voeuxEgal(teteLV(&mv), v)) return true;
|
||||
mv = *queueLV(&mv);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool listeVoeuxEgal(ListeVoeux* a, ListeVoeux* b) {
|
||||
int l = longueurLV(a);
|
||||
if (l != longueurLV(b))
|
||||
return false;
|
||||
MaillonVoeux* at = *a;
|
||||
MaillonVoeux* bt = *b;
|
||||
for (int i = 0; i < l; i++) {
|
||||
if (!voeuxEgal(at->voeux, bt->voeux)) return false;
|
||||
at = at->suiv;
|
||||
bt = bt->suiv;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
@ -0,0 +1,33 @@
|
||||
#include "src/logique/candidature/voeux.h"
|
||||
#include <stdbool.h>
|
||||
|
||||
//Listes de voeux
|
||||
typedef struct maillonVoeux {
|
||||
Voeux* voeux;
|
||||
struct maillonVoeux* suiv;
|
||||
} MaillonVoeux, * ListeVoeux;
|
||||
|
||||
/*
|
||||
* Manipulations sur les listes de voeux
|
||||
*/
|
||||
ListeVoeux nouvListeVoeux(void);
|
||||
|
||||
void ajouterVoeux(ListeVoeux* l, Voeux* v);
|
||||
|
||||
void supprimerVoeux(ListeVoeux* l, Voeux* v);
|
||||
|
||||
ListeVoeux* queueLV(ListeVoeux* l);
|
||||
|
||||
Voeux* teteLV(ListeVoeux* l);
|
||||
|
||||
bool videLV(ListeVoeux* l);
|
||||
|
||||
int longueurLV(ListeVoeux* l);
|
||||
|
||||
void freeListeVoeux(ListeVoeux* l);
|
||||
|
||||
bool contientVoeux(ListeVoeux* l, Voeux* v);
|
||||
|
||||
bool listeVoeuxEgal(ListeVoeux* a, ListeVoeux* b);
|
||||
|
||||
ListeVoeux filtrerLVPourIut(ListeVoeux* lv, VilleIUT* iut);
|
||||
@ -1,91 +1,48 @@
|
||||
#ifndef compte_h
|
||||
#define compte_h
|
||||
|
||||
#include <stdbool.h>
|
||||
#include "src/logique/compte/compte.h"
|
||||
#include "src/logique/formation/ville_iut.h"
|
||||
#include "src/logique/formation/departement.h"
|
||||
|
||||
typedef enum {
|
||||
CANDIDAT, RECRUTEUR, ADMINISTRATEUR
|
||||
} TypeCompte;
|
||||
|
||||
#define LONGUEUR_MAX_NOM 32
|
||||
#define LONGUEUR_MAX_PRENOM 32
|
||||
#define LONGUEUR_MAX_MDP 64
|
||||
|
||||
char* nomTypeCompte(TypeCompte tc);
|
||||
|
||||
|
||||
/**
|
||||
* Détermine la structure d'un personnel travaillant pour une IUT
|
||||
* Voire même dans un département spécifique.
|
||||
* */
|
||||
typedef struct {
|
||||
/**
|
||||
* L'IUT dans lequel travaille ce membre du personnel
|
||||
* */
|
||||
VilleIUT* iut;
|
||||
/**
|
||||
* Eventuellement le département où il est rattaché (NULL si il n'est pas rattaché à un département spécifique)
|
||||
* Le département ne vaut pas null si le membre du personnel est un recruteur.
|
||||
* S'il est administrateur, le département vaudra alors NULL.
|
||||
* */
|
||||
Dep* dept;
|
||||
} Personnel;
|
||||
|
||||
|
||||
typedef struct {
|
||||
char* nom;
|
||||
char* prenom;
|
||||
int identifiant;
|
||||
TypeCompte type;
|
||||
Personnel* personnel; //Vaut NULL si type = CANDIDAT
|
||||
} Compte;
|
||||
|
||||
|
||||
|
||||
void freeCompte(Compte* c);
|
||||
|
||||
/**
|
||||
* Definit une liste chainé de compte.
|
||||
* Cette liste est triée sur les identifiants des comptes.bin et n'accepte pas les doublons.
|
||||
* */
|
||||
typedef struct maillonCompte {
|
||||
Compte* compte;
|
||||
int hashmdp;
|
||||
struct maillonCompte* suiv;
|
||||
} MaillonCompte, *ListeCompte;
|
||||
|
||||
ListeCompte *queueLC(ListeCompte *l);
|
||||
struct personnel;
|
||||
typedef struct personnel Personnel;
|
||||
|
||||
Compte *teteLC(ListeCompte *l);
|
||||
|
||||
int longueurLC(ListeCompte *l);
|
||||
|
||||
bool videLC(ListeCompte *l);
|
||||
|
||||
#define LONGUEUR_MAX_NOM 32
|
||||
#define LONGUEUR_MAX_PRENOM 32
|
||||
#define LONGUEUR_MAX_MDP 64
|
||||
|
||||
ListeCompte chargerComptes(char* nomFich, VilleIUT* tiut[], int nbVilles);
|
||||
struct compte;
|
||||
typedef struct compte Compte;
|
||||
|
||||
void sauvegarderComptes(char* nomFich, ListeCompte* lc);
|
||||
Compte* nouvCandidat(char* nom, char* prenom, int id);
|
||||
Compte* nouvAdministrateur(char* nom, char* prenom, int id, VilleIUT* iut);
|
||||
Compte* nouvRecruteur(char* nom, char* prenom, int id, VilleIUT* iut, Dep* dep);
|
||||
|
||||
/**
|
||||
* Libère la liste <u>et aussi les comptes.bin qu'elle contient</u>
|
||||
* */
|
||||
void freeListeCompte(ListeCompte* lc);
|
||||
int getIDCompte(Compte* c);
|
||||
char* getNom(Compte* c);
|
||||
char* getPrenom(Compte* c);
|
||||
TypeCompte getType(Compte* c);
|
||||
VilleIUT* getIutPersonnel(Compte* c);
|
||||
Dep* getDepPersonnel(Compte* c);
|
||||
|
||||
/**
|
||||
*
|
||||
* */
|
||||
Compte* creerCompte(ListeCompte* lc, char* nom, char* prenom, TypeCompte type, Personnel* personnel, char* mdp);
|
||||
void freeCompte(Compte* c);
|
||||
|
||||
/**
|
||||
* permet de trouver un compte dans le fichier des comptes,
|
||||
* Le compte n'est réllement retourné que si le mot de passe est le bon
|
||||
* */
|
||||
Compte* debloquerCompte(ListeCompte* lc, int identifiant, char* mdp);
|
||||
Compte* lireCompte(FILE* f, VilleIUT* tiut[], int nbVilles);
|
||||
void ecrireCompte(Compte* c, FILE* f);
|
||||
|
||||
/**
|
||||
* Trouve et retourne un compte comportant l'identifiant.
|
||||
* */
|
||||
Compte* trouverCompte(ListeCompte* lc, int identifiant);
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,72 @@
|
||||
#include "src/logique/compte/gestion_compte.h"
|
||||
|
||||
int hashMdp(char* mdp) {
|
||||
int len = strlen(mdp);
|
||||
int hash = 1;
|
||||
for (int i = 0; i < len; i++) {
|
||||
hash *= (31 + mdp[i]) % 1000000007;
|
||||
}
|
||||
return hash;
|
||||
}
|
||||
|
||||
|
||||
Compte* trouverCompte(ListeCompte* lc, int identifiant) {
|
||||
MaillonCompte* m = *lc;
|
||||
while (m != NULL) {
|
||||
if (m->compte->identifiant == identifiant)
|
||||
return m->compte;
|
||||
m = m->suiv;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
|
||||
int trouverIdentifiantValide(ListeCompte* lc) {
|
||||
MaillonCompte* m = *lc;
|
||||
int id = 1;
|
||||
while (m != NULL && m->compte->identifiant == id++)
|
||||
m = m->suiv;
|
||||
return id;
|
||||
}
|
||||
|
||||
Compte* creerCompte(ListeCompte* lc,
|
||||
char* nom,
|
||||
char* prenom,
|
||||
TypeCompte type,
|
||||
VilleIUT* iut,
|
||||
Dep* dept,
|
||||
char* mdp) {
|
||||
|
||||
int identifiant = trouverIdentifiantValide(lc);
|
||||
Compte* compte;
|
||||
switch (type) {
|
||||
case CANDIDAT:
|
||||
compte = nouvCandidat(nom, prenom, id);
|
||||
break;
|
||||
case ADMINISTRATEUR:
|
||||
compte = nouvAdministrateur(nom, prenom, id, iut);
|
||||
break;
|
||||
case RECRUTEUR:
|
||||
compte = nouvRecruteur(nom, prenom, id, iut, dept);
|
||||
break;
|
||||
}
|
||||
ajouterCompte(lc, hashMdp(mdp), compte);
|
||||
return compte;
|
||||
}
|
||||
|
||||
/**
|
||||
* permet de trouver un compte dans le fichier des comptes.bin,
|
||||
* avec un nom et prenom correspondant, pour le bon mot de passe
|
||||
* */
|
||||
Compte* debloquerCompte(ListeCompte* lc, int identifiant, char* mdp) {
|
||||
ListeCompte m = *lc;
|
||||
while (!videLC(m)) {
|
||||
if (getID(tete(m)) == identifiant) break;
|
||||
m = queueLC(m);
|
||||
}
|
||||
|
||||
if (m != NULL && m->hashmdp == hashMdp(mdp))
|
||||
return m->compte;
|
||||
return NULL;
|
||||
}
|
||||
@ -0,0 +1,18 @@
|
||||
#include "src/logique/compte/liste_compte.h"
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
* */
|
||||
Compte* creerCompte(ListeCompte* lc, char* nom, char* prenom, TypeCompte type, VilleIUT* iut, Dep* dept, char* mdp);
|
||||
|
||||
/**
|
||||
* permet de trouver un compte dans le fichier des comptes,
|
||||
* Le compte n'est réllement retourné que si le mot de passe est le bon
|
||||
* */
|
||||
Compte* debloquerCompte(ListeCompte* lc, int identifiant, char* mdp);
|
||||
|
||||
/**
|
||||
* Trouve et retourne un compte comportant l'identifiant.
|
||||
* */
|
||||
Compte* trouverCompte(ListeCompte* lc, int identifiant);
|
||||
@ -0,0 +1,123 @@
|
||||
#include "src/logique/compte/liste_compte.h"
|
||||
#include "src/logique/compte/compte.h"
|
||||
|
||||
|
||||
struct maillonCompte {
|
||||
Compte* compte;
|
||||
int hashmdp;
|
||||
struct maillonCompte* suiv;
|
||||
};
|
||||
|
||||
|
||||
|
||||
//minimum de fonctions requises par compte.c pour manipuler la liste des comptes.bin.
|
||||
ListeCompte nouvListeComptes(void) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ListeCompte* queueLC(ListeCompte* l) {
|
||||
if (videLC(l))
|
||||
fatal(LISTE_VIDE, "La liste de compte est vide.");
|
||||
return &(*l)->suiv;
|
||||
}
|
||||
|
||||
Compte* teteLC(ListeCompte* l) {
|
||||
if (videLC(l))
|
||||
fatal(LISTE_VIDE, "La liste de compte est vide.");
|
||||
return (*l)->compte;
|
||||
}
|
||||
|
||||
int longueurLC(ListeCompte* l) {
|
||||
MaillonCompte* mc = *l;
|
||||
int nb = 0;
|
||||
while (mc != NULL) {
|
||||
nb++;
|
||||
mc = mc->suiv;
|
||||
}
|
||||
return nb;
|
||||
}
|
||||
|
||||
bool videLC(ListeCompte* lc) {
|
||||
return *lc == NULL;
|
||||
}
|
||||
|
||||
|
||||
//TODO expliquer pourquoi je fais la technique iterative et pas recursive ici (bcp d'elements possibles dans cette liste)
|
||||
/**
|
||||
* ajoute un compte s'il n'existe pas déja un compte portant le meme identifiant.
|
||||
* \return true Si le nouveau compte a pu être inséré dans la liste, false s'il existe deja un compte avec le meme identifiant.
|
||||
* */
|
||||
bool ajouterCompte(ListeCompte* lc, int mdpHash, Compte* c) {
|
||||
MaillonCompte** m = lc;
|
||||
//on cherche le bon emplacement où insérer le compte
|
||||
while (*m != NULL && (*m)->compte->identifiant < c->identifiant) {
|
||||
m = &(*m)->suiv;
|
||||
}
|
||||
|
||||
if (*m != NULL && (*m)->compte->identifiant == c->identifiant) //il existe un compte avec le meme identifiant
|
||||
return false;
|
||||
|
||||
MaillonCompte* nouv = (MaillonCompte*) malloc(sizeof(MaillonCompte));
|
||||
if (nouv == NULL)
|
||||
fatal(ERREUR_MEMOIRE, "impossible d'allouer un nouveau compte.");
|
||||
nouv->compte = c;
|
||||
nouv->hashmdp = mdpHash;
|
||||
nouv->suiv = *m; //Le nouveau maillon pointe vers le maillon remplacé
|
||||
*m = nouv; //le pointeur du maillon remplacé devient le nouveau maillon
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
void freeListeCompte(ListeCompte* lc) {
|
||||
MaillonCompte* m = *lc;
|
||||
while (m != NULL) {
|
||||
MaillonCompte* aux = m;
|
||||
m = m->suiv;
|
||||
free(aux);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
ListeCompte chargerComptes(char* nomFich, VilleIUT* tiut[], int nbVilles) {
|
||||
FILE* f = fopen(nomFich, "rb");
|
||||
if (f == NULL)
|
||||
fatal(OUVERTURE_FICHIER, "impossible de lire dans le fichier des comptes.bin..");
|
||||
|
||||
ListeCompte lc = nouvListeComptes();
|
||||
int nb;
|
||||
if (!fread(&nb, sizeof(int), 1, f)) { //le fichier est vide
|
||||
fclose(f);
|
||||
return lc;
|
||||
}
|
||||
|
||||
int mdpHash;
|
||||
|
||||
for (int i = 0; i < nb; i++) {
|
||||
Compte* c = lireCompte(f, tiut, nbVilles);
|
||||
fread(&mdpHash, sizeof(int), 1, f);
|
||||
ajouterCompte(&lc, mdpHash, c);
|
||||
}
|
||||
fclose(f);
|
||||
return lc;
|
||||
}
|
||||
|
||||
|
||||
void sauvegarderComptes(char* nomFich, ListeCompte* lc) {
|
||||
FILE* f = fopen(nomFich, "wb");
|
||||
if (f == NULL)
|
||||
fatal(OUVERTURE_FICHIER, "impossible d'ecrire dans le fichier.");
|
||||
|
||||
MaillonCompte* m = *lc;
|
||||
int l = longueurLC(lc);
|
||||
fwrite(&l, sizeof(int), 1, f);
|
||||
while (m != NULL) {
|
||||
ecrireCompte(m->compte, f);
|
||||
fwrite(&m->hashmdp, sizeof(int), 1, f);
|
||||
m = m->suiv;
|
||||
}
|
||||
fclose(f);
|
||||
}
|
||||
|
||||
@ -0,0 +1,33 @@
|
||||
#include "src/logique/compte/compte.h"
|
||||
#include "src/logique/formation/ville_iut.h"
|
||||
#include "src/logique/formation/tab_iut.h"
|
||||
|
||||
|
||||
/**
|
||||
* Definit une liste chainé de compte.
|
||||
* Cette liste est triée sur les identifiants des comptes.bin et n'accepte pas les doublons.
|
||||
* */
|
||||
|
||||
struct compte;
|
||||
typedef struct compte Compte;
|
||||
|
||||
struct maillonCompte;
|
||||
typedef struct maillonCompte MaillonCompte, * ListeCompte;
|
||||
|
||||
ListeCompte* queueLC(ListeCompte* l);
|
||||
|
||||
Compte* teteLC(ListeCompte* l);
|
||||
|
||||
int longueurLC(ListeCompte* l);
|
||||
|
||||
bool videLC(ListeCompte* l);
|
||||
|
||||
|
||||
ListeCompte chargerComptes(char* nomFich, VilleIUT* tiut[], int nbVilles);
|
||||
|
||||
void sauvegarderComptes(char* nomFich, ListeCompte* lc);
|
||||
|
||||
/**
|
||||
* Libère la liste <u>et aussi les comptes.bin qu'elle contient</u>
|
||||
* */
|
||||
void freeListeCompte(ListeCompte* lc);
|
||||
@ -0,0 +1,53 @@
|
||||
#include "src/logique/formation/departement.h"
|
||||
|
||||
struct dep {
|
||||
/**
|
||||
* Le nom du département.
|
||||
* */
|
||||
char departement[TAILLE_NOM_DEPARTEMENT];
|
||||
/**
|
||||
* Le nombre de places disponnibles en première année
|
||||
* */
|
||||
int nbP;
|
||||
/**
|
||||
* Le nom du responsable du département.
|
||||
* */
|
||||
char responsable[TAILLE_NOM_RESPONSABLE];
|
||||
|
||||
/**
|
||||
* Les resultats d'admissions du centre d'examen du departement.
|
||||
* */
|
||||
ResultatsAdmission* admissions;
|
||||
};
|
||||
|
||||
char* getNomDept(Dep* dept) {
|
||||
return dept->departement;
|
||||
}
|
||||
|
||||
int getNbPlacesDispo(Dep* dept) {
|
||||
return dept->nbP;
|
||||
}
|
||||
|
||||
void setNbPlacesDispo(Dep* dept, int nbPlaces) {
|
||||
if (nbPlaces < 0)
|
||||
fatal(ARGUMENT_INVALIDE, "le nombre de places disponnibles est inférieur.");
|
||||
dept->nbP = nbPlaces;
|
||||
}
|
||||
char* getNomResponsable(Dep* dept) {
|
||||
return dept->responsable;
|
||||
}
|
||||
void setNomResponsable(Dep* dept, char nomResp[TAILLE_NOM_RESPONSABLE]) {
|
||||
strcpy(dept->responsable, nomResp);
|
||||
}
|
||||
|
||||
|
||||
Dep* lireDepartement(FILE* f) {
|
||||
Dep* d = (Dep*) malloc(sizeof(Dep));
|
||||
if (d == NULL)
|
||||
fatal(ERREUR_MEMOIRE, "impossible de malloc un nouveau Departement.");
|
||||
fscanf(f, "%s", d->departement);
|
||||
fscanf(f, "%d%*c", &d->nbP);
|
||||
fgets(d->responsable, 30, fe);
|
||||
d->responsable[strlen(d->responsable) - 1] = '\0';
|
||||
d->admissions = lireResultatsAdmission()
|
||||
}
|
||||
@ -0,0 +1,21 @@
|
||||
#ifndef departement_h
|
||||
#define departement_h
|
||||
|
||||
#define TAILLE_NOM_DEPARTEMENT 31
|
||||
#define TAILLE_NOM_RESPONSABLE 31
|
||||
|
||||
|
||||
/**
|
||||
* Structure d'un département d'IUT.
|
||||
* */
|
||||
struct dep;
|
||||
typedef struct dep Dep;
|
||||
|
||||
Dep* lireDepartement(FILE* f);
|
||||
char* getNomDept(Dep* dept);
|
||||
int getNbPlacesDispo(Dep* dept);
|
||||
void setNbPlacesDispo(Dep* dept, int nbPlaces);
|
||||
char* getNomResponsable(Dep* dept);
|
||||
void setNomResponsable(Dep* dept, char nomResp[TAILLE_NOM_RESPONSABLE]);
|
||||
|
||||
#endif
|
||||
@ -1,5 +0,0 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
@ -0,0 +1,130 @@
|
||||
#include "src/logique/formation/tab_iut.h"
|
||||
|
||||
|
||||
int indiceVilleInsertion(VilleIUT *tab[], char *nomVille, int nb)
|
||||
{
|
||||
int inf=0, sup=nb-1, m;
|
||||
while(inf<=sup)
|
||||
{
|
||||
m=(inf+sup)/2;
|
||||
int cmp = strcmp(tab[m]->ville, nomVille);
|
||||
if(cmp==0)
|
||||
return m;
|
||||
|
||||
else if(cmp < 0)
|
||||
inf=m+1;
|
||||
else sup=m-1;
|
||||
}
|
||||
return inf;
|
||||
}
|
||||
|
||||
|
||||
void insererVilleIUT(VilleIUT* tab[], int nbVilles, int nbmax, VilleIUT* iut) {
|
||||
if (nbVilles == nbmax)
|
||||
fatal(TABLEAU_PLEIN, "Le tableau des villes est plein");
|
||||
int idx = indiceVilleInsertion(tab, iut->ville, nbVilles);
|
||||
for (int i = nbVilles; i > idx; i--)
|
||||
tab[i] = tab[i - 1];
|
||||
tab[idx] = iut;
|
||||
}
|
||||
|
||||
|
||||
int chargerVillesIUT(char* nomFich, VilleIUT *tab[], int nbmax)
|
||||
{
|
||||
FILE *fe = fopen(nomFich, "r");
|
||||
if(fe==NULL)
|
||||
fatal(OUVERTURE_FICHIER, "Impossible de lire le fichier des formations");
|
||||
int i = 0;
|
||||
VilleIUT* vi;
|
||||
vi=lireVilleIUT(fe);
|
||||
while(!feof(fe))
|
||||
{
|
||||
if(i==nbmax)
|
||||
{
|
||||
fclose(fe);
|
||||
fatal(TABLEAU_PLEIN, "Plus assez de place dans le tableau des formations !");
|
||||
}
|
||||
insererVilleIUT(tab, i, nbmax, vi);
|
||||
i=i+1;
|
||||
vi=lireVilleIUT(fe);
|
||||
}
|
||||
fclose(fe);
|
||||
return i;
|
||||
}
|
||||
|
||||
void libererVillesIUT(VilleIUT *tab[], int nb)
|
||||
{
|
||||
for(int i=0; i<nb; i++)
|
||||
free(tab[i]);
|
||||
}
|
||||
|
||||
void sauvegarderVilleIUT(VilleIUT* iut, FILE* f) {
|
||||
fprintf(f, "%s\n%d\n", iut->ville, longueurLD(iut->ldept));
|
||||
Dep* dep;
|
||||
ListeDept ldept = iut->ldept;
|
||||
while (!(videLD(ldept))) {
|
||||
dep = teteLD(ldept);
|
||||
fprintf(f, "%s\n%d\n%s\n", dep->departement, dep->nbP, dep->responsable);
|
||||
ldept = queueLD(ldept);
|
||||
}
|
||||
}
|
||||
|
||||
int sauvegarderVillesIUT(char* nomFich, VilleIUT *tab[], int nb)
|
||||
{
|
||||
FILE *fe = fopen(nomFich, "w");
|
||||
if(fe==NULL)
|
||||
return -1; //TODO : code erreur
|
||||
for(int i=0; i<nb; i++)
|
||||
{
|
||||
sauvegarderVilleIUT(tab[i], fe);
|
||||
}
|
||||
fclose(fe);
|
||||
return 0; //TODO : code erreur
|
||||
}
|
||||
|
||||
int indiceVille(VilleIUT *tab[], char *nomVille, int nb)
|
||||
{
|
||||
int inf=0, sup=nb-1, m;
|
||||
while(inf<=sup)
|
||||
{
|
||||
m=(inf+sup)/2;
|
||||
int cmp = strcmp(tab[m]->ville, nomVille);
|
||||
if(cmp==0)
|
||||
{
|
||||
return m;
|
||||
}
|
||||
else if(cmp < 0)
|
||||
inf=m+1;
|
||||
else sup=m-1;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
VilleIUT* creerVilleIUT(VilleIUT *tab[], int nbVilles, int nbmax, char *nomVille, bool* existe) {
|
||||
int idx = indiceVille(tab, nomVille, nbVilles);
|
||||
if (idx != -1) {
|
||||
*existe = true;
|
||||
return tab[idx];
|
||||
}
|
||||
if (nbVilles == nbmax)
|
||||
fatal(TABLEAU_PLEIN, "Le tableau des iuts est plein !");
|
||||
*existe = false;
|
||||
VilleIUT* iut = (VilleIUT*) malloc(sizeof(VilleIUT));
|
||||
if (iut == NULL)
|
||||
fatal(ERREUR_MEMOIRE, "Impossible de malloc une nouvelle VilleIUT");
|
||||
strcpy(iut->ville, nomVille);
|
||||
iut->ldept = listeDeptNouv();
|
||||
insererVilleIUT(tab, nbVilles, nbmax, iut);
|
||||
return iut;
|
||||
}
|
||||
|
||||
bool villeExiste(VilleIUT* tab[], char* nomVille, int nbVilles) {
|
||||
return indiceVille(tab, nomVille, nbVilles) != -1;
|
||||
}
|
||||
|
||||
VilleIUT* trouverVille(VilleIUT* tab[], char* nomVille, int nbVilles) {
|
||||
int idx = indiceVille(tab, nomVille, nbVilles);
|
||||
if (idx == -1) return NULL;
|
||||
return tab[idx];
|
||||
}
|
||||
@ -0,0 +1,17 @@
|
||||
#ifndef tab_iut_h
|
||||
#define tab_iut_h
|
||||
|
||||
#include "src/logique/formation/ville_iut.h"
|
||||
#include <stdbool.h>
|
||||
|
||||
int chargerVillesIUT(char* nomFich, VilleIUT *tab[], int nbmax);
|
||||
int sauvegarderVillesIUT(char* nomFich, VilleIUT *tab[], int nb);
|
||||
void libererVillesIUT(VilleIUT *tab[], int nb);
|
||||
|
||||
|
||||
int indiceVille(VilleIUT *tab[], char *nomVille, int nb);
|
||||
bool villeExiste(VilleIUT* tab[], char* nomVille, int nb);
|
||||
VilleIUT* trouverVille(VilleIUT* tab[], char* nomVille, int nb);
|
||||
VilleIUT* creerVilleIUT(VilleIUT *tab[], int nbVilles, int nbmax, char *nomVille, bool* existe);
|
||||
|
||||
#endif
|
||||
@ -1,155 +1,43 @@
|
||||
#include "ville_iut.h"
|
||||
#include "src/logique/formation/ville_iut.h"
|
||||
#include "src/logique/formation/liste_dept.h"
|
||||
|
||||
struct villeIUT {
|
||||
char ville[TAILLE_NOM_VILLE];
|
||||
ListeDept ldept;
|
||||
};
|
||||
|
||||
VilleIUT* lireVilleIUT(FILE *fe)
|
||||
{
|
||||
VilleIUT* vi = (VilleIUT*) malloc(sizeof(VilleIUT));
|
||||
if (vi == NULL)
|
||||
fatal(ERREUR_MEMOIRE, "Impossible de malloc une nouvelle VilleIUT");
|
||||
int nbIut = 0;
|
||||
vi->ldept = listeDeptNouv();
|
||||
fscanf(fe, "%s", vi->ville);
|
||||
fscanf(fe, "%d", &nbIut);
|
||||
for(int i=0; i<nbIut; i++)
|
||||
{
|
||||
Dep* d = (Dep *) malloc(sizeof(Dep));
|
||||
if (d == NULL)
|
||||
fatal(ERREUR_MEMOIRE, "impossible de malloc un nouveau Departement.");
|
||||
fscanf(fe, "%s", d->departement);
|
||||
fscanf(fe, "%d%*c", &d->nbP);
|
||||
fgets(d->responsable, 30, fe);
|
||||
d->responsable[strlen(d->responsable) - 1] = '\0';
|
||||
vi->ldept=insererLD(vi->ldept, d);
|
||||
}
|
||||
return vi;
|
||||
}
|
||||
|
||||
|
||||
|
||||
int indiceVilleInsertion(VilleIUT *tab[], char *nomVille, int nb)
|
||||
{
|
||||
int inf=0, sup=nb-1, m;
|
||||
while(inf<=sup)
|
||||
{
|
||||
m=(inf+sup)/2;
|
||||
int cmp = strcmp(tab[m]->ville, nomVille);
|
||||
if(cmp==0)
|
||||
return m;
|
||||
|
||||
else if(cmp < 0)
|
||||
inf=m+1;
|
||||
else sup=m-1;
|
||||
}
|
||||
return inf;
|
||||
}
|
||||
|
||||
|
||||
void insererVilleIUT(VilleIUT* tab[], int nbVilles, int nbmax, VilleIUT* iut) {
|
||||
if (nbVilles == nbmax)
|
||||
fatal(TABLEAU_PLEIN, "Le tableau des villes est plein");
|
||||
int idx = indiceVilleInsertion(tab, iut->ville, nbVilles);
|
||||
for (int i = nbVilles; i > idx; i--)
|
||||
tab[i] = tab[i - 1];
|
||||
tab[idx] = iut;
|
||||
}
|
||||
|
||||
|
||||
int chargerVillesIUT(char* nomFich, VilleIUT *tab[], int nbmax)
|
||||
{
|
||||
FILE *fe = fopen(nomFich, "r");
|
||||
if(fe==NULL)
|
||||
fatal(OUVERTURE_FICHIER, "Impossible de lire le fichier des formations");
|
||||
int i = 0;
|
||||
VilleIUT* vi;
|
||||
vi=lireVilleIUT(fe);
|
||||
while(!feof(fe))
|
||||
{
|
||||
if(i==nbmax)
|
||||
{
|
||||
fclose(fe);
|
||||
fatal(TABLEAU_PLEIN, "Plus assez de place dans le tableau des formations !");
|
||||
}
|
||||
insererVilleIUT(tab, i, nbmax, vi);
|
||||
i=i+1;
|
||||
vi=lireVilleIUT(fe);
|
||||
}
|
||||
fclose(fe);
|
||||
return i;
|
||||
ListeDept* getDepartements(VilleIUT* iut) {
|
||||
return iut->ldept;
|
||||
}
|
||||
|
||||
void libererVillesIUT(VilleIUT *tab[], int nb)
|
||||
{
|
||||
for(int i=0; i<nb; i++)
|
||||
free(tab[i]);
|
||||
Dep* getDepartement(VilleIUT* iut, char* nomDept) {
|
||||
return trouverDepartement(iut->ldept, nomDept);
|
||||
}
|
||||
|
||||
void sauvegarderVilleIUT(VilleIUT* iut, FILE* f) {
|
||||
fprintf(f, "%s\n%d\n", iut->ville, longueurLD(iut->ldept));
|
||||
Dep* dep;
|
||||
ListeDept ldept = iut->ldept;
|
||||
while (!(videLD(ldept))) {
|
||||
dep = teteLD(ldept);
|
||||
fprintf(f, "%s\n%d\n%s\n", dep->departement, dep->nbP, dep->responsable);
|
||||
ldept = queueLD(ldept);
|
||||
}
|
||||
char* getNomVille(VilleIUT* iut) {
|
||||
return iut->ville;
|
||||
}
|
||||
|
||||
int sauvegarderVillesIUT(char* nomFich, VilleIUT *tab[], int nb)
|
||||
{
|
||||
FILE *fe = fopen(nomFich, "w");
|
||||
if(fe==NULL)
|
||||
return -1; //TODO : code erreur
|
||||
for(int i=0; i<nb; i++)
|
||||
{
|
||||
sauvegarderVilleIUT(tab[i], fe);
|
||||
}
|
||||
fclose(fe);
|
||||
return 0; //TODO : code erreur
|
||||
VilleIUT* nouvVilleIUT(char* nomVille) {
|
||||
VilleIUT* vi = (VilleIUT*) malloc(sizeof(VilleIUT));
|
||||
if (vi == NULL)
|
||||
fatal(ERREUR_MEMOIRE, "Impossible de malloc une nouvelle VilleIUT");
|
||||
vi->ldept = listeDepNouv();
|
||||
return vi;
|
||||
}
|
||||
|
||||
int indiceVille(VilleIUT *tab[], char *nomVille, int nb)
|
||||
{
|
||||
int inf=0, sup=nb-1, m;
|
||||
while(inf<=sup)
|
||||
{
|
||||
m=(inf+sup)/2;
|
||||
int cmp = strcmp(tab[m]->ville, nomVille);
|
||||
if(cmp==0)
|
||||
{
|
||||
return m;
|
||||
}
|
||||
else if(cmp < 0)
|
||||
inf=m+1;
|
||||
else sup=m-1;
|
||||
VilleIUT* lireVilleIUT(FILE* fe) {
|
||||
char nomVille[TAILLE_NOM_VILLE];
|
||||
fscanf(fe, "%s", nomVille);
|
||||
VilleIUT* vi = nouvVilleIUT(nomVille);
|
||||
int nbIut = 0;
|
||||
fscanf(fe, "%d", &nbIut);
|
||||
for (int i = 0; i < nbIut; i++) {
|
||||
Dep* d = lireDepartement(fe);
|
||||
vi->ldept = insererLD(vi->ldept, d);
|
||||
}
|
||||
return -1;
|
||||
return vi;
|
||||
}
|
||||
|
||||
|
||||
VilleIUT* creerVilleIUT(VilleIUT *tab[], int nbVilles, int nbmax, char *nomVille, bool* existe) {
|
||||
int idx = indiceVille(tab, nomVille, nbVilles);
|
||||
if (idx != -1) {
|
||||
*existe = true;
|
||||
return tab[idx];
|
||||
}
|
||||
if (nbVilles == nbmax)
|
||||
fatal(TABLEAU_PLEIN, "Le tableau des iuts est plein !");
|
||||
*existe = false;
|
||||
VilleIUT* iut = (VilleIUT*) malloc(sizeof(VilleIUT));
|
||||
if (iut == NULL)
|
||||
fatal(ERREUR_MEMOIRE, "Impossible de malloc une nouvelle VilleIUT");
|
||||
strcpy(iut->ville, nomVille);
|
||||
iut->ldept = listeDeptNouv();
|
||||
insererVilleIUT(tab, nbVilles, nbmax, iut);
|
||||
return iut;
|
||||
}
|
||||
|
||||
bool villeExiste(VilleIUT* tab[], char* nomVille, int nbVilles) {
|
||||
return indiceVille(tab, nomVille, nbVilles) != -1;
|
||||
}
|
||||
|
||||
VilleIUT* trouverVille(VilleIUT* tab[], char* nomVille, int nbVilles) {
|
||||
int idx = indiceVille(tab, nomVille, nbVilles);
|
||||
if (idx == -1) return NULL;
|
||||
return tab[idx];
|
||||
}
|
||||
@ -1,27 +1,19 @@
|
||||
#include "liste_dept.h"
|
||||
#include "iut.h"
|
||||
#include "../erreur.h"
|
||||
#ifndef ville_iut_h
|
||||
#define ville_iut_h
|
||||
|
||||
#define TAILLE_NOM_VILLE 31
|
||||
|
||||
|
||||
|
||||
typedef struct {
|
||||
char ville[TAILLE_NOM_VILLE];
|
||||
ListeDept ldept;
|
||||
} VilleIUT;
|
||||
#include "src/logique/erreur.h"
|
||||
#include "src/logique/formation/liste_dept.h"
|
||||
|
||||
#define TAILLE_NOM_VILLE 31
|
||||
|
||||
int chargerVillesIUT(char* nomFich, VilleIUT *tab[], int nbmax);
|
||||
int sauvegarderVillesIUT(char* nomFich, VilleIUT *tab[], int nb);
|
||||
void libererVillesIUT(VilleIUT *tab[], int nb);
|
||||
struct villeIUT;
|
||||
typedef struct villeIUT VilleIUT;
|
||||
|
||||
ListeDept* getDepartements(VilleIUT* iut);
|
||||
Dep* getDepartement(VilleIUT* iut, char* nomDept);
|
||||
char* getNomVille(VilleIUT* iut);
|
||||
|
||||
int indiceVille(VilleIUT *tab[], char *nomVille, int nb);
|
||||
bool villeExiste(VilleIUT* tab[], char* nomVille, int nb);
|
||||
VilleIUT* trouverVille(VilleIUT* tab[], char* nomVille, int nb);
|
||||
VilleIUT* creerVilleIUT(VilleIUT *tab[], int nbVilles, int nbmax, char *nomVille, bool* existe);
|
||||
VilleIUT* nouvVilleIUT(char* nomVille);
|
||||
VilleIUT* lireVilleIUT(FILE *fe);
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,89 @@
|
||||
#include "src/logique/recrutement/admissions.h"
|
||||
|
||||
|
||||
struct resultatsAdmission {
|
||||
/**
|
||||
* Le nombre de places restant disponnibles dans le département.
|
||||
* */
|
||||
int* nbPlacesDispo;
|
||||
/**
|
||||
* La place minimum dans la file d'attente qu'il faut pour que les candidats
|
||||
* en attente puissent être accepté par l'iut.
|
||||
* */
|
||||
int placeMinimumFAAdmis;
|
||||
|
||||
/**
|
||||
* Contient la liste des candidats acceptés par l'iut.
|
||||
* NOTE: lorsque le candidat refuse la proposition, il est supprimé de la liste.
|
||||
* La taille de cette liste ne peut dépasser le nombre de places du département.
|
||||
* */
|
||||
ListeProfil accepte;
|
||||
/**
|
||||
* File des profil en attente.
|
||||
* Lorsqu'un candidat accepte une proposition, son profil est supprimé de toutes les files d'attentes.
|
||||
* */
|
||||
FileProfil attente;
|
||||
};
|
||||
|
||||
FILE* ouvrirFichierResultats(char* emplacement, char* nomVille, char* nomDep, char* prefix) {
|
||||
char* fileName = (char*) malloc(sizeof(char) * (strlen(emplacement)
|
||||
+ 1
|
||||
+ strlen(prefix)
|
||||
+ strlen(nomVille)
|
||||
+ 1
|
||||
+ strlen(nomDep)));
|
||||
strcpy(fileName, emplacement);
|
||||
strcat(fileName, "/");
|
||||
strcat(fileName, prefix);
|
||||
strcat(fileName, nomVille);
|
||||
strcat(fileName, "_");
|
||||
strcat(fileName, nomDep);
|
||||
FILE* f = fopen(fileName, "w");
|
||||
if (f == NULL) {
|
||||
fprintf(stderr, "Impossible d'ouvrir le fichier %s en ecriture.", fileName);
|
||||
exit(OUVERTURE_FICHIER);
|
||||
}
|
||||
return f;
|
||||
}
|
||||
|
||||
void sauvegarderResultatsAdmission(ResultatsAdmission* resultats, char* emplacement, char* nomVille, char* nomDept) {
|
||||
FILE* accepte = ouvrirFichierResultats(emplacement, nomVille, nomDept, "accepte_");
|
||||
FILE* attente = ouvrirFichierResultats(emplacement, nomVille, nomDept, "attente_");
|
||||
/*int placeEnAttente = 0;
|
||||
while (!videLP(resultat)) {
|
||||
Profil* p = teteLP(resultat);
|
||||
int id = p->id;
|
||||
switch (*p->decision) {
|
||||
case ACCEPTE:
|
||||
fprintf(accepte, "%d\n", id);
|
||||
break;
|
||||
case EN_ATTENTE:
|
||||
fprintf(attente, "%d %d\n", id, ++placeEnAttente);
|
||||
break;
|
||||
}
|
||||
resultat = queueLP(resultat);
|
||||
}*/
|
||||
fclose(accepte);
|
||||
fclose(attente);
|
||||
}
|
||||
|
||||
ResultatsAdmission* lireResultatsAdmission(char* emplacement, char* nomVille, char* nomDept, int* nbPlacesDispo) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ResultatsAdmission* nouvResultatsAdmissions(int* nbPlacesDispo, int placeMinimumFAAdmis) {
|
||||
ResultatsAdmission* admissions = (ResultatsAdmission*) malloc(sizeof(ResultatsAdmission));
|
||||
admissions->placeMinimumFAAdmis = placeMinimumFAAdmis;
|
||||
admissions->nbPlacesDispo = nbPlacesDispo;
|
||||
admissions->accepte = nouvListeProfil();
|
||||
admissions->attente = nouvFileProfil();
|
||||
return admissions;
|
||||
}
|
||||
|
||||
bool mettreEnAttente(ResultatsAdmission* adm, Profil* p) {
|
||||
return false;
|
||||
}
|
||||
|
||||
bool transfererVersAcceptes(ResultatsAdmission* adm, Profil* p) {
|
||||
return false;
|
||||
}
|
||||
@ -0,0 +1,24 @@
|
||||
#ifndef admissions_h
|
||||
#define admissions_h
|
||||
|
||||
#include "src/logique/recrutement/profil.h"
|
||||
#include "src/logique/recrutement/file_profil.h"
|
||||
#include "src/logique/recrutement/liste_profil.h"
|
||||
|
||||
/**
|
||||
* Definit une structure représentant le résultat des decisons du centre d'examen de l'iut
|
||||
* du département d'un IUT.
|
||||
* */
|
||||
struct resultatsAdmission;
|
||||
typedef struct resultatsAdmission ResultatsAdmission;
|
||||
|
||||
void sauvegarderResultatsAdmission(ResultatsAdmission* resultats, char* emplacement, char* nomVille, char* nomDept);
|
||||
ResultatsAdmission* lireResultatsAdmission(char* emplacement, char* nomVille, char* nomDept, int* nbPlacesDispo);
|
||||
ResultatsAdmission* nouvResultatsAdmissions(int* nbPlacesDispo, int placeMinimumFAAdmis);
|
||||
|
||||
|
||||
bool mettreEnAttente(ResultatsAdmission* adm, Profil* p);
|
||||
|
||||
bool transfererVersAcceptes(ResultatsAdmission* adm, Profil* p);
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,31 @@
|
||||
#include "src/logique/recrutement/file_profil.h"
|
||||
|
||||
FileProfil nouvFileProfil() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
bool videFP(FileProfil* fp) {
|
||||
return *fp == NULL;
|
||||
}
|
||||
|
||||
void offerProfil(FileProfil* fp, Profil* p) {
|
||||
MaillonProfil* mp = (MaillonProfil*)malloc(sizeof(MaillonProfil));
|
||||
if (mp == NULL)
|
||||
fatal(ERREUR_MEMOIRE, "Impossible de malloc un nouveau maillon profil.");
|
||||
mp->profil = p;
|
||||
mp->suiv = *fp;
|
||||
*fp = mp;
|
||||
}
|
||||
|
||||
Profil* pollProfil(FileProfil* fp) {
|
||||
if (videFP(fp))
|
||||
return NULL;
|
||||
MaillonProfil* tete = (*fp)->suiv;
|
||||
Profil* p = tete->profil;
|
||||
free(tete);
|
||||
return p;
|
||||
}
|
||||
|
||||
void freeFileProfil(FileProfil* fp) {
|
||||
while (pollProfil(fp) != NULL);
|
||||
}
|
||||
@ -0,0 +1,17 @@
|
||||
#include "src/logique/recrutement/profil.h"
|
||||
|
||||
/**
|
||||
* Définit une File FIFO de profils
|
||||
* */
|
||||
typedef MaillonProfil* FileProfil;
|
||||
|
||||
FileProfil nouvFileProfil();
|
||||
|
||||
bool videFP(FileProfil* fp);
|
||||
|
||||
void offerProfil(FileProfil* fp, Profil* p);
|
||||
|
||||
Profil* pollProfil(FileProfil* fp);
|
||||
|
||||
void freeFileProfil(FileProfil* fp);
|
||||
|
||||
@ -0,0 +1,108 @@
|
||||
#include "src/logique/recrutement/profil.h"
|
||||
|
||||
ListeProfil nouvListeProfil() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void freeListeProfil(ListeProfil* lp) {
|
||||
while (!videLP(lp)) {
|
||||
free(aux);
|
||||
aux = queueLP(aux);
|
||||
}
|
||||
}
|
||||
|
||||
void ajouterProfils(ListeProfil* lp, Candidature* candid, VilleIUT* iut, Dep* dept) {
|
||||
ListeVoeux* lv = &candid->voeuxs;
|
||||
while (!videLV(lv)) {
|
||||
Voeux* v = teteLV(lv);
|
||||
if (strcmp(v->nomVille, iut->ville) == 0 && strcmp(v->departement, dept->departement) == 0) {
|
||||
ajouterProfil(lp, nouvProfil(candid->candidat->identifiant, candid->dossier, &v->decisionJury));
|
||||
}
|
||||
lv = queueLV(lv);
|
||||
}
|
||||
}
|
||||
|
||||
ListeProfil extraireProfils(ListeCandidature* lc, VilleIUT* iut, Dep* dept) {
|
||||
ListeProfil lp = nouvListeProfil();
|
||||
while (!videLCa(lc)) {
|
||||
Candidature* candid = teteLCa(lc);
|
||||
ajouterProfils(&lp, candid, iut, dept);
|
||||
lc = queueLCa(lc);
|
||||
}
|
||||
return lp;
|
||||
}
|
||||
|
||||
Profil* trouverProfil(ListeProfil* lp, int id) {
|
||||
while (!videLP(lp)) {
|
||||
Profil* p = teteLP(lp);
|
||||
if (getID(p) == id)
|
||||
return p;
|
||||
lp = queueLP(lp);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
bool videLP(ListeProfil* lp) {
|
||||
return *lp == NULL;
|
||||
}
|
||||
|
||||
Profil* teteLP(ListeProfil* lp) {
|
||||
return (*lp)->profil;
|
||||
}
|
||||
|
||||
ListeProfil* queueLP(ListeProfil* lp) {
|
||||
return &(*lp)->suiv;
|
||||
}
|
||||
|
||||
void ajouterProfil(ListeProfil* lp, Profil* p) {
|
||||
MaillonProfil* mp = (MaillonProfil*) malloc(sizeof(MaillonProfil));
|
||||
if (mp == NULL)
|
||||
fatal(ERREUR_MEMOIRE, "impossible de malloc un nouveau MaillonProfil");
|
||||
ListeProfil* pos = lp; //recherche du maillon avec une note inférieure à la note du profil en ajout.
|
||||
while (!videLP(pos)) {
|
||||
if (teteLP(pos)->note <= p->note)
|
||||
break;
|
||||
pos = queueLP(pos);
|
||||
}
|
||||
mp->profil = p;
|
||||
mp->suiv = *pos;
|
||||
*pos = mp;
|
||||
}
|
||||
|
||||
bool supprimerProfil(ListeProfil* lp, int id) {
|
||||
if (videLP(lp))
|
||||
return false;
|
||||
MaillonProfil** pos = NULL;
|
||||
ListeProfil* aux = lp;
|
||||
//recherche du maillon avec une note inférieure à la note du profil en ajout.
|
||||
while (!videLP(aux)) {
|
||||
if (teteLP(aux)->id == id) {
|
||||
pos = aux;
|
||||
break;
|
||||
}
|
||||
aux = queueLP(aux);
|
||||
}
|
||||
if (pos == NULL)
|
||||
return false;
|
||||
*aux = (*aux)->suiv;
|
||||
free(*aux);
|
||||
return true;
|
||||
}
|
||||
|
||||
void trierLP(ListeProfil* lp) {
|
||||
if (videLP(lp))
|
||||
return;
|
||||
|
||||
ListeProfil* aux = lp;
|
||||
MaillonProfil* max = *aux;
|
||||
while (!videLP(aux)) {
|
||||
if ((*aux)->profil->note > max->profil->note)
|
||||
max = *aux;
|
||||
aux = queueLP(aux);
|
||||
}
|
||||
//le contennu de la tete de la liste echange avec le contenu du maillon maximum
|
||||
MaillonProfil aux2 = *max;
|
||||
*max = **lp;
|
||||
**lp = aux2;
|
||||
trierLP(queueLP(lp));
|
||||
}
|
||||
@ -0,0 +1,36 @@
|
||||
#ifndef liste_profil_h
|
||||
#define liste_profil_h
|
||||
|
||||
#include "src/logique/recrutement/profil.h"
|
||||
#include "src/logique/formation/liste_dept.h"
|
||||
#include "src/logique/candidature/liste_candidature.h"
|
||||
#include "src/logique/formation/ville_iut.h"
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Définit une Liste chainée triée par ordre décroissant sur la note de chaque profil.
|
||||
* */
|
||||
typedef MaillonProfil* ListeProfil;
|
||||
|
||||
ListeProfil nouvListeProfil();
|
||||
|
||||
void freeListeProfil(ListeProfil* lp);
|
||||
|
||||
ListeProfil extraireProfils(ListeCandidature* lc, VilleIUT* iut, Dep* dept);
|
||||
|
||||
Profil* trouverProfil(ListeProfil* lp, int id);
|
||||
|
||||
bool videLP(ListeProfil* lp);
|
||||
|
||||
Profil* teteLP(ListeProfil* lp);
|
||||
|
||||
ListeProfil* queueLP(ListeProfil* lp);
|
||||
|
||||
void ajouterProfil(ListeProfil* lp, Profil* p);
|
||||
|
||||
bool supprimerProfil(ListeProfil* lp, int id);
|
||||
|
||||
void trierLP(ListeProfil* lp);
|
||||
|
||||
#endif
|
||||
@ -1,108 +1,51 @@
|
||||
#include "src/logique/candidature/candidature.h"
|
||||
#include "src/logique/recrutement/profil.h"
|
||||
|
||||
ListeProfil nouvListeProfil() {
|
||||
return NULL;
|
||||
}
|
||||
struct profil {
|
||||
int id; //l'identifiant du candidat
|
||||
Dossier* dossier; //le dossier scolaire du candidat
|
||||
int* decision; //La décision prise par le jury, pointeur vers Voeux#decisionJury
|
||||
float note; //la note attribuée par le jury pour ce profil.
|
||||
};
|
||||
|
||||
void ajouterProfils(ListeProfil* lp, Candidature* candid, VilleIUT* iut, Dep* dept) {
|
||||
ListeVoeux* lv = &candid->voeuxs;
|
||||
while (!videLV(lv)) {
|
||||
Voeux* v = teteLV(lv);
|
||||
if (strcmp(v->nomVille, iut->ville) == 0 && strcmp(v->departement, dept->departement) == 0) {
|
||||
Profil* profil = (Profil*) malloc(sizeof(Profil));
|
||||
if (profil == NULL)
|
||||
fatal(ERREUR_MEMOIRE, "Impossible de malloc un nouveau profil");
|
||||
profil->id = candid->candidat->identifiant;
|
||||
profil->dossier = candid->dossier;
|
||||
profil->decision = &v->decisionJury;
|
||||
profil->note = -1;
|
||||
ajouterProfil(lp, profil);
|
||||
}
|
||||
lv = queueLV(lv);
|
||||
}
|
||||
}
|
||||
|
||||
ListeProfil extraireProfils(ListeCandidature* lc, VilleIUT* iut, Dep* dept) {
|
||||
ListeProfil lp = nouvListeProfil();
|
||||
while (!videLCa(lc)) {
|
||||
Candidature* candid = teteLCa(lc);
|
||||
ajouterProfils(&lp, candid, iut, dept);
|
||||
lc = queueLCa(lc);
|
||||
}
|
||||
return lp;
|
||||
Profil* nouvProfil(int id, Dossier* dossier, int* decision) {
|
||||
Profil* p = (Profil*) malloc(sizeof(Profil));
|
||||
if (p == NULL)
|
||||
fatal(ERREUR_MEMOIRE, "impossible de malloc un nouveau profil");
|
||||
p->id = id;
|
||||
p->dossier = dossier;
|
||||
p->decision = decision;
|
||||
p->note = -1;
|
||||
return p;
|
||||
}
|
||||
|
||||
Profil* trouverProfil(ListeProfil* lp, int id) {
|
||||
while (!videLP(lp)) {
|
||||
Profil* p = teteLP(lp);
|
||||
if (p->id == id)
|
||||
return p;
|
||||
lp = queueLP(lp);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
bool videLP(ListeProfil* lp) {
|
||||
return *lp == NULL;
|
||||
}
|
||||
|
||||
Profil* teteLP(ListeProfil* lp) {
|
||||
return (*lp)->profil;
|
||||
int getIDProfil(Profil* p) {
|
||||
return p->id;
|
||||
}
|
||||
|
||||
ListeProfil* queueLP(ListeProfil* lp) {
|
||||
return &(*lp)->suiv;
|
||||
Dossier* getDossierProfil(Profil* p) {
|
||||
return p->dossier;
|
||||
}
|
||||
|
||||
void ajouterProfil(ListeProfil* lp, Profil* p) {
|
||||
MaillonProfil* mp = (MaillonProfil*) malloc(sizeof(MaillonProfil));
|
||||
if (mp == NULL)
|
||||
fatal(ERREUR_MEMOIRE, "impossible de malloc un nouveau MaillonProfil");
|
||||
ListeProfil* pos = lp; //recherche du maillon avec une note inférieure à la note du profil en ajout.
|
||||
while (!videLP(pos)) {
|
||||
if (teteLP(pos)->note <= p->note)
|
||||
break;
|
||||
pos = queueLP(pos);
|
||||
}
|
||||
mp->profil = p;
|
||||
mp->suiv = *pos;
|
||||
*pos = mp;
|
||||
int getDecision(Profil* p) {
|
||||
return *p->decision;
|
||||
}
|
||||
|
||||
bool supprimerProfil(ListeProfil* lp, int id) {
|
||||
if (videLP(lp))
|
||||
return false;
|
||||
MaillonProfil** pos = NULL;
|
||||
ListeProfil* aux = lp;
|
||||
//recherche du maillon avec une note inférieure à la note du profil en ajout.
|
||||
while (!videLP(aux)) {
|
||||
if (teteLP(aux)->id == id) {
|
||||
pos = aux;
|
||||
break;
|
||||
}
|
||||
aux = queueLP(aux);
|
||||
}
|
||||
if (pos == NULL)
|
||||
return false;
|
||||
*aux = (*aux)->suiv;
|
||||
free(*aux);
|
||||
return true;
|
||||
void setDecision(Profil* p, int decision) {
|
||||
if (decision != REFUSE && decision != EN_ATTENTE && decision != ACCEPTE)
|
||||
fatal(ARGUMENT_INVALIDE, "impossible de set une decision sur le profil: type de décision inconnu.");
|
||||
*p->decision = decision;
|
||||
}
|
||||
|
||||
void trierLP(ListeProfil* lp) {
|
||||
if (videLP(lp))
|
||||
return;
|
||||
float getNote(Profil* p) {
|
||||
return p->note;
|
||||
}
|
||||
|
||||
ListeProfil* aux = lp;
|
||||
MaillonProfil* max = *aux;
|
||||
while (!videLP(aux)) {
|
||||
if ((*aux)->profil->note > max->profil->note)
|
||||
max = *aux;
|
||||
aux = queueLP(aux);
|
||||
}
|
||||
//le contennu de la tete de la liste echange avec le contenu du maillon maximum
|
||||
MaillonProfil aux2 = *max;
|
||||
*max = **lp;
|
||||
**lp = aux2;
|
||||
trierLP(queueLP(lp));
|
||||
void setNote(Profil* p, float note) {
|
||||
if (note < 0 || note > 20)
|
||||
fatal(ARGUMENT_INVALIDE, "impossible de set une note sur le profil: la note est en dehors des limites ([0;20])");
|
||||
p->note = note;
|
||||
}
|
||||
@ -1,36 +1,35 @@
|
||||
#ifndef profil_h
|
||||
#define profil_h
|
||||
|
||||
#include "src/logique/candidature/candidature.h"
|
||||
#include "src/logique/candidature/dossier.h"
|
||||
#include "src/logique/candidature/voeux.h"
|
||||
#include <stdbool.h>
|
||||
|
||||
typedef struct {
|
||||
int id; //l'identifiant du candidat
|
||||
Dossier* dossier; //le dossier scolaire du candidat
|
||||
int* decision; //La décision prise par le jury, pointeur vers Voeux#decisionJury
|
||||
float note; //la note attribuée par le jury pour ce profil.
|
||||
} Profil;
|
||||
/**
|
||||
* Définit la structure d'un profil soumit à examen.
|
||||
* */
|
||||
struct profil;
|
||||
typedef struct profil Profil;
|
||||
|
||||
/**
|
||||
* Définit une liste chainée triée par ordre décroissant sur la note de chaque profil.
|
||||
* Definit un maillon contenant un profil.
|
||||
* */
|
||||
typedef struct maillonProfil {
|
||||
Profil* profil;
|
||||
struct maillonProfil* suiv;
|
||||
} MaillonProfil, *ListeProfil;
|
||||
|
||||
ListeProfil nouvListeProfil();
|
||||
|
||||
ListeProfil extraireProfils(ListeCandidature* lc, VilleIUT* iut, Dep* dept);
|
||||
|
||||
Profil* trouverProfil(ListeProfil* lp, int id);
|
||||
|
||||
bool videLP(ListeProfil* lp);
|
||||
} MaillonProfil;
|
||||
|
||||
Profil* teteLP(ListeProfil* lp);
|
||||
|
||||
ListeProfil* queueLP(ListeProfil* lp);
|
||||
Profil* nouvProfil(int id, Dossier* dossier, int* decision);
|
||||
|
||||
void ajouterProfil(ListeProfil* lp, Profil* p);
|
||||
|
||||
bool supprimerProfil(ListeProfil* lp, int id);
|
||||
//getters et setters
|
||||
int getIDProfil(Profil* p);
|
||||
Dossier* getDossierProfil(Profil* p);
|
||||
int getDecision(Profil* p);
|
||||
void setDecision(Profil* p, int decision);
|
||||
float getNote(Profil* p);
|
||||
void setNote(Profil* p, float note);
|
||||
|
||||
void trierLP(ListeProfil* lp);
|
||||
#endif
|
||||
@ -1 +1 @@
|
||||
2 <- 0 = phase de candidature, 1 = phase d'examen des voeuxs, 2 = phase de consultation des résultats.
|
||||
0 <- 0 = phase de candidature, 1 = phase d'examen des voeuxs, 2 = phase de consultation des résultats.
|
||||
|
||||
Reference in new issue