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
|
#ifndef app_env_h
|
||||||
#define app_bundle_h
|
#define app_env_h
|
||||||
|
|
||||||
#include "src/logique/candidature/candidature.h"
|
#include "src/logique/candidature/candidature.h"
|
||||||
|
#include "src/logique/candidature/liste_candidature.h"
|
||||||
#include "src/logique/compte/compte.h"
|
#include "src/logique/compte/compte.h"
|
||||||
#include "src/logique/formation/ville_iut.h"
|
#include "src/logique/formation/ville_iut.h"
|
||||||
|
|
||||||
#define NB_MAX_FORMATIONS 100
|
#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.
|
* Enum représentant la phase.txt actuelle.
|
||||||
* Chaque phase.txt permet d'influencer les actions faisables sur une IUT.
|
* 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_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
|
* 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] compte le compte du recruteur
|
||||||
* \param[in] profils liste des différents profils que le recruteur devra examiner.
|
* \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
|
#ifndef candidature_h
|
||||||
#define 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/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.
|
* Structure représentant la candidature d'un candidat.
|
||||||
* */
|
* */
|
||||||
typedef struct {
|
struct candidature;
|
||||||
/**
|
typedef struct candidature Candidature;
|
||||||
* 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);
|
|
||||||
|
|
||||||
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);
|
void freeCandidature(Candidature* c);
|
||||||
|
|
||||||
int longueurLCa(ListeCandidature* l);
|
|
||||||
|
|
||||||
bool videLCa(ListeCandidature* l);
|
|
||||||
|
|
||||||
ListeCandidature filtrerLCPourDept(ListeCandidature* lc, VilleIUT* iut, Dep* dept);
|
|
||||||
|
|
||||||
|
|
||||||
#endif
|
#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
|
#ifndef compte_h
|
||||||
#define compte_h
|
#define compte_h
|
||||||
|
|
||||||
#include <stdbool.h>
|
#include <stdbool.h>
|
||||||
#include "src/logique/compte/compte.h"
|
|
||||||
#include "src/logique/formation/ville_iut.h"
|
#include "src/logique/formation/ville_iut.h"
|
||||||
|
#include "src/logique/formation/departement.h"
|
||||||
|
|
||||||
typedef enum {
|
typedef enum {
|
||||||
CANDIDAT, RECRUTEUR, ADMINISTRATEUR
|
CANDIDAT, RECRUTEUR, ADMINISTRATEUR
|
||||||
} TypeCompte;
|
} TypeCompte;
|
||||||
|
|
||||||
#define LONGUEUR_MAX_NOM 32
|
|
||||||
#define LONGUEUR_MAX_PRENOM 32
|
|
||||||
#define LONGUEUR_MAX_MDP 64
|
|
||||||
|
|
||||||
char* nomTypeCompte(TypeCompte tc);
|
char* nomTypeCompte(TypeCompte tc);
|
||||||
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Détermine la structure d'un personnel travaillant pour une IUT
|
* Détermine la structure d'un personnel travaillant pour une IUT
|
||||||
* Voire même dans un département spécifique.
|
* 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);
|
||||||
|
|
||||||
/**
|
int getIDCompte(Compte* c);
|
||||||
* Libère la liste <u>et aussi les comptes.bin qu'elle contient</u>
|
char* getNom(Compte* c);
|
||||||
* */
|
char* getPrenom(Compte* c);
|
||||||
void freeListeCompte(ListeCompte* lc);
|
TypeCompte getType(Compte* c);
|
||||||
|
VilleIUT* getIutPersonnel(Compte* c);
|
||||||
|
Dep* getDepPersonnel(Compte* c);
|
||||||
|
|
||||||
/**
|
void freeCompte(Compte* c);
|
||||||
*
|
|
||||||
* */
|
|
||||||
Compte* creerCompte(ListeCompte* lc, char* nom, char* prenom, TypeCompte type, Personnel* personnel, char* mdp);
|
|
||||||
|
|
||||||
/**
|
Compte* lireCompte(FILE* f, VilleIUT* tiut[], int nbVilles);
|
||||||
* permet de trouver un compte dans le fichier des comptes,
|
void ecrireCompte(Compte* c, FILE* f);
|
||||||
* 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);
|
|
||||||
|
|
||||||
#endif
|
#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)
|
ListeDept* getDepartements(VilleIUT* iut) {
|
||||||
{
|
return iut->ldept;
|
||||||
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;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void libererVillesIUT(VilleIUT *tab[], int nb)
|
Dep* getDepartement(VilleIUT* iut, char* nomDept) {
|
||||||
{
|
return trouverDepartement(iut->ldept, nomDept);
|
||||||
for(int i=0; i<nb; i++)
|
|
||||||
free(tab[i]);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void sauvegarderVilleIUT(VilleIUT* iut, FILE* f) {
|
char* getNomVille(VilleIUT* iut) {
|
||||||
fprintf(f, "%s\n%d\n", iut->ville, longueurLD(iut->ldept));
|
return iut->ville;
|
||||||
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)
|
VilleIUT* nouvVilleIUT(char* nomVille) {
|
||||||
{
|
VilleIUT* vi = (VilleIUT*) malloc(sizeof(VilleIUT));
|
||||||
FILE *fe = fopen(nomFich, "w");
|
if (vi == NULL)
|
||||||
if(fe==NULL)
|
fatal(ERREUR_MEMOIRE, "Impossible de malloc une nouvelle VilleIUT");
|
||||||
return -1; //TODO : code erreur
|
vi->ldept = listeDepNouv();
|
||||||
for(int i=0; i<nb; i++)
|
return vi;
|
||||||
{
|
|
||||||
sauvegarderVilleIUT(tab[i], fe);
|
|
||||||
}
|
|
||||||
fclose(fe);
|
|
||||||
return 0; //TODO : code erreur
|
|
||||||
}
|
}
|
||||||
|
|
||||||
int indiceVille(VilleIUT *tab[], char *nomVille, int nb)
|
VilleIUT* lireVilleIUT(FILE* fe) {
|
||||||
{
|
char nomVille[TAILLE_NOM_VILLE];
|
||||||
int inf=0, sup=nb-1, m;
|
fscanf(fe, "%s", nomVille);
|
||||||
while(inf<=sup)
|
VilleIUT* vi = nouvVilleIUT(nomVille);
|
||||||
{
|
int nbIut = 0;
|
||||||
m=(inf+sup)/2;
|
fscanf(fe, "%d", &nbIut);
|
||||||
int cmp = strcmp(tab[m]->ville, nomVille);
|
for (int i = 0; i < nbIut; i++) {
|
||||||
if(cmp==0)
|
Dep* d = lireDepartement(fe);
|
||||||
{
|
vi->ldept = insererLD(vi->ldept, d);
|
||||||
return m;
|
|
||||||
}
|
|
||||||
else if(cmp < 0)
|
|
||||||
inf=m+1;
|
|
||||||
else sup=m-1;
|
|
||||||
}
|
}
|
||||||
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
|
#ifndef ville_iut_h
|
||||||
#define ville_iut_h
|
#define ville_iut_h
|
||||||
|
|
||||||
#define TAILLE_NOM_VILLE 31
|
#include "src/logique/erreur.h"
|
||||||
|
#include "src/logique/formation/liste_dept.h"
|
||||||
|
|
||||||
|
|
||||||
typedef struct {
|
|
||||||
char ville[TAILLE_NOM_VILLE];
|
|
||||||
ListeDept ldept;
|
|
||||||
} VilleIUT;
|
|
||||||
|
|
||||||
|
#define TAILLE_NOM_VILLE 31
|
||||||
|
|
||||||
int chargerVillesIUT(char* nomFich, VilleIUT *tab[], int nbmax);
|
struct villeIUT;
|
||||||
int sauvegarderVillesIUT(char* nomFich, VilleIUT *tab[], int nb);
|
typedef struct villeIUT VilleIUT;
|
||||||
void libererVillesIUT(VilleIUT *tab[], int nb);
|
|
||||||
|
|
||||||
|
ListeDept* getDepartements(VilleIUT* iut);
|
||||||
|
Dep* getDepartement(VilleIUT* iut, char* nomDept);
|
||||||
|
char* getNomVille(VilleIUT* iut);
|
||||||
|
|
||||||
int indiceVille(VilleIUT *tab[], char *nomVille, int nb);
|
VilleIUT* nouvVilleIUT(char* nomVille);
|
||||||
bool villeExiste(VilleIUT* tab[], char* nomVille, int nb);
|
VilleIUT* lireVilleIUT(FILE *fe);
|
||||||
VilleIUT* trouverVille(VilleIUT* tab[], char* nomVille, int nb);
|
|
||||||
VilleIUT* creerVilleIUT(VilleIUT *tab[], int nbVilles, int nbmax, char *nomVille, bool* existe);
|
|
||||||
|
|
||||||
#endif
|
#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"
|
#include "src/logique/recrutement/profil.h"
|
||||||
|
|
||||||
ListeProfil nouvListeProfil() {
|
struct profil {
|
||||||
return NULL;
|
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) {
|
Profil* nouvProfil(int id, Dossier* dossier, int* decision) {
|
||||||
ListeProfil lp = nouvListeProfil();
|
Profil* p = (Profil*) malloc(sizeof(Profil));
|
||||||
while (!videLCa(lc)) {
|
if (p == NULL)
|
||||||
Candidature* candid = teteLCa(lc);
|
fatal(ERREUR_MEMOIRE, "impossible de malloc un nouveau profil");
|
||||||
ajouterProfils(&lp, candid, iut, dept);
|
p->id = id;
|
||||||
lc = queueLCa(lc);
|
p->dossier = dossier;
|
||||||
}
|
p->decision = decision;
|
||||||
return lp;
|
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) {
|
int getIDProfil(Profil* p) {
|
||||||
return (*lp)->profil;
|
return p->id;
|
||||||
}
|
}
|
||||||
|
|
||||||
ListeProfil* queueLP(ListeProfil* lp) {
|
Dossier* getDossierProfil(Profil* p) {
|
||||||
return &(*lp)->suiv;
|
return p->dossier;
|
||||||
}
|
}
|
||||||
|
|
||||||
void ajouterProfil(ListeProfil* lp, Profil* p) {
|
int getDecision(Profil* p) {
|
||||||
MaillonProfil* mp = (MaillonProfil*) malloc(sizeof(MaillonProfil));
|
return *p->decision;
|
||||||
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) {
|
void setDecision(Profil* p, int decision) {
|
||||||
if (videLP(lp))
|
if (decision != REFUSE && decision != EN_ATTENTE && decision != ACCEPTE)
|
||||||
return false;
|
fatal(ARGUMENT_INVALIDE, "impossible de set une decision sur le profil: type de décision inconnu.");
|
||||||
MaillonProfil** pos = NULL;
|
*p->decision = decision;
|
||||||
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) {
|
float getNote(Profil* p) {
|
||||||
if (videLP(lp))
|
return p->note;
|
||||||
return;
|
}
|
||||||
|
|
||||||
ListeProfil* aux = lp;
|
void setNote(Profil* p, float note) {
|
||||||
MaillonProfil* max = *aux;
|
if (note < 0 || note > 20)
|
||||||
while (!videLP(aux)) {
|
fatal(ARGUMENT_INVALIDE, "impossible de set une note sur le profil: la note est en dehors des limites ([0;20])");
|
||||||
if ((*aux)->profil->note > max->profil->note)
|
p->note = 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));
|
|
||||||
}
|
}
|
||||||
@ -1,36 +1,35 @@
|
|||||||
|
#ifndef profil_h
|
||||||
|
#define profil_h
|
||||||
|
|
||||||
#include "src/logique/candidature/candidature.h"
|
#include "src/logique/candidature/candidature.h"
|
||||||
|
#include "src/logique/candidature/dossier.h"
|
||||||
#include "src/logique/candidature/voeux.h"
|
#include "src/logique/candidature/voeux.h"
|
||||||
#include <stdbool.h>
|
#include <stdbool.h>
|
||||||
|
|
||||||
typedef struct {
|
/**
|
||||||
int id; //l'identifiant du candidat
|
* Définit la structure d'un profil soumit à examen.
|
||||||
Dossier* dossier; //le dossier scolaire du candidat
|
* */
|
||||||
int* decision; //La décision prise par le jury, pointeur vers Voeux#decisionJury
|
struct profil;
|
||||||
float note; //la note attribuée par le jury pour ce profil.
|
typedef struct profil 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 {
|
typedef struct maillonProfil {
|
||||||
Profil* profil;
|
Profil* profil;
|
||||||
struct maillonProfil* suiv;
|
struct maillonProfil* suiv;
|
||||||
} MaillonProfil, *ListeProfil;
|
} MaillonProfil;
|
||||||
|
|
||||||
ListeProfil nouvListeProfil();
|
|
||||||
|
|
||||||
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);
|
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