corrcted routes

src/routes/assistantes_maternelles/assistantes_maternelles.controller.ts

@@ -1,7 +1,14 @@
-import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common';
+import {
+  Controller,
+  Get,
+  Post,
+  Body,
+  Patch,
+  Param,
+  Delete,
+} from '@nestjs/common';
 import { AssistantesMaternellesService } from './assistantes_maternelles.service';
 import { ApiBody, ApiResponse, ApiTags } from '@nestjs/swagger';
-import { BaseController } from 'src/common/base.controller';
 import { AssistanteMaternelle } from 'src/entities/assistantes_maternelles.entity';
 import { Roles } from 'src/common/decorators/roles.decorator';
 import { RoleType } from 'src/entities/users.entity';
@@ -10,51 +17,48 @@ import { UpdateAssistanteDto } from '../user/dto/update_assistante.dto';
 
 @ApiTags("Assistantes Maternelles")
 @Controller('assistantes-maternelles')
-export class AssistantesMaternellesController extends BaseController<AssistanteMaternelle> {
-  constructor(private readonly assistantesMaternellesService: AssistantesMaternellesService) {
-    super(assistantesMaternellesService);
-  }
+export class AssistantesMaternellesController {
+  constructor(private readonly assistantesMaternellesService: AssistantesMaternellesService) {}
 
-  @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE) //Seul les utilisateurs super admin et gestionnaire peuvent accéder à cette route
+  @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE)
   @ApiResponse({ status: 201, description: 'Assistante maternelle créée avec succès' })
-  @ApiResponse({ status: 403, description: 'Accès refusé : Reservé aux super_admins et gestionnaires' })
+  @ApiResponse({ status: 403, description: 'Accès refusé : Réservé aux super_admins et gestionnaires' })
   @ApiBody({ type: CreateAssistanteDto })
   @Post()
   create(@Body() dto: CreateAssistanteDto): Promise<AssistanteMaternelle> {
     return this.assistantesMaternellesService.create(dto);
   }
 
-  //Lister toutes les nounous
-  @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE) //Seul les utilisateurs super admin et gestionnaire peuvent accéder à cette route
+  @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE)
   @Get()
   @ApiResponse({ status: 200, description: 'Liste des assistantes maternelles' })
-  @ApiResponse({ status: 403, description: 'Accès refusé : Reservé aux super_admins et gestionnaires' })
-  override getAll(): Promise<AssistanteMaternelle[]> {
+  @ApiResponse({ status: 403, description: 'Accès refusé : Réservé aux super_admins et gestionnaires' })
+  getAll(): Promise<AssistanteMaternelle[]> {
     return this.assistantesMaternellesService.findAll();
   }
 
-  @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE) //Seul les utilisateurs super admin et gestionnaire peuvent accéder à cette route
+  @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE)
   @Get(':id')
   @ApiResponse({ status: 200, description: 'Détails de l\'assistante maternelle' })
   @ApiResponse({ status: 404, description: 'Assistante maternelle non trouvée' })
-  @ApiResponse({ status: 403, description: 'Accès refusé : Reservé aux super_admins et gestionnaires' })
+  @ApiResponse({ status: 403, description: 'Accès refusé : Réservé aux super_admins et gestionnaires' })
   getOne(@Param('id') user_id: string): Promise<AssistanteMaternelle> {
     return this.assistantesMaternellesService.findOne(user_id);
   }
 
-  @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE) //Seul les utilisateurs super admin et gestionnaire peuvent accéder à cette route
+  @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE)
   @ApiBody({ type: UpdateAssistanteDto })
   @ApiResponse({ status: 200, description: 'Assistante maternelle mise à jour avec succès' })
-  @ApiResponse({ status: 403, description: 'Accès refusé : Reservé aux super_admins et gestionnaires' })
+  @ApiResponse({ status: 403, description: 'Accès refusé : Réservé aux super_admins et gestionnaires' })
   @ApiResponse({ status: 404, description: 'Assistante maternelle non trouvée' })
   @Patch(':id')
   update(@Param('id') id: string, @Body() dto: UpdateAssistanteDto): Promise<AssistanteMaternelle> {
     return this.assistantesMaternellesService.update(id, dto);
   }
 
-  @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE) //Seul les utilisateurs super admin et gestionnaire peuvent accéder à cette route
+  @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE)
   @ApiResponse({ status: 200, description: 'Assistante maternelle supprimée avec succès' })
-  @ApiResponse({ status: 403, description: 'Accès refusé : Reservé aux super_admins et gestionnaires' })
+  @ApiResponse({ status: 403, description: 'Accès refusé : Réservé aux super_admins et gestionnaires' })
   @ApiResponse({ status: 404, description: 'Assistante maternelle non trouvée' })
   @Delete(':id')
   remove(@Param('id') id: string): Promise<void> {

src/routes/assistantes_maternelles/assistantes_maternelles.service.ts

@@ -1,67 +1,77 @@
-import { BadRequestException, ConflictException, Injectable, NotFoundException } from '@nestjs/common';
-import { BaseService } from 'src/common/base.service';
+import {
+  BadRequestException,
+  ConflictException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { DeepPartial, Repository } from 'typeorm';
+import { Repository } from 'typeorm';
 import { RoleType, Users } from 'src/entities/users.entity';
-import { UpdateAssistanteDto } from '../user/dto/update_assistante.dto';
 import { AssistanteMaternelle } from 'src/entities/assistantes_maternelles.entity';
 import { CreateAssistanteDto } from '../user/dto/create_assistante.dto';
+import { UpdateAssistanteDto } from '../user/dto/update_assistante.dto';
 
 @Injectable()
-export class AssistantesMaternellesService extends BaseService<AssistanteMaternelle> {
+export class AssistantesMaternellesService {
   constructor(
     @InjectRepository(AssistanteMaternelle)
     private readonly assistantesMaternelleRepository: Repository<AssistanteMaternelle>,
+    @InjectRepository(Users)
     private readonly usersRepository: Repository<Users>
-  ) {
-    super(assistantesMaternelleRepository);
-  }
+  ) {}
 
-  override async create(data: DeepPartial<AssistanteMaternelle>): Promise<AssistanteMaternelle> {
-    const dto = data as CreateAssistanteDto;
+  // Création d’une assistante maternelle
+  async create(dto: CreateAssistanteDto): Promise<AssistanteMaternelle> {
     const user = await this.usersRepository.findOneBy({ id: dto.user_id });
     if (!user) throw new NotFoundException('Utilisateur introuvable');
-    if (user.role !== RoleType.ASSISTANTE_MATERNELLE) throw new BadRequestException('Acces reserve aux assistantes maternelles');
+    if (user.role !== RoleType.ASSISTANTE_MATERNELLE) {
+      throw new BadRequestException('Accès réservé aux assistantes maternelles');
+    }
+
     const exist = await this.assistantesMaternelleRepository.findOneBy({ user_id: dto.user_id });
-    if (exist) throw new ConflictException('Assistante maternelle deja existante');
+    if (exist) throw new ConflictException('Assistante maternelle déjà existante');
 
     const entity = this.assistantesMaternelleRepository.create({
       user_id: dto.user_id,
       user: { ...user, role: RoleType.ASSISTANTE_MATERNELLE },
       approval_number: dto.numero_agrement,
-      birthdate: new Date(dto.date_naissance),
+      birthdate: dto.date_naissance ? new Date(dto.date_naissance) : undefined,
       birthplace_city: dto.ville_naissance,
       birthplace_country: dto.pays_naissance,
       nir: dto.nir_chiffre,
       max_children: dto.nb_max_enfants,
       biography: dto.biographie,
       available: dto.disponible ?? true,
-      city: dto.ville_residence,
-
+      residence_city: dto.ville_residence,
     });
+
     return this.assistantesMaternelleRepository.save(entity);
   }
 
-  override async findAll(): Promise<AssistanteMaternelle[]> {
+  // Liste des assistantes maternelles
+  async findAll(): Promise<AssistanteMaternelle[]> {
     return this.assistantesMaternelleRepository.find({
       relations: ['user'],
     });
   }
 
-  override async findOne(user_id: string): Promise<AssistanteMaternelle> {
-    const assistante_maternelle = await this.assistantesMaternelleRepository.findOne({
+  // Récupérer une assistante maternelle par user_id
+  async findOne(user_id: string): Promise<AssistanteMaternelle> {
+    const assistante = await this.assistantesMaternelleRepository.findOne({
       where: { user_id },
       relations: ['user'],
     });
-    if (!assistante_maternelle) throw new NotFoundException('Assistante maternelle introuvable');
-    return assistante_maternelle;
+    if (!assistante) throw new NotFoundException('Assistante maternelle introuvable');
+    return assistante;
   }
 
+  // Mise à jour
   async update(id: string, dto: UpdateAssistanteDto): Promise<AssistanteMaternelle> {
     await this.assistantesMaternelleRepository.update(id, dto);
     return this.findOne(id);
   }
 
+  // Suppression
   async remove(id: string): Promise<void> {
     await this.assistantesMaternelleRepository.delete(id);
   }

src/routes/gestionnaires/gestionnaires.controller.ts

@@ -1,55 +1,52 @@
-import { Controller, Get, Post, Body, Patch, Param, Delete, ForbiddenException } from '@nestjs/common';
+import {
+  Controller,
+  Get,
+  Post,
+  Body,
+  Patch,
+  Param,
+  Delete,
+} from '@nestjs/common';
 import { GestionnairesService } from './gestionnaires.service';
 import { RoleType, Users } from 'src/entities/users.entity';
-import { ApiBody } from '@nestjs/swagger';
-import { BaseController } from 'src/common/base.controller';
 import { Roles } from 'src/common/decorators/roles.decorator';
 import { UpdateGestionnaireDto } from '../user/dto/update_gestionnaire.dto';
 import { CreateGestionnaireDto } from '../user/dto/create_gestionnaire.dto';
 
 @Controller('gestionnaires')
-export class GestionnairesController extends BaseController<Users> {
-  constructor(private readonly gestionnairesService: GestionnairesService) {
-    super(gestionnairesService);
-  }
+export class GestionnairesController {
+  constructor(private readonly gestionnairesService: GestionnairesService) { }
 
   @Roles(RoleType.SUPER_ADMIN)
   @Post()
-  create(@Body() createGestionnaireDto: CreateGestionnaireDto) {
-    return this.gestionnairesService.create(createGestionnaireDto);
+  create(@Body() dto: CreateGestionnaireDto): Promise<Users> {
+    return this.gestionnairesService.create(dto);
   }
 
-  //Lister tous les gestionnaires
   @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE)
   @Get()
   getAll(): Promise<Users[]> {
-    //Dans gestionnaire service le findAll cherche deja les gestionnaires
-    const gestionnaire = this.gestionnairesService.findAll();
-    return gestionnaire;
+    return this.gestionnairesService.findAll();
   }
 
-  //Récupérer un gestionnaire
   @Roles(RoleType.GESTIONNAIRE, RoleType.SUPER_ADMIN)
   @Get(':id')
-  findOne(@Param('id') id: string) {
+  findOne(@Param('id') id: string): Promise<Users> {
     return this.gestionnairesService.findOne(id);
   }
 
-
-  //Modifier un gestionnaire
   @Roles(RoleType.SUPER_ADMIN)
   @Patch(':id')
   update(
     @Param('id') id: string,
     @Body() dto: UpdateGestionnaireDto,
-  ) {
-    const update_gestionnaire = this.gestionnairesService.update(id, dto);
-    return update_gestionnaire;
+  ): Promise<Users | null> {
+    return this.gestionnairesService.update(id, dto);
   }
 
   @Roles(RoleType.SUPER_ADMIN)
   @Delete(':id')
-  remove(@Param('id') id: string) {
+  remove(@Param('id') id: string): Promise<void> {
     return this.gestionnairesService.remove(id);
   }
 }

src/routes/gestionnaires/gestionnaires.service.ts

@@ -1,50 +1,88 @@
-import { ConflictException, ForbiddenException, Injectable, NotFoundException } from '@nestjs/common';
-import { BaseService } from 'src/common/base.service';
+import {
+  ConflictException,
+  ForbiddenException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 import { RoleType, Users } from 'src/entities/users.entity';
-import { InjectRepository } from '@nestjs/typeorm';
-import { UpdateGestionnaireDto } from '../user/dto/update_gestionnaire.dto';
 import { CreateGestionnaireDto } from '../user/dto/create_gestionnaire.dto';
+import { UpdateGestionnaireDto } from '../user/dto/update_gestionnaire.dto';
+import * as bcrypt from 'bcrypt';
 
 @Injectable()
-export class GestionnairesService extends BaseService<Users> {
+export class GestionnairesService {
   constructor(
     @InjectRepository(Users)
     private readonly gestionnaireRepository: Repository<Users>,
-  ) {
-    super(gestionnaireRepository);
-  }
-  override async create(dto: CreateGestionnaireDto): Promise<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à utilise');
+    if (exist) throw new ConflictException('Email déjà utilisé');
+
+    const salt = await bcrypt.genSalt();
+    const password_hash = await bcrypt.hash(dto.password, salt);
 
     const entity = this.gestionnaireRepository.create({
-      ...dto,
+      email: dto.email,
+      password_hash,
+      first_name: dto.first_name,
+      last_name: dto.last_name,
+      gender: dto.gender,
+      status: dto.status,
+      phone: dto.phone,
+      address: dto.address,
+      photo_url: dto.photo_url,
+      consent_photo: dto.consent_photo ?? false,
+      consent_photo_at: dto.consent_photo_at ? new Date(dto.consent_photo_at) : undefined,
+      must_change_password: dto.must_change_password ?? false,
       role: RoleType.GESTIONNAIRE,
     });
+
     return this.gestionnaireRepository.save(entity);
   }
 
-  override async findAll(): Promise<Users[]> {
-    // Retourner seulement les utilisateurs avec le rôle de gestionnaire
-    const all_gestionnaires = await this.gestionnaireRepository.find({ where: { role: RoleType.GESTIONNAIRE } });
-    return all_gestionnaires;
+  // Liste des gestionnaires
+  async findAll(): Promise<Users[]> {
+    return this.gestionnaireRepository.find({ where: { role: RoleType.GESTIONNAIRE } });
   }
 
-  override async findOne(id: string): Promise<Users> {
-    const gestionnaire = await this.gestionnaireRepository.findOne({ where: { id, 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;
   }
 
-  async update(id: string, dto: UpdateGestionnaireDto): Promise<Users> {
-    await this.gestionnaireRepository.update(id, dto);
-    return this.findOne(id);
+  // Mise à jour d’un gestionnaire
+  async update(id: string, dto: UpdateGestionnaireDto): Promise<Users | null> {
+    const gestionnaire = await this.findOne(id);
+    if (!gestionnaire) throw new NotFoundException('Gestionnaire introuvable');
+
+    if (dto.password) {
+      const salt = await bcrypt.genSalt();
+      gestionnaire.password_hash = await bcrypt.hash(dto.password, salt);
+    }
+
+    if (dto.consent_photo_at !== undefined) {
+      gestionnaire.consent_photo_at = dto.consent_photo_at
+        ? new Date(dto.consent_photo_at)
+        : undefined;
+    }
+
+    Object.assign(gestionnaire, dto);
+    return this.gestionnaireRepository.save(gestionnaire);
   }
 
+  // Suppression d’un gestionnaire
   async remove(id: string): Promise<void> {
-    await this.findOne(id);
+    const gestionnaire = await this.findOne(id);
+    if (!gestionnaire) throw new NotFoundException('Gestionnaire introuvable');
     await this.gestionnaireRepository.delete(id);
   }
 }

src/routes/parents/parents.controller.ts

@@ -1,73 +1,64 @@
-import { Body, Controller, Delete, Get, Param, Patch, Post } from '@nestjs/common';
-import { BaseController } from 'src/common/base.controller';
-import { Parents } from 'src/entities/parents.entity';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Patch,
+  Post,
+} from '@nestjs/common';
 import { ParentsService } from './parents.service';
+import { Parents } from 'src/entities/parents.entity';
 import { Roles } from 'src/common/decorators/roles.decorator';
 import { RoleType } from 'src/entities/users.entity';
-import * as typeorm from 'typeorm';
 import { ApiBody, ApiResponse, ApiTags } from '@nestjs/swagger';
 import { CreateParentDto } from '../user/dto/create_parent.dto';
 import { UpdateParentsDto } from '../user/dto/update_parent.dto';
 
-
 @ApiTags('Parents')
 @Controller('parents')
-export class ParentsController extends BaseController<Parents> {
-    constructor(private readonly parentsService: ParentsService) {
-        super(parentsService);
-    }
+export class ParentsController {
+  constructor(private readonly parentsService: ParentsService) {}
 
-    //Lister tous les parents
-    @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE) //Seul les utilisateurs super admin et gestionnaire peuvent accéder à cette route
-    @Get()
-    @ApiResponse({ status: 200, description: 'Liste des parents' })
-    @ApiResponse({ status: 403, description: 'Accès refusé : Reservé aux super_admins' })
-    override getAll(): Promise<Parents[]> {
-        return this.parentsService.findAll();
-    }
+  @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE)
+  @Get()
+  @ApiResponse({ status: 200, description: 'Liste des parents' })
+  @ApiResponse({ status: 403, description: 'Accès refusé : Réservé aux super_admins' })
+  getAll(): Promise<Parents[]> {
+    return this.parentsService.findAll();
+  }
 
-    //Rechercher par user_id
-    @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE) //Seul les utilisateurs super admin et gestionnaire peuvent accéder à cette route
-    @Get(':id')
-    @ApiResponse({ status: 200, description: 'Détails du parent par ID utilisateur' })
-    @ApiResponse({ status: 404, description: 'Parent non trouvé' })
-    getOne(@Param('id') user_id: string): Promise<Parents> {
-        return this.parentsService.findOne(user_id);
-    }
+  @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE)
+  @Get(':id')
+  @ApiResponse({ status: 200, description: 'Détails du parent par ID utilisateur' })
+  @ApiResponse({ status: 404, description: 'Parent non trouvé' })
+  getOne(@Param('id') user_id: string): Promise<Parents> {
+    return this.parentsService.findOne(user_id);
+  }
 
-    //Creation de parents
-    @Post()
-    @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE)
-    @ApiBody({ type: CreateParentDto })
-    @ApiResponse({ status: 201, description: 'Parent créé avec succès' })
-    create(data: typeorm.DeepPartial<Parents>): Promise<Parents> {
-        const dto = data as CreateParentDto;
-        return this.parentsService.create({ ...dto, 
-            user: { ...(dto as any).user, role: RoleType.PARENT } });
-    }
+  @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE)
+  @Post()
+  @ApiBody({ type: CreateParentDto })
+  @ApiResponse({ status: 201, description: 'Parent créé avec succès' })
+  create(@Body() dto: CreateParentDto): Promise<Parents> {
+    return this.parentsService.create(dto);
+  }
 
+  @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE)
+  @Patch(':id')
+  @ApiBody({ type: UpdateParentsDto })
+  @ApiResponse({ status: 200, description: 'Parent mis à jour avec succès' })
+  @ApiResponse({ status: 404, description: 'Parent introuvable' })
+  update(@Param('id') id: string, @Body() dto: UpdateParentsDto): Promise<Parents> {
+    return this.parentsService.update(id, dto);
+  }
 
-
-    //Modifier un parent
-    @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE) //Seul les utilisateurs super admin et gestionnaire peuvent accéder à cette route
-    @Patch(':id')
-    @ApiBody({ type: UpdateParentsDto })
-    @ApiResponse({ status: 200, description: 'Parent mis a jour avec succès' })
-    @ApiResponse({ status: 404, description: 'Parent introuvable' })
-    update(
-        @Param('id') id: string,
-        @Body() dto: UpdateParentsDto
-    ): Promise<Parents> {
-        return this.parentsService.update(id, dto);
-    }
-
-    //Supprmer un parent
-    @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE) //Seul les utilisateurs super admin et gestionnaire peuvent accéder à cette route
-    @Delete(':id')
-    @ApiResponse({ status: 200, description: 'Parent supprime avec succès' })
-    @ApiResponse({ status: 404, description: 'Parent introuvable' })
-    @ApiResponse({ status: 403, description: 'Acces refuse' })
-    remove(@Param('id') id: string): Promise<void> {
-        return this.parentsService.remove(id);
-    }
+  @Roles(RoleType.SUPER_ADMIN, RoleType.GESTIONNAIRE)
+  @Delete(':id')
+  @ApiResponse({ status: 200, description: 'Parent supprimé avec succès' })
+  @ApiResponse({ status: 404, description: 'Parent introuvable' })
+  @ApiResponse({ status: 403, description: 'Accès refusé' })
+  remove(@Param('id') id: string): Promise<void> {
+    return this.parentsService.remove(id);
+  }
 }

src/routes/parents/parents.service.ts

@@ -1,69 +1,79 @@
-import { BadRequestException, ConflictException, Injectable, NotFoundException } from '@nestjs/common';
+import {
+  BadRequestException,
+  ConflictException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { BaseService } from 'src/common/base.service';
+import { Repository } from 'typeorm';
 import { Parents } from 'src/entities/parents.entity';
 import { RoleType, Users } from 'src/entities/users.entity';
-import { DeepPartial, Repository } from 'typeorm';
 import { CreateParentDto } from '../user/dto/create_parent.dto';
 import { UpdateParentsDto } from '../user/dto/update_parent.dto';
 
 @Injectable()
-export class ParentsService extends BaseService<Parents> {
-    constructor(
-        @InjectRepository(Parents) private readonly parentsRepository: Repository<Parents>,
-        @InjectRepository(Users) private readonly usersRepository: Repository<Users>,
-    ) {
-        super(parentsRepository);
+export class ParentsService {
+  constructor(
+    @InjectRepository(Parents)
+    private readonly parentsRepository: Repository<Parents>,
+    @InjectRepository(Users)
+    private readonly usersRepository: Repository<Users>,
+  ) {}
+
+  // Création d’un parent
+  async create(dto: CreateParentDto): Promise<Parents> {
+    const user = await this.usersRepository.findOneBy({ id: dto.user_id });
+    if (!user) throw new NotFoundException('Utilisateur introuvable');
+    if (user.role !== RoleType.PARENT) {
+      throw new BadRequestException('Accès réservé aux parents');
     }
 
-    override async create(data: DeepPartial<Parents>): Promise<Parents> {
-        const dto = data as CreateParentDto;
-        const user = await this.usersRepository.findOneBy({ id: dto.user_id });
-        if (!user) throw new NotFoundException('Utilisateur introuvable');
-        if (user.role !== RoleType.PARENT) throw new BadRequestException('Accès réservé aux parents');
+    const exist = await this.parentsRepository.findOneBy({ user_id: dto.user_id });
+    if (exist) throw new ConflictException('Ce parent existe déjà');
 
-        const exist = await this.parentsRepository.findOneBy({ user_id: dto.user_id });
-        if (exist) throw new ConflictException('Ce parent existe déjà');
-
-        let co_parent: Users | null = null;
-        if (dto.co_parent_id) {
-            co_parent = await this.usersRepository.findOneBy({ id: dto.co_parent_id });
-            if (!co_parent) throw new NotFoundException('Co-parent introuvable');
-            if (co_parent.role !== RoleType.PARENT) throw new BadRequestException('Accès réservé aux parents');
-        }
-
-        const entity = this.parentsRepository.create({
-            user_id: dto.user_id,
-            user,
-            co_parent: co_parent ?? undefined,
-        });
-
-        return this.parentsRepository.save(entity);
+    let co_parent: Users | null = null;
+    if (dto.co_parent_id) {
+      co_parent = await this.usersRepository.findOneBy({ id: dto.co_parent_id });
+      if (!co_parent) throw new NotFoundException('Co-parent introuvable');
+      if (co_parent.role !== RoleType.PARENT) {
+        throw new BadRequestException('Accès réservé aux parents');
+      }
     }
 
+    const entity = this.parentsRepository.create({
+      user_id: dto.user_id,
+      user,
+      co_parent: co_parent ?? undefined,
+    });
 
-    override async findAll(): Promise<Parents[]> {
-        return this.parentsRepository.find({
-            relations: ['user', 'co_parent',
-                'parentChildren', 'dossiers'],
-        });
-    }
+    return this.parentsRepository.save(entity);
+  }
 
-    override async findOne(user_id: string): Promise<Parents> {
-        const parent = await this.parentsRepository.findOne({
-            where: { user_id },
-            relations: ['user', 'co_parent', 'parentChildren', 'dossiers'],
-        });
-        if (!parent) throw new NotFoundException('Parent introuvable');
-        return parent;
-    }
+  // Liste des parents
+  async findAll(): Promise<Parents[]> {
+    return this.parentsRepository.find({
+      relations: ['user', 'co_parent', 'parentChildren', 'dossiers'],
+    });
+  }
 
-    async update(id: string, dto: UpdateParentsDto): Promise<Parents> {
-        await this.parentsRepository.update(id, dto);
-        return this.findOne(id);
-    }
+  // Récupérer un parent par user_id
+  async findOne(user_id: string): Promise<Parents> {
+    const parent = await this.parentsRepository.findOne({
+      where: { user_id },
+      relations: ['user', 'co_parent', 'parentChildren', 'dossiers'],
+    });
+    if (!parent) throw new NotFoundException('Parent introuvable');
+    return parent;
+  }
 
-    async remove(id: string): Promise<void> {
-        await this.parentsRepository.delete(id);
-    }
-}
+  // Mise à jour
+  async update(id: string, dto: UpdateParentsDto): Promise<Parents> {
+    await this.parentsRepository.update(id, dto);
+    return this.findOne(id);
+  }
+
+  // Suppression
+  async remove(id: string): Promise<void> {
+    await this.parentsRepository.delete(id);
+  }
+}