gestionnaires route added

src/routes/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();
+  });
+});

src/routes/gestionnaires/gestionnaires.controller.ts

@@ -0,0 +1,55 @@
+import { Controller, Get, Post, Body, Patch, Param, Delete, ForbiddenException } 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);
+  }
+
+  @Roles(RoleType.SUPER_ADMIN)
+  @Post()
+  create(@Body() createGestionnaireDto: CreateGestionnaireDto) {
+    return this.gestionnairesService.create(createGestionnaireDto);
+  }
+
+  //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;
+  }
+
+  //Récupérer un gestionnaire
+  @Roles(RoleType.GESTIONNAIRE, RoleType.SUPER_ADMIN)
+  @Get(':id')
+  findOne(@Param('id') id: string) {
+    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;
+  }
+
+  @Roles(RoleType.SUPER_ADMIN)
+  @Delete(':id')
+  remove(@Param('id') id: string) {
+    return this.gestionnairesService.remove(id);
+  }
+}

src/routes/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 { }

src/routes/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();
+  });
+});

src/routes/gestionnaires/gestionnaires.service.ts

@@ -0,0 +1,50 @@
+import { ConflictException, ForbiddenException, Injectable, NotFoundException } from '@nestjs/common';
+import { BaseService } from 'src/common/base.service';
+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';
+
+@Injectable()
+export class GestionnairesService extends BaseService<Users> {
+  constructor(
+    @InjectRepository(Users)
+    private readonly gestionnaireRepository: Repository<Users>,
+  ) {
+    super(gestionnaireRepository);
+  }
+  override async create(dto: CreateGestionnaireDto): Promise<Users> {
+
+    const exist = await this.gestionnaireRepository.findOneBy({ email: dto.email });
+    if (exist) throw new ConflictException('Email déjà utilise');
+
+    const entity = this.gestionnaireRepository.create({
+      ...dto,
+      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;
+  }
+
+  override 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);
+  }
+
+  async remove(id: string): Promise<void> {
+    await this.findOne(id);
+    await this.gestionnaireRepository.delete(id);
+  }
+}