🔐 Stateless Authentication with JWT

In a monolithic application, user sessions are often stored in memory. In a Microservices Architecture, this is impossible because requests are routed to different independent servers. We use JSON Web Tokens (JWT) to solve this:

• Statelessness: When a user logs in, the Authentification service verifies the credentials and returns a signed JWT. This token contains the user's identity and role.
• Decentralized Security: The frontend attaches this token to the header (Authorization: Bearer <token>) of subsequent requests. Services like Ordonance can instantly verify the token's validity without needing to query a shared session database, keeping the architecture truly decoupled and fast.

🏗️ Microservices Architecture Detail

The application is decomposed into isolated containerized services. This design pattern ensures high availability, independent scalability, and separation of concerns.

📋 Prerequisites

To run this project locally, ensure you have the following tools installed on your machine:

• Docker
• Docker Compose
• Node.js (Only required if you want to run the local test.js script)

🛠️ Installation and Setup

The entire infrastructure, including databases and message brokers, is orchestrated using Docker Compose.

1. Clone the repository:

   git clone <your-repository-url>
   cd Projet
   

2. Start the infrastructure: Run the following command at the root of the project to build the images and start all containers in the background:

   docker-compose up --build -d
   

3. Access the interfaces:

   • Pharmacy Web Dashboard: http://localhost:8080
   • RabbitMQ Management Interface: http://localhost:15672 (Credentials: guest / guest)
   • MongoDB Database: localhost:27017

4. Stop the infrastructure: To gracefully stop and remove the containers:

   docker-compose down
   

🔗 Detailed API Endpoints & Usage

Below is a breakdown of the core REST API endpoints exposed by the microservices.

1. Authentication Service (Port 5002)

• POST /auth/register: Register a new user.
  • Payload: { "nom": "Dupont", "prenom": "Jean", "email": "jean@example.com", "mot_de_passe": "password", "role": "Patient" }
• POST /auth/login: Authenticate a user and receive a JWT.
  • Payload: { "email": "jean@example.com", "mot_de_passe": "password" }
  • Returns: { "token": "eyJhbGciOiJIUz..." }

2. Medicament Service (Port 5000)

• POST /medicament/ajouter: Add a new medication to the inventory.
  • Payload: { "nom_commercial": "Paracetamol", "quantite_stock": 100, "prix_unitaire": 5, ... }
• GET /medicament/liste: Retrieve the list of all medications.

3. Ordonance Service (Port 5001)

Requires JWT Token in Headers: Authorization: Bearer <token>

• POST /ordonance/ajouter: Create a new prescription. Triggers a RabbitMQ event upon success.
  • Payload: { "numero_ordonnance": "ORD-001", "nom_patient": "Jean", "medicaments_prescrits": [...] }

4. Personnel Service (Port 5003)

• POST /personnel/ajouter: Hire/Add a new staff member.
  • Payload: { "matricule": "EMP-001", "nom": "Dr. Martin", "poste": "Médecin", ... }
• GET /personnel/liste: Get all active personnel.

🧪 Automated Testing

A global end-to-end test script (test.js) is provided at the root of the project. It uses axios to simulate a complete user journey across all microservices (Register -> Login -> Add Medication -> Create Prescription -> Add Personnel).

To run the test suite:

1. Ensure your Docker containers are running (docker-compose up -d).
2. Open a terminal at the root of the project.
3. Install axios (if not installed globally): npm install axios
4. Execute the script:

   node test.js
   

If successful, the terminal will output "=== Tous les tests ont réussi ! ===".

📂 Project Structure

Projet/
├── authentification/   # Auth microservice source code (Node.js/Express)
├── frontend/           # Static SPA (HTML, CSS, JS) served by Nginx
├── medicament/         # Medication microservice source code
├── notification/       # Async notification worker (RabbitMQ consumer)
├── ordonance/          # Prescription microservice source code
├── personnel/          # Personnel management microservice
├── docker-compose.yml  # Docker orchestration and networking config
└── test.js             # E2E integration test script

🤝 Contributing

1. Fork the project
2. Create your feature branch (git checkout -b feature/NewFeature)
3. Commit your changes (git commit -m 'Add NewFeature')
4. Push to the branch (git push origin feature/NewFeature)
5. Open a Pull Request