STIR Workflow de Gestion des Congés et Recommandation est une application web développée dans le cadre d'un stage d'ingénieur au sein de la Société Tunisienne des Industries de Raffinage (STIR).

Le projet vise à digitaliser le processus de gestion des congés tout en intégrant des fonctionnalités intelligentes permettant d'exploiter les données des employés et de proposer des recommandations d'activités adaptées à leurs profils.

L'application est conçue selon une architecture Full Stack et microservices, avec plusieurs services indépendants communiquant via des API.

Le projet a plusieurs objectifs :

• Digitaliser la gestion des demandes de congé.
• Automatiser le workflow de validation.
• Centraliser les données des employés et des demandes.
• Assurer la traçabilité des validations et des refus.
• Gérer les utilisateurs selon leurs rôles.
• Sécuriser l'application avec JWT.
• Exploiter les données des employés.
• Analyser les compétences et informations liées aux employés.
• Proposer des activités adaptées aux employés grâce à un service de recommandation.
• Préparer le déploiement des différents services avec Docker et Kubernetes sur Azure.

Le système est composé de plusieurs services :

                         ┌─────────────────────┐
                         │      Frontend       │
                         │    React + Vite     │
                         └──────────┬──────────┘
                                    │
                                  REST API
                                    │
                                    ▼
                         ┌─────────────────────┐
                         │       Backend       │
                         │     Spring Boot     │
                         │   Security + JWT    │
                         └──────┬──────┬───────┘
                                │      │
                    ┌───────────┘      └───────────────┐
                    │                                  │
                    ▼                                  ▼
             ┌──────────────┐                  ┌──────────────┐
             │   MongoDB    │                  │ Model / AI   │
             │   Database   │                  │   Service    │
             └──────────────┘                  └──────┬───────┘
                                                      │
                                                      ▼
                                            ┌──────────────────┐
                                            │ Recommendation   │
                                            │     Service      │
                                            └──────────────────┘

Le processus de validation suit plusieurs niveaux :

Employé
   │
   ▼
Création d'une demande
   │
   ▼
Chef de service
   │
   ├── Refus → Justification
   │
   ▼
Sous-directeur
   │
   ├── Refus → Justification
   │
   ▼
Directeur
   │
   ├── Refus → Justification
   │
   ▼
Ressources Humaines
   │
   ▼
Demande approuvée

Chaque niveau possède des droits correspondant à son rôle.

Le système centralise les informations relatives aux employés.

Les données peuvent notamment être utilisées pour :

• Identifier les compétences.
• Consulter les expériences.
• Analyser les activités réalisées.
• Exploiter les évaluations.
• Identifier les domaines d'intérêt.
• Calculer la pertinence d'une activité pour un employé.

Ces informations constituent la base du système de recommandation.

Le projet contient un service indépendant dédié au traitement intelligent des données.

Ce service est développé avec :

• Python
• Flask
• Machine Learning
• NLP selon les besoins du modèle

Il communique avec le backend via une API REST.

Exemple :

Backend Spring Boot
        │
        │ HTTP Request
        ▼
   Model Service
        │
        │ Analyse
        ▼
    Résultats

L'objectif du service est de traiter les informations relatives aux employés et aux activités afin de fournir des données exploitables par le système de recommandation.

Une fonctionnalité importante du projet est la recommandation d'activités aux employés.

Le système exploite différentes informations :

                 Employé
                    │
        ┌───────────┼────────────┐
        ▼           ▼            ▼
    Compétences  Expérience   Activités
        │           │            │
        └───────────┼────────────┘
                    ▼
              Model / AI
                    │
                    ▼
          Matching / Scoring
                    │
                    ▼
       Recommandations d'activités

Le système peut ainsi déterminer quelles activités sont pertinentes pour un employé en fonction de son profil et des informations disponibles.

Employé
 ├── Java
 ├── Spring Boot
 ├── MongoDB
 └── 2 ans d'expérience

             ↓

Analyse du profil

             ↓

Activités disponibles

             ↓

Calcul de pertinence

             ↓

Recommandations

Cette fonctionnalité permet d'aider les responsables à identifier les employés pouvant être associés à certaines activités internes.

MongoDB constitue la base de données principale du projet.

Elle permet de stocker notamment :

• Utilisateurs
• Employés
• Demandes de congé
• Activités
• Notifications
• Sessions
• Historique des recommandations
• Logs d'audit
• Informations nécessaires au système de recommandation

Exemples de collections :

users
employees
activities
notifications
sessions
recommendationhistories
auditlogs

L'application utilise :

• Spring Security
• JWT
• Contrôle d'accès basé sur les rôles

Les rôles principaux sont :

ROLE_EMPLOYEE
ROLE_CHEF
ROLE_SOUS_DIRECTEUR
ROLE_DIRECTEUR
ROLE_RH
ROLE_ADMIN

Chaque rôle possède des permissions spécifiques.

Les demandes peuvent prendre les statuts suivants :

PENDING_CHEF
REFUSED_CHEF

PENDING_SOUS_DIRECTEUR
REFUSED_SOUS_DIRECTEUR

PENDING_DIRECTEUR
REFUSED_DIRECTEUR

PENDING_RH
REFUSED_RH

APPROVED

Lorsqu'une demande est refusée, une justification est enregistrée.

• React 19
• Vite
• React Router DOM
• Axios
• Bootstrap 5
• React Icons

• Java
• Spring Boot 3.5.3
• Spring Security
• JWT
• REST API
• Maven

• MongoDB 7

• Python
• Flask
• Machine Learning
• NLP

• Docker
• Docker Compose
• Kubernetes
• Microsoft Azure
• Azure Container Registry (ACR)
• Azure Kubernetes Service (AKS)
• Kubernetes Ingress
• Helm

Chaque service peut être exécuté dans son propre conteneur :

┌───────────────────────┐
│ Frontend Container    │
└───────────────────────┘

┌───────────────────────┐
│ Backend Container     │
└───────────────────────┘

┌───────────────────────┐
│ Model Container       │
└───────────────────────┘

┌───────────────────────┐
│ MongoDB Container     │
└───────────────────────┘

Les services peuvent être lancés avec :

docker compose up --build

Pour arrêter les services :

docker compose down

Le déploiement cloud prévu repose sur Microsoft Azure.

Les ressources du projet sont regroupées dans :

stir-rg

L'Azure Container Registry (ACR) permet de stocker les images Docker des différents services :

ACR
│
├── Frontend Image
├── Backend Image
└── Model Image

Le projet utilise un cluster Azure Kubernetes Service (AKS) pour héberger les différents composants.

Cluster :

stir-aks

Architecture cible :

                    Internet
                       │
                       ▼
                  ┌─────────┐
                  │ Ingress │
                  └────┬────┘
                       │
        ┌──────────────┼───────────────┐
        ▼              ▼               ▼
   Frontend Pod   Backend Pod      Model Pod
                       │               │
                       │               │
                       ▼               ▼
                  MongoDB Pod     Recommendation
                                       Service

Les composants sont organisés sous forme de ressources Kubernetes :

AKS Cluster
│
├── Frontend Deployment
├── Backend Deployment
├── Model Deployment
├── MongoDB
│
├── Services
│
└── Ingress

Exemple d'organisation :

k8s/
├── frontend.yaml
├── backend.yaml
├── model.yaml
├── mongodb.yaml
└── ingress.yaml

STIR-Workflow/
│
├── BackendStiirworkflow/
│   ├── src/
│   ├── pom.xml
│   └── Dockerfile
│
├── stir-frontend/
│   ├── src/
│   ├── package.json
│   └── Dockerfile
│
├── projASSu/
│   ├── app.py
│   ├── requirements.txt
│   └── Dockerfile
│
├── k8s/
│   ├── frontend.yaml
│   ├── backend.yaml
│   ├── model.yaml
│   ├── mongodb.yaml
│   └── ingress.yaml
│
├── docker-compose.yml
│
└── README.md

• Node.js
• npm
• Java JDK
• Maven
• Python
• Docker Desktop
• MongoDB

cd BackendStiirworkflow
mvn clean install
mvn spring-boot:run

Backend :

http://localhost:8080

cd stir-frontend
npm install
npm run dev

Frontend :

http://localhost:5173

cd projASSu
pip install -r requirements.txt
python app.py

Model Service :

http://localhost:5000

POST /api/auth/login

Exemple :

{
  "username": "user",
  "password": "password"
}

Le serveur retourne un JWT permettant d'accéder aux ressources protégées.

POST /analyze

Le backend peut communiquer avec le service Model via cet endpoint.

Les informations sensibles sont stockées dans des fichiers .env.

Exemple :

MONGO_URI=mongodb://localhost:27017/stirworkflow
JWT_SECRET=your_secret
AI_SERVICE_URL=http://localhost:5000

Les fichiers .env ne doivent pas être commités dans Git.

• Authentification
• JWT / Spring Security
• Gestion des rôles
• Gestion des employés
• Gestion des demandes de congé
• Workflow multi-niveaux
• Gestion des refus et justifications
• Dashboards selon les rôles
• MongoDB
• Service Model / AI
• Gestion des activités
• Système de recommandation des activités
• Docker
• Docker Compose

• Azure Resource Group
• Azure Container Registry (ACR)
• Préparation du cluster Azure Kubernetes Service (AKS)
• Préparation des manifests Kubernetes
• Déploiement complet sur AKS
• CI/CD
• Monitoring

Projet réalisé dans le cadre d'un stage d'ingénieur à la Société Tunisienne des Industries de Raffinage (STIR).

Le projet permet de mettre en pratique :

• Développement Full Stack
• React
• Spring Boot
• MongoDB
• REST API
• Spring Security
• JWT
• Python
• Machine Learning / NLP
• Système de recommandation
• Docker
• Kubernetes
• Microsoft Azure
• Azure AKS
• Azure ACR
• Architecture microservices

Mohamed Dhia Romdhane

Projet réalisé dans le cadre d'un stage d'ingénieur à la STIR.