feat: Modules Sites et Types - Ajout des modules de gestion des sites et des types de machines/composants/pièces

src/sites/sites.controller.spec.ts

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

src/sites/sites.controller.ts

@@ -0,0 +1,33 @@
+import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common';
+import { SitesService } from './sites.service';
+import { CreateSiteDto, UpdateSiteDto } from '../shared/dto/site.dto';
+
+@Controller('sites')
+export class SitesController {
+  constructor(private readonly sitesService: SitesService) {}
+
+  @Post()
+  create(@Body() createSiteDto: CreateSiteDto) {
+    return this.sitesService.create(createSiteDto);
+  }
+
+  @Get()
+  findAll() {
+    return this.sitesService.findAll();
+  }
+
+  @Get(':id')
+  findOne(@Param('id') id: string) {
+    return this.sitesService.findOne(id);
+  }
+
+  @Patch(':id')
+  update(@Param('id') id: string, @Body() updateSiteDto: UpdateSiteDto) {
+    return this.sitesService.update(id, updateSiteDto);
+  }
+
+  @Delete(':id')
+  remove(@Param('id') id: string) {
+    return this.sitesService.remove(id);
+  }
+}

src/sites/sites.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { SitesController } from './sites.controller';
+import { SitesService } from './sites.service';
+
+@Module({
+  controllers: [SitesController],
+  providers: [SitesService]
+})
+export class SitesModule {}

src/sites/sites.service.spec.ts

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

src/sites/sites.service.ts

@@ -0,0 +1,82 @@
+import { Injectable } from '@nestjs/common';
+import { PrismaService } from '../prisma/prisma.service';
+import { CreateSiteDto, UpdateSiteDto } from '../shared/dto/site.dto';
+
+@Injectable()
+export class SitesService {
+  constructor(private prisma: PrismaService) {}
+
+  async create(createSiteDto: CreateSiteDto) {
+    return this.prisma.site.create({
+      data: createSiteDto,
+    });
+  }
+
+  async findAll() {
+    return this.prisma.site.findMany({
+      include: {
+        machines: {
+          include: {
+            typeMachine: true,
+            composants: {
+              include: {
+                typeComposant: true,
+                sousComposants: true,
+                pieces: true,
+              },
+            },
+            pieces: true,
+          },
+        },
+      },
+    });
+  }
+
+  async findOne(id: string) {
+    return this.prisma.site.findUnique({
+      where: { id },
+      include: {
+        machines: {
+          include: {
+            typeMachine: true,
+            composants: {
+              include: {
+                typeComposant: true,
+                sousComposants: true,
+                pieces: true,
+              },
+            },
+            pieces: true,
+          },
+        },
+      },
+    });
+  }
+
+  async update(id: string, updateSiteDto: UpdateSiteDto) {
+    return this.prisma.site.update({
+      where: { id },
+      data: updateSiteDto,
+    });
+  }
+
+  async remove(id: string) {
+    // Vérifier s'il y a des machines liées à ce site
+    const machinesInSite = await this.prisma.machine.findMany({
+      where: { siteId: id },
+      select: { id: true, name: true },
+    });
+
+    if (machinesInSite.length > 0) {
+      const machineNames = machinesInSite.map(m => m.name).join(', ');
+      throw new Error(
+        `Impossible de supprimer ce site car il contient ${machinesInSite.length} machine(s): ${machineNames}. ` +
+        `Veuillez d'abord supprimer ou déplacer ces machines vers un autre site.`
+      );
+    }
+
+    return this.prisma.site.delete({
+      where: { id },
+    });
+  }
+}