feat: Intégration du backend NestJS depuis YNOV

- Framework: NestJS avec TypeORM
- Authentification: JWT (access + refresh tokens)
- Gestion utilisateurs: CRUD complet avec validation
- Routes: auth, users, parents, assistantes maternelles
- Dockerfile pour conteneurisation

backend/src/routes/user/dto/create_admin.dto.ts

@@ -0,0 +1,4 @@
+import { OmitType } from "@nestjs/swagger";
+import { CreateUserDto } from "./create_user.dto";
+
+export class CreateAdminDto extends OmitType(CreateUserDto, ['role'] as const) {}

backend/src/routes/user/dto/create_assistante.dto.ts

@@ -0,0 +1,56 @@
+import { OmitType } from "@nestjs/swagger";
+import { IsBoolean, IsDateString, IsInt, IsNotEmpty, IsOptional, IsString, IsUUID, Length, Matches, Max, Min } from "class-validator";
+import { CreateUserDto } from "./create_user.dto";
+
+export class CreateAssistanteDto extends OmitType(CreateUserDto, ['role', 'photo_url', 'consentement_photo'] as const) {
+    @IsUUID()
+    @IsNotEmpty()
+    user_id?: string;
+
+    @IsString()
+    @IsNotEmpty()
+    @Length(1, 50)
+    approval_number: string;
+
+    @Matches(/^\d{15}$/)
+    @IsNotEmpty()
+    nir: string;
+
+    @IsInt()
+    @Min(1)
+    @Max(10)
+    @IsNotEmpty()
+    max_children: number;
+
+    @IsString()
+    @IsNotEmpty()
+    photo_url: string;
+
+    @IsBoolean()
+    @IsNotEmpty()
+    consentement_photo: boolean;
+
+    @IsDateString()
+    @IsNotEmpty()
+    agreement_date: string;
+
+    @IsString()
+    @IsNotEmpty()
+    @Length(1, 100)
+    residence_city: string;
+
+    @IsOptional()
+    biography?: string;
+
+    @IsOptional()
+    available?: boolean;
+
+    @IsOptional()
+    years_experience?: number;
+
+    @IsOptional()
+    specialty?: string;
+
+    @IsOptional()
+    places_available?: number;
+}

backend/src/routes/user/dto/create_gestionnaire.dto.ts

@@ -0,0 +1,4 @@
+import { OmitType } from "@nestjs/swagger";
+import { CreateUserDto } from "./create_user.dto";
+
+export class CreateGestionnaireDto extends OmitType(CreateUserDto, ['role'] as const) {}

backend/src/routes/user/dto/create_parent.dto.ts

@@ -0,0 +1,17 @@
+import { OmitType } from "@nestjs/swagger";
+import { CreateUserDto } from "./create_user.dto";
+import { IsNotEmpty, IsOptional, IsString, IsUUID } from "class-validator";
+
+export class CreateParentDto extends OmitType(CreateUserDto, ['role', 'photo_url'] as const) {
+    @IsUUID()
+    @IsNotEmpty()
+    user_id: string;
+
+    @IsOptional()
+    @IsUUID()
+    co_parent_id?: string;
+
+    @IsString()
+    @IsNotEmpty()
+    photo_url: string;
+}

backend/src/routes/user/dto/create_user.dto.ts

@@ -0,0 +1,105 @@
+import { ApiProperty } from '@nestjs/swagger';
+import {
+  IsBoolean,
+  IsDateString,
+  IsEmail,
+  IsEnum,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  MinLength,
+  MaxLength,
+} from 'class-validator';
+import { RoleType, GenreType, StatutUtilisateurType, SituationFamilialeType } from 'src/entities/users.entity';
+
+export class CreateUserDto {
+  @ApiProperty({ example: 'sosso.test@example.com' })
+  @IsEmail()
+  @IsNotEmpty()
+  email: string;
+
+  @ApiProperty({ minLength: 6, example: 'Mon_motdepasse_fort_1234?' })
+  @IsString()
+  @IsNotEmpty()
+  @MinLength(6)
+  password: string;
+
+  @ApiProperty({ example: 'Julien' })
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(100)
+  prenom: string;
+
+  @ApiProperty({ example: 'Dupont' })
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(100)
+  nom: string;
+
+  @ApiProperty({ enum: GenreType, required: false, default: GenreType.AUTRE })
+  @IsOptional()
+  @IsEnum(GenreType)
+  genre?: GenreType = GenreType.AUTRE;
+
+  @ApiProperty({ enum: RoleType })
+  @IsEnum(RoleType)
+  role: RoleType;
+
+  @ApiProperty({ enum: StatutUtilisateurType, required: false, default: StatutUtilisateurType.EN_ATTENTE })
+  @IsOptional()
+  @IsEnum(StatutUtilisateurType)
+  statut?: StatutUtilisateurType = StatutUtilisateurType.EN_ATTENTE;
+
+  @ApiProperty({ example: SituationFamilialeType.MARIE, required: false, enum: SituationFamilialeType, default: SituationFamilialeType.MARIE})
+  @IsOptional()
+  @IsEnum(SituationFamilialeType)
+  situation_familiale?: SituationFamilialeType;
+
+  @ApiProperty({ example: '+33123456789' })
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(20)
+  telephone: string;
+
+  @ApiProperty({ example: 'Paris', required: false })
+  @IsOptional()
+  @IsString()
+  @MaxLength(150)
+  ville?: string;
+
+  @ApiProperty({ example: '75000', required: false })
+  @IsOptional()
+  @IsString()
+  @MaxLength(10)
+  code_postal?: string;
+
+  @ApiProperty({ example: '10 rue de la paix, 75000 Paris' })
+  @IsString()
+  @IsNotEmpty()
+  adresse: string;
+
+  @ApiProperty({ example: 'https://example.com/photo.jpg', required: false })
+  @IsOptional()
+  @IsString()
+  photo_url?: string;
+
+  @ApiProperty({ default: false })
+  @IsOptional()
+  @IsBoolean()
+  consentement_photo?: boolean = false;
+
+  @ApiProperty({ required: false })
+  @IsOptional()
+  @IsDateString({}, { message: 'date_consentement_photo doit être une date ISO valide' })
+  date_consentement_photo?: string | null;
+
+  @ApiProperty({ default: false })
+  @IsOptional()
+  @IsBoolean()
+  changement_mdp_obligatoire?: boolean = false;
+
+  @ApiProperty({ example: true })
+  @IsBoolean()
+  @IsNotEmpty()
+  cguAccepted: boolean;
+}

backend/src/routes/user/dto/update_admin.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from "@nestjs/swagger";
+import { CreateAdminDto } from "./create_admin.dto";
+
+export class UpdateAdminDto extends PartialType(CreateAdminDto) {} 

backend/src/routes/user/dto/update_assistante.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from "@nestjs/swagger";
+import { CreateAssistanteDto } from "./create_assistante.dto";
+
+export class UpdateAssistanteDto extends PartialType(CreateAssistanteDto) {}

backend/src/routes/user/dto/update_gestionnaire.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from "@nestjs/swagger";
+import { CreateGestionnaireDto } from "./create_gestionnaire.dto";
+
+export class UpdateGestionnaireDto extends PartialType(CreateGestionnaireDto) {}

backend/src/routes/user/dto/update_parent.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from "@nestjs/swagger";
+import { CreateParentDto } from "./create_parent.dto";
+
+export class UpdateParentsDto extends PartialType(CreateParentDto) {}

backend/src/routes/user/dto/update_user.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from "@nestjs/swagger";
+import { CreateUserDto } from "./create_user.dto";
+
+export class UpdateUserDto extends PartialType(CreateUserDto) {}

backend/src/routes/user/gestionnaires/gestionnaires.controller.spec.ts

@@ -0,0 +1,20 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { GestionnairesController } from './gestionnaires.controller';
+import { GestionnairesService } from './gestionnaires.service';
+
+describe('GestionnairesController', () => {
+  let controller: GestionnairesController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [GestionnairesController],
+      providers: [GestionnairesService],
+    }).compile();
+
+    controller = module.get<GestionnairesController>(GestionnairesController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

backend/src/routes/user/gestionnaires/gestionnaires.controller.ts

@@ -0,0 +1,73 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Body,
+  Patch,
+  Param,
+  Delete,
+  UseGuards,
+} from '@nestjs/common';
+import { GestionnairesService } from './gestionnaires.service';
+import { RoleType, Users } from 'src/entities/users.entity';
+import { Roles } from 'src/common/decorators/roles.decorator';
+import { UpdateGestionnaireDto } from '../dto/update_gestionnaire.dto';
+import { CreateGestionnaireDto } from '../dto/create_gestionnaire.dto';
+import { RolesGuard } from 'src/common/guards/roles.guard';
+import { ApiBearerAuth, ApiBody, ApiOperation, ApiParam, ApiResponse, ApiTags } from '@nestjs/swagger';
+import { AuthGuard } from 'src/common/guards/auth.guard';
+
+
+@ApiTags('Gestionnaires')
+@ApiBearerAuth('access-token')
+@UseGuards(AuthGuard, RolesGuard)
+@Controller('gestionnaires')
+export class GestionnairesController {
+  constructor(private readonly gestionnairesService: GestionnairesService) { }
+
+  @Roles(RoleType.SUPER_ADMIN)
+  @ApiResponse({ status: 201, description: 'Le gestionnaire a été créé avec succès.', type: Users })
+  @ApiResponse({ status: 409, description: 'Conflit. L\'email est déjà utilisé.' })
+  @ApiOperation({ summary: 'Création d\'un gestionnaire' })
+  @ApiBody({ type: CreateGestionnaireDto })
+  @Post()
+  create(@Body() dto: CreateGestionnaireDto): Promise<Users> {
+    return this.gestionnairesService.create(dto);
+  }
+
+  @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE)
+  @ApiOperation({ summary: 'Liste des gestionnaires' })
+  @ApiResponse({ status: 200, description: 'Liste des gestionnaires : ', type: [Users] })
+  @Get()
+  getAll(): Promise<Users[]> {
+    return this.gestionnairesService.findAll();
+  }
+
+  @Roles(RoleType.GESTIONNAIRE, RoleType.SUPER_ADMIN)
+  @ApiOperation({ summary: 'Récupérer un gestionnaire par ID' })
+  @ApiResponse({ status: 400, description: 'ID invalide' })
+  @ApiResponse({ status: 403, description: 'Accès refusé' })
+  @ApiResponse({ status: 401, description: 'Non authentifié' })
+  @ApiParam({ name: 'id', description: 'ID du gestionnaire' })
+  @ApiResponse({ status: 200, description: 'Gestionnaire trouvé', type: Users })
+  @ApiResponse({ status: 404, description: 'Gestionnaire non trouvé' })
+  @Get(':id')
+  findOne(@Param('id') id: string): Promise<Users> {
+    return this.gestionnairesService.findOne(id);
+  }
+
+  @Roles(RoleType.SUPER_ADMIN)
+  @ApiOperation({ summary: 'Mettre à jour un gestionnaire' })
+  @ApiResponse({ status: 200, description: 'Le gestionnaire a été mis à jour avec succès.', type: Users })
+  @ApiResponse({ status: 404, description: 'Gestionnaire non trouvé' })
+  @ApiResponse({ status: 403, description: 'Accès refusé' })
+  @ApiResponse({ status: 401, description: 'Non authentifié' })
+  @ApiParam({ name: 'id', description: 'ID du gestionnaire' })
+  @Patch(':id')
+  update(
+    @Param('id') id: string,
+    @Body() dto: UpdateGestionnaireDto,
+  ): Promise<Users | null> {
+    return this.gestionnairesService.update(id, dto);
+  }
+}

backend/src/routes/user/gestionnaires/gestionnaires.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { GestionnairesService } from './gestionnaires.service';
+import { GestionnairesController } from './gestionnaires.controller';
+import { Users } from 'src/entities/users.entity';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Users])],
+  controllers: [GestionnairesController],
+  providers: [GestionnairesService],
+})
+export class GestionnairesModule { }

backend/src/routes/user/gestionnaires/gestionnaires.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { GestionnairesService } from './gestionnaires.service';
+
+describe('GestionnairesService', () => {
+  let service: GestionnairesService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [GestionnairesService],
+    }).compile();
+
+    service = module.get<GestionnairesService>(GestionnairesService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

backend/src/routes/user/gestionnaires/gestionnaires.service.ts

@@ -0,0 +1,87 @@
+import {
+  ConflictException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { RoleType, Users } from 'src/entities/users.entity';
+import { CreateGestionnaireDto } from '../dto/create_gestionnaire.dto';
+import { UpdateGestionnaireDto } from '../dto/update_gestionnaire.dto';
+import * as bcrypt from 'bcrypt';
+
+@Injectable()
+export class GestionnairesService {
+  constructor(
+    @InjectRepository(Users)
+    private readonly gestionnaireRepository: Repository<Users>,
+  ) { }
+
+  // Création d’un gestionnaire
+  async create(dto: CreateGestionnaireDto): Promise<Users> {
+    const exist = await this.gestionnaireRepository.findOneBy({ email: dto.email });
+    if (exist) throw new ConflictException('Email déjà utilisé');
+
+    const salt = await bcrypt.genSalt();
+    const hashedPassword = await bcrypt.hash(dto.password, salt);
+
+    const entity = this.gestionnaireRepository.create({
+      email: dto.email,
+      password: hashedPassword,
+      prenom: dto.prenom,
+      nom: dto.nom,
+      genre: dto.genre,
+      statut: dto.statut,
+      telephone: dto.telephone,
+      adresse: dto.adresse,
+      photo_url: dto.photo_url,
+      consentement_photo: dto.consentement_photo ?? false,
+      date_consentement_photo: dto.date_consentement_photo
+        ? new Date(dto.date_consentement_photo)
+        : undefined,
+      changement_mdp_obligatoire: dto.changement_mdp_obligatoire ?? false,
+      role: RoleType.GESTIONNAIRE,
+    });
+    return this.gestionnaireRepository.save(entity);
+  }
+
+  // Liste des gestionnaires
+  async findAll(): Promise<Users[]> {
+    return this.gestionnaireRepository.find({ where: { role: RoleType.GESTIONNAIRE } });
+  }
+
+  // Récupérer un gestionnaire par ID
+  async findOne(id: string): Promise<Users> {
+    const gestionnaire = await this.gestionnaireRepository.findOne({
+      where: { id, role: RoleType.GESTIONNAIRE },
+    });
+    if (!gestionnaire) throw new NotFoundException('Gestionnaire introuvable');
+    return gestionnaire;
+  }
+
+  // Mise à jour d’un gestionnaire
+  async update(id: string, dto: UpdateGestionnaireDto): Promise<Users> {
+    const gestionnaire = await this.findOne(id);
+
+    if (dto.password) {
+      const salt = await bcrypt.genSalt();
+      gestionnaire.password = await bcrypt.hash(dto.password, salt);
+    }
+
+    if (dto.date_consentement_photo !== undefined) {
+      gestionnaire.date_consentement_photo = dto.date_consentement_photo
+        ? new Date(dto.date_consentement_photo)
+        : undefined;
+    }
+
+    const { password, date_consentement_photo, ...rest } = dto;
+    Object.entries(rest).forEach(([key, value]) => {
+      if (value !== undefined) {
+        (gestionnaire as any)[key] = value;
+      }
+    });
+
+    return this.gestionnaireRepository.save(gestionnaire);
+  }
+
+}

backend/src/routes/user/user.controller.spec.ts

@@ -0,0 +1,20 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { UserController } from './user.controller';
+import { UserService } from './user.service';
+
+describe('UserController', () => {
+  let controller: UserController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [UserController],
+      providers: [UserService],
+    }).compile();
+
+    controller = module.get<UserController>(UserController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

backend/src/routes/user/user.controller.ts

@@ -0,0 +1,94 @@
+import { Body, Controller, Delete, Get, Param, Patch, Post, UseGuards } from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiParam, ApiResponse, ApiTags } from '@nestjs/swagger';
+import { AuthGuard } from 'src/common/guards/auth.guard';
+import { Roles } from 'src/common/decorators/roles.decorator';
+import { User } from 'src/common/decorators/user.decorator';
+import { RoleType, Users } from 'src/entities/users.entity';
+import { UserService } from './user.service';
+import { CreateUserDto } from './dto/create_user.dto';
+import { UpdateUserDto } from './dto/update_user.dto';
+
+@ApiTags('Utilisateurs')
+@ApiBearerAuth('access-token')
+@UseGuards(AuthGuard)
+@Controller('users')
+export class UserController {
+  constructor(private readonly userService: UserService) { }
+
+  // Création d'un utilisateur (réservée aux super admins)
+  @Post()
+  @Roles(RoleType.SUPER_ADMIN)
+  @ApiOperation({ summary: 'Créer un nouvel utilisateur (super admin seulement)' })
+  createUser(
+    @Body() dto: CreateUserDto,
+    @User() currentUser: Users
+  ) {
+    return this.userService.createUser(dto, currentUser);
+  }
+
+  // Lister tous les utilisateurs (super_admin uniquement)
+  @Get()
+  @Roles(RoleType.SUPER_ADMIN)
+  @ApiOperation({ summary: 'Lister tous les utilisateurs' })
+  findAll() {
+    return this.userService.findAll();
+  }
+
+  // Récupérer un utilisateur par son ID
+  @Get(':id')
+  @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE)
+  @ApiOperation({ summary: 'Trouver un utilisateur par son id' })
+  @ApiParam({ name: 'id', description: "UUID de l'utilisateur" })
+  findOne(@Param('id') id: string) {
+    return this.userService.findOne(id);
+  }
+
+  // Modifier un utilisateur (réservé super_admin)
+  @Patch(':id')
+  @Roles(RoleType.SUPER_ADMIN)
+  @ApiOperation({ summary: 'Mettre à jour un utilisateur' })
+  @ApiParam({ name: 'id', description: "UUID de l'utilisateur" })
+  updateUser(
+    @Param('id') id: string,
+    @Body() dto: UpdateUserDto,
+    @User() currentUser: Users
+  ) {
+    return this.userService.updateUser(id, dto, currentUser);
+  }
+
+  @Patch(':id/valider')
+  @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE, RoleType.ADMINISTRATEUR)
+  @ApiOperation({ summary: 'Valider un compte utilisateur' })
+  @ApiParam({ name: 'id', description: "UUID de l'utilisateur" })
+  @ApiResponse({ status: 400, description: 'ID invalide' })
+  @ApiResponse({ status: 403, description: 'Accès refusé' })
+  @ApiResponse({ status: 200, description: 'Compte validé avec succès' })
+  validate(
+    @Param('id') id: string,
+    @User() currentUser: Users,
+    @Body('comment') comment?: string,
+  ) {
+    return this.userService.validateUser(id, currentUser, comment);
+  }
+
+  @Patch(':id/suspendre')
+  @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE, RoleType.ADMINISTRATEUR)
+  @ApiOperation({ summary: 'Suspendre un compte utilisateur' })
+  @ApiParam({ name: 'id', description: "UUID de l'utilisateur" })
+  suspend(
+    @Param('id') id: string,
+    @User() currentUser: Users,
+    @Body('comment') comment?: string,
+  ) {
+    return this.userService.suspendUser(id, currentUser, comment);
+  }
+
+  // Supprimer un utilisateur (super_admin uniquement)
+  @Delete(':id')
+  @Roles(RoleType.SUPER_ADMIN)
+  @ApiOperation({ summary: 'Supprimer un utilisateur' })
+  @ApiParam({ name: 'id', description: "UUID de l'utilisateur" })
+  remove(@Param('id') id: string, @User() currentUser: Users) {
+    return this.userService.remove(id, currentUser);
+  }
+}

backend/src/routes/user/user.module.ts

@@ -0,0 +1,28 @@
+import { forwardRef, Module } from '@nestjs/common';
+import { UserController } from './user.controller';
+import { UserService } from './user.service';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { Users } from 'src/entities/users.entity';
+import { AuthModule } from '../auth/auth.module';
+import { Validation } from 'src/entities/validations.entity';
+import { ParentsModule } from '../parents/parents.module';
+import { AssistanteMaternelle } from 'src/entities/assistantes_maternelles.entity';
+import { AssistantesMaternellesModule } from '../assistantes_maternelles/assistantes_maternelles.module';
+import { Parents } from 'src/entities/parents.entity';
+
+@Module({
+  imports: [TypeOrmModule.forFeature(
+    [
+      Users,
+      Validation,
+      Parents,
+      AssistanteMaternelle,
+    ]), forwardRef(() => AuthModule),
+    ParentsModule,
+    AssistantesMaternellesModule,
+  ],
+  controllers: [UserController],
+  providers: [UserService],
+  exports: [UserService],
+})
+export class UserModule { }

backend/src/routes/user/user.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { UserService } from './user.service';
+
+describe('UserService', () => {
+  let service: UserService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [UserService],
+    }).compile();
+
+    service = module.get<UserService>(UserService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

backend/src/routes/user/user.service.ts

@@ -0,0 +1,233 @@
+import { BadRequestException, ForbiddenException, Injectable, NotFoundException } from "@nestjs/common";
+import { InjectRepository } from "@nestjs/typeorm";
+import { RoleType, StatutUtilisateurType, Users } from "src/entities/users.entity";
+import { In, Repository } from "typeorm";
+import { CreateUserDto } from "./dto/create_user.dto";
+import { UpdateUserDto } from "./dto/update_user.dto";
+import * as bcrypt from 'bcrypt';
+import { StatutValidationType, Validation } from "src/entities/validations.entity";
+import { Parents } from "src/entities/parents.entity";
+import { AssistanteMaternelle } from "src/entities/assistantes_maternelles.entity";
+
+@Injectable()
+export class UserService {
+    constructor(
+        @InjectRepository(Users)
+        private readonly usersRepository: Repository<Users>,
+
+        @InjectRepository(Validation)
+        private readonly validationRepository: Repository<Validation>,
+
+        @InjectRepository(Parents)
+        private readonly parentsRepository: Repository<Parents>,
+
+        @InjectRepository(AssistanteMaternelle)
+        private readonly assistantesRepository: Repository<AssistanteMaternelle>
+    ) { }
+
+    async createUser(dto: CreateUserDto, currentUser?: Users): Promise<Users> {
+        if (!dto.cguAccepted) {
+            throw new BadRequestException(
+                'Vous devez accepter les CGU et la Politique de confidentialité pour créer un compte.',
+            );
+        }
+
+        const exist = await this.usersRepository.findOneBy({ email: dto.email });
+        if (exist) throw new BadRequestException('Email déjà utilisé');
+
+        const isSuperAdmin = currentUser?.role === RoleType.SUPER_ADMIN;
+        const isAdmin = currentUser?.role === RoleType.ADMINISTRATEUR;
+
+        let role: RoleType;
+
+        if (dto.role === RoleType.GESTIONNAIRE) {
+            if (!isAdmin && !isSuperAdmin) {
+                throw new ForbiddenException('Seuls les administrateurs peuvent créer un gestionnaire');
+            }
+            role = RoleType.GESTIONNAIRE;
+        } else if (dto.role === RoleType.ADMINISTRATEUR) {
+            if (!isAdmin && !isSuperAdmin) {
+                throw new ForbiddenException('Seuls les administrateurs peuvent créer un administrateur');
+            }
+            role = RoleType.ADMINISTRATEUR;
+        } else if (dto.role === RoleType.ASSISTANTE_MATERNELLE) {
+            role = RoleType.ASSISTANTE_MATERNELLE;
+            if (!dto.photo_url) {
+                throw new BadRequestException(
+                    'La photo de profil est obligatoire pour les assistantes maternelles.',
+                );
+            }
+        } else {
+            role = RoleType.PARENT;
+        }
+
+        const statut = isSuperAdmin
+            ? dto.statut ?? StatutUtilisateurType.EN_ATTENTE
+            : StatutUtilisateurType.EN_ATTENTE;
+
+        if (!dto.nom?.trim()) throw new BadRequestException('Nom est obligatoire.');
+        if (!dto.prenom?.trim()) throw new BadRequestException('Prénom est obligatoire.');
+        if (!dto.adresse?.trim()) throw new BadRequestException('Adresse est obligatoire.');
+        if (!dto.telephone?.trim()) throw new BadRequestException('Téléphone est obligatoire.');
+
+        let consentDate: Date | undefined;
+        if (dto.consentement_photo && dto.date_consentement_photo) {
+            const parsed = new Date(dto.date_consentement_photo);
+            if (!isNaN(parsed.getTime())) {
+                consentDate = parsed;
+            }
+        }
+
+        const salt = await bcrypt.genSalt();
+        const hashedPassword = await bcrypt.hash(dto.password, salt);
+
+        const entity = this.usersRepository.create({
+            email: dto.email,
+            password: hashedPassword,
+            prenom: dto.prenom,
+            nom: dto.nom,
+            role,
+            statut,
+            genre: dto.genre,
+            telephone: dto.telephone,
+            ville: dto.ville,
+            code_postal: dto.code_postal,
+            adresse: dto.adresse,
+            photo_url: dto.photo_url,
+            consentement_photo: dto.consentement_photo ?? false,
+            date_consentement_photo: consentDate,
+            changement_mdp_obligatoire:
+                role === RoleType.ADMINISTRATEUR || role === RoleType.GESTIONNAIRE
+                    ? true
+                    : dto.changement_mdp_obligatoire ?? false,
+        });
+
+        const saved = await this.usersRepository.save(entity);
+        return this.findOne(saved.id);
+    }
+
+    async findAll(): Promise<Users[]> {
+        return this.usersRepository.find();
+    }
+
+    async findOneBy(where: Partial<Users>): Promise<Users | null> {
+        return this.usersRepository.findOne({ where });
+    }
+
+    async findOne(id: string): Promise<Users> {
+        const user = await this.usersRepository.findOne({ where: { id } });
+        if (!user) {
+            throw new NotFoundException('Utilisateur introuvable');
+        }
+        return user;
+    }
+
+    async findByEmailOrNull(email: string): Promise<Users | null> {
+        return this.usersRepository.findOne({ where: { email } });
+    }
+
+    async updateUser(id: string, dto: UpdateUserDto, currentUser: Users): Promise<Users> {
+        const user = await this.findOne(id);
+
+        // Interdire changement de rôle si pas super admin
+        if (dto.role && currentUser.role !== RoleType.SUPER_ADMIN) {
+            throw new ForbiddenException('Accès réservé aux super admins');
+        }
+
+        // Empêcher de modifier le flag changement_mdp_obligatoire pour admin/gestionnaire
+        if (
+            (user.role === RoleType.ADMINISTRATEUR || user.role === RoleType.GESTIONNAIRE) &&
+            dto.changement_mdp_obligatoire === false
+        ) {
+            throw new ForbiddenException(
+                'Impossible de désactiver l’obligation de changement de mot de passe pour ce rôle',
+            );
+        }
+
+        // Gestion du mot de passe
+        if (dto.password) {
+            const salt = await bcrypt.genSalt();
+            user.password = await bcrypt.hash(dto.password, salt);
+            delete (dto as any).password;
+            // Une fois le mot de passe changé, on peut lever l’obligation
+            user.changement_mdp_obligatoire = false;
+        }
+
+        // Conversion de la date de consentement
+        if (dto.date_consentement_photo !== undefined) {
+            user.date_consentement_photo = dto.date_consentement_photo
+                ? new Date(dto.date_consentement_photo)
+                : undefined;
+            delete (dto as any).date_consentement_photo;
+        }
+
+        Object.assign(user, dto);
+        return this.usersRepository.save(user);
+    }
+
+    // Valider un compte utilisateur
+    async validateUser(user_id: string, currentUser: Users, comment?: string): Promise<Users> {
+        if (![RoleType.SUPER_ADMIN, RoleType.ADMINISTRATEUR, RoleType.GESTIONNAIRE].includes(currentUser.role)) {
+            throw new ForbiddenException('Accès réservé aux super admins, administrateurs et gestionnaires');
+        }
+
+        const user = await this.usersRepository.findOne({ where: { id: user_id } });
+        if (!user) throw new NotFoundException('Utilisateur introuvable');
+       
+        user.statut = StatutUtilisateurType.ACTIF;
+        const savedUser = await this.usersRepository.save(user);
+        if (user.role === RoleType.PARENT) {
+            const existParent = await this.parentsRepository.findOneBy({ user_id: user.id });
+            if (!existParent) {
+                const parentEntity = this.parentsRepository.create({ user_id: user.id, user });
+                await this.parentsRepository.save(parentEntity);
+            }
+        } else if (user.role === RoleType.ASSISTANTE_MATERNELLE) {
+            const existAssistante = await this.assistantesRepository.findOneBy({ user_id: user.id });
+            if (!existAssistante) {
+                const assistanteEntity = this.assistantesRepository.create({ user_id: user.id, user });
+                await this.assistantesRepository.save(assistanteEntity);
+            }
+        }
+        const validation = this.validationRepository.create({
+            user: savedUser,
+            type: 'validation_compte',
+            status: StatutValidationType.VALIDE,
+            validated_by: currentUser,
+            comment,
+        });
+        await this.validationRepository.save(validation);
+        return savedUser;
+    }
+
+
+    // Mettre un compte en statut suspendu
+    async suspendUser(user_id: string, currentUser: Users, comment?: string): Promise<Users> {
+        if (![RoleType.SUPER_ADMIN, RoleType.ADMINISTRATEUR, RoleType.GESTIONNAIRE].includes(currentUser.role)) {
+            throw new ForbiddenException('Accès réservé aux super admins, administrateurs et gestionnaires');
+        }
+        const user = await this.usersRepository.findOne({ where: { id: user_id } });
+        if (!user) throw new NotFoundException('Utilisateur introuvable');
+        user.statut = StatutUtilisateurType.SUSPENDU;
+        const savedUser = await this.usersRepository.save(user);
+
+        const suspend = this.validationRepository.create({
+            user: savedUser,
+            type: 'suspension_compte',
+            status: StatutValidationType.VALIDE,
+            validated_by: currentUser,
+            comment,
+        })
+        await this.validationRepository.save(suspend);
+        return savedUser;
+    }
+    async remove(id: string, currentUser: Users): Promise<void> {
+        if (currentUser.role !== RoleType.SUPER_ADMIN) {
+            throw new ForbiddenException('Accès réservé aux super admins');
+        }
+        const result = await this.usersRepository.delete(id);
+        if (result.affected === 0) {
+            throw new NotFoundException('Utilisateur introuvable');
+        }
+    }
+}