Validate component and piece requirements

src/pieces/pieces.service.spec.ts

@@ -1,19 +1,85 @@
+import { BadRequestException } from '@nestjs/common';
 import { Test, TestingModule } from '@nestjs/testing';
 import { PiecesService } from './pieces.service';
 import { PrismaService } from '../prisma/prisma.service';
+import { CreatePieceDto } from '../shared/dto/piece.dto';
 
 describe('PiecesService', () => {
   let service: PiecesService;
+  let prisma: any;
 
   beforeEach(async () => {
+    prisma = {
+      piece: {
+        create: jest.fn(),
+      },
+      machine: {
+        findUnique: jest.fn(),
+      },
+      composant: {
+        findUnique: jest.fn(),
+      },
+    };
+
     const module: TestingModule = await Test.createTestingModule({
-      providers: [PiecesService, PrismaService],
+      providers: [PiecesService, { provide: PrismaService, useValue: prisma }],
     }).compile();
 
     service = module.get<PiecesService>(PiecesService);
   });
 
-  it('should be defined', () => {
-    expect(service).toBeDefined();
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should create a piece when requirement matches the machine skeleton', async () => {
+    const dto: CreatePieceDto = {
+      name: 'Piece A',
+      machineId: 'machine-1',
+      typePieceId: 'type-piece-1',
+      typeMachinePieceRequirementId: 'req-1',
+    };
+
+    prisma.machine.findUnique.mockResolvedValue({
+      id: 'machine-1',
+      typeMachine: {
+        pieceRequirements: [
+          { id: 'req-1', typePieceId: 'type-piece-1' },
+        ],
+      },
+    });
+
+    const created = { id: 'piece-1' };
+    prisma.piece.create.mockResolvedValue(created);
+
+    await expect(service.create(dto)).resolves.toEqual(created);
+    expect(prisma.piece.create).toHaveBeenCalled();
+    expect(prisma.piece.create.mock.calls[0][0].data.machineId).toBe(
+      'machine-1',
+    );
+  });
+
+  it('should refuse creation when requirement does not belong to machine skeleton', async () => {
+    const dto: CreatePieceDto = {
+      name: 'Piece A',
+      machineId: 'machine-1',
+      typePieceId: 'type-piece-1',
+      typeMachinePieceRequirementId: 'req-2',
+    };
+
+    prisma.machine.findUnique.mockResolvedValue({
+      id: 'machine-1',
+      typeMachine: {
+        pieceRequirements: [
+          { id: 'req-1', typePieceId: 'type-piece-1' },
+        ],
+      },
+    });
+
+    await expect(service.create(dto)).rejects.toBeInstanceOf(
+      BadRequestException,
+    );
+
+    expect(prisma.piece.create).not.toHaveBeenCalled();
   });
 });

src/pieces/pieces.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { BadRequestException, Injectable } from '@nestjs/common';
 import { PrismaService } from '../prisma/prisma.service';
 import { CreatePieceDto, UpdatePieceDto } from '../shared/dto/piece.dto';
 
@@ -7,8 +7,74 @@ export class PiecesService {
   constructor(private prisma: PrismaService) {}
 
   async create(createPieceDto: CreatePieceDto) {
+    const requirementId = createPieceDto.typeMachinePieceRequirementId;
+
+    let machineId = createPieceDto.machineId;
+
+    if (createPieceDto.composantId) {
+      const composantMachineId = await this.resolveMachineIdFromComposant(
+        createPieceDto.composantId,
+      );
+
+      if (machineId && machineId !== composantMachineId) {
+        throw new BadRequestException(
+          'Le composant ciblé appartient à une autre machine que celle fournie.',
+        );
+      }
+
+      machineId = composantMachineId;
+    }
+
+    if (!machineId) {
+      throw new BadRequestException(
+        'Un machineId ou un composantId valide est requis pour créer une pièce.',
+      );
+    }
+
+    const machine = await this.prisma.machine.findUnique({
+      where: { id: machineId },
+      include: {
+        typeMachine: {
+          include: {
+            pieceRequirements: true,
+          },
+        },
+      },
+    });
+
+    if (!machine || !machine.typeMachine) {
+      throw new BadRequestException(
+        'La machine ciblée doit être associée à un type de machine pour valider les requirements.',
+      );
+    }
+
+    const requirement = machine.typeMachine.pieceRequirements.find(
+      (pieceRequirement) => pieceRequirement.id === requirementId,
+    );
+
+    if (!requirement) {
+      throw new BadRequestException(
+        'Le requirement de pièce fourni ne correspond pas au squelette de la machine.',
+      );
+    }
+
+    if (
+      createPieceDto.typePieceId &&
+      createPieceDto.typePieceId !== requirement.typePieceId
+    ) {
+      throw new BadRequestException(
+        'Le type de pièce fourni ne correspond pas au requirement pour cette machine.',
+      );
+    }
+
+    const data = {
+      ...createPieceDto,
+      machineId,
+      typePieceId: createPieceDto.typePieceId ?? requirement.typePieceId,
+    };
+
     return this.prisma.piece.create({
-      data: createPieceDto,
+      data,
       include: {
         machine: true,
         composant: true,
@@ -101,6 +167,37 @@ export class PiecesService {
     });
   }
 
+  private async resolveMachineIdFromComposant(
+    composantId: string,
+  ): Promise<string> {
+    const composant = await this.prisma.composant.findUnique({
+      where: { id: composantId },
+      select: {
+        id: true,
+        machineId: true,
+        parentComposantId: true,
+      },
+    });
+
+    if (!composant) {
+      throw new BadRequestException(
+        'Le composant spécifié est introuvable.',
+      );
+    }
+
+    if (composant.machineId) {
+      return composant.machineId;
+    }
+
+    if (composant.parentComposantId) {
+      return this.resolveMachineIdFromComposant(composant.parentComposantId);
+    }
+
+    throw new BadRequestException(
+      'Impossible de déterminer la machine associée à ce composant.',
+    );
+  }
+
   async findByComposant(composantId: string) {
     return this.prisma.piece.findMany({
       where: { composantId },