feat: Add feature in component and piece for support group

src/machines/machines.service.ts

@@ -1,17 +1,41 @@
 import { Injectable } from '@nestjs/common';
 import { PrismaService } from '../prisma/prisma.service';
-import { CreateMachineDto, UpdateMachineDto } from '../shared/dto/machine.dto';
+import { 
+  CreateMachineDto, 
+  UpdateMachineDto,
+  MachineComponentSelectionDto,
+  MachinePieceSelectionDto
+} from '../shared/dto/machine.dto';
 
 @Injectable()
 export class MachinesService {
   constructor(private prisma: PrismaService) {}
 
   async create(createMachineDto: CreateMachineDto) {
-    // Récupérer le type de machine pour hériter de sa structure
+    const {
+      componentSelections = [],
+      pieceSelections = [],
+      ...machineData
+    } = createMachineDto;
+
+    if (!machineData.typeMachineId) {
+      throw new Error('typeMachineId est requis pour créer une machine à partir d\'un squelette.');
+    }
+
     const typeMachine = await this.prisma.typeMachine.findUnique({
-      where: { id: createMachineDto.typeMachineId },
+      where: { id: machineData.typeMachineId },
       include: {
         customFields: true,
+        componentRequirements: {
+          include: {
+            typeComposant: true,
+          },
+        },
+        pieceRequirements: {
+          include: {
+            typePiece: true,
+          },
+        },
       },
     });
 
@@ -19,11 +43,152 @@ export class MachinesService {
       throw new Error('Type de machine non trouvé');
     }
 
-    // Créer la machine avec la structure héritée du type
+    const componentRequirementMap = new Map(
+      typeMachine.componentRequirements.map((requirement) => [requirement.id, requirement]),
+    );
+    const pieceRequirementMap = new Map(
+      typeMachine.pieceRequirements.map((requirement) => [requirement.id, requirement]),
+    );
+
+    const componentSelectionMap = new Map<string, MachineComponentSelectionDto[]>();
+    for (const selection of componentSelections) {
+      const requirement = componentRequirementMap.get(selection.requirementId);
+      if (!requirement) {
+        throw new Error(`Sélection de composant invalide: requirementId=${selection.requirementId}`);
+      }
+      if (!componentSelectionMap.has(requirement.id)) {
+        componentSelectionMap.set(requirement.id, []);
+      }
+      componentSelectionMap.get(requirement.id)!.push(selection);
+    }
+
+    const pieceSelectionMap = new Map<string, MachinePieceSelectionDto[]>();
+    for (const selection of pieceSelections) {
+      const requirement = pieceRequirementMap.get(selection.requirementId);
+      if (!requirement) {
+        throw new Error(`Sélection de pièce invalide: requirementId=${selection.requirementId}`);
+      }
+      if (!pieceSelectionMap.has(requirement.id)) {
+        pieceSelectionMap.set(requirement.id, []);
+      }
+      pieceSelectionMap.get(requirement.id)!.push(selection);
+    }
+
+    const componentModelIds = Array.from(
+      new Set(componentSelections.map((selection) => selection.componentModelId).filter(Boolean)),
+    ) as string[];
+    const componentModels = componentModelIds.length
+      ? await this.prisma.composantModel.findMany({
+          where: { id: { in: componentModelIds } },
+        })
+      : [];
+    const componentModelMap = new Map(componentModels.map((model) => [model.id, model]));
+
+    const pieceModelIds = Array.from(
+      new Set(pieceSelections.map((selection) => selection.pieceModelId).filter(Boolean)),
+    ) as string[];
+    const pieceModels = pieceModelIds.length
+      ? await this.prisma.pieceModel.findMany({
+          where: { id: { in: pieceModelIds } },
+        })
+      : [];
+    const pieceModelMap = new Map(pieceModels.map((model) => [model.id, model]));
+
+    for (const requirement of typeMachine.componentRequirements) {
+      const selections = componentSelectionMap.get(requirement.id) ?? [];
+      const min = requirement.minCount ?? (requirement.required ? 1 : 0);
+      const max = requirement.maxCount ?? undefined;
+
+      if (selections.length < min) {
+        throw new Error(
+          `Le groupe de composants "${requirement.label || requirement.typeComposant?.name || requirement.id}" requiert au moins ${min} sélection(s).`,
+        );
+      }
+
+      if (max !== undefined && selections.length > max) {
+        throw new Error(
+          `Le groupe de composants "${requirement.label || requirement.typeComposant?.name || requirement.id}" ne peut pas dépasser ${max} sélection(s).`,
+        );
+      }
+
+      if (!requirement.allowNewModels) {
+        const missingModel = selections.find((selection) => !selection.componentModelId);
+        if (missingModel) {
+          throw new Error(
+            `Le groupe de composants "${requirement.label || requirement.typeComposant?.name || requirement.id}" n'autorise que la sélection de modèles existants.`,
+          );
+        }
+      }
+    }
+
+    for (const requirement of typeMachine.pieceRequirements) {
+      const selections = pieceSelectionMap.get(requirement.id) ?? [];
+      const min = requirement.minCount ?? (requirement.required ? 1 : 0);
+      const max = requirement.maxCount ?? undefined;
+
+      if (selections.length < min) {
+        throw new Error(
+          `Le groupe de pièces "${requirement.label || requirement.typePiece?.name || requirement.id}" requiert au moins ${min} sélection(s).`,
+        );
+      }
+
+      if (max !== undefined && selections.length > max) {
+        throw new Error(
+          `Le groupe de pièces "${requirement.label || requirement.typePiece?.name || requirement.id}" ne peut pas dépasser ${max} sélection(s).`,
+        );
+      }
+
+      if (!requirement.allowNewModels) {
+        const missingModel = selections.find((selection) => !selection.pieceModelId);
+        if (missingModel) {
+          throw new Error(
+            `Le groupe de pièces "${requirement.label || requirement.typePiece?.name || requirement.id}" n'autorise que la sélection de modèles existants.`,
+          );
+        }
+      }
+    }
+
+    for (const selection of componentSelections) {
+      if (!selection.componentModelId) {
+        continue;
+      }
+      const model = componentModelMap.get(selection.componentModelId);
+      if (!model) {
+        throw new Error(`Modèle de composant introuvable: ${selection.componentModelId}`);
+      }
+      const requirement = componentRequirementMap.get(selection.requirementId);
+      if (!requirement) {
+        throw new Error(`Requirement de composant introuvable: ${selection.requirementId}`);
+      }
+      if (model.typeComposantId !== requirement.typeComposantId) {
+        throw new Error(
+          `Le modèle de composant "${model.name}" n'appartient pas au type de composant attendu pour ce groupe.`,
+        );
+      }
+    }
+
+    for (const selection of pieceSelections) {
+      if (!selection.pieceModelId) {
+        continue;
+      }
+      const model = pieceModelMap.get(selection.pieceModelId);
+      if (!model) {
+        throw new Error(`Modèle de pièce introuvable: ${selection.pieceModelId}`);
+      }
+      const requirement = pieceRequirementMap.get(selection.requirementId);
+      if (!requirement) {
+        throw new Error(`Requirement de pièce introuvable: ${selection.requirementId}`);
+      }
+      if (model.typePieceId !== requirement.typePieceId) {
+        throw new Error(
+          `Le modèle de pièce "${model.name}" n'appartient pas au type de pièce attendu pour ce groupe.`,
+        );
+      }
+    }
+
     return await this.prisma.$transaction(async (prisma) => {
-      // 1. Créer la machine
       const machine = await prisma.machine.create({
-        data: createMachineDto,
+        data: machineData,
         include: {
           site: true,
           typeMachine: true,
@@ -31,37 +196,71 @@ export class MachinesService {
         },
       });
 
-      // 2. Créer les composants basés sur la structure du type
-      const components = (typeMachine as any).components;
-      if (components) {
-        await this.createComponentsFromType(prisma, machine.id, components);
+      if (typeMachine.componentRequirements.length > 0) {
+        for (const requirement of typeMachine.componentRequirements) {
+          const selections = componentSelectionMap.get(requirement.id) ?? [];
+          for (const selection of selections) {
+            const model = selection.componentModelId ? componentModelMap.get(selection.componentModelId) : undefined;
+            const definition = this.normalizeComponentSelection(selection, requirement, model);
+            await this.createComponentsFromType(prisma, machine.id, [definition]);
+          }
+        }
+      } else {
+        const legacyComponents = (typeMachine as any).components;
+        if (legacyComponents) {
+          await this.createComponentsFromType(prisma, machine.id, legacyComponents);
+        }
       }
 
-      // 3. Créer les pièces de machine basées sur le type
-      const machinePieces = (typeMachine as any).machinePieces;
-      if (machinePieces) {
-        await this.createMachinePiecesFromType(prisma, machine.id, machinePieces);
+      if (typeMachine.pieceRequirements.length > 0) {
+        for (const requirement of typeMachine.pieceRequirements) {
+          const selections = pieceSelectionMap.get(requirement.id) ?? [];
+          for (const selection of selections) {
+            const model = selection.pieceModelId ? pieceModelMap.get(selection.pieceModelId) : undefined;
+            const definition = this.normalizePieceSelection(selection, requirement, model);
+            await this.createMachinePiecesFromType(prisma, machine.id, [definition]);
+          }
+        }
+      } else {
+        const legacyPieces = (typeMachine as any).machinePieces;
+        if (legacyPieces) {
+          await this.createMachinePiecesFromType(prisma, machine.id, legacyPieces);
+        }
       }
 
-      // 4. Créer les champs personnalisés de la machine basés sur le type
       if (typeMachine.customFields && typeMachine.customFields.length > 0) {
         await this.createMachineCustomFieldsFromType(prisma, machine.id, typeMachine.customFields);
       }
 
-      // 5. Retourner la machine avec sa structure complète
-      return await prisma.machine.findUnique({
+      return prisma.machine.findUnique({
         where: { id: machine.id },
         include: {
           site: true,
           typeMachine: {
             include: {
               customFields: true,
+              componentRequirements: {
+                include: {
+                  typeComposant: true,
+                },
+              },
+              pieceRequirements: {
+                include: {
+                  typePiece: true,
+                },
+              },
             },
           },
           constructeur: true,
           composants: {
             include: {
               typeComposant: true,
+              composantModel: true,
+              typeMachineComponentRequirement: {
+                include: {
+                  typeComposant: true,
+                },
+              },
               sousComposants: true,
               pieces: {
                 include: {
@@ -71,6 +270,12 @@ export class MachinesService {
                     },
                   },
                   constructeur: true,
+                  pieceModel: true,
+                  typeMachinePieceRequirement: {
+                    include: {
+                      typePiece: true,
+                    },
+                  },
                 },
               },
               constructeur: true,
@@ -84,6 +289,12 @@ export class MachinesService {
                 },
               },
               constructeur: true,
+              pieceModel: true,
+              typeMachinePieceRequirement: {
+                include: {
+                  typePiece: true,
+                },
+              },
             },
           },
           customFieldValues: {
@@ -97,19 +308,97 @@ export class MachinesService {
     });
   }
 
+  private cloneStructure(definition: any): any {
+    if (definition === undefined || definition === null) {
+      return {};
+    }
+
+    try {
+      return JSON.parse(JSON.stringify(definition));
+    } catch (error) {
+      if (Array.isArray(definition)) {
+        return definition.map((item) => this.cloneStructure(item));
+      }
+
+      if (typeof definition === 'object') {
+        return { ...definition };
+      }
+
+      return definition;
+    }
+  }
+
+  private normalizeComponentSelection(
+    selection: MachineComponentSelectionDto,
+    requirement: any,
+    model?: any,
+  ): any {
+    const baseDefinition = selection.definition ?? (model?.structure ?? {});
+    const definition = this.cloneStructure(baseDefinition);
+    const prepared: any = definition && typeof definition === 'object' && !Array.isArray(definition) ? definition : {};
+
+    prepared.name = prepared.name || model?.name || requirement?.typeComposant?.name || 'Composant';
+    prepared.reference = prepared.reference ?? model?.structure?.reference ?? '';
+    prepared.emplacement = prepared.emplacement ?? model?.structure?.emplacement ?? '';
+    prepared.prix = prepared.prix ?? model?.structure?.prix ?? null;
+
+    prepared.customFields = Array.isArray(prepared.customFields) ? prepared.customFields : [];
+    prepared.pieces = Array.isArray(prepared.pieces)
+      ? prepared.pieces
+      : prepared.pieces
+      ? [prepared.pieces]
+      : [];
+    prepared.subComponents = Array.isArray(prepared.subComponents)
+      ? prepared.subComponents
+      : prepared.subComponents
+      ? [prepared.subComponents]
+      : [];
+
+    prepared.typeComposantId = prepared.typeComposantId || requirement?.typeComposantId || model?.typeComposantId || null;
+    prepared.__componentModelId = selection.componentModelId ?? null;
+    prepared.__requirementId = requirement?.id ?? null;
+
+    return prepared;
+  }
+
+  private normalizePieceSelection(
+    selection: MachinePieceSelectionDto,
+    requirement: any,
+    model?: any,
+  ): any {
+    const baseDefinition = selection.definition ?? (model?.structure ?? {});
+    const definition = this.cloneStructure(baseDefinition);
+    const prepared: any = definition && typeof definition === 'object' && !Array.isArray(definition) ? definition : {};
+
+    prepared.name = prepared.name || model?.name || requirement?.typePiece?.name || 'Pièce';
+    prepared.customFields = Array.isArray(prepared.customFields) ? prepared.customFields : [];
+    prepared.typePieceId = prepared.typePieceId || requirement?.typePieceId || model?.typePieceId || null;
+    prepared.__pieceModelId = selection.pieceModelId ?? null;
+    prepared.__requirementId = requirement?.id ?? null;
+
+    return prepared;
+  }
+
   private async createComponentsFromType(prisma: any, machineId: string, components: any[], parentComposantId?: string) {
     for (const component of components) {
-      if (!component.name) continue;
+      if (!component || !component.name) continue;
 
-      // Créer d'abord le type de composant s'il n'existe pas
-      let typeComposant: any = null;
-      if (component.customFields && component.customFields.length > 0) {
-        // Chercher d'abord si le type de composant existe déjà
-        typeComposant = await prisma.typeComposant.findFirst({
-          where: { name: component.name }
+      const customFields = Array.isArray(component.customFields) ? component.customFields : [];
+      const componentPieces = Array.isArray(component.pieces) ? component.pieces : [];
+      const subComponents = Array.isArray(component.subComponents) ? component.subComponents : [];
+
+      const componentModelId = component.__componentModelId ?? null;
+      const requirementId = component.__requirementId ?? null;
+      const providedTypeComposantId = component.typeComposantId
+        ?? (component.typeComposant && component.typeComposant.id ? component.typeComposant.id : null);
+
+      let typeComposantId: string | null = providedTypeComposantId ?? null;
+
+      if (!typeComposantId && customFields.length > 0) {
+        let typeComposant = await prisma.typeComposant.findFirst({
+          where: { name: component.name },
         });
 
-        // Si le type n'existe pas, le créer
         if (!typeComposant) {
           typeComposant = await prisma.typeComposant.create({
             data: {
@@ -118,8 +407,7 @@ export class MachinesService {
             },
           });
 
-          // Créer les champs personnalisés pour le type de composant
-          for (const customField of component.customFields) {
+          for (const customField of customFields) {
             await prisma.customField.create({
               data: {
                 name: customField.name,
@@ -132,6 +420,8 @@ export class MachinesService {
             });
           }
         }
+
+        typeComposantId = typeComposant.id;
       }
 
       const createdComposant = await prisma.composant.create({
@@ -140,21 +430,22 @@ export class MachinesService {
           reference: component.reference || '',
           constructeurId: await this.resolveConstructeurId(prisma, component.constructeur),
           emplacement: component.emplacement || '',
-          prix: component.prix || null,
+          prix: component.prix ?? null,
           machineId,
           parentComposantId,
-          typeComposantId: typeComposant?.id || null,
+          typeComposantId,
+          composantModelId: componentModelId,
+          typeMachineComponentRequirementId: requirementId,
         },
       });
 
-      // Créer les valeurs des champs personnalisés pour le composant
-      if (typeComposant && typeComposant.id) {
-        const customFields = await prisma.customField.findMany({
-          where: { typeComposantId: typeComposant.id },
+      if (typeComposantId) {
+        const typeCustomFields = await prisma.customField.findMany({
+          where: { typeComposantId },
         });
 
-        for (const customField of customFields) {
-          const defaultValue = component.customFields?.find(cf => cf.name === customField.name)?.defaultValue || '';
+        for (const customField of typeCustomFields) {
+          const defaultValue = customFields.find((cf) => cf.name === customField.name)?.defaultValue || '';
           await prisma.customFieldValue.create({
             data: {
               value: defaultValue,
@@ -165,79 +456,81 @@ export class MachinesService {
         }
       }
 
-      // Créer les pièces du composant avec leurs champs personnalisés
-      if (component.pieces) {
-        for (const piece of component.pieces) {
-          if (!piece || !piece.name) continue;
-          
-          // Créer d'abord le type de pièce s'il n'existe pas
-          let typePiece: any = null;
-          if (piece.customFields && piece.customFields.length > 0) {
-            // Chercher d'abord si le type de pièce existe déjà
-            typePiece = await prisma.typePiece.findFirst({
-              where: { name: piece.name }
-            });
+      for (const piece of componentPieces) {
+        if (!piece || !piece.name) continue;
 
-            // Si le type n'existe pas, le créer
-            if (!typePiece) {
-              typePiece = await prisma.typePiece.create({
-                data: {
-                  name: piece.name,
-                  description: piece.description || '',
-                },
-              });
+        const pieceCustomFields = Array.isArray(piece.customFields) ? piece.customFields : [];
+        const pieceModelId = piece.__pieceModelId ?? null;
+        const pieceRequirementId = piece.__requirementId ?? null;
+        const providedTypePieceId = piece.typePieceId
+          ?? (piece.typePiece && piece.typePiece.id ? piece.typePiece.id : null);
 
-              // Créer les champs personnalisés pour le type de pièce
-              for (const customField of piece.customFields) {
-                await prisma.customField.create({
-                  data: {
-                    name: customField.name,
-                    type: customField.type,
-                    required: customField.required || false,
-                    defaultValue: customField.defaultValue,
-                    options: customField.options || [],
-                    typePieceId: typePiece.id,
-                  },
-                });
-              }
-            }
-          }
-          
-          const createdPiece = await prisma.piece.create({
-            data: {
-              name: piece.name,
-              reference: piece.reference || '',
-              constructeurId: await this.resolveConstructeurId(prisma, piece.constructeur),
-              emplacement: piece.emplacement || '',
-              prix: piece.prix || null,
-              composantId: createdComposant.id,
-              typePieceId: typePiece?.id || null,
-            },
+        let typePieceId: string | null = providedTypePieceId ?? null;
+
+        if (!typePieceId && pieceCustomFields.length > 0) {
+          let typePiece = await prisma.typePiece.findFirst({
+            where: { name: piece.name },
           });
 
-          // Créer les valeurs des champs personnalisés pour la pièce
-          if (typePiece && typePiece.id) {
-            const customFields = await prisma.customField.findMany({
-              where: { typePieceId: typePiece.id },
+          if (!typePiece) {
+            typePiece = await prisma.typePiece.create({
+              data: {
+                name: piece.name,
+                description: piece.description || '',
+              },
             });
 
-            for (const customField of customFields) {
-              const defaultValue = piece.customFields?.find(cf => cf.name === customField.name)?.defaultValue || '';
-              await prisma.customFieldValue.create({
+            for (const customField of pieceCustomFields) {
+              await prisma.customField.create({
                 data: {
-                  value: defaultValue,
-                  customFieldId: customField.id,
-                  pieceId: createdPiece.id,
+                  name: customField.name,
+                  type: customField.type,
+                  required: customField.required || false,
+                  defaultValue: customField.defaultValue,
+                  options: customField.options || [],
+                  typePieceId: typePiece.id,
                 },
               });
             }
           }
+
+          typePieceId = typePiece.id;
+        }
+
+        const createdPiece = await prisma.piece.create({
+          data: {
+            name: piece.name,
+            reference: piece.reference || '',
+            constructeurId: await this.resolveConstructeurId(prisma, piece.constructeur),
+            emplacement: piece.emplacement || '',
+            prix: piece.prix ?? null,
+            composantId: createdComposant.id,
+            typePieceId,
+            pieceModelId,
+            typeMachinePieceRequirementId: pieceRequirementId,
+          },
+        });
+
+        if (typePieceId) {
+          const typePieceCustomFields = await prisma.customField.findMany({
+            where: { typePieceId },
+          });
+
+          for (const customField of typePieceCustomFields) {
+            const defaultValue = pieceCustomFields.find((cf) => cf.name === customField.name)?.defaultValue || '';
+            await prisma.customFieldValue.create({
+              data: {
+                value: defaultValue,
+                customFieldId: customField.id,
+                pieceId: createdPiece.id,
+              },
+            });
+          }
         }
       }
 
-      // Créer les sous-composants récursivement
-      if (component.subComponents) {
-        await this.createComponentsFromType(prisma, machineId, component.subComponents, createdComposant.id);
+      if (subComponents.length > 0) {
+        await this.createComponentsFromType(prisma, machineId, subComponents, createdComposant.id);
       }
     }
   }
@@ -245,19 +538,76 @@ export class MachinesService {
   private async createMachinePiecesFromType(prisma: any, machineId: string, machinePieces: any[]) {
     for (const piece of machinePieces) {
       if (!piece || !piece.name) continue;
-      
+
+      const customFields = Array.isArray(piece.customFields) ? piece.customFields : [];
+      const pieceModelId = piece.__pieceModelId ?? null;
+      const requirementId = piece.__requirementId ?? null;
+      const providedTypePieceId = piece.typePieceId
+        ?? (piece.typePiece && piece.typePiece.id ? piece.typePiece.id : null);
+
+      let typePieceId: string | null = providedTypePieceId ?? null;
+
+      if (!typePieceId && customFields.length > 0) {
+        let typePiece = await prisma.typePiece.findFirst({
+          where: { name: piece.name },
+        });
+
+        if (!typePiece) {
+          typePiece = await prisma.typePiece.create({
+            data: {
+              name: piece.name,
+              description: piece.description || '',
+            },
+          });
+
+          for (const customField of customFields) {
+            await prisma.customField.create({
+              data: {
+                name: customField.name,
+                type: customField.type,
+                required: customField.required || false,
+                defaultValue: customField.defaultValue,
+                options: customField.options || [],
+                typePieceId: typePiece.id,
+              },
+            });
+          }
+        }
+
+        typePieceId = typePiece.id;
+      }
+
       const createdPiece = await prisma.piece.create({
         data: {
           name: piece.name,
-          machineId,
+          reference: piece.reference || '',
           constructeurId: await this.resolveConstructeurId(prisma, piece.constructeur),
+          emplacement: piece.emplacement || '',
+          prix: piece.prix ?? null,
+          machineId,
+          typePieceId,
+          pieceModelId,
+          typeMachinePieceRequirementId: requirementId,
         },
       });
 
-      // Copier les champs personnalisés du type vers la pièce
-      if (piece.customFields && piece.customFields.length > 0) {
-        for (const customField of piece.customFields) {
-          // Créer le champ personnalisé
+      if (typePieceId) {
+        const typePieceCustomFields = await prisma.customField.findMany({
+          where: { typePieceId },
+        });
+
+        for (const customField of typePieceCustomFields) {
+          const defaultValue = customFields.find((cf) => cf.name === customField.name)?.defaultValue || '';
+          await prisma.customFieldValue.create({
+            data: {
+              value: defaultValue,
+              customFieldId: customField.id,
+              pieceId: createdPiece.id,
+            },
+          });
+        }
+      } else if (customFields.length > 0) {
+        for (const customField of customFields) {
           const createdCustomField = await prisma.customField.create({
             data: {
               name: customField.name,
@@ -265,11 +615,10 @@ export class MachinesService {
               required: customField.required || false,
               defaultValue: customField.defaultValue,
               options: customField.options || [],
-              typePieceId: null, // Ce champ sera lié à la pièce individuelle
+              typePieceId: null,
             },
           });
 
-          // Créer la valeur par défaut
           await prisma.customFieldValue.create({
             data: {
               value: customField.defaultValue || '',
@@ -316,12 +665,28 @@ export class MachinesService {
         typeMachine: {
           include: {
             customFields: true,
+            componentRequirements: {
+              include: {
+                typeComposant: true,
+              },
+            },
+            pieceRequirements: {
+              include: {
+                typePiece: true,
+              },
+            },
           },
         },
         constructeur: true,
         composants: {
           include: {
             typeComposant: true,
+            composantModel: true,
+            typeMachineComponentRequirement: {
+              include: {
+                typeComposant: true,
+              },
+            },
             sousComposants: true,
             customFieldValues: {
               include: {
@@ -337,6 +702,12 @@ export class MachinesService {
                   },
                 },
                 constructeur: true,
+                pieceModel: true,
+                typeMachinePieceRequirement: {
+                  include: {
+                    typePiece: true,
+                  },
+                },
               },
             },
           },
@@ -349,6 +720,12 @@ export class MachinesService {
               },
             },
             constructeur: true,
+            pieceModel: true,
+            typeMachinePieceRequirement: {
+              include: {
+                typePiece: true,
+              },
+            },
           },
         },
         customFieldValues: {
@@ -369,12 +746,28 @@ export class MachinesService {
         typeMachine: {
           include: {
             customFields: true,
+            componentRequirements: {
+              include: {
+                typeComposant: true,
+              },
+            },
+            pieceRequirements: {
+              include: {
+                typePiece: true,
+              },
+            },
           },
         },
         constructeur: true,
         composants: {
           include: {
             typeComposant: true,
+            composantModel: true,
+            typeMachineComponentRequirement: {
+              include: {
+                typeComposant: true,
+              },
+            },
             sousComposants: true,
             customFieldValues: {
               include: {
@@ -390,6 +783,12 @@ export class MachinesService {
                   },
                 },
                 constructeur: true,
+                pieceModel: true,
+                typeMachinePieceRequirement: {
+                  include: {
+                    typePiece: true,
+                  },
+                },
               },
             },
           },
@@ -402,6 +801,12 @@ export class MachinesService {
               },
             },
             constructeur: true,
+            pieceModel: true,
+            typeMachinePieceRequirement: {
+              include: {
+                typePiece: true,
+              },
+            },
           },
         },
         customFieldValues: {
@@ -423,17 +828,39 @@ export class MachinesService {
         typeMachine: {
           include: {
             customFields: true,
+            componentRequirements: {
+              include: {
+                typeComposant: true,
+              },
+            },
+            pieceRequirements: {
+              include: {
+                typePiece: true,
+              },
+            },
           },
         },
         constructeur: true,
         composants: {
           include: {
             typeComposant: true,
+            composantModel: true,
+            typeMachineComponentRequirement: {
+              include: {
+                typeComposant: true,
+              },
+            },
             sousComposants: true,
             constructeur: true,
             pieces: {
               include: {
                 constructeur: true,
+                pieceModel: true,
+                typeMachinePieceRequirement: {
+                  include: {
+                    typePiece: true,
+                  },
+                },
                 customFieldValues: {
                   include: {
                     customField: true,
@@ -446,6 +873,12 @@ export class MachinesService {
         pieces: {
           include: {
             constructeur: true,
+            pieceModel: true,
+            typeMachinePieceRequirement: {
+              include: {
+                typePiece: true,
+              },
+            },
             customFieldValues: {
               include: {
                 customField: true,