Aller au contenu

API Backend PsychoEnLigneV2 — Référence complète des routes pour le frontend

Contexte

Ce document recense l'ensemble des routes HTTP exposées par le backend PsychoEnLigneV2, organisées par module. Il est destiné à guider le développement du frontend : pour chaque route, on trouvera la méthode HTTP, le chemin, les données d'entrée attendues et la structure de retour.

Il complète la gestion des thèmes côté UI et s'appuie sur le Guide d'Architecture partagé pour les conventions générales.

Format de réponse HTTP standard

Toutes les routes retournent l'une de ces deux enveloppes :

// Succès
{ "succes": true, "message": "...", "data": { ... }, "timestamp": "ISO8601" }

// Erreur
{ "succes": false, "code": "CODE_ERREUR", "message": "...", "timestamp": "ISO8601" }

Les champs adresseIP et userAgent présents dans les DTOs d'entrée sont injectés côté serveur depuis le middleware — le frontend n'a pas à les envoyer. #dto

MODULE AUTH — /api/auth

Préfixe : /api/auth · Pas de versionnage /v1 pour ce module.

Table des routes

Méthode Path Authentifié Description
POST /connexion Non Connexion utilisateur
POST /register Non Inscription
POST /refresh Non Rafraîchir le token JWT
POST /verify-email Non Vérifier l'email après inscription
POST /logout Oui Déconnexion
POST /verify-email-change Oui Confirmer le changement d'email
POST /change-email Oui Demander un changement d'email
PUT /change-password Oui Changer le mot de passe
POST /reset-password/request Non Demander un reset de mot de passe
POST /reset-password/verify Non Vérifier le token de reset
POST /reset-password/confirm Non Confirmer le nouveau mot de passe
POST /2fa/generate-secret Oui Générer le secret TOTP
POST /2fa/activate Oui Activer le 2FA
POST /2fa/verify Non Vérifier le code 2FA (après connexion)
POST /2fa/deactivate Oui Désactiver le 2FA
POST /2fa/backup-codes/generate Oui Générer les codes de récupération
POST /2fa/backup-codes/verify Non Utiliser un code de récupération
POST /2fa/backup-codes/revoke Oui Révoquer les codes de récupération
GET /sessions/events Oui Historique des événements de session
POST /sessions/revoke-all Oui Révoquer toutes les sessions
GET /sessions/ Oui Lister les sessions actives
DELETE /sessions/:idSession Oui Révoquer une session précise
POST /tokens/validate Non Valider un access token
POST /tokens/revoke-all Oui Révoquer tous les tokens
POST /tokens/revoke Oui Révoquer un token précis
GET /profile Oui Obtenir le profil de l'utilisateur connecté
PUT /profile Oui Modifier le profil
GET /parametres/:idUtilisateur Oui Paramètres de sécurité d'un utilisateur
DELETE /delete-account Oui Supprimer le compte
GET /history Oui Historique des actions
POST /security/block-ip Oui Bloquer une IP
POST /security/unblock-ip Oui Débloquer une IP
GET /security/logs Oui Logs de sécurité
GET /security/suspicious-connections Oui Connexions suspectes

POST /connexion

Corps de la requête : 

{
  email: string;            // obligatoire
  motDePasse: string;       // obligatoire
}

Réponse succès — data : 

{
  utilisateur?: {
    id: string;
    nom: string;
    prenom: string;
    email: string;
    role: string;
    permissions?: string[];
  };
  token?: {
    accessToken: string;
    refreshToken: string;
    expiresIn: number;
  };
  requires2FA?: boolean;
  requires2FAConfiguration?: boolean;
  methode2FA?: 'EMAIL' | 'APPLICATION';
  sessionId?: string;
  deuxiemeFacteur?: {
    requis: boolean;
    methode: string;
    codeEnvoye: boolean;
    configure: boolean;
  };
}

Codes d'erreur possibles : CREDENTIALS_INVALIDES | COMPTE_INACTIF | COMPTE_VERROUILLE | TROP_TENTATIVES | EMAIL_INVALIDE | EMAIL_NON_VERIFIE | MOT_DE_PASSE_REQUIS | DEUX_FACTEURS_REQUIS | ERREUR_SERVEUR | ERREUR_GENERATION_TOKEN | ERREUR_CREATION_SESSION | ERREUR_ENVOI_CODE_2FA

Flux 2FA : si requires2FA: true, rediriger vers l'écran de vérification 2FA et appeler POST /2fa/verify avec le sessionId reçu.

POST /register

Corps de la requête : 

{
  nom: string;                                  // obligatoire
  prenom: string;                               // obligatoire
  email: string;                                // obligatoire
  motDePasse: string;                           // obligatoire
  confirmationMotDePasse: string;               // obligatoire
  accepteCGU: boolean;                          // obligatoire
  organisationCible?: 'CARITAS' | 'AUTRE';
}

Réponse succès — data : 

{
  utilisateur?: {
    idUtilisateur: string;
    nom: string;
    prenom: string;
    email: string;
  };
  codeVerificationEnvoye: boolean;
  warnings?: string[];
}

Codes d'erreur : EMAIL_DEJA_UTILISE | CGU_NON_ACCEPTEES | MOT_DE_PASSE_FAIBLE | MOTS_DE_PASSE_DIFFERENTS | EMAIL_INVALIDE | DONNEES_INVALIDES | ERREUR_ENVOI_EMAIL

POST /refresh

Corps de la requête : 

{
  refreshToken: string;   // obligatoire
}

Réponse succès — data : 

{
  accessToken: string;
  refreshToken: string;
  expiresIn: number;
  requiresLogin?: boolean;   // true = session expirée, rediriger vers login
}

Codes d'erreur : TOKEN_INVALIDE | TOKEN_EXPIRE | SESSION_INVALIDE | SESSION_EXPIREE | UTILISATEUR_INACTIF | IP_BLOQUEE

POST /verify-email

Corps de la requête : 

{
  email: string;    // obligatoire
  code: string;     // obligatoire — code reçu par email
}

Réponse succès — data : 

{
  emailVerifie: {
    idUtilisateur: string;
    email: string;
    dateVerification: string;
  };
}

Codes d'erreur : UTILISATEUR_INTROUVABLE | EMAIL_DEJA_VERIFIE | CODE_INVALIDE | CODE_EXPIRE | CODE_DEJA_UTILISE

PUT /change-password

Corps de la requête : 

{
  idUtilisateur: string;          // obligatoire
  ancienMotDePasse: string;       // obligatoire
  nouveauMotDePasse: string;      // obligatoire
  confirmerMotDePasse: string;    // obligatoire
}

Réponse succès — data : 

{
  motDePasseChange: {
    idUtilisateur: string;
    email: string;
    updatedAt: string;
    sessionsInvalidees: number;
  };
}

Codes d'erreur : UTILISATEUR_INTROUVABLE | ANCIEN_MOT_DE_PASSE_INCORRECT | NOUVEAU_MOT_DE_PASSE_IDENTIQUE | MOT_DE_PASSE_TROP_COURT | MOT_DE_PASSE_SANS_MAJUSCULE | MOT_DE_PASSE_SANS_CHIFFRE | MOT_DE_PASSE_SANS_CARACTERE_SPECIAL | MOTS_DE_PASSE_NON_IDENTIQUES

POST /2fa/verify

Appelé après connexion quand requires2FA: true. Le sessionId est retourné par POST /connexion.

Corps de la requête : 

{
  sessionId: string;                       // obligatoire
  code: string;                            // obligatoire — code saisi par l'utilisateur
  methode: '2FA_EMAIL' | '2FA_TOTP';      // obligatoire
}

Réponse succès — data : 

{
  utilisateur: {
    idUtilisateur: string;
    email: string;
    nom: string;
    prenom?: string;
    role: string;
    organisationCible?: string;
  };
  accessToken: string;
  refreshToken: string;
  expiresIn: number;
  idSession: string;
  dateExpirationSession: string;
  tentativesRestantes?: number;
  avertissements?: string[];
}

Codes d'erreur : SESSION_INVALIDE | SESSION_EXPIREE | CODE_INVALIDE | CODE_EXPIRE | TROP_TENTATIVES | METHODE_INCORRECTE

POST /2fa/activate

Corps de la requête : 

{
  idUtilisateur: string;
  methode: 'EMAIL' | 'APPLICATION';    // obligatoire
  motDePasse?: string;
  secretTOTP?: string;                  // requis si methode = APPLICATION
  codeVerification: string;            // obligatoire
}

Réponse succès — data : 

{
  activation: {
    idUtilisateur: string;
    methode: string;
    dateActivation: string;
    codesBackup: string[];             // à afficher une seule fois à l'utilisateur
    sessionsAReauthentifier: number;
  };
}

POST /reset-password/request

Corps de la requête : 

{ email: string; }

Réponse : { succes: true, message: "Email envoyé si le compte existe" }

POST /reset-password/confirm

Corps de la requête : 

{
  token: string;
  nouveauMotDePasse: string;
  confirmerMotDePasse: string;
}

MODULE UTILISATEURS — /api/admin/users

Toutes les routes sont authentifiées (réservées aux admins). ⚠️ Préfixe /api/admin/users — pas /api/v1/utilisateurs (corrigé le 20260505).

Table des routes

Méthode Path Description
GET /stats Statistiques globales
GET /export Export CSV/JSON
GET / Lister avec filtres et pagination
POST / Créer un utilisateur
GET /:id Obtenir un utilisateur
PUT /:id Mettre à jour un utilisateur
DELETE /:id Supprimer un utilisateur
POST /:id/change-role Changer le rôle
POST /:id/toggle-active Activer / désactiver

Routes de Rôles — /api/admin/roles

Méthode Path Description
GET / Lister les rôles
POST / Créer un rôle
GET /:idRole Obtenir un rôle
PATCH /:idRole Modifier un rôle
DELETE /:idRole Supprimer un rôle
GET /:idRole/permissions Lister les permissions d'un rôle
PUT /:idRole/permissions Assigner des permissions

Routes de Permissions — /api/admin/permissions

Méthode Path Description
GET / Lister toutes les permissions disponibles

GET /api/admin/users/

Query params : 

// filtres (optionnels)
role?: string | string[];
isActive?: boolean;
isVerified?: boolean;
deuxFacteursActive?: boolean;
estVerrouille?: boolean;
searchTerm?: string;
pays?: string;
organisation?: string;
dateCreationDebut?: string;       // ISO8601
dateCreationFin?: string;
dateDerniereConnexionDebut?: string;
dateDerniereConnexionFin?: string;

// pagination
page?: number;                    // défaut : 1
limit?: number;                   // défaut : 20
sortBy?: 'createdAt' | 'dateDerniereConnexion' | 'nom' | 'email' | 'role';
sortOrder?: 'asc' | 'desc';

Réponse succès — data : 

{
  utilisateurs: {
    idUtilisateur: string;
    email: string;
    nom: string;
    prenom: string;
    role: string;
    organisation?: string;
    poste?: string;
    telephone?: string;
    pays?: string;
    isActive: boolean;
    isVerified: boolean;
    deuxFacteursActive: boolean;
    estVerrouille: boolean;
    dateCreation: string;
    dateDerniereConnexion?: string;
  }[];
  pagination: {
    page: number;
    limit: number;
    total: number;
    totalPages: number;
    hasNext: boolean;
    hasPrev: boolean;
  };
}

POST /api/admin/users/

Corps : 

{
  email: string;                    // obligatoire
  motDePasse: string;               // obligatoire
  nom: string;                      // obligatoire
  prenom: string;                   // obligatoire
  idRole: string;                   // obligatoire — CUID du rôle
  createdBy: string;                // obligatoire — CUID de l'admin créateur
  telephone?: string;
  pays?: string;
  langue?: string;
  organisation?: string;
  poste?: string;
  isActive?: boolean;
  emailNotifications?: boolean;
}

Codes d'erreur : EMAIL_DEJA_UTILISE | EMAIL_INVALIDE | ROLE_INVALIDE | ROLE_INTROUVABLE | MOT_DE_PASSE_TROP_FAIBLE | PERMISSION_REFUSEE

PUT /api/admin/users/:id

Corps : 

{
  idAdmin: string;                  // obligatoire
  donnees: {
    nom?: string;
    prenom?: string;
    email?: string;
    telephone?: string;
    organisation?: string;
    poste?: string;
    role?: string;
    permissions?: Record<string, unknown>;
    isActive?: boolean;
    emailNotifications?: boolean;
  };
}

Codes d'erreur : UTILISATEUR_INTROUVABLE | EMAIL_DEJA_UTILISE | MODIFICATION_SUPER_ADMIN_LIMITEE | AUCUNE_MODIFICATION | PERMISSION_REFUSEE

MODULE PATIENTS — /api/v1/patients

Toutes les routes sont authentifiées.

Table des routes

Méthode Path Description
GET / Lister les patients (paginé)
POST / Créer un dossier patient
GET /:id Obtenir un dossier patient
PUT /:id Modifier un dossier patient
DELETE /:id Supprimer (soft delete)
GET /:id/dossier Consulter le dossier complet
GET /:id/historique Historique des consultations
POST /:id/documents Ajouter un document
DELETE /:id/documents/:docId Supprimer un document

GET /api/v1/patients/

Query params : 

page?: number;
taillePage?: number;
filtre?: string;         // recherche textuelle

Réponse succès — data : 

{
  patients: PatientPublicDTO[];
  total: number;
  page: number;
  taillePage: number;
}

PatientPublicDTO : 

{
  id: string;
  utilisateurId: string;
  dateNaissance?: string;
  sexe?: 'MASCULIN' | 'FEMININ' | 'AUTRE';
  adresse?: string;
  ville?: string;
  codePostal?: string;
  pays?: string;
  groupeSanguin?: string;
  allergies?: string[];
  antecedents?: string;
  assuranceNom?: string;
  assuranceNumero?: string;
  softDeleteAt?: string;
  createdAt: string;
  updatedAt: string;
}

POST /api/v1/patients/

Corps : 

{
  utilisateurId: string;                // obligatoire — CUID de l'utilisateur
  dateNaissance?: string;               // ISO8601
  sexe?: 'MASCULIN' | 'FEMININ' | 'AUTRE';
  adresse?: string;
  ville?: string;
  codePostal?: string;
  pays?: string;
  groupeSanguin?: 'A+' | 'A-' | 'B+' | 'B-' | 'AB+' | 'AB-' | 'O+' | 'O-';
  allergies?: string[];
  antecedents?: string;
  assuranceNom?: string;
  assuranceNumero?: string;
  notesConfident?: string;
}

Codes d'erreur : DOSSIER_DEJA_EXISTANT | DONNEES_INVALIDES | ERREUR_SERVEUR

MODULE PRATICIENS — /api/v1/praticiens

Table des routes

Méthode Path Authentifié Description
GET /typesPraticien Non Lister les types de praticien
POST /typesPraticien Oui Créer un type de praticien
GET / Oui Lister les praticiens
POST / Oui Créer un profil praticien
GET /:id Oui Obtenir un profil
PUT /:id Oui Modifier un profil
GET /:id/disponibilites Oui Obtenir les disponibilités
POST /:id/disponibilites Oui Ajouter une disponibilité
PUT /:id/disponibilites/:dispId Oui Modifier une disponibilité
DELETE /:id/disponibilites/:dispId Oui Supprimer une disponibilité
PATCH /:id/disponibilites/:dispId/actif Oui Activer / désactiver une disponibilité

GET /api/v1/praticiens/typesPraticien (public)

Réponse succès — data : 

{
  typesPraticien: {
    id: string;
    nom: string;
    description?: string;
  }[];
}

POST /api/v1/praticiens/

Corps : 

{
  utilisateurId: string;            // obligatoire — CUID utilisateur
  typePraticienId: string;          // obligatoire — CUID type praticien
  numeroRegistre: string;           // obligatoire — numéro d'ordre professionnel
  bio?: string;
  tarifConsultation?: number;
  dureeConsultDefaut?: number;      // en minutes
  consultationEnLigne?: boolean;
}

PraticienPublicDTO : 

{
  id: string;
  utilisateurId: string;
  typePraticienId: string;
  numeroRegistre: string;
  bio?: string;
  tarifConsultation?: number;
  dureeConsultDefaut?: number;
  consultationEnLigne?: boolean;
  estDisponible: boolean;
  createdAt: string;
  updatedAt: string;
}

Codes d'erreur : PROFIL_DEJA_EXISTANT | NUMERO_REGISTRE_DEJA_UTILISE | SPECIALITE_INTROUVABLE | DONNEES_INVALIDES

POST /api/v1/praticiens/:id/disponibilites

Corps : 

{
  jourSemaine?: 0 | 1 | 2 | 3 | 4 | 5 | 6;   // 0 = dimanche
  dateSpecifique?: string;                       // ISO8601 — pour un créneau ponctuel
  heureDebut: string;                           // obligatoire — format "HH:mm"
  heureFin: string;                             // obligatoire — format "HH:mm"
  actif?: boolean;
}

Codes d'erreur : HEURE_INVALIDE | JOUR_INVALIDE | DATE_SPECIFIQUE_REQUISE | DISPONIBILITE_INTROUVABLE

MODULE RENDEZ-VOUS — /api/v1/rendez-vous

Toutes les routes sont authentifiées.

Table des routes

Méthode Path Description
GET /creneaux Obtenir les créneaux disponibles
GET /praticien/:praticienId RDV d'un praticien
GET /patient/:patientId RDV d'un patient
POST / Prendre un rendez-vous
GET /:id Obtenir un RDV
PATCH /:id/confirmer Confirmer un RDV
PATCH /:id/annuler Annuler un RDV
PATCH /:id/terminer Marquer terminé
PATCH /:id/absence Marquer comme absence
PATCH /:id/rappel Envoyer un rappel

GET /api/v1/rendez-vous/creneaux

Query params : 

praticienId: string;                              // obligatoire
date: string;                                     // obligatoire — ISO8601
typeConsultation?: 'PRESENTIEL' | 'VISIOCONFERENCE';
dureeMinutes?: number;

Réponse succès — data : 

{
  creneaux: {
    heureDebut: string;
    heureFin: string;
    dateHeure: string;
    typeConsultation: 'PRESENTIEL' | 'VISIOCONFERENCE';
  }[];
}

POST /api/v1/rendez-vous/

Corps : 

{
  patientId: string;                            // obligatoire — CUID patient
  praticienId: string;                          // obligatoire — CUID praticien
  dateHeure: string;                            // obligatoire — ISO8601
  typeConsultation: 'PRESENTIEL' | 'VISIOCONFERENCE';  // obligatoire
  dureeMinutes?: number;
  lienVisio?: string;                           // requis si VISIOCONFERENCE
  notePatient?: string;
}

RendezVousPublicDTO : 

{
  id: string;
  patientId: string;
  praticienId: string;
  dateHeure: string;
  dureeMinutes: number;
  typeConsultation: 'PRESENTIEL' | 'VISIOCONFERENCE';
  statut: 'EN_ATTENTE' | 'CONFIRME' | 'TERMINE' | 'ANNULE' | 'ABSENCE';
  lienVisio?: string;
  notePatient?: string;
  rappelEnvoye: boolean;
  createdAt: string;
  updatedAt: string;
}

Codes d'erreur : DATE_PASSEE | MEDECIN_NON_DISPONIBLE | CRENEAU_INDISPONIBLE | CRENEAU_DEJA_PRIS | DONNEES_INVALIDES

PATCH /api/v1/rendez-vous/:id/[action]

Toutes les actions de transition d'état (confirmer, annuler, terminer, absence, rappel) prennent le même format :

Corps : {} (vide ou métadonnées optionnelles selon l'action)

Réponse succès — data : 

{ rendezVous: RendezVousPublicDTO }

Code d'erreur commun : TRANSITION_INVALIDE — la transition demandée n'est pas autorisée depuis l'état actuel.

MODULE CONSULTATIONS — /api/v1/consultations

Toutes les routes sont authentifiées. #consultation

Table des routes

Méthode Path Description
GET /praticien/:praticienId Consultations d'un praticien
GET /patient/:patientId Consultations d'un patient
POST / Ouvrir une consultation
GET /:id Obtenir une consultation
PUT /:id Mettre à jour
PATCH /:id/archiver Archiver
POST /:id/enregistrements Ajouter un enregistrement
DELETE /:id/enregistrements/:enrId Supprimer un enregistrement

POST /api/v1/consultations/

Ouvre une consultation depuis un RDV terminé. Le flux est : RDV terminé → Consultation → Facture.

Corps : 

{
  rendezVousId: string;     // obligatoire — CUID du RDV (doit être à l'état TERMINE)
  notesPraticien?: string;
  diagnostic?: string;
  traitement?: string;
  suiviPrevu?: string;
}

ConsultationPublicDTO : 

{
  id: string;
  rendezVousId: string;
  notesPraticien?: string;
  diagnostic?: string;
  traitement?: string;
  suiviPrevu?: string;
  estArchivee: boolean;
  enregistrements: {
    id: string;
    consultationId: string;
    type: string;
    cheminFichier: string;
    tailleFichier: number;
    dureeSecondes?: number;
    createdAt: string;
  }[];
  createdAt: string;
  updatedAt: string;
}

Codes d'erreur : RENDEZVOUS_INTROUVABLE | RENDEZVOUS_NON_TERMINE | CONSULTATION_DEJA_EXISTANTE | DONNEES_INVALIDES

PUT /api/v1/consultations/:id

Corps : 

{
  notesPraticien?: string;
  diagnostic?: string;
  traitement?: string;
  suiviPrevu?: string;
}

Code d'erreur : CONSULTATION_ARCHIVEE — impossible de modifier une consultation archivée.

MODULE FACTURATION — /api/v1/facturation

Toutes les routes sont authentifiées. Flux : Consultation → Facture → Paiement(s). #facturation

Table des routes

Méthode Path Description
GET / Lister les factures
POST / Générer une facture
POST /payer Enregistrer un paiement
GET /:id Obtenir une facture
DELETE /:id Annuler une facture

POST /api/v1/facturation/ (Générer)

Corps : 

{
  consultationId: string;     // obligatoire — CUID consultation
  idUtilisateur: string;      // obligatoire — CUID de l'utilisateur effectuant l'action
}

FactureDTO : 

{
  id: string;
  consultationId: string;
  numero: string;             // ex: "FAC-2026-0001"
  montantHT: number;
  tauxTVA: number;
  montantTVA: number;
  montantTTC: number;
  statut: 'EN_ATTENTE' | 'PARTIELLE' | 'PAYEE' | 'ANNULEE';
  dateEcheance: string;
  notes?: string;
  createdAt: string;
  updatedAt: string;
}

Codes d'erreur : FACTURE_DEJA_EXISTANTE | CONSULTATION_INTROUVABLE | PRATICIEN_INTROUVABLE | CONSULTATION_SANS_FACTURE

POST /api/v1/facturation/payer

Corps : 

{
  factureId: string;                                // obligatoire
  montant: number;                                  // obligatoire
  methode: 'ESPECES' | 'CARTE' | 'VIREMENT' | 'CHEQUE' | 'MOBILE_MONEY';  // obligatoire
  reference?: string;
  idUtilisateur: string;                            // obligatoire
}

Réponse succès — data : FactureAvecPaiementsDTO

// FactureAvecPaiementsDTO extends FactureDTO
{
  ...FactureDTO,
  paiements: {
    id: string;
    factureId: string;
    montant: number;
    methode: string;
    reference?: string;
    createdAt: string;
  }[];
  totalPaye: number;
  resteADouer: number;
}

Codes d'erreur : PAIEMENT_EXCEDE_RESTE_DU | FACTURE_ANNULEE | FACTURE_INTROUVABLE | DONNEES_INVALIDES

GET /api/v1/facturation/

Query params : 

idUtilisateur: string;    // obligatoire
patientId?: string;
praticienId?: string;

Réponse succès — data : FactureDTO[]

MODULE NOTIFICATIONS — /api/v1/notifications

Toutes les routes sont authentifiées.

Table des routes

Méthode Path Description
POST / Envoyer une notification
GET / Lister les notifications de l'utilisateur
POST /:id/lire Marquer une notification comme lue

POST /api/v1/notifications/

Corps : 

{
  destinataireId: string;                         // obligatoire — CUID utilisateur
  canal: 'EMAIL' | 'IN_APP';                      // obligatoire
  sujet: string;                                  // obligatoire
  contenu: string;                                // obligatoire
  emailDestinataire?: string;                     // requis si canal = EMAIL
  typeNotification?: 'ALERTE' | 'INFO' | 'RAPPEL';
}

Réponse succès — data : 

{ notificationId: string; }

Codes d'erreur : DONNEES_INVALIDES | SERVICE_INDISPONIBLE | ERREUR_SERVEUR

GET /api/v1/notifications/

Query params : 

utilisateurId: string;              // obligatoire
statut?: 'NON_LUE' | 'LUE';
page?: number;
limite?: number;

Réponse succès — data : 

{
  notifications: {
    id: string;
    utilisateurId: string;
    type: string;
    titre: string;
    contenu: string;
    statut: 'NON_LUE' | 'LUE';
    dateCreation: string;
    dateLecture?: string;
  }[];
  total: number;
  page: number;
  totalPages: number;
}

POST /api/v1/notifications/:id/lire

Corps : 

{ utilisateurId: string; }    // obligatoire

Codes d'erreur : NOTIFICATION_INTROUVABLE | ACTION_NON_AUTORISEE

Flux métier principaux

INSCRIPTION → verify-email → CONNEXION → (2FA ?) → ACCESS TOKEN
ACCESS TOKEN → refresh (avant expiration) → NOUVEAU TOKEN
RDV → confirmer → terminer → CONSULTATION → FACTURE → payer
Flux Étapes
Onboarding POST /register → POST /verify-email → POST /connexion
Connexion 2FA POST /connexion (reçoit sessionId) → POST /2fa/verify (reçoit tokens)
Prise de RDV GET /creneaux → POST /rendez-vous → PATCH /:id/confirmer
Facturation PATCH /rendez-vous/:id/terminer → POST /consultations → POST /facturation → POST /facturation/payer

Décision / Conclusion

Ce document est la référence contractuelle entre le backend et le frontend. Les IDs sont des CUIDs (jamais des UUIDs) — ne pas valider avec uuid(). Les tokens JWT sont stockés côté client (localStorage ou cookie httpOnly selon la stratégie de sécurité).

Convention des préfixes (mis à jour 20260505) : - Module Auth : /api/auth (sans /v1) - Modules admin (Utilisateurs, Rôles, Permissions) : /api/admin/... (sans /v1) - Tous les autres modules : /api/v1/{module}

À faire

  • [ ] Vérifier les champs exacts des enums Sexe, GroupeSanguin, MethodePaiement dans les schémas Prisma
  • [ ] Documenter les headers d'authentification (Authorization: Bearer <token>)
  • [ ] Documenter les routes GET /:id de chaque module (structure identique aux créations)
  • [x] Corriger les préfixes admin : /api/v1/utilisateurs → /api/admin/users, etc. (20260505)

Liens connexes