//  Approche BLOQUANTE — ne pas utiliser en Node.js
const donnees = lirebdd();   // Le programme s'ARRÊTE et attend
                              // Pendant ce temps : 0 requête traitée
console.log(donnees);

//  Approche NON-BLOQUANTE avec callback — Node.js
lirebdd(function(donnees) {
  console.log(donnees);       // Exécuté QUAND la BDD répond
});
// Node.js continue immédiatement ici — autres requêtes traitées

// Exercice classique — prédire l'ordre d'affichage
console.log('1 - Début');
setTimeout(function() {
  console.log('2 - setTimeout');
}, 0);  // 0 ms de délai !
console.log('3 - Fin');

// Résultat : 1, 3, 2
// Explication : Node.js exécute d'abord tout le code synchrone (1 et 3),
// puis traite les callbacks (2) — même avec un délai de 0 ms.

# Vérifier l'installation
node --version      # Ex : v20.11.0
npm --version       # Ex : 10.2.4

# Initialiser un projet
mkdir mon-api && cd mon-api
npm init -y         # Crée package.json avec valeurs par défaut

# Installer des dépendances
npm install express                # Production → dependencies
npm install nodemon --save-dev     # Développement → devDependencies

# Après un git clone (réinstaller tout depuis package.json)
npm install

{
  "name": "mon-api",
  "version": "1.0.0",
  "description": "API REST Node.js — skilling.ma",
  "main": "index.js",
  "scripts": {
    "start": "node index.js",       // Production  : npm start
    "dev":   "nodemon index.js"     // Développement : npm run dev
  },
  "dependencies": {
    "express": "^4.18.2"            // Dépendance de production
  },
  "devDependencies": {
    "nodemon": "^3.0.1"             // Seulement en développement
  }
}

// calculatrice.js — définir et exporter des fonctions

function addition(a, b) {
  return a + b;
}

function multiplication(a, b) {
  return a * b;
}

// Sans module.exports, les fonctions sont inaccessibles depuis l'extérieur
module.exports = {
  addition:       addition,
  multiplication: multiplication
};

// app.js — importer et utiliser le module
const calc = require('./calculatrice'); // './' = même dossier

console.log('5 + 3 =', calc.addition(5, 3));         // 8
console.log('4 × 3 =', calc.multiplication(4, 3));   // 12

// serveur.js — Premier serveur HTTP Node.js natif (sans Express)
const http = require('http');
const PORT = 3000;

const serveur = http.createServer(function(req, res) {
  const url     = req.url;    // Ex: '/produits' ou '/'
  const methode = req.method; // Ex: 'GET', 'POST'

  console.log(`${methode} ${url}`); // Log chaque requête dans le terminal

  if (url === '/' && methode === 'GET') {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({
      message: 'API Node.js opérationnelle',
      version: '1.0.0'
    }));

  } else if (url === '/produits' && methode === 'GET') {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({
      produits: [
        { id: 1, nom: 'Tajine',   prix: 120 },
        { id: 2, nom: 'Couscous', prix: 85  }
      ]
    }));

  } else {
    res.writeHead(404, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({
      erreur:       'Route introuvable',
      url_demandee: url
    }));
  }
});

serveur.listen(PORT, function() {
  console.log(`Serveur démarré sur http://localhost:${PORT}`);
});

//  Node.js natif — lourd et fragile pour 20+ routes
const http = require('http');
http.createServer(function(req, res) {
  if (req.url === '/produits' && req.method === 'GET') {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ produits: [] }));
  } else if (req.url.startsWith('/produits/') && req.method === 'GET') {
    const id = req.url.split('/')[2]; // fragile — ne gère pas /produits/1/photos
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ id: id }));
  } // ... et ainsi de suite pour chaque route
}).listen(3000);

//  Express — lisible, maintenable, professionnel
const express = require('express');
const app = express();
app.use(express.json()); // Parse le JSON du body automatiquement

app.get('/produits', function(req, res) {
  res.json({ produits: [] }); // Content-Type + JSON.stringify automatiques
});

app.get('/produits/:id', function(req, res) {
  const id = req.params.id; // Extraction automatique, sûre
  res.json({ produit_id: id });
});

app.listen(3000);

const express = require('Express');       // Ligne 1
const app = express;                      // Ligne 2

app.get('/articles', function(req, res) {
  res.status(200).json({ articles: [] });
});

app.get('/articles/:id', function(req, res) {
  const id = req.body.id;                 // Ligne 9
  res.json({ id: id });
});

app.post('/articles', function(req, res) {
  const article = req.body;
  res.status(200).json({ article });      // Ligne 15
});

app.Listen(3000, function() {             // Ligne 18
  console.log('Serveur démarré');
});

const EventEmitter = require('events'); // Module natif — pas de npm install

const emetteur = new EventEmitter();

// Deux listeners indépendants sur le même événement
emetteur.on('nouvelle_commande', function(commande) {
  console.log('Stock mis à jour pour :', commande.produit);
});

emetteur.on('nouvelle_commande', function(commande) {
  console.log('Email de confirmation envoyé à :', commande.client);
});

// .once() s'exécute UNE SEULE fois puis se désabonne automatiquement
emetteur.once('demarrage', function() {
  console.log('Serveur initialisé — ce message n'apparaît qu'une fois');
});

emetteur.emit('demarrage');            // → affiche le message
emetteur.emit('demarrage');            // → rien (once désabonné)

emetteur.emit('nouvelle_commande', {
  client:  'Mohamed',
  produit: 'Tajine',
  prix:    120
});
// Résultat : les deux listeners s'exécutent indépendamment

const fs = require('fs');

console.log('1 - Début');

setTimeout(function() {
  console.log('3 - Après 2 secondes');
}, 2000);

console.log('2 - Fin du code synchrone');
// Ordre d'affichage : 1, 2, (2 secondes), 3

// Lecture de fichier avec callback — convention error-first
fs.readFile('data.json', 'utf8', function(erreur, contenu) {
  // PREMIER argument = toujours l'erreur (null si pas d'erreur)
  if (erreur) {
    console.error('Erreur lecture :', erreur.message);
    return; // Stopper si erreur — ne jamais continuer sans données valides
  }
  // SECOND argument = le résultat (seulement si pas d'erreur)
  const donnees = JSON.parse(contenu);
  console.log('Données lues :', donnees);
});

mkdir mon-api && cd mon-api
npm init -y
npm install express
npm install nodemon --save-dev

const express = require('express');
const app     = express();        // Appeler express() avec () — erreur classique : oublier les ()
const PORT    = 3000;

// Middleware global : parse automatiquement le body JSON des requêtes POST/PUT
// Sans cette ligne, req.body sera undefined dans toutes les routes POST/PUT
app.use(express.json());

// Routes ici...

app.listen(PORT, function() {
  console.log(`Serveur Express : http://localhost:${PORT}`);
});

const express = require('express');
const app     = express();
const PORT    = 3000;
app.use(express.json());

// Données statiques (remplacées par MongoDB en séance 8)
const produits = [
  { id: 1, nom: 'Tajine',   prix: 120 },
  { id: 2, nom: 'Couscous', prix: 85  },
  { id: 3, nom: 'Harira',   prix: 45  }
];

// ── GET /produits — liste complète ────────────────────
app.get('/produits', function(req, res) {
  res.status(200).json({
    produits: produits,
    total: produits.length // Bonne pratique : inclure le total
  });
});

// ── GET /produits/:id — un produit par id ────────────
app.get('/produits/:id', function(req, res) {
  const id      = parseInt(req.params.id); // req.params.id est toujours une string
  const produit = produits.find(p => p.id === id);

  if (!produit) {
    return res.status(404).json({
      erreur:     'Produit introuvable',
      id_demande: id
    });
  }
  res.status(200).json({ produit });
});

// ── POST /produits — créer un produit ────────────────
app.post('/produits', function(req, res) {
  // Validation des données — toujours valider avant de traiter
  if (!req.body.nom || !req.body.prix) {
    return res.status(400).json({
      erreur: 'Les champs nom et prix sont obligatoires'
    });
  }
  res.status(201).json({ // 201 Created — pas 200 pour une création
    message: 'Produit créé avec succès',
    produit: req.body
  });
});

// ── PUT /produits/:id — modifier un produit ──────────
app.put('/produits/:id', function(req, res) {
  const id = parseInt(req.params.id);
  res.status(200).json({
    message:       `Produit ${id} modifié avec succès`,
    modifications: req.body
  });
});

// ── DELETE /produits/:id — supprimer un produit ──────
app.delete('/produits/:id', function(req, res) {
  const id = parseInt(req.params.id);
  res.status(200).json({
    message: `Produit ${id} supprimé avec succès`
  });
});

app.listen(PORT, () => console.log(`http://localhost:${PORT}`));

{
  "equipes": [
    {
      "id": 1,
      "nom": "Wydad Club Athlétique",
      "ville": "Casablanca",
      "fondation": 1937,
      "stade": "Complexe Mohammed V",
      "titres_nationaux": 22
    },
    {
      "id": 2,
      "nom": "Raja Athletic Club",
      "ville": "Casablanca",
      "fondation": 1949,
      "stade": "Complexe Mohammed V",
      "titres_nationaux": 13
    },
    {
      "id": 3,
      "nom": "FUS Rabat",
      "ville": "Rabat",
      "fondation": 1946,
      "stade": "Stade Prince Moulay Abdellah",
      "titres_nationaux": 5
    },
    {
      "id": 4,
      "nom": "Moghreb Athlétique Tétouan",
      "ville": "Tetouan",
      "fondation": 1922,
      "stade": "Stade Saniat Rmel",
      "titres_nationaux": 2
    },
    {
      "id": 5,
      "nom": "Hassania Union Sport Agadir",
      "ville": "Agadir",
      "fondation": 1946,
      "stade": "Stade Adrar",
      "titres_nationaux": 1
    }
  ]
}

api-equipes/
├── data/
│   └── equipes.json       ← données
├── routes/
│   └── equipes.js         ← toutes les routes /equipes
├── .gitignore             ← contient : node_modules/
├── package.json
└── index.js               ← point d'entrée du serveur

const express = require('express');
const router  = express.Router(); // Mini-routeur indépendant
const fs      = require('fs');
const path    = require('path');

// path.join() construit un chemin compatible Windows et Linux
const FICHIER = path.join(__dirname, '..', 'data', 'equipes.json');

// Fonction utilitaire réutilisable dans toutes les routes
function lireEquipes(callback) {
  fs.readFile(FICHIER, 'utf8', function(erreur, contenu) {
    if (erreur) {
      callback(erreur, null);
      return;
    }
    const donnees = JSON.parse(contenu);
    callback(null, donnees.equipes);
  });
}

// ── GET /equipes — liste complète ─────────────────────
router.get('/', function(req, res) {  // Chemin '/' car préfixe /equipes défini dans index.js
  lireEquipes(function(erreur, equipes) {
    if (erreur) {
      return res.status(500).json({ erreur: 'Erreur serveur' });
    }
    res.status(200).json({
      total:   equipes.length,
      equipes: equipes
    });
  });
});

// ── GET /equipes/:id — une équipe ─────────────────────
router.get('/:id', function(req, res) {
  const idDemande = parseInt(req.params.id);

  // Validation : l'id doit être un nombre
  if (isNaN(idDemande)) {
    return res.status(400).json({ erreur: 'L'id doit être un nombre entier' });
  }

  lireEquipes(function(erreur, equipes) {
    if (erreur) {
      return res.status(500).json({ erreur: 'Erreur serveur' });
    }
    const equipe = equipes.find(e => e.id === idDemande);

    if (!equipe) {
      return res.status(404).json({
        erreur:     'Equipe introuvable',
        id_demande: idDemande
      });
    }
    res.status(200).json({ equipe });
  });
});

module.exports = router;

const express = require('express');
const app     = express();
const PORT    = 3000;

app.use(express.json());

// Monter le router equipes — toutes ses routes seront préfixées par /equipes
const equipesRouter = require('./routes/equipes');
app.use('/equipes', equipesRouter);

app.get('/', function(req, res) {
  res.json({ message: 'API Equipes — opérationnelle', routes: ['GET /equipes', 'GET /equipes/:id'] });
});

app.listen(PORT, () => console.log(`http://localhost:${PORT}`));

const express = require('______');      // (1)
const router  = express.______();       // (2)
const fs      = require('fs');
const path    = require('path');

const FICHIER = path.join(__dirname, '..', 'data', 'stades.json');

router.____('/stades', function(req, res) {  // (3)
  fs.readFile(FICHIER, '____', function(erreur, contenu) {  // (4)
    if (______) {                             // (5)
      return res.status(____).json({ erreur: 'Erreur serveur' });  // (6)
    }
    const donnees = JSON.______(contenu);    // (7)
    res.status(200).______({ stades: donnees.stades });  // (8)
  });
});

router.get('/stades/:nom', function(req, res) {
  const nomDemande = req.______.nom;          // (9)
  fs.readFile(FICHIER, 'utf8', function(erreur, contenu) {
    if (erreur) { return res.status(500).json({ erreur: 'Erreur serveur' }); }
    const stades = JSON.parse(contenu).stades;
    const stade  = stades.find(s => s.nom === ______);  // (10)
    if (!stade) {
      return res.status(______).json({ erreur: 'Stade introuvable' });  // (11)
    }
    res.______(200).json({ stade });          // (12)
  });
});

module.exports = ______;                      // (13)

// Schéma du chaînage :
// Requête → [express.json()] → [logger] → [route handler] → Réponse

// Middleware 1 : logger — s'applique à TOUTES les routes
app.use(function(req, res, next) {
  console.log(`[${new Date().toISOString()}] ${req.method} ${req.url}`);
  next(); // Indispensable — sinon la requête reste bloquée ici
});

// Middleware 2 : parse le body JSON (middleware fourni par Express)
app.use(express.json());
// Sans cette ligne : req.body === undefined dans POST et PUT

// Route handler — exécutée APRÈS les deux middlewares
app.post('/equipes', function(req, res) {
  console.log(req.body); // Maintenant disponible grâce à express.json()
  res.json({ recu: req.body });
});

// Fonction utilitaire : réécrire le fichier JSON
function ecrireEquipes(equipes, callback) {
  const donnees   = JSON.stringify({ equipes: equipes }, null, 2);
  fs.writeFile(FICHIER, donnees, 'utf8', callback);
}

// ── POST /equipes ─────────────────────────────────────────
router.post('/', function(req, res) {
  const { nom, ville, fondation, stade, titres_nationaux } = req.body;

  // Validation — les champs obligatoires doivent être présents et valides
  if (!nom || typeof nom !== 'string' || nom.trim() === '') {
    return res.status(400).json({ erreur: 'Le champ nom est obligatoire (string non vide)' });
  }
  if (!ville || typeof ville !== 'string') {
    return res.status(400).json({ erreur: 'Le champ ville est obligatoire' });
  }
  if (fondation !== undefined && (typeof fondation !== 'number' || fondation < 1800)) {
    return res.status(400).json({ erreur: 'fondation doit être un nombre >= 1800' });
  }

  lireEquipes(function(erreur, equipes) {
    if (erreur) return res.status(500).json({ erreur: 'Erreur lecture fichier' });

    // Générer un id unique : max des ids existants + 1
    const nouvelId = equipes.length > 0
      ? Math.max(...equipes.map(e => e.id)) + 1
      : 1;

    const nouvelleEquipe = {
      id:               nouvelId,
      nom:              nom.trim(),
      ville:            ville.trim(),
      fondation:        fondation || null,
      stade:            stade || null,
      titres_nationaux: titres_nationaux || 0
    };

    equipes.push(nouvelleEquipe);

    ecrireEquipes(equipes, function(erreurEcriture) {
      if (erreurEcriture) return res.status(500).json({ erreur: 'Erreur écriture fichier' });
      res.status(201).json({
        message: 'Équipe créée avec succès',
        equipe:  nouvelleEquipe
      });
    });
  });
});

// ── PUT /equipes/:id ──────────────────────────────────────
router.put('/:id', function(req, res) {
  const idDemande = parseInt(req.params.id);

  if (isNaN(idDemande)) {
    return res.status(400).json({ erreur: 'L'id doit être un nombre entier' });
  }

  lireEquipes(function(erreur, equipes) {
    if (erreur) return res.status(500).json({ erreur: 'Erreur lecture fichier' });

    // findIndex() retourne l'indice dans le tableau (-1 si non trouvé)
    const index = equipes.findIndex(e => e.id === idDemande);

    if (index === -1) {
      return res.status(404).json({
        erreur:     'Équipe introuvable',
        id_demande: idDemande
      });
    }

    // Fusion partielle : les champs de req.body écrasent uniquement les champs correspondants
    equipes[index] = Object.assign({}, equipes[index], req.body, { id: idDemande });
    // { id: idDemande } garantit que l'id ne peut pas être modifié depuis le body

    ecrireEquipes(equipes, function(erreurEcriture) {
      if (erreurEcriture) return res.status(500).json({ erreur: 'Erreur écriture fichier' });
      res.status(200).json({
        message: 'Équipe modifiée avec succès',
        equipe:  equipes[index]
      });
    });
  });
});

// ── DELETE /equipes/:id ───────────────────────────────────
router.delete('/:id', function(req, res) {
  const idDemande = parseInt(req.params.id);

  if (isNaN(idDemande)) {
    return res.status(400).json({ erreur: 'L'id doit être un nombre entier' });
  }

  lireEquipes(function(erreur, equipes) {
    if (erreur) return res.status(500).json({ erreur: 'Erreur lecture fichier' });

    const equipeASupprimer = equipes.find(e => e.id === idDemande);

    if (!equipeASupprimer) {
      return res.status(404).json({
        erreur:     'Équipe introuvable',
        id_demande: idDemande
      });
    }

    // filter() crée un NOUVEAU tableau sans l'équipe à supprimer
    // Ne modifie pas le tableau original — plus sûr que splice()
    const equipesRestantes = equipes.filter(e => e.id !== idDemande);

    ecrireEquipes(equipesRestantes, function(erreurEcriture) {
      if (erreurEcriture) return res.status(500).json({ erreur: 'Erreur écriture fichier' });
      res.status(200).json({
        message: 'Équipe supprimée avec succès',
        equipe:  equipeASupprimer // Confirmer ce qui a été supprimé
      });
    });
  });
});

// Routes montées ici...
app.use('/equipes', equipesRouter);

// Route 404 — aucune route précédente ne correspond
app.use(function(req, res) {
  res.status(404).json({
    erreur: 'Route introuvable',
    url:    req.url,
    methode: req.method
  });
});

// Middleware d'erreur — TOUJOURS déclaré en dernier, TOUJOURS 4 paramètres
app.use(function(err, req, res, next) {
  console.error('[ERREUR]', err.message);
  res.status(err.status || 500).json({
    erreur:  err.message || 'Erreur interne du serveur',
    details: process.env.NODE_ENV === 'development' ? err.stack : undefined
  });
});

// Dans une route, déclencher le middleware d'erreur :
router.get('/:id', function(req, res, next) {
  lireEquipes(function(err, equipes) {
    if (err) return next(err); // Passe l'erreur au middleware global
    // ...
  });
});

# 1. Vérifier que MongoDB est démarré
mongod --version  # Ex: db version v7.0.4

# 2. Installer le driver officiel Node.js
npm install mongodb

# Structure du projet après ajout MongoDB :
# api-equipes/
# ├── config/
# │   └── mongodb.js   ← nouveau : gestion connexion
# ├── routes/
# │   └── equipes.js   ← sera mis à jour pour MongoDB
# └── index.js

const { MongoClient } = require('mongodb');

// Chaîne de connexion — en production, toujours dans une variable d'environnement
const URI  = process.env.MONGO_URI || 'mongodb://localhost:27017';
const DBNAME = 'bdmonapi';

let base; // Variable qui stocke la connexion — réutilisée par toutes les routes

async function connecter() {
  try {
    const client = new MongoClient(URI);
    await client.connect();
    base = client.db(DBNAME);
    console.log(`MongoDB connecté : ${DBNAME}`);
  } catch (err) {
    console.error('Erreur connexion MongoDB :', err.message);
    process.exit(1); // Arrêter le serveur si MongoDB est inaccessible
  }
}

function getBase() {
  if (!base) throw new Error('MongoDB non connecté — appeler connecter() d'abord');
  return base;
}

module.exports = { connecter, getBase };

const express        = require('express');
const { connecter }  = require('./config/mongodb');
const equipesRouter  = require('./routes/equipes');

const app  = express();
const PORT = 3000;

app.use(express.json());
app.use('/equipes', equipesRouter);

// Connecter MongoDB AVANT de démarrer Express
// Garantit que la base est prête avant d'accepter des requêtes
connecter().then(function() {
  app.listen(PORT, function() {
    console.log(`Serveur : http://localhost:${PORT}`);
  });
});

const { MongoClient } = require('mongodb');

async function main() {
  const client = new MongoClient('mongodb://localhost:27017');

  try {
    await client.connect();
    console.log('Connexion établie');

    const base       = client.db('bdmonapi');
    const collection = base.collection('equipe');

    // find({}) = tous les documents — {} = filtre vide = aucun filtre
    // find() retourne un CURSOR, pas les données directement
    // toArray() convertit le cursor en tableau JavaScript
    const equipes = await collection.find({}).toArray();
    console.log('Équipes trouvées :', equipes.length);
    equipes.forEach(e => console.log('-', e.nom, '|', e.ville));

  } finally {
    await client.close(); // Toujours fermer la connexion
    console.log('Connexion fermée');
  }
}

main().catch(console.error);

const { ObjectId } = require('mongodb');
const { getBase }  = require('../config/mongodb');

// Fonction utilitaire : valider et convertir un id depuis req.params
function parseObjectId(idString) {
  if (!ObjectId.isValid(idString)) {
    return null; // Format invalide — déclencher un 400
  }
  return new ObjectId(idString);
}
// Usage : const objectId = parseObjectId(req.params.id);
//         if (!objectId) return res.status(400).json({ erreur: 'Id invalide' });

// ── GET /equipes ─────────────────────────────────────────
router.get('/', async function(req, res) {
  try {
    const collection = getBase().collection('equipe');

    // Options de requête depuis les query params
    const ville = req.query.ville;   // Filtre optionnel : /equipes?ville=Rabat
    const tri   = req.query.tri || 'nom'; // Tri par défaut sur le nom

    const filtre = ville ? { ville: ville } : {};

    const equipes = await collection
      .find(filtre)
      .sort({ [tri]: 1 })    // 1 = croissant, -1 = décroissant
      .toArray();

    res.status(200).json({
      total:   equipes.length,
      equipes: equipes
    });
  } catch (err) {
    res.status(500).json({ erreur: 'Erreur serveur MongoDB' });
  }
});

// ── GET /equipes/:id ─────────────────────────────────────
router.get('/:id', async function(req, res) {
  const objectId = parseObjectId(req.params.id);
  if (!objectId) {
    return res.status(400).json({ erreur: 'Format d'id invalide (ObjectId attendu)' });
  }

  try {
    const collection = getBase().collection('equipe');
    const equipe     = await collection.findOne({ _id: objectId });

    // findOne() retourne null si aucun document ne correspond — pas d'exception
    if (!equipe) {
      return res.status(404).json({
        erreur: 'Équipe introuvable',
        id:     req.params.id
      });
    }

    res.status(200).json({ equipe });
  } catch (err) {
    res.status(500).json({ erreur: 'Erreur serveur MongoDB' });
  }
});

// ── POST /equipes ────────────────────────────────────────
router.post('/', async function(req, res) {
  const { nom, ville, fondation, stade, titres_nationaux } = req.body;

  if (!nom || !ville) {
    return res.status(400).json({ erreur: 'nom et ville sont obligatoires' });
  }

  const nouvelleEquipe = {
    nom:              nom.trim(),
    ville:            ville.trim(),
    fondation:        fondation || null,
    stade:            stade || null,
    titres_nationaux: titres_nationaux || 0,
    createdAt:        new Date()  // MongoDB peut stocker des dates natives
  };

  try {
    const collection = getBase().collection('equipe');
    const resultat   = await collection.insertOne(nouvelleEquipe);

    // insertOne() retourne { acknowledged: true, insertedId: ObjectId(...) }
    res.status(201).json({
      message:  'Équipe créée avec succès',
      insertedId: resultat.insertedId,
      equipe:   { _id: resultat.insertedId, ...nouvelleEquipe }
    });
  } catch (err) {
    res.status(500).json({ erreur: 'Erreur insertion MongoDB' });
  }
});

// ── PUT /equipes/:id ─────────────────────────────────────
router.put('/:id', async function(req, res) {
  const objectId = parseObjectId(req.params.id);
  if (!objectId) {
    return res.status(400).json({ erreur: 'Format d'id invalide' });
  }

  if (Object.keys(req.body).length === 0) {
    return res.status(400).json({ erreur: 'Body vide — aucune modification fournie' });
  }

  // Empêcher la modification du champ _id
  const { _id, ...modifications } = req.body;

  try {
    const collection = getBase().collection('equipe');

    const resultat = await collection.updateOne(
      { _id: objectId },          // Filtre : quel document modifier
      { $set: modifications }     // Opérateur $set : modifier uniquement les champs fournis
    );

    // matchedCount = 0 → aucun document avec cet _id
    if (resultat.matchedCount === 0) {
      return res.status(404).json({ erreur: 'Équipe introuvable' });
    }

    // Récupérer le document mis à jour pour le renvoyer
    const equipeMAJ = await collection.findOne({ _id: objectId });
    res.status(200).json({
      message: 'Équipe modifiée avec succès',
      equipe:  equipeMAJ
    });
  } catch (err) {
    res.status(500).json({ erreur: 'Erreur MongoDB' });
  }
});

// ── DELETE /equipes/:id ──────────────────────────────────
router.delete('/:id', async function(req, res) {
  const objectId = parseObjectId(req.params.id);
  if (!objectId) {
    return res.status(400).json({ erreur: 'Format d'id invalide' });
  }

  try {
    const collection = getBase().collection('equipe');

    // Récupérer l'équipe avant suppression pour la confirmer dans la réponse
    const equipe = await collection.findOne({ _id: objectId });
    if (!equipe) {
      return res.status(404).json({ erreur: 'Équipe introuvable' });
    }

    const resultat = await collection.deleteOne({ _id: objectId });

    // deletedCount = 0 si aucun document supprimé (race condition possible)
    if (resultat.deletedCount === 0) {
      return res.status(500).json({ erreur: 'Suppression échouée' });
    }

    res.status(200).json({
      message: 'Équipe supprimée avec succès',
      equipe:  equipe // Confirmer ce qui a été supprimé
    });
  } catch (err) {
    res.status(500).json({ erreur: 'Erreur MongoDB' });
  }
});

npm install jsonwebtoken bcryptjs dotenv

MONGO_URI=mongodb://localhost:27017
JWT_SECRET=une_chaine_aleatoire_longue_et_complexe_min_32_chars
JWT_EXPIRES_IN=7d
PORT=3000

require('dotenv').config(); // TOUJOURS en premiere ligne
const express = require('express');
// ...

const express  = require('express');
const router   = express.Router();
const bcrypt   = require('bcryptjs');
const jwt      = require('jsonwebtoken');
const { getBase } = require('../config/mongodb');

// ── POST /auth/register ───────────────────────────────────
router.post('/register', async function(req, res) {
  const { email, motDePasse, role } = req.body;

  if (!email || !motDePasse) {
    return res.status(400).json({ erreur: 'email et motDePasse obligatoires' });
  }

  const collection = getBase().collection('utilisateur');

  // Verifier que l'email n'existe pas deja
  const existant = await collection.findOne({ email });
  if (existant) {
    return res.status(409).json({ erreur: 'Email deja utilise' });
  }

  // Hasher le mot de passe — saltRounds=12 recommande en production
  const hash = await bcrypt.hash(motDePasse, 12);

  const utilisateur = {
    email,
    motDePasse: hash,           // Stocker le hash, jamais le mot de passe brut
    role:       role || 'user', // Defaut : user, pas admin
    createdAt:  new Date()
  };

  const resultat = await collection.insertOne(utilisateur);
  res.status(201).json({
    message: 'Compte cree avec succes',
    userId:  resultat.insertedId
  });
});

// ── POST /auth/login ──────────────────────────────────────
router.post('/login', async function(req, res) {
  const { email, motDePasse } = req.body;

  if (!email || !motDePasse) {
    return res.status(400).json({ erreur: 'email et motDePasse obligatoires' });
  }

  const collection   = getBase().collection('utilisateur');
  const utilisateur  = await collection.findOne({ email });

  // Meme message si email inexistant ou mot de passe incorrect
  // Evite de reveler quels emails existent en base
  if (!utilisateur) {
    return res.status(401).json({ erreur: 'Identifiants incorrects' });
  }

  const motDePasseValide = await bcrypt.compare(motDePasse, utilisateur.motDePasse);
  if (!motDePasseValide) {
    return res.status(401).json({ erreur: 'Identifiants incorrects' });
  }

  // Generer le JWT
  const token = jwt.sign(
    { userId: utilisateur._id, email: utilisateur.email, role: utilisateur.role },
    process.env.JWT_SECRET,
    { expiresIn: process.env.JWT_EXPIRES_IN || '7d' }
  );

  res.status(200).json({
    message: 'Connexion reussie',
    token:   token  // Le client stocke ce token et l'envoie dans Authorization: Bearer 
  });
});

module.exports = router;

const jwt = require('jsonwebtoken');

function isAuthenticated(req, res, next) {
  const authHeader = req.headers.authorization;

  // Cas 1 : header absent
  if (!authHeader) {
    return res.status(401).json({ erreur: 'Token manquant — Authorization: Bearer <token>' });
  }

  // Cas 2 : format invalide (doit etre "Bearer <token>")
  const parties = authHeader.split(' ');
  if (parties.length !== 2 || parties[0] !== 'Bearer') {
    return res.status(401).json({ erreur: 'Format invalide — utiliser Authorization: Bearer <token>' });
  }

  const token = parties[1];

  try {
    // jwt.verify() decode ET verifie la signature + expiration
    const payload = jwt.verify(token, process.env.JWT_SECRET);
    req.utilisateur = payload; // Disponible dans toutes les routes suivantes
    next(); // Passer a la route handler
  } catch (err) {
    if (err.name === 'TokenExpiredError') {
      return res.status(401).json({ erreur: 'Token expire — reconnectez-vous' });
    }
    // JsonWebTokenError, NotBeforeError ou autre
    return res.status(401).json({ erreur: 'Token invalide' });
  }
}

module.exports = isAuthenticated;

// isAdmin doit toujours etre utilise APRES isAuthenticated
function isAdmin(req, res, next) {
  // req.utilisateur est place par isAuthenticated
  if (!req.utilisateur || req.utilisateur.role !== 'admin') {
    return res.status(403).json({
      erreur: 'Acces reserve aux administrateurs'
    });
  }
  next();
}

module.exports = isAdmin;

const isAuthenticated = require('../middlewares/isAuthenticated');
const isAdmin         = require('../middlewares/isAdmin');

// GET public — pas de protection
router.get('/', async function(req, res) { /* ... */ });

// PUT protege — utilisateur authentifie requis
router.put('/:id', isAuthenticated, async function(req, res) { /* ... */ });

// DELETE protege — admin uniquement
router.delete('/:id', isAuthenticated, isAdmin, async function(req, res) { /* ... */ });
// L'ordre compte : isAuthenticated s'execute avant isAdmin
// Si le token est invalide, isAuthenticated bloque et isAdmin ne s'execute jamais

npm install helmet cors express-rate-limit express-validator

const helmet      = require('helmet');
const cors        = require('cors');
const rateLimit   = require('express-rate-limit');

// helmet : applique ~15 headers de securite en une ligne
app.use(helmet());
// Supprime X-Powered-By, ajoute X-Content-Type-Options, X-Frame-Options, etc.

// CORS : autoriser uniquement les origines connues
app.use(cors({
  origin:  ['http://localhost:4200', 'https://mon-frontend.ma'],
  methods: ['GET', 'POST', 'PUT', 'DELETE'],
  allowedHeaders: ['Content-Type', 'Authorization']
}));

// Rate limiting general — 100 req par IP par 15 min
const limiterGeneral = rateLimit({
  windowMs: 15 * 60 * 1000,  // 15 minutes
  max:      100,
  message:  { erreur: 'Trop de requetes — reessayez dans 15 minutes' }
});
app.use(limiterGeneral);

// Rate limiting strict sur login — 10 tentatives par IP par 15 min
const limiterLogin = rateLimit({
  windowMs: 15 * 60 * 1000,
  max:      10,
  message:  { erreur: 'Trop de tentatives de connexion — reessayez dans 15 minutes' }
});
app.use('/auth/login', limiterLogin);

const { body, validationResult } = require('express-validator');

// Regles de validation pour /register
const reglesRegister = [
  body('email')
    .isEmail()
    .normalizeEmail()
    .withMessage('Email invalide'),
  body('motDePasse')
    .isLength({ min: 8 })
    .withMessage('Mot de passe : 8 caracteres minimum')
    .matches(/[A-Z]/)
    .withMessage('Mot de passe : au moins une majuscule')
];

router.post('/register', reglesRegister, async function(req, res) {
  // Verifier les erreurs de validation
  const erreurs = validationResult(req);
  if (!erreurs.isEmpty()) {
    return res.status(400).json({
      erreur:  'Donnees invalides',
      details: erreurs.array() // Liste de toutes les erreurs de validation
    });
  }
  // Suite du code register...
});

api-equipes/
├── config/
│   └── mongodb.js         connecter(), getBase()
├── middlewares/
│   ├── isAuthenticated.js  jwt.verify(), req.utilisateur
│   └── isAdmin.js          role === admin
├── routes/
│   ├── auth.js             POST /auth/register, POST /auth/login
│   ├── equipes.js          CRUD complet MongoDB
│   └── stades.js           CRUD complet MongoDB
├── .env                JWT_SECRET, MONGO_URI, PORT
├── .gitignore          node_modules/, .env
├── package.json
└── index.js            helmet, cors, rateLimit, routes

const express      = require('express');
const { createProxyMiddleware } = require('http-proxy-middleware');
const app          = express();

// Routing : redirige vers le bon service selon le chemin
app.use('/auth',        createProxyMiddleware({ target: 'http://localhost:3001', changeOrigin: true }));
app.use('/equipes',     createProxyMiddleware({ target: 'http://localhost:3002', changeOrigin: true }));
app.use('/stades',      createProxyMiddleware({ target: 'http://localhost:3003', changeOrigin: true }));
app.use('/competitions',createProxyMiddleware({ target: 'http://localhost:3004', changeOrigin: true }));

app.listen(3000, () => console.log('API Gateway: http://localhost:3000'));

app-microservices/
├── auth-service/      port 3001  → /auth/register, /login, /verify
├── produit-service/   port 3002  → /produits  (CRUD + stock)
├── commande-service/  port 3003  → /commandes (orchestration)
├── gateway/           port 3000  → proxy vers les 3 services
└── shared/
    └── authClient.js     middleware isAuthenticated partage

// Route GET /health — presente sur TOUS les services
app.get('/health', async function(req, res) {
  try {
    // Verifier la connexion MongoDB
    await getBase().command({ ping: 1 });
    res.status(200).json({
      status:    'ok',
      service:   'produit-service',
      timestamp: new Date().toISOString()
    });
  } catch (err) {
    res.status(503).json({ status: 'error', message: 'MongoDB indisponible' });
  }
});

const express     = require('express');
const router      = express.Router();
const { ObjectId } = require('mongodb');
const { getBase } = require('../config/mongodb');

// ── GET /produits — liste avec filtres et pagination ──────
router.get('/', async function(req, res) {
  const { categorie, minPrix, maxPrix, page = 1, limite = 10 } = req.query;

  const filtre = {};
  if (categorie) filtre.categorie = categorie;
  if (minPrix || maxPrix) {
    filtre.prix = {};
    if (minPrix) filtre.prix.$gte = parseFloat(minPrix);
    if (maxPrix) filtre.prix.$lte = parseFloat(maxPrix);
  }

  const skip  = (parseInt(page) - 1) * parseInt(limite);
  const col   = getBase().collection('produit');
  const total = await col.countDocuments(filtre);
  const produits = await col.find(filtre).skip(skip).limit(parseInt(limite)).toArray();

  res.json({
    total,
    page:    parseInt(page),
    pages:   Math.ceil(total / parseInt(limite)),
    produits
  });
});

// ── GET /produits/:id — avec champ calcule disponible ─────
router.get('/:id', async function(req, res) {
  if (!ObjectId.isValid(req.params.id))
    return res.status(400).json({ erreur: 'Id invalide' });

  const produit = await getBase().collection('produit')
    .findOne({ _id: new ObjectId(req.params.id) });

  if (!produit) return res.status(404).json({ erreur: 'Produit introuvable' });

  // Champ calcule : commande-service l'utilisera pour valider la commande
  res.json({ produit: { ...produit, disponible: produit.stock > 0 } });
});

module.exports = router;

// GET /auth/verify — appele par les autres services, pas par le client
router.get('/verify', function(req, res) {
  const header = req.headers.authorization;
  if (!header) return res.status(401).json({ erreur: 'Token manquant' });

  const token = header.split(' ')[1];
  try {
    const payload = jwt.verify(token, process.env.JWT_SECRET);
    res.status(200).json({ userId: payload.userId, email: payload.email, role: payload.role });
  } catch (err) {
    res.status(401).json({ erreur: err.name === 'TokenExpiredError' ? 'Token expire' : 'Token invalide' });
  }
});

const axios = require('axios');

async function verifierToken(token) {
  try {
    const reponse = await axios.get('http://localhost:3001/auth/verify', {
      headers:  { Authorization: `Bearer ${token}` },
      timeout:  5000  // 5 secondes max — eviter d'attendre indefiniment
    });
    return reponse.data; // { userId, email, role }

  } catch (err) {
    if (err.response) {
      // Le serveur a repondu avec une erreur HTTP (401, 403...)
      throw { statut: err.response.status, message: err.response.data.erreur };
    } else {
      // ECONNREFUSED = service arrete, ECONNABORTED = timeout
      throw { statut: 503, message: 'auth-service indisponible' };
    }
  }
}

router.post('/', async function(req, res) {
  // Etape 1 : verifier le token via auth-service
  const token      = req.headers.authorization?.split(' ')[1];
  const utilisateur = await verifierToken(token); // Lance exception si invalide

  const { produitId, quantite } = req.body;

  // Etape 2 : verifier le produit et le stock via produit-service
  const repProduit = await axios.get(`http://localhost:3002/produits/${produitId}`, { timeout: 5000 });
  const produit    = repProduit.data.produit;

  if (!produit.disponible) {
    return res.status(409).json({ erreur: 'Produit hors stock' });
  }

  // Etape 3 : creer la commande avec denormalisation
  // On copie nom et prix du produit — si le produit change, la commande reste coherente
  const commande = {
    userId:      utilisateur.userId,
    produitId:   produitId,
    nomProduit:  produit.nom,    // Denormalisation
    prixUnitaire:produit.prix,   // Denormalisation
    quantite:    quantite,
    total:       produit.prix * quantite,
    statut:      'en_attente',
    createdAt:   new Date()
  };

  const resultat = await getBase().collection('commande').insertOne(commande);
  res.status(201).json({ message: 'Commande creee', commandeId: resultat.insertedId });
});

const axios = require('axios');

const AUTH_URL = process.env.AUTH_SERVICE_URL || 'http://localhost:3001';

async function verifierToken(token) {
  try {
    const rep = await axios.get(`${AUTH_URL}/auth/verify`, {
      headers: { Authorization: `Bearer ${token}` },
      timeout: 5000
    });
    return rep.data;
  } catch (err) {
    if (err.response) throw { statut: err.response.status, message: err.response.data.erreur };
    throw { statut: 503, message: 'auth-service indisponible' };
  }
}

// Middleware isAuthenticated partage entre tous les services
function isAuthenticated(req, res, next) {
  const token = req.headers.authorization?.split(' ')[1];
  if (!token) return res.status(401).json({ erreur: 'Token manquant' });

  verifierToken(token)
    .then(function(payload) {
      req.utilisateur = payload;
      next();
    })
    .catch(function(err) {
      res.status(err.statut || 401).json({ erreur: err.message });
    });
}

// Middleware isAdmin — utiliser apres isAuthenticated
function isAdmin(req, res, next) {
  if (!req.utilisateur || req.utilisateur.role !== 'admin') {
    return res.status(403).json({ erreur: 'Acces admin requis' });
  }
  next();
}

module.exports = { verifierToken, isAuthenticated, isAdmin };

// Chemin relatif depuis produit-service/ vers shared/
const { isAuthenticated, isAdmin } = require('../../shared/authClient');

// GET public
router.get('/', async function(req, res) { /* ... */ });

// POST protege — user connecte requis
router.post('/', isAuthenticated, async function(req, res) { /* ... */ });

// DELETE — admin uniquement
router.delete('/:id', isAuthenticated, isAdmin, async function(req, res) { /* ... */ });

# Avec Docker (recommande)
docker run -d --name rabbitmq   -p 5672:5672   -p 15672:15672   rabbitmq:3-management

# Interface web : http://localhost:15672
# Identifiants par defaut : guest / guest

mkdir app-microservices/test-amqp && cd app-microservices/test-amqp
npm init -y
npm install amqplib   # Bibliotheque officielle AMQP 0-9-1 pour Node.js

const amqplib = require('amqplib');

const RABBITMQ_URL  = 'amqp://guest:guest@localhost:5672';
const EXCHANGE_NOM  = 'commandes';
const EXCHANGE_TYPE = 'fanout'; // Broadcast : tous les consumers abonnes recoivent le message

async function publier(evenement) {
  let connexion;
  try {
    connexion = await amqplib.connect(RABBITMQ_URL);           // Etape 1 : connexion TCP
    const channel = await connexion.createChannel();           // Etape 2 : canal logique

    await channel.assertExchange(                              // Etape 3 : declarer l'exchange
      EXCHANGE_NOM, EXCHANGE_TYPE, { durable: true }          // durable: true = survit au redemarrage
    );

    const buffer = Buffer.from(JSON.stringify(evenement));    // amqplib envoie des Buffer
    channel.publish(EXCHANGE_NOM, '', buffer, {
      persistent: true   // Message ecrit sur disque — survit au redemarrage RabbitMQ
    });
    console.log('Message publie :', JSON.stringify(evenement));

    await channel.close();
    await connexion.close();
  } catch (e) {
    console.error('Erreur RabbitMQ :', e.message);
    if (connexion) await connexion.close().catch(() => {});
    process.exit(1);
  }
}

publier({
  type:       'commande.creee',
  commandeId: 'cmd-test-001',
  userId:     'user-karim',
  total:      215,
  timestamp:  new Date().toISOString()
});

const amqplib = require('amqplib');

const RABBITMQ_URL = 'amqp://guest:guest@localhost:5672';
const EXCHANGE_NOM = 'commandes';
const QUEUE_NOM    = 'queue-notifs';

async function demarrerConsumer() {
  try {
    const connexion = await amqplib.connect(RABBITMQ_URL);
    const channel   = await connexion.createChannel();
    console.log('Consumer connecte a RabbitMQ');

    await channel.assertExchange(EXCHANGE_NOM, 'fanout', { durable: true }); // Idempotent

    await channel.assertQueue(QUEUE_NOM, { durable: true });  // Creer si inexistante
    await channel.bindQueue(QUEUE_NOM, EXCHANGE_NOM, '');     // '' = routing key vide (fanout)
    console.log('En attente de messages dans', QUEUE_NOM);

    channel.consume(QUEUE_NOM, function(msg) {
      if (msg === null) { console.log('Consumer annule'); return; }
      try {
        const contenu = JSON.parse(msg.content.toString()); // msg.content est un Buffer
        console.log('Message recu :', contenu);
        console.log(`Email envoye : commande ${contenu.commandeId} — ${contenu.total} MAD`);
        channel.ack(msg);   // OBLIGATOIRE — confirmer le traitement
      } catch (e) {
        console.error('Erreur traitement :', e.message);
        channel.nack(msg, false, false); // false, false = pas de requeue (evite boucle infinie)
      }
    }, { noAck: false }); // noAck: false = mode manuel — on gere l'ack

    process.on('SIGINT', async () => {
      await channel.close();
      await connexion.close();
      console.log('Consumer arrete proprement');
      process.exit(0);
    });
  } catch (e) {
    console.error('Erreur consumer :', e.message);
    process.exit(1);
  }
}

demarrerConsumer();

const amqplib = require('amqplib');

const RABBITMQ_URL = process.env.RABBITMQ_URL || 'amqp://guest:guest@localhost:5672';
const EXCHANGE_NOM = process.env.EXCHANGE_NOM  || 'commandes';

let channel = null; // Singleton — une seule connexion partagee

async function connecterRabbitMQ() {
  try {
    const connexion = await amqplib.connect(RABBITMQ_URL);
    channel = await connexion.createChannel();
    await channel.assertExchange(EXCHANGE_NOM, 'fanout', { durable: true });
    console.log('RabbitMQ connecte — exchange:', EXCHANGE_NOM);

    connexion.on('close', () => {
      console.warn('Connexion RabbitMQ perdue — reconnexion dans 5s');
      channel = null;
      setTimeout(connecterRabbitMQ, 5000); // Reconnexion automatique
    });
  } catch (e) {
    console.warn('RabbitMQ indisponible :', e.message, '— retry dans 5s');
    setTimeout(connecterRabbitMQ, 5000);
  }
}

async function publierEvenement(evenement) {
  if (!channel) {
    console.warn('RabbitMQ indisponible — evenement non publie:', evenement.type);
    return false; // Ne pas bloquer la creation de commande
  }
  try {
    const buffer = Buffer.from(JSON.stringify(evenement));
    channel.publish(EXCHANGE_NOM, '', buffer, { persistent: true });
    return true;
  } catch (e) {
    console.warn('Erreur publication RabbitMQ :', e.message);
    return false;
  }
}

module.exports = { connecterRabbitMQ, publierEvenement, EXCHANGE_NOM };

# Ubuntu / Debian
sudo apt update && sudo apt install nginx -y
sudo systemctl start nginx

# macOS (Homebrew)
brew install nginx && brew services start nginx

# Verification (tous systemes) : http://localhost → "Welcome to nginx!"

# Tester la syntaxe du fichier (TOUJOURS avant reload)
sudo nginx -t
# Recharger sans redemarrer (zero downtime)
sudo nginx -s reload

events {
  worker_connections 1024;  # Connexions simultanees par worker process
}

http {
  # Definir les groupes de serveurs backend
  upstream auth_service     { server localhost:3001; }
  upstream produit_service  { server localhost:3002; }
  upstream commande_service { server localhost:3003; }

  server {
    listen 80;
    server_name localhost;

    # Headers transmis aux services backend
    proxy_set_header Host            $host;
    proxy_set_header X-Real-IP       $remote_addr;
    proxy_set_header Authorization   $http_authorization;  # CRITIQUE : transmettre le token JWT

    proxy_connect_timeout  5s;
    proxy_read_timeout    30s;

    location /auth/     { proxy_pass http://auth_service/auth/; }
    location /produits/ { proxy_pass http://produit_service/produits/; }
    location /commandes/{ proxy_pass http://commande_service/commandes/; }

    location /nginx-health {
      return 200 '{"service":"nginx","statut":"actif"}';
      add_header Content-Type application/json;
    }

    # Page d'erreur si service Node.js en panne
    error_page 502 503 504 /erreur_service.json;
    location = /erreur_service.json {
      return 503 '{"erreur":"Service temporairement indisponible"}';
      add_header Content-Type application/json;
    }
  }
}

# Telecharger : https://www.docker.com/products/docker-desktop/
# Windows : installer avec WSL2 active, redemarrer
# macOS   : glisser Docker.app dans Applications
# Linux   : sudo apt install docker.io docker-compose -y

docker version          # Versions Client et Server
docker info             # Configuration complete du daemon
docker run hello-world  # Premier conteneur — test complet

# 1 — Conteneur interactif
docker run -it node:18-alpine sh      # -it = interactif + TTY
# Dans le conteneur : node --version, ls /, exit

# 2 — Conteneur en arriere-plan
docker run -d --name mon-node node:18-alpine sleep 3600

# 3 — Lister les conteneurs
docker ps          # Actifs uniquement
docker ps -a       # Tous (actifs + arretes)

# 4 — Executer dans un conteneur actif
docker exec mon-node node --version
docker exec -it mon-node sh

# 5 — Logs
docker logs mon-node
docker logs -f mon-node   # Temps reel (Ctrl+C)

# 6 — Arreter et redemarrer
docker stop mon-node      # SIGTERM → attendre → SIGKILL
docker start mon-node

# 7 — Inspecter
docker inspect mon-node
docker inspect mon-node | grep IPAddress

# 8 — Supprimer
docker rm mon-node         # Doit etre arrete
docker rm -f mon-node      # Force (arret + suppression)

# 9 — Gerer les images
docker images              # Lister les images locales
docker rmi hello-world     # Supprimer une image
docker image prune         # Supprimer les images non utilisees

# 10 — Statistiques temps reel
docker run -d --name stats-test node:18-alpine sleep 3600
docker stats stats-test    # CPU%, RAM, reseau (Ctrl+C)
docker stop stats-test && docker rm stats-test

# 11 — Copier des fichiers
docker run -d --name copy-test node:18-alpine sleep 3600
echo "console.log('Bonjour')" > test.js
docker cp test.js copy-test:/tmp/test.js  # local → conteneur
docker exec copy-test node /tmp/test.js
docker stop copy-test && docker rm copy-test

# 12 — Nettoyage
docker system prune      # Conteneurs arretes + images non utilisees
docker system df         # Espace utilise par Docker

cd app-microservices
cd auth-service && npm install && cd ..

docker run -d \
  --name auth-service \
  -p 3001:3001 \
  -e PORT=3001 \
  -e MONGO_URI=mongodb://host.docker.internal:27017 \
  -e NOM_BASE=bdms-auth \
  -e JWT_SECRET=secret_dev_123 \
  -e JWT_EXPIRES_IN=24h \
  -v $(pwd)/auth-service:/app \
  -w /app \
  node:18-alpine \
  node index.js

docker ps                     # Verifier
docker logs auth-service      # Observer les logs
docker logs -f auth-service   # Temps reel

# ── Etape 1 : Image de base ─────────────────────────────────
FROM node:18-alpine              # Alpine = ~50 Mo vs ~1 Go pour node:18

# ── Etape 2 : Repertoire de travail ─────────────────────────
WORKDIR /app                     # Cree /app et s'y positionne

# ── Etape 3 : Copier les manifestes de dependances ──────────
COPY package*.json ./            # package.json + package-lock.json

# ── Etape 4 : Installer les dependances ─────────────────────
RUN npm install --production     # Sans devDependencies — image plus legere

# ── Etape 5 : Copier le code source ─────────────────────────
COPY . .                         # Copier tout le reste dans /app

# ── Etape 6 : Variables d'environnement par defaut ──────────
ENV NODE_ENV=production
ENV PORT=3001

# ── Etape 7 : Port documente ─────────────────────────────────
EXPOSE 3001                      # Informatif — le mapping se fait avec -p

# ── Etape 8 : Commande de demarrage ─────────────────────────
CMD ["node", "index.js"]         # Exec form — sans shell intermediaire

cd app-microservices/auth-service

# Construire l'image — observer chaque Step dans la sortie
docker build -t bdms-auth:1.0.0 .
# Step 1/8 : FROM node:18-alpine   → telecharge ou utilise le cache
# Step 4/8 : RUN npm install       → installe les dependances (long la 1ere fois)
# Step 5/8 : COPY . .              → copie le code source

docker images | grep bdms-auth        # Verifier la taille de l'image
docker image history bdms-auth:1.0.0  # Chaque ligne = une couche (layer)

# Lancer le conteneur depuis l'image construite (plus de -v pour le code)
docker run -d   --name auth-service   -p 3001:3001   -e MONGO_URI=mongodb://host.docker.internal:27017   -e NOM_BASE=bdms-auth   -e JWT_SECRET=secret_dev_123   -e JWT_EXPIRES_IN=24h   bdms-auth:1.0.0   # Image construite — le code est DANS l'image

node_modules    # 300 Mo — npm install les cree dans l'image
.env            # Ne jamais inclure les secrets dans l'image
.env.local
.env.*

*.log
npm-debug.log*

.git
.gitignore
README.md
Dockerfile
.dockerignore

cd app-microservices/produit-service
docker build -t bdms-produit:1.0.0 .
docker run -d --name produit-service -p 3002:3002   -e MONGO_URI=mongodb://host.docker.internal:27017   -e NOM_BASE=bdms-produits   -e AUTH_SERVICE_URL=http://host.docker.internal:3001   bdms-produit:1.0.0

① ________  node:18-alpine
② ________  /app
③ ________  package*.json ./
RUN npm install ④ ________
⑤ ________  .  .
ENV NODE_ENV=production
ENV PORT=3003
EXPOSE 3003
⑥ ________  ["node", "index.js"]

version: '3.9'

services:

  # ── MongoDB ──────────────────────────────────────────────────
  mongodb:
    image: mongo:7.0
    container_name: bdms-mongodb
    ports:
      - "27017:27017"         # Acces MongoDB Compass depuis l'hote
    environment:
      MONGO_INITDB_ROOT_USERNAME: admin
      MONGO_INITDB_ROOT_PASSWORD: secret
    volumes:
      - mongo_data:/data/db   # Volume nomme — donnees persistantes
    networks:
      - bdms-network

  # ── auth-service ─────────────────────────────────────────────
  auth-service:
    build:
      context: ./auth-service  # Construire l'image depuis le Dockerfile
    container_name: bdms-auth
    ports:
      - "3001:3001"
    environment:
      PORT: 3001
      MONGO_URI: mongodb://admin:secret@mongodb:27017  # 'mongodb' = nom du service
      NOM_BASE: bdms-auth
      JWT_SECRET: secret_dev_123
      JWT_EXPIRES_IN: 24h
    depends_on:
      - mongodb
    networks:
      - bdms-network
    restart: on-failure   # Redemarrer si MongoDB pas encore pret

  # ── produit-service ──────────────────────────────────────────
  produit-service:
    build:
      context: ./produit-service
    container_name: bdms-produit
    ports:
      - "3002:3002"
    environment:
      PORT: 3002
      MONGO_URI: mongodb://admin:secret@mongodb:27017
      NOM_BASE: bdms-produits
      AUTH_SERVICE_URL: http://auth-service:3001  # 'auth-service' = nom du service
    depends_on:
      - mongodb
      - auth-service
    networks:
      - bdms-network
    restart: on-failure

  # ── commande-service ─────────────────────────────────────────
  commande-service:
    build:
      context: ./commande-service
    container_name: bdms-commande
    ports:
      - "3003:3003"
    environment:
      PORT: 3003
      MONGO_URI: mongodb://admin:secret@mongodb:27017
      NOM_BASE: bdms-commandes
      AUTH_SERVICE_URL: http://auth-service:3001
      PRODUIT_SERVICE_URL: http://produit-service:3002
    depends_on:
      - mongodb
      - auth-service
      - produit-service
    networks:
      - bdms-network
    restart: on-failure

volumes:
  mongo_data:     # Docker gere le stockage — persiste entre down/up

networks:
  bdms-network:
    driver: bridge  # Reseau isole — les services se contactent par leur nom

cd app-microservices  # Se placer la ou est docker-compose.yml

# 1 — Demarrer
docker-compose up -d          # detached — libere le terminal
docker-compose up --build -d  # Force le rebuild avant demarrage

# 2 — Lister les services
docker-compose ps             # Etat de tous les services

# 3 — Logs
docker-compose logs           # Tous les services
docker-compose logs auth-service
docker-compose logs -f auth-service  # Temps reel

# 4 — Executer dans un service
docker-compose exec auth-service sh      # Shell interactif
docker-compose exec mongodb mongosh      # Shell MongoDB

# 5 — Arreter sans supprimer
docker-compose stop
docker-compose start          # Relancer les conteneurs arretes

# 6 — Arreter ET supprimer
docker-compose down           # Supprime conteneurs + reseau
docker-compose down -v        # Supprime aussi les volumes (donnees perdues)
docker-compose down --rmi all # Supprime aussi les images buildees

# 7 — Reconstruire une image
docker-compose build auth-service
docker-compose build --no-cache   # Rebuild sans cache

# 8 — Scaler
docker-compose up -d --scale auth-service=3  # 3 instances
docker-compose ps  # auth-service_1, _2, _3

  notif-service:
    ① ________ :
      context: ./notif-service
    container_name: bdms-notif
    ② ________ :
      RABBITMQ_URL: amqp://guest:guest@rabbitmq:5672
      EXCHANGE_NOM: commandes
    ③ ________ :
      - rabbitmq
    ④ ________ :
      - bdms-network
    restart: ⑤ ________

docker network ls                          # Lister tous les reseaux
docker network inspect app-microservices_bdms-network  # Conteneurs connectes + IPs

# Tester l'isolation — 2 conteneurs dans des reseaux differents
docker network create reseau-a
docker network create reseau-b
docker run -d --name cont-a --network reseau-a node:18-alpine sleep 300
docker run -d --name cont-b --network reseau-b node:18-alpine sleep 300
docker exec cont-a ping cont-b   # Attendu : ECHEC — reseaux isoles
docker stop cont-a cont-b && docker rm cont-a cont-b
docker network rm reseau-a reseau-b

# Volume nomme — persiste apres suppression du conteneur
docker volume create test-vol
docker run -d --name vol-test -v test-vol:/data node:18-alpine sleep 300
docker exec vol-test sh -c "echo hello > /data/test.txt"
docker stop vol-test && docker rm vol-test
docker run --rm -v test-vol:/data node:18-alpine cat /data/test.txt  # hello persiste !
docker volume rm test-vol

# Bind mount — dossier hote visible dans le conteneur
mkdir -p /tmp/test-logs
docker run -d --name bind-test -v /tmp/test-logs:/app/logs node:18-alpine sleep 300
docker exec bind-test sh -c "echo log-entry > /app/logs/app.log"
cat /tmp/test-logs/app.log   # Visible sur l'hote immediatement
docker stop bind-test && docker rm bind-test

MONGO_ROOT_USER=admin
MONGO_ROOT_PASSWORD=motdepasse_fort_2024
JWT_SECRET=cle_secrete_longue_et_aleatoire_xyz789
JWT_EXPIRES_IN=24h
RABBITMQ_USER=rmquser
RABBITMQ_PASSWORD=rmqpassword
AUTH_PORT=3001
PRODUIT_PORT=3002
COMMANDE_PORT=3003

services:
  mongodb:
    image: mongo:7.0
    networks:
      - bdms-backend

  auth-service:
    build: { context: ./auth-service }
    ports:
      - "3001:3001"
    environment:
      MONGO_URI: mongodb://admin:secret@localhost:27017  # ERREUR 1
    depends_on:
      - auth-service  # ERREUR 2
    networks:
      - bdms-frontend
      - bdms-backend

  nginx:
    image: nginx:1.25-alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf  # ERREUR 3 — manque :ro
    networks:
      - bdms-frontend
      - bdms-backend  # ERREUR 4

networks:
  bdms-frontend:
  bdms-backend:

docker-compose config  # Valide le YAML et affiche la config resolue (.env inclus)

cd app-microservices
docker-compose up --build -d   # Build + demarrage de tous les services
docker-compose ps              # Verifier que tous sont Running

const amqplib = require('amqplib');
const { MongoClient } = require('mongodb');

const RABBITMQ_URL = process.env.RABBITMQ_URL || 'amqp://localhost';
const MONGO_URI    = process.env.MONGO_URI    || 'mongodb://localhost:27017';
const NOM_BASE     = process.env.NOM_BASE     || 'bdms-analytics';
const EXCHANGE_NOM = 'commandes';

let db;

async function connecterMongo() {
  const client = new MongoClient(MONGO_URI);
  await client.connect();
  db = client.db(NOM_BASE);
  console.log('[ANALYTICS] MongoDB connecte');
}

async function demarrerConsumer() {
  const connexion = await amqplib.connect(RABBITMQ_URL);
  const channel   = await connexion.createChannel();
  await channel.assertExchange(EXCHANGE_NOM, 'fanout', { durable: true });
  const { queue } = await channel.assertQueue('queue-analytics', { durable: true });
  await channel.bindQueue(queue, EXCHANGE_NOM, '');

  channel.consume(queue, async (msg) => {
    if (!msg) return;
    const evt = JSON.parse(msg.content.toString());
    await db.collection('evenements').insertOne({
      ...evt, timestamp: new Date(), source: 'commande.creee'
    });
    console.log('[ANALYTICS] Enregistre :', evt.commandeId);
    channel.ack(msg);
  }, { noAck: false });

  console.log('[ANALYTICS] Consumer actif — ecoute queue-analytics');
}

connecterMongo().then(demarrerConsumer).catch(console.error);

  analytics-service:
    build: { context: ./analytics-service }
    container_name: bdms-analytics
    environment:
      MONGO_URI: mongodb://${MONGO_ROOT_USER}:${MONGO_ROOT_PASSWORD}@mongodb:27017
      NOM_BASE: bdms-analytics
      RABBITMQ_URL: amqp://${RABBITMQ_USER}:${RABBITMQ_PASSWORD}@rabbitmq:5672
      EXCHANGE_NOM: commandes
    depends_on:
      mongodb:
        condition: service_healthy
      rabbitmq:
        condition: service_healthy
    networks:
      - bdms-backend   # Acces MongoDB + RabbitMQ — pas d'acces HTTP entrant depuis Nginx
    restart: on-failure

# Installation Azure CLI
# Windows : https://aka.ms/installazurecliwindows
# macOS   : brew install azure-cli
# Linux   : curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

az --version   # Verifier l'installation

# Connexion
az login       # Ouvre le navigateur — se connecter avec le compte Azure Free

# Abonnement actif
az account show
az account list --output table

# Creer le groupe de ressources
az group create --name rg-bdms-dev --location francecentral
# Attendu : { "provisioningState": "Succeeded" }

az group list --output table   # Verifier

# Supprimer en fin de seance (eviter la facturation)
az group delete --name rg-bdms-dev --yes --no-wait

# Groupe de ressources
az group create --name rg-bdms-dev --location francecentral

# App Service Plan Linux F1 (gratuit)
az appservice plan create   --name plan-bdms-dev   --resource-group rg-bdms-dev   --sku F1   --is-linux   # Obligatoire pour Node.js sur Linux et les conteneurs

# Web App (mode code Node.js 18)
az webapp create   --name bdms-auth-dev \           # Nom unique mondialement
  --resource-group rg-bdms-dev   --plan plan-bdms-dev   --runtime 'NODE:18-lts'

# Recuperer l'URL de l'application
az webapp show   --name bdms-auth-dev   --resource-group rg-bdms-dev   --query defaultHostName --output tsv
# → bdms-auth-dev.azurewebsites.net

az webapp config appsettings set   --name bdms-auth-dev   --resource-group rg-bdms-dev   --settings     PORT=8080     NODE_ENV=production     JWT_SECRET=secret_azure_dev_123     JWT_EXPIRES_IN=24h
# App Service utilise le port 8080 par defaut (pas 3001)

az webapp config appsettings list   --name bdms-auth-dev   --resource-group rg-bdms-dev   --output table

# Surveillance > Metriques : CPU Percentage, Memory, Http 5xx, Response Time
# Surveillance > Flux de journaux : logs en temps reel (equivalent docker logs -f)
# Configuration : App Settings, connexion strings, Always On

# Streamer les logs depuis le terminal
az webapp log config   --name bdms-auth-dev   --resource-group rg-bdms-dev   --application-logging filesystem   --docker-container-logging filesystem

az webapp log tail   --name bdms-auth-dev   --resource-group rg-bdms-dev   # Ctrl+C pour arreter

# Nettoyage IMPORTANT - eviter la facturation
az group delete --name rg-bdms-dev --yes --no-wait

Format : [registry/][username/]nom[:tag]

node:18-alpine
  └─ registry  : docker.io (implicite — Docker Hub)
  └─ username  : library (images officielles — implicite)
  └─ nom       : node
  └─ tag       : 18-alpine

moncompte/bdms-auth:1.0.0
  └─ registry  : docker.io (implicite)
  └─ username  : moncompte
  └─ nom       : bdms-auth
  └─ tag       : 1.0.0

monacr.azurecr.io/bdms-auth:1.0.0
  └─ registry  : monacr.azurecr.io (ACR — explicite)
  └─ nom       : bdms-auth
  └─ tag       : 1.0.0

Regles :
  Si registry omis  → Docker Hub par defaut
  Si tag omis       → :latest par defaut (a eviter en production)

docker images | grep bdms-auth   # Affiche : bdms-auth  1.0.0

# docker tag SOURCE DESTINATION
docker tag bdms-auth:1.0.0 VOTRE_USERNAME/bdms-auth:1.0.0
docker tag bdms-auth:1.0.0 VOTRE_USERNAME/bdms-auth:latest

docker images | grep bdms-auth
# 3 lignes affichees — MAIS meme IMAGE ID pour les 3
# docker tag cree un pointeur (alias), pas une copie
# Supprimer un alias ne supprime pas l'image si d'autres tags pointent vers elle

# 1 — Se connecter
docker login
# Username: VOTRE_USERNAME
# Password: VOTRE_MOT_DE_PASSE
# Attendu : Login Succeeded
# Credentials stockes dans ~/.docker/config.json — ne jamais partager

# 2 — Construire si necessite
cd app-microservices/auth-service
docker build -t bdms-auth:1.0.0 .

# 3 — Taguer avec le prefixe username/
docker tag bdms-auth:1.0.0 VOTRE_USERNAME/bdms-auth:1.0.0
docker tag bdms-auth:1.0.0 VOTRE_USERNAME/bdms-auth:latest

# 4 — Pousser vers Docker Hub
docker push VOTRE_USERNAME/bdms-auth:1.0.0
# Observer la sortie : chaque couche — Preparing > Waiting > Pushing > Pushed
# Si :latest pointe vers la meme image → Layer already exists (push instantane)
docker push VOTRE_USERNAME/bdms-auth:latest

# 5 — Verifier le pull depuis une machine vierge (simulation)
docker rmi VOTRE_USERNAME/bdms-auth:1.0.0 VOTRE_USERNAME/bdms-auth:latest bdms-auth:1.0.0
docker images | grep bdms-auth   # Doit etre vide
docker pull VOTRE_USERNAME/bdms-auth:1.0.0   # Telecharge depuis Docker Hub
docker run -d --name auth-test -p 3001:3001   -e MONGO_URI=mongodb://host.docker.internal:27017   -e JWT_SECRET=test VOTRE_USERNAME/bdms-auth:1.0.0
docker logs auth-test   # Attendu : auth-service : http://localhost:3001
docker stop auth-test && docker rm auth-test

# bdms-produit
cd app-microservices/produit-service
docker build -t bdms-produit:1.0.0 .
docker tag bdms-produit:1.0.0 VOTRE_USERNAME/bdms-produit:1.0.0
docker tag bdms-produit:1.0.0 VOTRE_USERNAME/bdms-produit:latest
docker push VOTRE_USERNAME/bdms-produit:1.0.0
docker push VOTRE_USERNAME/bdms-produit:latest

# bdms-commande
cd ../commande-service
docker build -t bdms-commande:1.0.0 .
docker tag bdms-commande:1.0.0 VOTRE_USERNAME/bdms-commande:1.0.0
docker tag bdms-commande:1.0.0 VOTRE_USERNAME/bdms-commande:latest
docker push VOTRE_USERNAME/bdms-commande:1.0.0
docker push VOTRE_USERNAME/bdms-commande:latest

# Groupe de ressources
az group create --name rg-bdms-dev --location francecentral

# App Service Plan Linux F1
az appservice plan create   --name plan-bdms-dev   --resource-group rg-bdms-dev   --sku F1 --is-linux

# Web App en mode conteneur depuis Docker Hub
az webapp create   --name bdms-auth-dev   --resource-group rg-bdms-dev   --plan plan-bdms-dev   --deployment-container-image-name VOTRE_USERNAME/bdms-auth:1.0.0

# Recuperer l'URL
az webapp show   --name bdms-auth-dev   --resource-group rg-bdms-dev   --query defaultHostName --output tsv
# → bdms-auth-dev.azurewebsites.net

az webapp config appsettings set   --name bdms-auth-dev   --resource-group rg-bdms-dev   --settings     WEBSITES_PORT=3001 \         # CRITIQUE — port ecoute de auth-service
    NODE_ENV=production     MONGO_URI='mongodb://admin:mdp@host:27017'     NOM_BASE=bdms-auth     JWT_SECRET=secret_azure_prod_xyz \   # Jamais dans l'image
    JWT_EXPIRES_IN=24h

az webapp config appsettings list   --name bdms-auth-dev   --resource-group rg-bdms-dev   --output table

# Activer les logs
az webapp log config   --name bdms-auth-dev   --resource-group rg-bdms-dev   --application-logging filesystem \      # Logs Node.js (console.log)
  --docker-container-logging filesystem   # Logs du conteneur (demarrage, erreurs)

# Streamer les logs en temps reel (equivalent : docker logs -f)
az webapp log tail   --name bdms-auth-dev   --resource-group rg-bdms-dev   # Ctrl+C pour arreter

# Redemarrer (apres changement de config)
az webapp restart   --name bdms-auth-dev   --resource-group rg-bdms-dev

# Mettre a jour l'image sans recreer l'App Service
az webapp config container set   --name bdms-auth-dev   --resource-group rg-bdms-dev   --docker-custom-image-name VOTRE_USERNAME/bdms-auth:1.0.1  # Nouvelle version
# App Service telecharge la nouvelle image et redemarre automatiquement

# Creer l'App Service produit-service
az webapp create   --name bdms-produit-dev   --resource-group rg-bdms-dev   --plan plan-bdms-dev \           # Meme plan que auth-service
  --deployment-container-image-name VOTRE_USERNAME/bdms-produit:1.0.0

# Configurer les variables
az webapp config appsettings set   --name bdms-produit-dev   --resource-group rg-bdms-dev   --settings     WEBSITES_PORT=3002     NODE_ENV=production     MONGO_URI='mongodb://admin:mdp@host:27017'     NOM_BASE=bdms-produits     AUTH_SERVICE_URL=https://bdms-auth-dev.azurewebsites.net  # URL Azure de auth-service

# Activer les logs
az webapp log config   --name bdms-produit-dev   --resource-group rg-bdms-dev   --application-logging filesystem   --docker-container-logging filesystem

version: '3.9'

services:

  auth-service:
    image: VOTRE_USERNAME/bdms-auth:1.0.0   # Image pre-construite — pas de build:
    environment:
      WEBSITES_PORT: 3001
      PORT: 3001
      NODE_ENV: production
      MONGO_URI: ${MONGO_URI}       # Injecte depuis App Settings Azure
      NOM_BASE: bdms-auth
      JWT_SECRET: ${JWT_SECRET}     # Jamais en clair ici
      JWT_EXPIRES_IN: 24h
    ports:
      - '3001:3001'

  produit-service:
    image: VOTRE_USERNAME/bdms-produit:1.0.0
    environment:
      PORT: 3002
      NODE_ENV: production
      MONGO_URI: ${MONGO_URI}
      NOM_BASE: bdms-produits
      AUTH_SERVICE_URL: http://auth-service:3001  # DNS interne Azure = nom de service
    ports:
      - '3002:3002'

  commande-service:
    image: VOTRE_USERNAME/bdms-commande:1.0.0
    environment:
      PORT: 3003
      NODE_ENV: production
      MONGO_URI: ${MONGO_URI}
      NOM_BASE: bdms-commandes
      AUTH_SERVICE_URL: http://auth-service:3001
      PRODUIT_SERVICE_URL: http://produit-service:3002
    ports:
      - '3003:3003'

az group create --name rg-bdms-final --location francecentral

az appservice plan create   --name plan-bdms-final   --resource-group rg-bdms-final   --sku B1 --is-linux   # B1 recommande pour le multi-conteneurs

az webapp create   --name bdms-final-VOTRE_NOM \   # Nom unique mondialement
  --resource-group rg-bdms-final   --plan plan-bdms-final   --multicontainer-config-type compose \   # Mode multi-conteneurs
  --multicontainer-config-file docker-compose.azure.yml

# Injecter les secrets via App Settings (jamais dans le YAML)
az webapp config appsettings set   --name bdms-final-VOTRE_NOM   --resource-group rg-bdms-final   --settings     MONGO_URI='mongodb://admin:mdp@host:27017'     JWT_SECRET=secret_azure_final

# Activer les logs
az webapp log config   --name bdms-final-VOTRE_NOM   --resource-group rg-bdms-final   --application-logging filesystem \     # console.log de Node.js
  --docker-container-logging filesystem  # demarrage conteneur, erreurs Docker

# Streamer en temps reel
az webapp log tail   --name bdms-final-VOTRE_NOM   --resource-group rg-bdms-final

# Telecharger les logs en archive
az webapp log download   --name bdms-final-VOTRE_NOM   --resource-group rg-bdms-final   --log-file logs.zip

docker images | grep VOTRE_USERNAME   # Verifier les images locales

# Si une image manque — reconstruire et pousser
cd app-microservices/commande-service
docker build -t bdms-commande:1.0.0 .
docker tag bdms-commande:1.0.0 VOTRE_USERNAME/bdms-commande:1.0.0
docker push VOTRE_USERNAME/bdms-commande:1.0.0

             INTERNET
                 |
    Azure App Service (bdms-final-VOTRE_NOM)
    Plan B1 — France Centre — HTTPS automatique
    ┌────────────────────────────────────────────┐
    │  auth-service:3001                          │
    │  produit-service:3002                       │
    │  commande-service:3003                      │
    │                                            │
    │  DNS interne : http://auth-service:3001    │
    │  Secrets injectes via App Settings          │
    └────────────────────────────────────────────┘
         |                      |
    Docker Hub            MongoDB (local ou Cosmos DB)
    (images sources)      (base de donnees)

    Surveillance : Log Stream + Diagnostics + Metriques

CLIENT (Postman / Frontend)
        |
        | HTTP
        v
    NGINX :80  ← Gateway reverse proxy
    /auth      → auth-service:3001
    /cuisines  → cuisine-service:3002
    /commandes → commande-service:3003
    /livraisons→ livraison-service:3004

    RABBITMQ :5672  ← Broker de messages
    Exchange : darigo (fanout)
    ├── queue-notifs       → notif-service (consumer)
    └── queue-livreurs     → livraison-service (consumer)

    MONGODB
    ├── bddarigo-auth       (utilisateurs)
    ├── bddarigo-cuisines   (restaurants + plats)
    ├── bddarigo-commandes  (commandes)
    └── bddarigo-livraisons (missions livreurs)

mkdir darigo && cd darigo

# Creer les dossiers de chaque service
mkdir auth-service cuisine-service commande-service livraison-service notif-service nginx shared

# Initialiser chaque service Node.js
for service in auth-service cuisine-service commande-service livraison-service notif-service; do
  cd $service
  npm init -y
  npm install express mongoose dotenv bcryptjs jsonwebtoken cors helmet
  cd ..
done

# commande-service a besoin d'axios pour appeler les autres services
cd commande-service && npm install axios amqplib && cd ..
cd livraison-service && npm install amqplib && cd ..
cd notif-service && npm install amqplib mongoose dotenv && cd ..

MONGO_URI=mongodb://localhost:27017
JWT_SECRET=darigo_jwt_secret_longue_cle_2024
JWT_EXPIRES_IN=7d
RABBITMQ_URL=amqp://guest:guest@localhost:5672
EXCHANGE_NOM=darigo
AUTH_PORT=3001
CUISINE_PORT=3002
COMMANDE_PORT=3003
LIVRAISON_PORT=3004

node_modules/
.env
.env.local
*.log

darigo/
├── auth-service/
│   ├── config/mongodb.js
│   ├── middlewares/isAuthenticated.js
│   ├── routes/auth.js
│   ├── .env  .dockerignore  Dockerfile
│   └── index.js
├── cuisine-service/
│   ├── config/mongodb.js
│   ├── routes/restaurants.js  routes/plats.js
│   └── index.js
├── commande-service/
│   ├── config/mongodb.js
│   ├── routes/commandes.js
│   └── index.js
├── livraison-service/
│   └── index.js  (consumer RabbitMQ + routes statut)
├── notif-service/
│   └── index.js  (consumer RabbitMQ pur)
├── shared/
│   ├── authClient.js    (verifierToken, isAuthenticated)
│   └── rabbitmq.js      (connecter, publierEvenement)
├── nginx/nginx.conf
├── docker-compose.yml
└── .env

const { MongoClient } = require('mongodb');

const MONGO_URI = process.env.MONGO_URI || 'mongodb://localhost:27017';
const NOM_BASE  = process.env.NOM_BASE  || 'bddarigo-auth';

let base = null;

async function connecter() {
  const client = new MongoClient(MONGO_URI);
  await client.connect();
  base = client.db(NOM_BASE);
  console.log(`[auth-service] MongoDB connecte — base : ${NOM_BASE}`);
}

function getBase() {
  if (!base) throw new Error('MongoDB non connecte');
  return base;
}

module.exports = { connecter, getBase };

require('dotenv').config();
const express = require('express');
const helmet  = require('helmet');
const cors    = require('cors');
const { connecter } = require('./config/mongodb');
const authRoutes    = require('./routes/auth');

const app  = express();
const PORT = process.env.PORT || 3001;

app.use(helmet());
app.use(cors());
app.use(express.json());

app.get('/health', (req, res) => res.json({ service: 'auth-service', statut: 'actif' }));
app.use('/auth', authRoutes);

app.use((err, req, res, next) => {
  console.error('[auth-service] Erreur :', err.message);
  res.status(500).json({ erreur: 'Erreur interne du serveur' });
});

connecter().then(() => {
  app.listen(PORT, () => console.log(`[auth-service] http://localhost:${PORT}`));
}).catch(err => {
  console.error('[auth-service] Connexion MongoDB echouee :', err.message);
  process.exit(1);
});

const express = require('express');
const bcrypt  = require('bcryptjs');
const jwt     = require('jsonwebtoken');
const { getBase } = require('../config/mongodb');

const router = express.Router();

// ── POST /auth/register ───────────────────────────────────
router.post('/register', async (req, res) => {
  const { nom, email, motDePasse, role } = req.body;
  if (!nom || !email || !motDePasse)
    return res.status(400).json({ erreur: 'nom, email et motDePasse obligatoires' });

  const col = getBase().collection('utilisateurs');
  if (await col.findOne({ email }))
    return res.status(409).json({ erreur: 'Email deja utilise' });

  const hash = await bcrypt.hash(motDePasse, 12);
  const r = await col.insertOne({
    nom, email, motDePasse: hash,
    // role : 'client' | 'livreur' | 'restaurateur' | 'admin'
    role: role || 'client',
    createdAt: new Date()
  });
  res.status(201).json({ message: 'Compte cree', userId: r.insertedId });
});

// ── POST /auth/login ──────────────────────────────────────
router.post('/login', async (req, res) => {
  const { email, motDePasse } = req.body;
  if (!email || !motDePasse)
    return res.status(400).json({ erreur: 'email et motDePasse obligatoires' });

  const col  = getBase().collection('utilisateurs');
  const user = await col.findOne({ email });
  if (!user) return res.status(401).json({ erreur: 'Identifiants incorrects' });

  const ok = await bcrypt.compare(motDePasse, user.motDePasse);
  if (!ok) return res.status(401).json({ erreur: 'Identifiants incorrects' });

  const token = jwt.sign(
    { userId: user._id.toString(), nom: user.nom, email: user.email, role: user.role },
    process.env.JWT_SECRET,
    { expiresIn: process.env.JWT_EXPIRES_IN || '7d' }
  );
  res.json({ message: 'Connexion reussie', token });
});

// ── GET /auth/verify ── appele par les autres services ────
router.get('/verify', (req, res) => {
  const header = req.headers.authorization;
  if (!header) return res.status(401).json({ erreur: 'Token manquant' });

  const token = header.split(' ')[1];
  try {
    const payload = jwt.verify(token, process.env.JWT_SECRET);
    res.json({ userId: payload.userId, nom: payload.nom, email: payload.email, role: payload.role });
  } catch (err) {
    res.status(401).json({ erreur: err.name === 'TokenExpiredError' ? 'Token expire' : 'Token invalide' });
  }
});

module.exports = router;

const axios = require('axios');

const AUTH_URL = process.env.AUTH_SERVICE_URL || 'http://localhost:3001';

async function verifierToken(token) {
  try {
    const rep = await axios.get(`${AUTH_URL}/auth/verify`, {
      headers: { Authorization: `Bearer ${token}` },
      timeout: 5000
    });
    return rep.data; // { userId, nom, email, role }
  } catch (err) {
    if (err.response)
      throw { statut: err.response.status, message: err.response.data.erreur };
    throw { statut: 503, message: 'auth-service indisponible' };
  }
}

function isAuthenticated(req, res, next) {
  const token = req.headers.authorization?.split(' ')[1];
  if (!token) return res.status(401).json({ erreur: 'Token manquant — Authorization: Bearer token' });
  verifierToken(token)
    .then(payload => { req.utilisateur = payload; next(); })
    .catch(err => res.status(err.statut || 401).json({ erreur: err.message }));
}

function isRole(...roles) {
  return (req, res, next) => {
    if (!req.utilisateur || !roles.includes(req.utilisateur.role))
      return res.status(403).json({ erreur: `Acces reserve aux roles : ${roles.join(', ')}` });
    next();
  };
}

module.exports = { verifierToken, isAuthenticated, isRole };

require('dotenv').config();
const express = require('express');
const helmet  = require('helmet');
const cors    = require('cors');
const { connecter } = require('./config/mongodb');
const restaurantsRoutes = require('./routes/restaurants');
const platsRoutes       = require('./routes/plats');

const app  = express();
const PORT = process.env.PORT || 3002;

app.use(helmet()); app.use(cors()); app.use(express.json());

app.get('/health', (req, res) => res.json({ service: 'cuisine-service', statut: 'actif' }));
app.use('/restaurants', restaurantsRoutes);
app.use('/restaurants',  platsRoutes);  // /restaurants/:id/plats

app.use((err, req, res, next) => {
  console.error('[cuisine-service] :', err.message);
  res.status(500).json({ erreur: 'Erreur interne' });
});

connecter().then(() =>
  app.listen(PORT, () => console.log(`[cuisine-service] http://localhost:${PORT}`))
).catch(err => { console.error(err.message); process.exit(1); });

const express = require('express');
const { ObjectId } = require('mongodb');
const { getBase } = require('../config/mongodb');
const { isAuthenticated, isRole } = require('../../shared/authClient');

const router = express.Router();

// ── GET /restaurants — liste publique avec pagination ─────
router.get('/', async (req, res) => {
  const { ville, categorie, page = 1, limite = 10 } = req.query;
  const filtre = {};
  if (ville)      filtre.ville = new RegExp(ville, 'i');  // recherche insensible a la casse
  if (categorie)  filtre.categorie = categorie;

  const skip  = (parseInt(page) - 1) * parseInt(limite);
  const col   = getBase().collection('restaurants');
  const total = await col.countDocuments(filtre);
  const restaurants = await col.find(filtre)
    .sort({ note: -1 })               // trier par note decroissante
    .skip(skip).limit(parseInt(limite))
    .toArray();

  res.json({ total, page: parseInt(page), pages: Math.ceil(total / parseInt(limite)), restaurants });
});

// ── GET /restaurants/:id ──────────────────────────────────
router.get('/:id', async (req, res) => {
  if (!ObjectId.isValid(req.params.id))
    return res.status(400).json({ erreur: 'Id invalide' });

  const restaurant = await getBase().collection('restaurants')
    .findOne({ _id: new ObjectId(req.params.id) });
  if (!restaurant) return res.status(404).json({ erreur: 'Restaurant introuvable' });
  res.json({ restaurant });
});

// ── POST /restaurants — restaurateur ou admin uniquement ──
router.post('/', isAuthenticated, isRole('restaurateur', 'admin'), async (req, res) => {
  const { nom, ville, adresse, telephone, categorie, horaires } = req.body;
  if (!nom || !ville || !adresse || !categorie)
    return res.status(400).json({ erreur: 'nom, ville, adresse et categorie obligatoires' });

  const restaurant = {
    nom, ville, adresse, telephone: telephone || null,
    categorie,  // 'tajine' | 'couscous' | 'pizza' | 'burger' | 'sushi' ...
    horaires: horaires || null,
    note: 0,      // moyenne des avis
    nbAvis: 0,
    proprietaireId: req.utilisateur.userId,
    actif: true,
    createdAt: new Date()
  };
  const r = await getBase().collection('restaurants').insertOne(restaurant);
  res.status(201).json({ message: 'Restaurant cree', restaurantId: r.insertedId });
});

// ── PUT /restaurants/:id ──────────────────────────────────
router.put('/:id', isAuthenticated, isRole('restaurateur', 'admin'), async (req, res) => {
  if (!ObjectId.isValid(req.params.id))
    return res.status(400).json({ erreur: 'Id invalide' });

  const { nom, ville, adresse, telephone, categorie, horaires, actif } = req.body;
  const mise = {};
  if (nom !== undefined)       mise.nom = nom;
  if (ville !== undefined)     mise.ville = ville;
  if (adresse !== undefined)   mise.adresse = adresse;
  if (telephone !== undefined) mise.telephone = telephone;
  if (categorie !== undefined) mise.categorie = categorie;
  if (horaires !== undefined)  mise.horaires = horaires;
  if (actif !== undefined)     mise.actif = actif;
  mise.updatedAt = new Date();

  const r = await getBase().collection('restaurants')
    .updateOne({ _id: new ObjectId(req.params.id) }, { $set: mise });
  if (r.matchedCount === 0) return res.status(404).json({ erreur: 'Restaurant introuvable' });
  res.json({ message: 'Restaurant mis a jour' });
});

// ── DELETE /restaurants/:id — admin uniquement ────────────
router.delete('/:id', isAuthenticated, isRole('admin'), async (req, res) => {
  if (!ObjectId.isValid(req.params.id))
    return res.status(400).json({ erreur: 'Id invalide' });

  const r = await getBase().collection('restaurants')
    .deleteOne({ _id: new ObjectId(req.params.id) });
  if (r.deletedCount === 0) return res.status(404).json({ erreur: 'Restaurant introuvable' });
  res.json({ message: 'Restaurant supprime' });
});

module.exports = router;

const express = require('express');
const { ObjectId } = require('mongodb');
const { getBase } = require('../config/mongodb');
const { isAuthenticated, isRole } = require('../../shared/authClient');

const router = express.Router();

// ── GET /restaurants/:id/plats — liste publique ───────────
router.get('/:restaurantId/plats', async (req, res) => {
  if (!ObjectId.isValid(req.params.restaurantId))
    return res.status(400).json({ erreur: 'restaurantId invalide' });

  const plats = await getBase().collection('plats')
    .find({ restaurantId: req.params.restaurantId })
    .toArray();

  // Champ calcule : disponible selon le stock
  const platsAvecDispo = plats.map(p => ({ ...p, disponible: p.stock > 0 }));
  res.json({ restaurantId: req.params.restaurantId, plats: platsAvecDispo });
});

// ── POST /restaurants/:id/plats ───────────────────────────
router.post('/:restaurantId/plats', isAuthenticated, isRole('restaurateur', 'admin'), async (req, res) => {
  const { nom, description, prix, categorie, stock } = req.body;
  if (!nom || prix === undefined)
    return res.status(400).json({ erreur: 'nom et prix obligatoires' });

  const plat = {
    restaurantId: req.params.restaurantId,
    nom, description: description || '',
    prix: parseFloat(prix),
    categorie: categorie || 'plat',  // 'entree' | 'plat' | 'dessert' | 'boisson'
    stock: stock !== undefined ? parseInt(stock) : 999,
    actif: true,
    createdAt: new Date()
  };
  const r = await getBase().collection('plats').insertOne(plat);
  res.status(201).json({ message: 'Plat ajoute', platId: r.insertedId });
});

// ── PUT /restaurants/:rid/plats/:pid — modifier un plat ───
router.put('/:restaurantId/plats/:platId', isAuthenticated, isRole('restaurateur', 'admin'), async (req, res) => {
  if (!ObjectId.isValid(req.params.platId))
    return res.status(400).json({ erreur: 'platId invalide' });

  const { nom, description, prix, stock, actif } = req.body;
  const mise = {};
  if (nom !== undefined)         mise.nom = nom;
  if (description !== undefined) mise.description = description;
  if (prix !== undefined)        mise.prix = parseFloat(prix);
  if (stock !== undefined)       mise.stock = parseInt(stock);
  if (actif !== undefined)       mise.actif = actif;
  mise.updatedAt = new Date();

  const r = await getBase().collection('plats')
    .updateOne({ _id: new ObjectId(req.params.platId) }, { $set: mise });
  if (r.matchedCount === 0) return res.status(404).json({ erreur: 'Plat introuvable' });
  res.json({ message: 'Plat mis a jour' });
});

module.exports = router;

const amqplib = require('amqplib');

const RABBITMQ_URL = process.env.RABBITMQ_URL || 'amqp://guest:guest@localhost:5672';
const EXCHANGE_NOM = process.env.EXCHANGE_NOM  || 'darigo';

let channel = null;

async function connecterRabbitMQ() {
  try {
    const connexion = await amqplib.connect(RABBITMQ_URL);
    channel = await connexion.createChannel();
    await channel.assertExchange(EXCHANGE_NOM, 'fanout', { durable: true });
    console.log(`[RabbitMQ] Connecte — exchange : ${EXCHANGE_NOM}`);

    connexion.on('close', () => {
      console.warn('[RabbitMQ] Connexion perdue — reconnexion dans 5s');
      channel = null;
      setTimeout(connecterRabbitMQ, 5000);
    });
  } catch (err) {
    console.warn('[RabbitMQ] Indisponible :', err.message, '— retry dans 5s');
    setTimeout(connecterRabbitMQ, 5000);
  }
}

async function publierEvenement(evenement) {
  if (!channel) {
    console.warn('[RabbitMQ] Pas de channel — evenement ignore :', evenement.type);
    return false;
  }
  try {
    const buffer = Buffer.from(JSON.stringify(evenement));
    channel.publish(EXCHANGE_NOM, '', buffer, { persistent: true });
    console.log('[RabbitMQ] Evenement publie :', evenement.type, evenement.commandeId);
    return true;
  } catch (err) {
    console.warn('[RabbitMQ] Erreur publication :', err.message);
    return false;
  }
}

module.exports = { connecterRabbitMQ, publierEvenement };

const express = require('express');
const { ObjectId } = require('mongodb');
const axios   = require('axios');
const { getBase } = require('../config/mongodb');
const { isAuthenticated } = require('../../shared/authClient');
const { publierEvenement } = require('../../shared/rabbitmq');

const router = express.Router();

const CUISINE_URL = process.env.CUISINE_SERVICE_URL || 'http://localhost:3002';

// ── POST /commandes ───────────────────────────────────────
router.post('/', isAuthenticated, async (req, res) => {
  const { restaurantId, lignes } = req.body;
  // lignes = [{ platId, quantite }, ...]
  if (!restaurantId || !lignes || !lignes.length)
    return res.status(400).json({ erreur: 'restaurantId et lignes obligatoires' });

  // 1 — Verifier chaque plat + calculer le total
  let total = 0;
  const lignesDetail = [];

  for (const ligne of lignes) {
    const { platId, quantite } = ligne;
    if (!quantite || quantite < 1)
      return res.status(400).json({ erreur: `Quantite invalide pour le plat ${platId}` });

    let platData;
    try {
      const rep = await axios.get(
        `${CUISINE_URL}/restaurants/${restaurantId}/plats`,
        { timeout: 5000 }
      );
      platData = rep.data.plats.find(p => p._id.toString() === platId);
    } catch (err) {
      const statut = err.response ? err.response.status : 503;
      return res.status(statut).json({ erreur: 'cuisine-service indisponible ou restaurant introuvable' });
    }

    if (!platData)
      return res.status(404).json({ erreur: `Plat ${platId} introuvable dans ce restaurant` });
    if (!platData.disponible)
      return res.status(409).json({ erreur: `Plat "${platData.nom}" hors stock` });

    total += platData.prix * quantite;
    lignesDetail.push({
      platId,
      nomPlat: platData.nom,     // Denormalisation — snapshot au moment de la commande
      prixUnitaire: platData.prix,
      quantite,
      sousTotal: platData.prix * quantite
    });
  }

  // 2 — Creer la commande
  const commande = {
    clientId:     req.utilisateur.userId,
    nomClient:    req.utilisateur.nom,
    restaurantId,
    lignes:       lignesDetail,
    total:        Math.round(total * 100) / 100,  // arrondir a 2 decimales
    statut:       'en_attente',  // en_attente | confirmee | en_preparation | prete | en_livraison | livree | annulee
    livreurId:    null,
    createdAt:    new Date(),
    updatedAt:    new Date()
  };

  const r = await getBase().collection('commandes').insertOne(commande);
  const commandeId = r.insertedId.toString();

  // 3 — Publier l'evenement (ne bloque pas la reponse)
  await publierEvenement({
    type:        'commande.creee',
    commandeId,
    clientId:    req.utilisateur.userId,
    nomClient:   req.utilisateur.nom,
    restaurantId,
    total:       commande.total,
    lignes:      lignesDetail,
    timestamp:   new Date().toISOString()
  });

  // 4 — Repondre immediatement — sans attendre les consumers
  res.status(201).json({
    message:   'Commande creee',
    commandeId,
    total:     commande.total,
    statut:    commande.statut
  });
});

// ── GET /commandes — commandes du client connecte ─────────
router.get('/', isAuthenticated, async (req, res) => {
  const { statut } = req.query;
  const filtre = { clientId: req.utilisateur.userId };
  if (statut) filtre.statut = statut;

  const commandes = await getBase().collection('commandes')
    .find(filtre).sort({ createdAt: -1 }).toArray();
  res.json({ total: commandes.length, commandes });
});

// ── GET /commandes/:id ────────────────────────────────────
router.get('/:id', isAuthenticated, async (req, res) => {
  if (!ObjectId.isValid(req.params.id))
    return res.status(400).json({ erreur: 'Id invalide' });

  const commande = await getBase().collection('commandes')
    .findOne({ _id: new ObjectId(req.params.id) });
  if (!commande) return res.status(404).json({ erreur: 'Commande introuvable' });
  if (commande.clientId !== req.utilisateur.userId &&
      req.utilisateur.role !== 'admin')
    return res.status(403).json({ erreur: 'Acces non autorise' });

  res.json({ commande });
});

// ── PATCH /commandes/:id/statut ───────────────────────────
router.patch('/:id/statut', isAuthenticated, async (req, res) => {
  if (!ObjectId.isValid(req.params.id))
    return res.status(400).json({ erreur: 'Id invalide' });

  const { statut } = req.body;
  const statutsValides = ['confirmee','en_preparation','prete','en_livraison','livree','annulee'];
  if (!statutsValides.includes(statut))
    return res.status(400).json({ erreur: `Statut invalide. Valides : ${statutsValides.join(', ')}` });

  const r = await getBase().collection('commandes')
    .updateOne(
      { _id: new ObjectId(req.params.id) },
      { $set: { statut, updatedAt: new Date() } }
    );
  if (r.matchedCount === 0) return res.status(404).json({ erreur: 'Commande introuvable' });
  res.json({ message: `Statut mis a jour : ${statut}` });
});

module.exports = router;

require('dotenv').config();
const express = require('express');
const helmet  = require('helmet');
const cors    = require('cors');
const { connecter }         = require('./config/mongodb');
const { connecterRabbitMQ } = require('../shared/rabbitmq');
const commandesRoutes       = require('./routes/commandes');

const app  = express();
const PORT = process.env.PORT || 3003;

app.use(helmet()); app.use(cors()); app.use(express.json());

app.get('/health', (req, res) => res.json({ service: 'commande-service', statut: 'actif' }));
app.use('/commandes', commandesRoutes);

connecter().then(() => {
  connecterRabbitMQ(); // connexion asynchrone — ne bloque pas le demarrage
  app.listen(PORT, () => console.log(`[commande-service] http://localhost:${PORT}`));
}).catch(err => { console.error(err.message); process.exit(1); });

require('dotenv').config();
const express  = require('express');
const amqplib  = require('amqplib');
const { ObjectId } = require('mongodb');
const helmet   = require('helmet');
const cors     = require('cors');
const { connecter, getBase } = require('./config/mongodb');
const { isAuthenticated, isRole } = require('../shared/authClient');

const app  = express();
const PORT = process.env.PORT || 3004;

const RABBITMQ_URL = process.env.RABBITMQ_URL || 'amqp://guest:guest@localhost:5672';
const EXCHANGE_NOM = process.env.EXCHANGE_NOM  || 'darigo';
const QUEUE_NOM    = 'queue-livraisons';

app.use(helmet()); app.use(cors()); app.use(express.json());
app.get('/health', (req, res) => res.json({ service: 'livraison-service', statut: 'actif' }));

// ── Consumer RabbitMQ ─────────────────────────────────────
async function demarrerConsumer() {
  try {
    const connexion = await amqplib.connect(RABBITMQ_URL);
    const channel   = await connexion.createChannel();
    await channel.assertExchange(EXCHANGE_NOM, 'fanout', { durable: true });
    await channel.assertQueue(QUEUE_NOM, { durable: true });
    await channel.bindQueue(QUEUE_NOM, EXCHANGE_NOM, '');
    console.log(`[livraison-service] Consumer actif — ecoute ${QUEUE_NOM}`);

    channel.consume(QUEUE_NOM, async (msg) => {
      if (!msg) return;
      try {
        const evt = JSON.parse(msg.content.toString());
        if (evt.type !== 'commande.creee') { channel.ack(msg); return; }

        // Creer une mission de livraison en statut "disponible"
        await getBase().collection('livraisons').insertOne({
          commandeId:   evt.commandeId,
          clientId:     evt.clientId,
          nomClient:    evt.nomClient,
          restaurantId: evt.restaurantId,
          total:        evt.total,
          livreurId:    null,   // Pas encore affecte
          statut:       'disponible',  // disponible | acceptee | en_route | livree | annulee
          createdAt:    new Date()
        });
        console.log(`[livraison-service] Mission creee pour commande ${evt.commandeId}`);
        channel.ack(msg);
      } catch (err) {
        console.error('[livraison-service] Erreur traitement :', err.message);
        channel.nack(msg, false, false); // ne pas remettre en queue (eviter boucle)
      }
    }, { noAck: false });

    connexion.on('close', () => {
      console.warn('[livraison-service] RabbitMQ deconnecte — retry 5s');
      setTimeout(demarrerConsumer, 5000);
    });
  } catch (err) {
    console.warn('[livraison-service] RabbitMQ indisponible :', err.message, '— retry 5s');
    setTimeout(demarrerConsumer, 5000);
  }
}

// ── GET /livraisons — missions disponibles ou du livreur ──
app.get('/livraisons', isAuthenticated, async (req, res) => {
  const { statut } = req.query;
  const filtre = {};

  if (req.utilisateur.role === 'livreur') {
    // Un livreur voit ses missions acceptees + les missions disponibles
    if (statut) {
      filtre.statut = statut;
    } else {
      filtre.$or = [
        { statut: 'disponible' },
        { livreurId: req.utilisateur.userId }
      ];
    }
  } else if (req.utilisateur.role === 'admin') {
    if (statut) filtre.statut = statut;
  } else {
    // Client : uniquement ses livraisons
    filtre.clientId = req.utilisateur.userId;
  }

  const livraisons = await getBase().collection('livraisons')
    .find(filtre).sort({ createdAt: -1 }).toArray();
  res.json({ total: livraisons.length, livraisons });
});

// ── PATCH /livraisons/:id/accepter — livreur accepte ─────
app.patch('/livraisons/:id/accepter', isAuthenticated, isRole('livreur'), async (req, res) => {
  if (!ObjectId.isValid(req.params.id))
    return res.status(400).json({ erreur: 'Id invalide' });

  const r = await getBase().collection('livraisons').updateOne(
    { _id: new ObjectId(req.params.id), statut: 'disponible' },
    { $set: { livreurId: req.utilisateur.userId, statut: 'acceptee', updatedAt: new Date() } }
  );
  if (r.matchedCount === 0)
    return res.status(409).json({ erreur: 'Mission indisponible ou deja acceptee' });
  res.json({ message: 'Mission acceptee' });
});

// ── PATCH /livraisons/:id/statut — livreur met a jour ─────
app.patch('/livraisons/:id/statut', isAuthenticated, isRole('livreur', 'admin'), async (req, res) => {
  if (!ObjectId.isValid(req.params.id))
    return res.status(400).json({ erreur: 'Id invalide' });

  const { statut } = req.body;
  const valides = ['en_route', 'livree', 'annulee'];
  if (!valides.includes(statut))
    return res.status(400).json({ erreur: `Statut invalide. Valides : ${valides.join(', ')}` });

  const r = await getBase().collection('livraisons').updateOne(
    { _id: new ObjectId(req.params.id) },
    { $set: { statut, updatedAt: new Date() } }
  );
  if (r.matchedCount === 0) return res.status(404).json({ erreur: 'Mission introuvable' });
  res.json({ message: `Statut mis a jour : ${statut}` });
});

connecter().then(() => {
  demarrerConsumer();
  app.listen(PORT, () => console.log(`[livraison-service] http://localhost:${PORT}`));
}).catch(err => { console.error(err.message); process.exit(1); });

require('dotenv').config();
const express  = require('express');
const amqplib  = require('amqplib');
const { MongoClient } = require('mongodb');
const { isAuthenticated, isRole } = require('../shared/authClient');

const RABBITMQ_URL = process.env.RABBITMQ_URL || 'amqp://guest:guest@localhost:5672';
const EXCHANGE_NOM = process.env.EXCHANGE_NOM  || 'darigo';
const MONGO_URI    = process.env.MONGO_URI     || 'mongodb://localhost:27017';
const NOM_BASE     = process.env.NOM_BASE      || 'bddarigo-notifs';
const QUEUE_NOM    = 'queue-notifs';
const PORT         = process.env.PORT || 3005;

const app = express();
app.use(express.json());
let db = null;

// ── Connexion MongoDB ─────────────────────────────────────
async function connecterMongo() {
  const client = new MongoClient(MONGO_URI);
  await client.connect();
  db = client.db(NOM_BASE);
  console.log('[notif-service] MongoDB connecte');
}

// ── Consumer RabbitMQ ─────────────────────────────────────
async function demarrerConsumer() {
  try {
    const connexion = await amqplib.connect(RABBITMQ_URL);
    const channel   = await connexion.createChannel();
    await channel.assertExchange(EXCHANGE_NOM, 'fanout', { durable: true });
    await channel.assertQueue(QUEUE_NOM, { durable: true });
    await channel.bindQueue(QUEUE_NOM, EXCHANGE_NOM, '');
    console.log(`[notif-service] Consumer actif — ecoute tous les evenements darigo`);

    channel.consume(QUEUE_NOM, async (msg) => {
      if (!msg) return;
      try {
        const evt = JSON.parse(msg.content.toString());

        // Enregistrer l'evenement — peu importe son type
        await db.collection('evenements').insertOne({
          ...evt,
          recu_le: new Date()
        });

        // Simuler une notification selon le type
        switch (evt.type) {
          case 'commande.creee':
            console.log(`[notif-service] SMS envoye a ${evt.nomClient} — commande ${evt.commandeId} (${evt.total} MAD)`);
            break;
          default:
            console.log(`[notif-service] Evenement enregistre : ${evt.type}`);
        }

        channel.ack(msg);
      } catch (err) {
        console.error('[notif-service] Erreur :', err.message);
        channel.nack(msg, false, false);
      }
    }, { noAck: false });

    connexion.on('close', () => {
      console.warn('[notif-service] RabbitMQ deconnecte — retry 5s');
      setTimeout(demarrerConsumer, 5000);
    });
  } catch (err) {
    console.warn('[notif-service] RabbitMQ indisponible :', err.message, '— retry 5s');
    setTimeout(demarrerConsumer, 5000);
  }
}

// ── GET /notifs — historique admin ────────────────────────
app.get('/health', (req, res) => res.json({ service: 'notif-service', statut: 'actif' }));

app.get('/notifs', isAuthenticated, isRole('admin'), async (req, res) => {
  const { type, page = 1, limite = 20 } = req.query;
  const filtre = {};
  if (type) filtre.type = type;

  const skip  = (parseInt(page) - 1) * parseInt(limite);
  const total = await db.collection('evenements').countDocuments(filtre);
  const notifs = await db.collection('evenements')
    .find(filtre).sort({ recu_le: -1 }).skip(skip).limit(parseInt(limite)).toArray();

  res.json({ total, page: parseInt(page), notifs });
});

// ── Demarrage ─────────────────────────────────────────────
connecterMongo().then(() => {
  demarrerConsumer();
  app.listen(PORT, () => console.log(`[notif-service] http://localhost:${PORT}`));
}).catch(err => { console.error(err.message); process.exit(1); });

# Etape 1 : arreter notif-service (simuler une panne)
Ctrl+C dans le terminal notif-service

# Etape 2 : creer 3 commandes via Postman (POST /commandes)
# Les 201 arrivent normalement — commande-service ne depend pas de notif-service

# Etape 3 : verifier l'interface RabbitMQ
# http://localhost:15672 → queue-notifs → Messages Ready: 3

# Etape 4 : relancer notif-service
node notif-service/index.js

# Observer dans les logs : 3 messages consommes immediatement
# [notif-service] SMS envoye a Karim — commande cmd-xxx
# [notif-service] SMS envoye a Nadia — commande cmd-yyy
# [notif-service] SMS envoye a Youssef — commande cmd-zzz

# Etape 5 : verifier que les evenements sont dans MongoDB
# GET /notifs (admin token) → total: 3

events {
  worker_connections 1024;
}

http {
  # ── Rate limiting : 10 requetes/minute par IP sur /auth/login ──
  limit_req_zone $binary_remote_addr zone=auth_login:10m rate=10r/m;

  # ── Upstreams — noms des services docker-compose ────────────
  upstream auth_service      { server auth-service:3001; }
  upstream cuisine_service   { server cuisine-service:3002; }
  upstream commande_service  { server commande-service:3003; }
  upstream livraison_service { server livraison-service:3004; }

  server {
    listen 80;
    server_name localhost;

    # Headers transmis aux services backend
    proxy_set_header Host              $host;
    proxy_set_header X-Real-IP         $remote_addr;
    proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
    proxy_set_header Authorization     $http_authorization;  # CRITIQUE : transmettre le JWT

    proxy_connect_timeout  5s;
    proxy_read_timeout    30s;

    # ── Routes — ordre : du plus specifique au plus general ──
    location /auth/login {
      limit_req zone=auth_login burst=5 nodelay;  # max 5 en rafale
      proxy_pass http://auth_service/auth/login;
    }

    location /auth/      { proxy_pass http://auth_service/auth/; }
    location /cuisines/  { proxy_pass http://cuisine_service/restaurants/; }
    location /commandes/ { proxy_pass http://commande_service/commandes/; }
    location /livraisons/{ proxy_pass http://livraison_service/livraisons/; }

    # Health check Nginx
    location /nginx-health {
      return 200 '{"service":"nginx","statut":"actif"}';
      add_header Content-Type application/json;
    }

    # Page d'erreur JSON quand un service backend est hors ligne
    error_page 502 503 504 /erreur_service.json;
    location = /erreur_service.json {
      return 503 '{"erreur":"Service temporairement indisponible"}';
      add_header Content-Type application/json;
    }

    # Bloquer les acces directs aux endpoints internes
    location /notifs/ { return 403 '{"erreur":"Acces direct interdit"}'; }
  }
}

FROM node:18-alpine

WORKDIR /app

# Copier les manifestes AVANT le code source → npm install en cache
COPY package*.json ./
RUN npm install --production

# Copier le code source + le dossier shared/
COPY . .

ENV NODE_ENV=production
ENV PORT=3001

EXPOSE 3001

CMD ["node", "index.js"]

node_modules
.env
.env.*
*.log
.git
README.md

version: '3.9'

services:

  # ── Infrastructure ──────────────────────────────────────
  mongodb:
    image: mongo:7.0
    container_name: darigo-mongodb
    ports:
      - "27017:27017"
    environment:
      MONGO_INITDB_ROOT_USERNAME: ${MONGO_USER:-admin}
      MONGO_INITDB_ROOT_PASSWORD: ${MONGO_PASSWORD:-secret}
    volumes:
      - mongo_data:/data/db
    networks:
      - darigo-backend
    healthcheck:
      test: ["CMD", "mongosh", "--eval", "db.adminCommand('ping')"]
      interval: 5s
      retries: 5
      start_period: 10s

  rabbitmq:
    image: rabbitmq:3-management
    container_name: darigo-rabbitmq
    ports:
      - "15672:15672"    # Interface web
    environment:
      RABBITMQ_DEFAULT_USER: ${RABBITMQ_USER:-guest}
      RABBITMQ_DEFAULT_PASS: ${RABBITMQ_PASS:-guest}
    volumes:
      - rabbitmq_data:/var/lib/rabbitmq
    networks:
      - darigo-backend
    healthcheck:
      test: ["CMD", "rabbitmq-diagnostics", "ping"]
      interval: 10s
      retries: 5
      start_period: 30s

  # ── Services Node.js ─────────────────────────────────────
  auth-service:
    build:
      context: .                  # Racine du projet (pour inclure shared/)
      dockerfile: auth-service/Dockerfile
    container_name: darigo-auth
    environment:
      PORT: 3001
      MONGO_URI: mongodb://${MONGO_USER:-admin}:${MONGO_PASSWORD:-secret}@mongodb:27017
      NOM_BASE: bddarigo-auth
      JWT_SECRET: ${JWT_SECRET}
      JWT_EXPIRES_IN: ${JWT_EXPIRES_IN:-7d}
    depends_on:
      mongodb:
        condition: service_healthy
    networks:
      - darigo-frontend
      - darigo-backend
    restart: on-failure

  cuisine-service:
    build:
      context: .
      dockerfile: cuisine-service/Dockerfile
    container_name: darigo-cuisine
    environment:
      PORT: 3002
      MONGO_URI: mongodb://${MONGO_USER:-admin}:${MONGO_PASSWORD:-secret}@mongodb:27017
      NOM_BASE: bddarigo-cuisines
      AUTH_SERVICE_URL: http://auth-service:3001
    depends_on:
      mongodb:
        condition: service_healthy
      auth-service:
        condition: service_started
    networks:
      - darigo-frontend
      - darigo-backend
    restart: on-failure

  commande-service:
    build:
      context: .
      dockerfile: commande-service/Dockerfile
    container_name: darigo-commande
    environment:
      PORT: 3003
      MONGO_URI: mongodb://${MONGO_USER:-admin}:${MONGO_PASSWORD:-secret}@mongodb:27017
      NOM_BASE: bddarigo-commandes
      AUTH_SERVICE_URL: http://auth-service:3001
      CUISINE_SERVICE_URL: http://cuisine-service:3002
      RABBITMQ_URL: amqp://${RABBITMQ_USER:-guest}:${RABBITMQ_PASS:-guest}@rabbitmq:5672
      EXCHANGE_NOM: darigo
    depends_on:
      mongodb:
        condition: service_healthy
      rabbitmq:
        condition: service_healthy
      auth-service:
        condition: service_started
      cuisine-service:
        condition: service_started
    networks:
      - darigo-frontend
      - darigo-backend
    restart: on-failure

  livraison-service:
    build:
      context: .
      dockerfile: livraison-service/Dockerfile
    container_name: darigo-livraison
    environment:
      PORT: 3004
      MONGO_URI: mongodb://${MONGO_USER:-admin}:${MONGO_PASSWORD:-secret}@mongodb:27017
      NOM_BASE: bddarigo-livraisons
      AUTH_SERVICE_URL: http://auth-service:3001
      RABBITMQ_URL: amqp://${RABBITMQ_USER:-guest}:${RABBITMQ_PASS:-guest}@rabbitmq:5672
      EXCHANGE_NOM: darigo
    depends_on:
      mongodb:
        condition: service_healthy
      rabbitmq:
        condition: service_healthy
    networks:
      - darigo-frontend
      - darigo-backend
    restart: on-failure

  notif-service:
    build:
      context: .
      dockerfile: notif-service/Dockerfile
    container_name: darigo-notif
    environment:
      PORT: 3005
      MONGO_URI: mongodb://${MONGO_USER:-admin}:${MONGO_PASSWORD:-secret}@mongodb:27017
      NOM_BASE: bddarigo-notifs
      AUTH_SERVICE_URL: http://auth-service:3001
      RABBITMQ_URL: amqp://${RABBITMQ_USER:-guest}:${RABBITMQ_PASS:-guest}@rabbitmq:5672
      EXCHANGE_NOM: darigo
    depends_on:
      rabbitmq:
        condition: service_healthy
    networks:
      - darigo-backend    # Pas de frontend — pas de port HTTP entrant depuis Nginx
    restart: on-failure

  nginx:
    image: nginx:1.25-alpine
    container_name: darigo-nginx
    ports:
      - "80:80"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro    # :ro = lecture seule
    depends_on:
      - auth-service
      - cuisine-service
      - commande-service
      - livraison-service
    networks:
      - darigo-frontend   # Nginx uniquement en frontend — ne voit pas MongoDB
    restart: on-failure

volumes:
  mongo_data:
  rabbitmq_data:

networks:
  darigo-frontend:
    driver: bridge   # Nginx + services Node.js
  darigo-backend:
    driver: bridge   # Services Node.js + MongoDB + RabbitMQ

cd darigo
docker-compose up --build -d   # Build + demarrage

docker-compose ps              # 7 services Running
docker-compose logs -f         # Suivre tous les logs

docker login  # Se connecter a Docker Hub

USERNAME=VOTRE_USERNAME  # Remplacer par votre username Docker Hub

# Construire depuis la racine du projet (contexte = . pour inclure shared/)
for service in auth-service cuisine-service commande-service livraison-service notif-service; do
  echo "=== Build $service ==="
  docker build     -f $service/Dockerfile     -t darigo-${service%%-service}:1.0.0 \    # darigo-auth:1.0.0
    .                                          # Contexte = racine

  docker tag darigo-${service%%-service}:1.0.0 $USERNAME/darigo-${service%%-service}:1.0.0
  docker tag darigo-${service%%-service}:1.0.0 $USERNAME/darigo-${service%%-service}:latest
  docker push $USERNAME/darigo-${service%%-service}:1.0.0
  docker push $USERNAME/darigo-${service%%-service}:latest
done

# Verifier les 5 depots sur Docker Hub
# hub.docker.com/u/VOTRE_USERNAME

version: '3.9'
# DIFFERENCES avec le Compose local :
# - Pas de build: (images pre-construites sur Docker Hub)
# - Pas de volumes bind mount
# - Secrets injectes via App Settings Azure (${VAR})
# - DNS interne : noms de services = hostnames Azure

services:

  auth-service:
    image: VOTRE_USERNAME/darigo-auth:1.0.0
    environment:
      WEBSITES_PORT: 3001
      PORT: 3001
      NODE_ENV: production
      MONGO_URI: ${MONGO_URI}           # Injecte depuis App Settings
      NOM_BASE: bddarigo-auth
      JWT_SECRET: ${JWT_SECRET}
      JWT_EXPIRES_IN: 7d
    ports:
      - '3001:3001'

  cuisine-service:
    image: VOTRE_USERNAME/darigo-cuisine:1.0.0
    environment:
      PORT: 3002
      NODE_ENV: production
      MONGO_URI: ${MONGO_URI}
      NOM_BASE: bddarigo-cuisines
      AUTH_SERVICE_URL: http://auth-service:3001   # DNS interne Azure
    ports:
      - '3002:3002'

  commande-service:
    image: VOTRE_USERNAME/darigo-commande:1.0.0
    environment:
      PORT: 3003
      NODE_ENV: production
      MONGO_URI: ${MONGO_URI}
      NOM_BASE: bddarigo-commandes
      AUTH_SERVICE_URL: http://auth-service:3001
      CUISINE_SERVICE_URL: http://cuisine-service:3002
      RABBITMQ_URL: ${RABBITMQ_URL}
      EXCHANGE_NOM: darigo
    ports:
      - '3003:3003'

  livraison-service:
    image: VOTRE_USERNAME/darigo-livraison:1.0.0
    environment:
      PORT: 3004
      NODE_ENV: production
      MONGO_URI: ${MONGO_URI}
      NOM_BASE: bddarigo-livraisons
      AUTH_SERVICE_URL: http://auth-service:3001
      RABBITMQ_URL: ${RABBITMQ_URL}
      EXCHANGE_NOM: darigo
    ports:
      - '3004:3004'

  notif-service:
    image: VOTRE_USERNAME/darigo-notif:1.0.0
    environment:
      PORT: 3005
      NODE_ENV: production
      MONGO_URI: ${MONGO_URI}
      NOM_BASE: bddarigo-notifs
      AUTH_SERVICE_URL: http://auth-service:3001
      RABBITMQ_URL: ${RABBITMQ_URL}
      EXCHANGE_NOM: darigo
      # Pas de ports: — consumer pur, pas accessible depuis Nginx

az login

# 1 — Groupe de ressources
az group create --name rg-darigo-prod --location francecentral

# 2 — App Service Plan B1 Linux
az appservice plan create   --name plan-darigo   --resource-group rg-darigo-prod   --sku B1   --is-linux

# 3 — Web App multi-conteneurs
az webapp create   --name darigo-app \                     # Nom unique mondialement
  --resource-group rg-darigo-prod   --plan plan-darigo   --multicontainer-config-type compose   --multicontainer-config-file docker-compose.azure.yml

# 4 — Injecter les secrets (jamais dans l'image ni dans le YAML)
az webapp config appsettings set   --name darigo-app   --resource-group rg-darigo-prod   --settings     MONGO_URI='mongodb+srv://admin:pass@cluster.mongodb.net'     JWT_SECRET=darigo_prod_jwt_secret_2024_xyz     RABBITMQ_URL='amqps://user:pass@rabbitmq.cloudamqp.com/vhost'

# 5 — Activer les logs
az webapp log config   --name darigo-app   --resource-group rg-darigo-prod   --application-logging filesystem   --docker-container-logging filesystem

# Streamer les logs
az webapp log tail --name darigo-app --resource-group rg-darigo-prod

# URL publique
az webapp show --name darigo-app --resource-group rg-darigo-prod   --query defaultHostName --output tsv
# → darigo-app.azurewebsites.net