Plateforme de Recrutement en Ligne

Développée avec Django

Rapport de Projet

réalisé par :
Youssef el hilali
Ibtihal addala
Soufiane moussaoui
Elmouden Badre

17 mai 2025
Table des matières

1 Introduction 3
1.1 Contexte du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Problématique adressée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Objectifs du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4 Présentation de la solution développée . . . . . . . . . . . . . . . . . . . . 4

2 Analyse des besoins 5

2.1 Identification des utilisateurs . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.1 Candidat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.2 Recruteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 Besoins fonctionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2.1 Pour les candidats . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2.2 Pour les recruteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2.3 Pour les deux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.3 Besoins non fonctionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.4 Diagramme des cas d’utilisation . . . . . . . . . . . . . . . . . . . . . . . . 7

3 Conception 8
3.1 Architecture globale de l’application . . . . . . . . . . . . . . . . . . . . . . 8
3.2 Diagramme MVT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.3 Modèle de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.3.1 Description des entités et relations . . . . . . . . . . . . . . . . . . 9
3.3.2 Diagramme de classes / Schéma de base de données . . . . . . . . . 10
3.4 Interfaces utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.4.1 Maquettes (Wireframes) . . . . . . . . . . . . . . . . . . . . . . . . 10
3.4.2 Parcours utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

4 Implémentation 12
4.1 Environnement technique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
4.1.1 Technologies utilisées . . . . . . . . . . . . . . . . . . . . . . . . . . 12
4.1.2 Outils de développement . . . . . . . . . . . . . . . . . . . . . . . . 12
4.2 Structure du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
4.3 Détails d’implémentation des fonctionnalités clés . . . . . . . . . . . . . . . 13
4.3.1 Authentification personnalisée . . . . . . . . . . . . . . . . . . . . . 13
4.3.2 Gestion des offres d’emploi . . . . . . . . . . . . . . . . . . . . . . . 13
4.3.3 Gestion des CV (resumes) . . . . . . . . . . . . . . . . . . . . . . . 13
4.3.4 Soumission des candidatures . . . . . . . . . . . . . . . . . . . . . . 13
4.3.5 Choix techniques et justifications . . . . . . . . . . . . . . . . . . . 14
4.3.6 Comportements automatiques . . . . . . . . . . . . . . . . . . . . . 14
4.4 Détails d’implémentation des fonctionnalités clés . . . . . . . . . . . . . . 14
4.4.1 Les models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
4.4.2 Les views . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.4.3 URLs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.5 Difficultés rencontrées et solutions . . . . . . . . . . . . . . . . . . . . . . . 16

1
5 Tests et validation 18
5.1 Méthodologie de test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
5.2 Tests d’intégration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
5.3 Validation des fonctionnalités . . . . . . . . . . . . . . . . . . . . . . . . . 18
5.4 Performances et optimisations . . . . . . . . . . . . . . . . . . . . . . . . . 18

6 Manuel d’utilisation 20
6.1 Prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
6.2 Étapes d’installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
6.3 Guide d’utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
6.3.1 Page d’inscription . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
6.3.2 Tableaux de bord utilisateur (chercheur d’emploi et recruteur ) . . . 21
6.3.3 Page de détails d’une offre + formulaire de candidature . . . . . . . 22
6.3.4 Gestion des candidatures (recruteur) . . . . . . . . . . . . . . . . . 22

7 Bilan et perspectives 24
7.1 Comparaison des objectifs atteints vs objectifs initiaux . . . . . . . . . . . 24
7.2 Problèmes rencontrés et solutions apportées . . . . . . . . . . . . . . . . . 24
7.3 Apprentissages techniques et humains . . . . . . . . . . . . . . . . . . . . . 24
7.4 Améliorations envisagées . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

8 Conclusion 26

9 Références 27
9.1 Bibliographie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
9.2 Webographie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
9.3 Ressources utilisées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

2
Chapitre 1

Introduction

1.1 Contexte du projet

Dans un environnement professionnel en constante évolution, le processus de recrute-
ment a considérablement changé au cours des dernières années, notamment avec l’émer-
gence d’outils numériques performants. Les entreprises recherchent des moyens plus effi-
caces pour trouver des profils qualifiés, tandis que les candidats souhaitent accéder rapi-
dement à des offres adaptées à leurs compétences et aspirations.
Les plateformes d’offres d’emploi sont devenues des intermédiaires clés dans ce pro-
cessus. Elles permettent de publier, rechercher, filtrer et postuler à des offres à travers
des interfaces accessibles et intuitives. Dans ce contexte, la digitalisation du recrutement
représente un enjeu stratégique tant pour les entreprises que pour les chercheurs d’emploi.
C’est dans cette optique que s’inscrit ce projet de développement d’une plateforme web
destinée à faciliter le processus de recrutement à travers une solution technique construite
avec Django, un framework web Python puissant et structuré, reposant sur le modèle
MVT (Model-View-Template).

1.2 Problématique adressée

Malgré la diversité des plateformes existantes, plusieurs limites subsistent :
— L’expérience utilisateur n’est pas toujours optimisée pour les deux types d’utilisa-
teurs (recruteurs et candidats).
— Les processus de candidature sont parfois lourds et peu personnalisables.
— Le suivi des candidatures et les échanges entre utilisateurs manquent souvent de
fluidité.
— L’absence de notifications pertinentes peut entraîner une perte d’opportunités.
De plus, pour les étudiants et jeunes diplômés, il est parfois difficile d’avoir une in-
terface adaptée à leur profil débutant. D’un autre côté, les petites entreprises peinent à
trouver une plateforme accessible pour publier et gérer leurs offres.

1.3 Objectifs du projet

Le développement de ce projet a plusieurs objectifs, à la fois pédagogiques et tech-
niques :
— Apprentissage et maîtrise de Django : Comprendre et utiliser l’architecture MVT
(Model-View-Template) de Django, apprendre à structurer un projet de manière
modulaire.
— Double interface utilisateur : Mettre en place une gestion d’utilisateurs différenciée
avec des interfaces spécifiques pour les recruteurs et les candidats, tout en assurant
une expérience cohérente et fluide.

3
 — Fonctionnalités avancées :
— Formulaires personnalisés (inscription, connexion, ajout d’offre, candidature,
etc.)
— Publication d’offres avec critères multiples (compétences, type de contrat, lieu,
etc.)
— Système de candidature complet avec suivi et téléchargement de fichiers (CV,
lettre de motivation)
— Système de recherche filtrée et recommandations basiques d’offres
— Statistiques pour les recruteurs (nombre de vues, candidatures reçues)
— Notifications (email ou internes) pour informer des événements importants
— Utilisation d’outils modernes :
— Base de données MySQL
— Framework CSS Bootstrap pour un design réactif
— Django Authentication pour la sécurité et la gestion des sessions

1.4 Présentation de la solution développée

La solution développée est une application web conçue pour connecter des candidats
à la recherche d’un emploi avec des recruteurs souhaitant publier et gérer des offres.
L’interface est responsive, conviviale et adaptée aux deux types de profils :
— Côté candidat, l’utilisateur peut :
— Créer et personnaliser son profil
— Rechercher des offres selon différents critères
— Postuler en ligne avec ses documents (CV, lettre de motivation)
— Suivre l’état de ses candidatures
— Côté recruteur, l’entreprise peut :
— Publier des offres avec des champs complets et structurés
— Gérer les candidatures reçues (accepter, refuser, contacter)

4
Chapitre 2

Analyse des besoins

2.1 Identification des utilisateurs

Le système s’adresse à deux types principaux d’utilisateurs ayant des rôles et des
besoins distincts :

2.1.1 Candidat
Le candidat est une personne à la recherche d’un emploi ou d’un stage. Ses actions
principales sur la plateforme incluent :
— Création et gestion de son profil personnel
— Téléversement de son CV et autres documents justificatifs
— Navigation parmi les offres disponibles
— Filtrage des offres par mot-clé, lieu, type de contrat, etc.
— Candidature à une ou plusieurs offres
— Suivi des candidatures soumises
— Réception de notifications concernant les nouvelles offres ou les réponses des recru-
teurs

2.1.2 Recruteur
Le recruteur est une entreprise ou une organisation qui souhaite publier des offres
d’emploi pour recruter des candidats. Ses actions principales sont :
— Création et gestion du profil entreprise
— Publication de nouvelles offres d’emploi
— Consultation et gestion des candidatures reçues
— Recherche de profils de candidats selon différents critères
— Statistiques sur les offres (nombre de vues, nombre de candidatures)
— Communication avec les candidats via messagerie ou notifications

2.2 Besoins fonctionnels

Les besoins fonctionnels correspondent aux fonctionnalités que le système doit obliga-
toirement fournir. Voici les principaux :

5
2.2.1 Pour les candidats
— S’inscrire avec un rôle « candidat »
— Se connecter et se déconnecter
— Compléter et modifier leur profil (nom, prénom, email, compétences, expérience,
CV, etc.)
— Rechercher des offres selon des filtres multiples (mot-clé, contrat, localisation, etc.)
— Visualiser les détails d’une offre
— Postuler à une offre avec lettre de motivation et documents
— Suivre l’état de chaque candidature
— Recevoir des notifications (accusés de réception, réponse du recruteur, nouvelle offre)

2.2.2 Pour les recruteurs

— S’inscrire avec un rôle « recruteur »
— Créer et mettre à jour le profil de l’entreprise
— Publier de nouvelles offres d’emploi
— Gérer les candidatures reçues (accepter, refuser, contacter)
— Consulter des statistiques sur les offres publiées
— Rechercher des profils de candidats

2.2.3 Pour les deux

— Interface de gestion sécurisée (authentification, sessions)
— Tableau de bord personnalisé
— Messagerie ou zone d’échange entre recruteur et candidat
— Notifications en temps réel ou par mail

2.3 Besoins non fonctionnels

Les besoins non fonctionnels définissent les contraintes de qualité du système :
— Sécurité : gestion sécurisée des mots de passe, accès restreint aux interfaces selon
les rôles
— Ergonomie : interfaces simples, claires et accessibles pour tous les utilisateurs
— Réactivité : chargement rapide des pages et filtres
— Maintenabilité : code structuré selon le modèle MVT de Django
— Compatibilité : support des principaux navigateurs web et adaptation mobile (res-
ponsive design)
— Fiabilité : système stable avec gestion des erreurs et validation des formulaires

6
2.4 Diagramme des cas d’utilisation

7
Chapitre 3

Conception

3.1 Architecture globale de l’application

L’application repose sur une architecture web basée sur le framework Django, suivant
le modèle MVT (Model-View-Template). Elle est divisée en deux types d’utilisateurs :
— Candidats (JobSeekers) : peuvent créer un profil, téléverser leur CV, rechercher des
offres et y postuler.
— Recruteurs (Recruiters) : peuvent créer des offres d’emploi et consulter les candida-
tures reçues.
L’application est structurée en plusieurs modules :
— Authentification & gestion des utilisateurs
— Gestion des offres d’emploi
— Gestion des candidatures
— Dashboard & notifications

3.2 Diagramme MVT

Django repose sur une architecture appelée MVT (Modèle-Vue-Gabarit), qui est très
proche du modèle MVC (Modèle-Vue-Contrôleur), mais avec une particularité propre à
Django : c’est le framework qui joue le rôle de « contrôleur » en interne.

8
3.3 Modèle de données
3.3.1 Description des entités et relations
L’application est centrée autour de plusieurs entités principales :
— BaseUser : classe abstraite qui contient les attributs communs aux utilisateurs
(name, email, phone_number, etc.). Elle est héritée par :
— JobSeeker (chercheur d’emploi)
— Recruiter (recruteur)
— JobSeeker : utilisateur qui peut créer plusieurs CV (Resume), postuler à des offres
d’emploi (JobPost) via des candidatures (Application).
— Recruiter : utilisateur pouvant publier plusieurs offres d’emploi (JobPost).
— Resume : fichier de CV que possède un JobSeeker, et qui peut être utilisé pour
postuler à des offres.
— JobPost : annonce créée par un Recruiter, pouvant recevoir plusieurs candidatures.
— Application : relie un JobSeeker (via un CV) à une offre (JobPost). Contient la
lettre de motivation et le statut de la candidature.
Relations entre les entités :
— Un JobSeeker peut avoir plusieurs CVs (relation 1 à N).
— Un CV peut être utilisé dans plusieurs Applications.
— Un JobPost peut recevoir plusieurs Applications.
— Une Application est liée à un seul CV et un seul JobPost.
— Un Recruiter peut créer plusieurs JobPosts.

9
3.3.2 Diagramme de classes / Schéma de base de données

3.4 Interfaces utilisateur

3.4.1 Maquettes (Wireframes)
Les principales pages proposées dans l’application incluent :
— Page d’accueil
— Connexion / Inscription
— Profil candidat / recruteur
— Liste des offres
— Détail d’une offre
— Formulaire de candidature
— Dashboard candidat
— Dashboard recruteur

3.4.2 Parcours utilisateur

— Candidat :

10
 1. Inscription → Remplissage de profil → Téléversement CV
2. Recherche d’offres → Consultation → Candidature
3. Suivi des candidatures via Dashboard
4. Changer les information personnelles avec la page du paramètre
— Recruteur :
1. Inscription → Remplissage de profil pro
2. Création d’offres → Suivi des candidatures
3. Visualisation des détails d’un candidat / téléchargement de CV
4. Changer les information personnelles avec la page du paramètre

11
Chapitre 4

Implémentation

4.1 Environnement technique

4.1.1 Technologies utilisées
Le projet repose sur les technologies suivantes :
— Django (Python) : Framework principal pour le backend et l’architecture MVT.
— MySQL : Base de données relationnelle utilisée pour stocker les utilisateurs, offres,
candidatures, etc.
— HTML/CSS avec Bootstrap : Pour l’interface utilisateur responsive.
— Django Forms & Authentication : Pour la gestion des formulaires et des sessions
utilisateur.
— Git/GitHub : Pour la gestion de version du code source.

4.1.2 Outils de développement

— IDE : Visual Studio Code
— Serveur local : WampServer (pour MySQL)
— Gestionnaire de paquets : pip, venv
— Navigateur web : Google Chrome, Mozilla Firefox

4.2 Structure du projet

12
4.3 Détails d’implémentation des fonctionnalités clés
Le projet repose sur une architecture orientée objet avec des modèles personnalisés
définissant clairement les rôles des utilisateurs, les offres d’emploi, les candidatures, et les
documents associés. Voici les principales fonctionnalités mises en œuvre :

4.3.1 Authentification personnalisée

— Le modèle BaseUser hérite de AbstractUser mais désactive le champ username
par défaut, en utilisant plutôt l’adresse email comme identifiant principal (USER-
NAME_FIELD = ’email’).
— Il contient des champs supplémentaires comme : name, phone_number, profile_picture,
et profession.
— Deux sous-classes spécialisent ce modèle : JobSeeker (candidat) et Recruiter (recru-
teur), ce dernier ajoutant des champs comme position_title, department et com-
pany_name.

4.3.2 Gestion des offres d’emploi

— Le modèle JobPost permet aux recruteurs de publier des offres d’emploi.
— Il contient des champs spécifiques comme :
— title, location (informations de base)
— min_education, experience_level (prérequis)
— salary_min, salary_max, show_salary (gestion conditionnelle du salaire)
— Un champ status permet de définir si une offre est ongoing (active) ou terminated.
— La relation avec le recruteur est gérée via une clé étrangère (recruiter = Foreign-
Key(Recruiter)), ce qui permet de récupérer facilement toutes les offres postées par
un recruteur.

4.3.3 Gestion des CV (resumes)

— Le modèle Resume permet à chaque utilisateur de type JobSeeker d’uploader un ou
plusieurs fichiers de CV (FileField).
— Chaque document est lié à un utilisateur via une relation ForeignKey.

4.3.4 Soumission des candidatures

— Le modèle Application permet à un JobSeeker de postuler à une offre spécifique.
— Il contient :
— Une lettre de motivation (motivation_letter)
— Le statut de la candidature (pending, accepted, rejected)
— La liaison entre JobPost, JobSeeker et Resume est assurée via des clés étran-
gères.
— L’unicité des candidatures est assurée par une contrainte unique_together sur (job-
Post, jobSeeker) pour éviter les doublons.

13
 4.3.5 Choix techniques et justifications
— L’utilisation de classes abstraites (BaseUser) assure la réutilisabilité et la centrali-
sation de la logique commune à plusieurs types d’utilisateurs.
— La séparation des rôles (JobSeeker / Recruiter) améliore la lisibilité et l’organisation
du code métier.
— Les relations entre les entités sont conçues pour faciliter les requêtes complexes :
par exemple, accéder à toutes les candidatures d’un utilisateur, ou toutes les candi-
datures pour une offre donnée.

4.3.6 Comportements automatiques

— Les champs created_at et updated_at sont définis avec auto_now_add et auto_now,
ce qui permet de suivre les dates de création et de mise à jour automatiquement.
— Les choices définis pour certains champs (status, experience_level, etc.) permettent
de limiter les valeurs possibles et de faciliter leur affichage dans les interfaces utili-
sateur.

4.4 Détails d’implémentation des fonctionnalités clés

4.4.1 Les models
Modèle utilisateur personnalisé avec email comme identifiant :
1 class BaseUser ( AbstractUser ) :
2 username = None
3 email = models . EmailField ( unique = True )
4 name = models . CharField ( max_length =100)
5 phone_number = models . CharField ( max_length =20)
6 profile_picture = models . ImageField ( upload_to = ’ profile_pics / ’ , null =
True , blank = True )
7 profession = models . CharField ( max_length =100 , blank = True )
8

9 USERNAME_FIELD = ’ email ’
10 REQUIRED_FIELDS = []

Cet extrait définit une base commune pour les deux types d’utilisateurs en supprimant
l’authentification par username et en imposant une structure personnalisée plus adaptée
au projet.
1 class Application ( models . Model ) :
2 STATUS_CHOICES = [
3 ( ’ pending ’ , ’ En attente ’) ,
4 ( ’ accepted ’ , ’ A c c e p t e ’) ,
5 ( ’ rejected ’ , ’ R e f u s e ’) ,
6 ]
7
8 jobPost = models . ForeignKey ( JobPost , on_delete = models . CASCADE )
9 jobSeeker = models . ForeignKey ( JobSeeker , on_delete = models . CASCADE )
10 resume = models . ForeignKey ( Resume , on_delete = models . CASCADE )
11 motiv ation_le tter = models . TextField ()
12 status = models . CharField ( max_length =20 , choices = STATUS_CHOICES ,
default = ’ pending ’)
13 created_at = models . DateTimeField ( auto_now_add = True )

14
14 updated_at = models . DateTimeField ( auto_now = True )
15
16 class Meta :
17 unique_together = ( ’ jobPost ’ , ’ jobSeeker ’)
18
19 def __str__ ( self ) :
20 return f " Candidature de { self . jobSeeker . name } pour { self . jobPost
. title } "

Ce modèle définit une relation entre un candidat et une offre d’emploi, tout en stockant
des données essentielles comme :
— Le CV soumis (resume)
— La lettre de motivation
— Le statut de la candidature (en attente, acceptée, refusée)
— Les dates de création et de mise à jour
Le champ unique_together garantit qu’un candidat ne peut postuler qu’une seule fois
à une même offre, évitant les doublons.

4.4.2 Les views

1 class ResumeDelete ( View ) :
2 def post ( self , request , * args , ** kwargs ) :
3 resume = get_objec t_or_404 ( Resume , pk = kwargs [ ’ pk ’ ])
4 if resume . jobSeeker == request . user . jobseeker :
5 resume . delete ()
6 return redirect ( ’ settings ’)

— Méthode : POST
— Rôle : Supprimer un CV (Resume) appartenant à un chercheur d’emploi connecté.
— Condition : Vérifie si le CV appartient bien à l’utilisateur avant de le supprimer.
1 class ViewApplications ( View ) :
2 def get ( self , request , * args , ** kwargs ) :
3 job_post = get_ object_o r_404 ( JobPost , pk = kwargs [ ’ pk ’ ])
4 if job_post . recruiter != request . user . recruiter :
5 raise PermissionDenied
6 applications = Application . objects . filter ( jobPost = job_post )
7 return render ( request , ’ view_a pplicati ons . html ’ , {
8 ’ job_post ’: job_post ,
9 ’ applications ’: applications
10 })

— Méthode : GET
— Rôle : Permet à un recruteur de voir les candidatures reçues pour une offre d’emploi
spécifique.
— Condition : Seul un recruteur peut y accéder. Vérifie que l’offre lui appartient.
1 class U p da t e A p p l i c a t i o n S t a t u s ( View ) :
2 def post ( self , request , * args , ** kwargs ) :
3 application = get_ object_o r_404 ( Application , pk = kwargs [ ’ pk ’ ])
4 if application . jobPost . recruiter != request . user . recruiter :
5 raise PermissionDenied

15
6 new_status = request . POST . get ( ’ status ’)
7 if new_status in [ choice [0] for choice in Application .
STATUS_CHOICES ]:
8 application . status = new_status
9 application . save ()
10 return redirect ( ’ vie w_applic ations ’ , pk = application . jobPost . pk )

— Méthode : POST
— Rôle : Permet à un recruteur de mettre à jour le statut d’une candidature (Appli-
cation).
— Condition : Vérifie que l’utilisateur est bien le recruteur propriétaire de l’offre.

4.4.3 URLs
1 urlpatterns = [
2 path ( ’ ’ , views . Home . as_view () , name = ’ home ’) ,
3 path ( ’ login / ’ , views . LoginView . as_view () , name = ’ login ’) ,
4 path ( ’ logout / ’ , views . LogoutView . as_view () , name = ’ logout ’) ,
5 path ( ’ signup / ’ , views . Signup . as_view () , name = ’ signup ’) ,
6 path ( ’ jobposts / ’ , views . JobPosts . as_view () , name = ’ jobposts ’) ,
7 path ( ’ jobpost / < int : pk >/ ’ , views . JobPostDetail . as_view () , name = ’
jobpost_detail ’) ,
8 path ( ’ posts / ’ , views . Posts . as_view () , name = ’ posts ’) ,
9 path ( ’ jobpost / update / < int : pk >/ ’ , views . JobPostUpdate . as_view () , name
= ’ jobpost_update ’) ,
10 path ( ’ jobpost / delete / < int : pk >/ ’ , views . JobPostDelete . as_view () , name
= ’ jobpost_delete ’) ,
11 path ( ’ applications / ’ , views . Applications . as_view () , name = ’
applications ’) ,
12 path ( ’ application / delete / < int : pk >/ ’ , views . deleteApplication , name = ’
de le te _ap pl ic ati on ’) ,
13 path ( ’ view_a pplicati ons / < int : pk >/ ’ , views . ViewApplications . as_view ()
, name = ’ view_ap plicatio ns ’) ,
14 path ( ’ u p d a t e _ a p p l i c a t i o n _ s t a t u s / < int : pk >/ ’ , views .
U p d a t e A p p l i c a t i o n S t a t u s . as_view () , name = ’ u p d a t e _ a p p l i c a t i o n _ s t a t u s ’) ,
15 path ( ’ settings / ’ , views . Settings . as_view () , name = ’ settings ’) ,
16 path ( ’ resume / delete / < int : pk >/ ’ , views . ResumeDelete . as_view () , name = ’
resume_delete ’) ,
17 ]

4.5 Difficultés rencontrées et solutions

— Lors de modifications dans les modèles ([Link]), des erreurs comme Operatio-
nalError, app_label doesn’t match, ou des conflits de schéma ont été rencontrées
lors de la commande makemigrations ou migrate.
— Solution : réinitialisation contrôlée des migrations avec makemigrations, migrate et
suppression des anciens fichiers de migration si nécessaire.
— Le formulaire d’ajout de CV (ResumeForm) ne sauvegardait pas les fichiers. Le
champ [Link] n’était pas traité correctement.
— Solution : configuration correcte du MEDIA_ROOT et MEDIA_URL, et gestion
des fichiers dans les vues avec [Link].

16
— Besoin d’afficher dynamiquement des candidatures selon l’utilisateur connecté (Job-
Seeker), ou des offres d’emploi selon des critères (intitulé, localisation...).
— Solution : utilisation de Q() de Django pour construire des requêtes plus flexibles,
ajout de champs de filtre dans le template HTML.

17
Chapitre 5

Tests et validation

5.1 Méthodologie de test

Afin d’assurer la fiabilité et la stabilité du site, plusieurs niveaux de tests ont été
appliqués :
— Tests manuels pour valider les fonctionnalités principales dans le navigateur.
— Tests unitaires Django pour vérifier le bon comportement des modèles et vues.
— Tests d’intégration pour simuler des parcours utilisateurs.
— Vérifications visuelles et tests de formulaire pour garantir une bonne ergonomie.

5.2 Tests d’intégration

— Inscription → Connexion → Publication d’une offre → Candidature à une offre.
— Ajout et suppression d’un CV depuis l’espace "Paramètres".
— Sélection d’un candidat par un recruteur (changement de statut)

5.3 Validation des fonctionnalités

5.4 Performances et optimisations

— Optimisations SQL : Utilisation de select_related() pour minimiser les requêtes lors
de l’affichage des offres avec recruteurs.
— Compression des images : Redimensionnement automatique des images de profil
avec Pillow.
— Vérification des fichiers : Formats et tailles limités lors des uploads (CV, images).

18
— Filtres dynamiques : Utilisation de requêtes filter() pour l’affichage des offres selon
les critères (niveau, ville, etc.).
— Templates réutilisables : Utilisation de extends pour éviter la duplication de code
HTML.

19
 Chapitre 6

Manuel d’utilisation

6.1 Prérequis
Avant de lancer l’application, il est nécessaire de s’assurer que les éléments suivants
sont installés sur la machine :
— Python (version 3.8)
— pip (gestionnaire de paquets Python)
— Django (version recommandée 4.x)
— MySQL ou SQLite (selon la configuration de la base de données)
— Navigateur Web moderne (Chrome, Firefox, etc.)

6.2 Étapes d’installation

1 # Step 1: Clone the repository
2 git clone https :// github . com / skepticon7 / jobRadar . git
3 cd JobRadar
4
5 # Step 2: Create a virtual environment
6 python -m venv venv
7
8 # Step 3: Activate the virtual environment
9 venv \ Scripts \ activate
10
11 # Step 4: Install dependencies
12 pip install -r requirements . txt
13 # if the requirements . txt file is missing , generate it !
14 pip freeze > requirements . txt
15
16 # Step 5: Apply database migrations
17 python manage . py migrate
18
19 # Step 6: Run Django server
20 python manage . py runserver

6.3 Guide d’utilisation

Cette capture présente la page d’accueil du site, accessible à tous les utilisateurs. Elle
propose un accès rapide à la connexion et à l’inscription. L’utilisateur peut y entrer son
adresse e-mail et son mot de passe pour accéder à son espace personnel. En cas de première
visite, un lien permet de créer un compte.

20
 Figure 6.1 – page login

6.3.1 Page d’inscription

Cette page permet à un nouvel utilisateur de créer un compte en tant que chercheur
d’emploi ou recruteur. Le formulaire contient les champs essentiels comme le nom, l’email,
le mot de passe, ainsi qu’un champ pour choisir son type d’utilisateur. Une fois le formu-
laire validé, l’utilisateur est redirigé vers son tableau de bord personnalisé.

Figure 6.2 – page inscription

6.3.2 Tableaux de bord utilisateur (chercheur d’emploi et recru-

teur )
-Une fois connecté, le chercheur d’emploi accède à un tableau de bord qui lui permet
de consulter les offres d’emploi disponibles, de gérer son profil, d’ajouter un CV et de
suivre ses candidatures. La navigation est intuitive grâce à un menu latéral ou supérieur.
-Le recruteur, après authentification, est redirigé vers un espace de gestion où il peut
publier de nouvelles offres d’emploi, voir les candidatures reçues pour ses annonces, et mo-
difier les informations de son profil. La capture illustre les différentes options disponibles.

21
 Figure 6.3 – page accuiel chercheur emploi

Figure 6.4 – page accuiel recruteur emploi

6.3.3 Page de détails d’une offre + formulaire de candidature

En cliquant sur une offre, l’utilisateur accède à la page de détails qui présente toutes
les informations utiles concernant le poste. En bas de la page se trouve un formulaire de
candidature permettant d’ajouter un CV et une lettre de motivation. Une fois soumis, ces
informations sont envoyées au recruteur.

6.3.4 Gestion des candidatures (recruteur)

Cette capture illustre la vue disponible pour les recruteurs lorsqu’ils consultent les
candidatures reçues. Ils peuvent voir les informations de chaque candidat, consulter les
fichiers joints (CV et lettre), et éventuellement sélectionner un candidat en modifiant son
statut.

22
Figure 6.5 – Page de détails d’une offre + formulaire de candidature

Figure 6.6 – page accuiel chercheur emploi

23
Chapitre 7

Bilan et perspectives

7.1 Comparaison des objectifs atteints vs objectifs ini-

tiaux
Au démarrage du projet, l’objectif principal était de créer une plateforme web de
gestion d’offres d’emploi permettant :
— aux chercheurs d’emploi de créer un compte, consulter des offres et postuler avec
CV et lettre de motivation ;
— aux recruteurs de publier des offres et consulter les candidatures reçues.
Ces objectifs ont été largement atteints :
— Authentification et gestion des rôles fonctionnelles.
— Interface responsive pour les deux types d’utilisateurs.
— Fonction de publication, consultation et suppression d’offres.
— Système de candidature complet avec dépôt de fichiers.
— Tableau de bord personnalisés.

7.2 Problèmes rencontrés et solutions apportées

Plusieurs difficultés ont jalonné le développement :
— Problème de migration de la base de données lors de modifications des modèles
Django.
— Solution : réinitialisation contrôlée des migrations avec makemigrations, migrate et
suppression des anciens fichiers de migration si nécessaire.
— Upload de fichiers (CV/lettres de motivation) mal pris en compte au début.
— Solution : configuration correcte du MEDIA_ROOT et MEDIA_URL, et gestion
des fichiers dans les vues avec [Link].
— Filtrage dynamique des offres selon les critères (type de contrat, niveau d’études,
etc.) pas évident à optimiser.
— Solution : utilisation de Q() de Django pour construire des requêtes plus flexibles,
ajout de champs de filtre dans le template HTML.

7.3 Apprentissages techniques et humains

Ce projet a permis de consolider plusieurs compétences techniques :
— Maîtrise du framework Django, de ses vues (classes et fonctions), et de son ORM.
— Utilisation des sessions pour la gestion personnalisée des utilisateurs.
— Intégration de formulaires complexes, notamment pour les fichiers.

24
 — Gestion de la structure MVC propre à Django et bonne séparation des rôles.
Sur le plan humain :
— Amélioration de la capacité à travailler de manière autonome, gérer son temps et
résoudre des bugs de manière méthodique.
— Renforcement des compétences en communication écrite (documentation, messages
d’erreurs, validations utilisateurs).
— Expérience pratique de la gestion de projet agile avec des livrables itératifs.

7.4 Améliorations envisagées

Pour enrichir le projet, plusieurs évolutions peuvent être envisagées :
— Système de notation/avis : les recruteurs pourraient noter les candidats après en-
tretien, et inversement.
— Création d’une API REST : pour exposer les données et permettre la création d’une
future application mobile ou l’intégration avec des plateformes tierces.
— Amélioration de la recherche : mise en place d’un moteur de recherche plus perfor-
mant avec autocomplétion et suggestions.

25
Chapitre 8

Conclusion

Ce projet de plateforme de gestion d’offres d’emploi a été une expérience très enrichis-
sante tant sur le plan technique que personnel. L’objectif principal était de développer un
site web fonctionnel permettant aux chercheurs d’emploi de consulter et postuler à des
offres, et aux recruteurs de publier et gérer des candidatures. Cet objectif a été atteint
grâce à une implémentation structurée basée sur le framework Django.
Sur le plan fonctionnel, le site intègre avec succès des fonctionnalités clés telles que :
la création de comptes, la gestion de sessions selon le type d’utilisateur, la publication
d’offres d’emploi, le dépôt de candidatures avec fichiers, la visualisation des CV par les
recruteurs et la mise à jour de profils. Une attention particulière a été portée à la gestion
de la base de données, à l’ergonomie de l’interface, ainsi qu’à la sécurisation des accès via
les sessions.
L’expérience globale a permis de mettre en pratique de nombreuses notions étudiées
durant le cursus, tout en découvrant les réalités d’un projet web complet : contraintes de
temps, ajustements techniques, tests utilisateurs, et travail en autonomie. Des défis ont été
surmontés, notamment autour des migrations, de l’envoi de fichiers et de la structuration
des vues.
Ce projet a permis d’acquérir plusieurs compétences techniques : maîtrise avancée de
Django (vues, modèles, templates, formulaires), gestion des fichiers, configuration d’un
environnement de développement, et structuration MVC. Sur le plan organisationnel, il
a renforcé la capacité à planifier, documenter et tester un projet, à prendre des décisions
rapidement, et à maintenir une logique de travail cohérente du début à la fin.
Enfin, ce projet ouvre la voie à de nombreuses améliorations possibles (API REST,
système de messagerie, moteur de recherche optimisé) qui pourraient faire évoluer la
plateforme vers un véritable produit exploitable à plus grande échelle.

26
Chapitre 9

Références

9.1 Bibliographie
— Django Project Documentation – Django Software Foundation
— Python Programming – Mark Lutz
— Clean Code – Robert C. Martin
— Génie Logiciel – Ivar Jacobson

9.2 Webographie
— [Link] – Documentation officielle de Django
— [Link] – Forum de questions/réponses pour développeurs
— [Link] – Référence pour HTML, CSS et JavaScript
— [Link] – Tutoriels sur les technologies web
— [Link] – Assistance pour la structuration du code et la rédac-
tion

9.3 Ressources utilisées

— Framework : Django 4.x
— Langage : Python 3.x
— Base de données : Mysql
— Environnement de développement : Visual Studio Code/pycharm
— Outils : Git, GitHub, WampServer, Canva, PlantUML

27