Started multiline manipulations

src/domain/services/circuit-write.service.ts

@@ -7,6 +7,7 @@ import type {
   CreateCircuitDeviceRowInput,
   CreateCircuitInput,
   MoveCircuitDeviceRowInput,
+  MoveCircuitDeviceRowsBulkInput,
   ReorderSectionCircuitsInput,
   UpdateSectionEquipmentIdentifiersInput,
   UpdateCircuitDeviceRowInput,
@@ -365,6 +366,128 @@ export class CircuitWriteService {
     return this.deviceRowRepository.findById(rowId);
   }
 
+  async moveDeviceRowsBulk(input: MoveCircuitDeviceRowsBulkInput) {
+    const uniqueRowIds = [...new Set(input.rowIds)];
+    if (uniqueRowIds.length === 0) {
+      throw new Error("No device rows provided.");
+    }
+
+    const rows = [];
+    for (const rowId of uniqueRowIds) {
+      const row = await this.deviceRowRepository.findById(rowId);
+      if (!row) {
+        throw new Error("Invalid device row id.");
+      }
+      rows.push(row);
+    }
+
+    const sourceCircuits = new Map<string, Awaited<ReturnType<CircuitRepository["findById"]>>>();
+    for (const row of rows) {
+      if (!sourceCircuits.has(row.circuitId)) {
+        const circuit = await this.circuitRepository.findById(row.circuitId);
+        if (!circuit) {
+          throw new Error("Invalid circuit id.");
+        }
+        sourceCircuits.set(row.circuitId, circuit);
+      }
+    }
+
+    const referenceSourceCircuit = sourceCircuits.get(rows[0].circuitId)!;
+    let targetCircuit = input.targetCircuitId
+      ? await this.circuitRepository.findById(input.targetCircuitId)
+      : null;
+    if (input.targetCircuitId && !targetCircuit) {
+      throw new Error("Invalid target circuit id.");
+    }
+
+    if (!targetCircuit) {
+      if (!input.targetSectionId || !input.createNewCircuit) {
+        throw new Error("Invalid move target.");
+      }
+      const section = await this.assertSectionInList(input.targetSectionId, referenceSourceCircuit.circuitListId);
+      const nextIdentifier = await this.numberingService.getNextIdentifier(section.id);
+      const sectionCircuits = await this.circuitRepository.listBySection(section.id);
+      const nextSortOrder =
+        sectionCircuits.length > 0 ? Math.max(...sectionCircuits.map((circuit) => circuit.sortOrder)) + 10 : 10;
+      const createdId = await this.circuitRepository.create({
+        circuitListId: referenceSourceCircuit.circuitListId,
+        sectionId: section.id,
+        equipmentIdentifier: nextIdentifier,
+        displayName: "New circuit",
+        sortOrder: nextSortOrder,
+        isReserve: false,
+      });
+      targetCircuit = await this.circuitRepository.findById(createdId);
+      if (!targetCircuit) {
+        throw new Error("Failed to create target circuit.");
+      }
+    }
+
+    for (const sourceCircuit of sourceCircuits.values()) {
+      if (sourceCircuit.circuitListId !== targetCircuit.circuitListId) {
+        throw new Error("All moved rows must belong to same circuit list as target.");
+      }
+    }
+
+    const targetCount = await this.deviceRowRepository.countByCircuit(targetCircuit.id);
+    let offset = 1;
+    for (const row of rows) {
+      await this.deviceRowRepository.moveToCircuit(row.id, targetCircuit.id, (targetCount + offset) * 10);
+      offset += 1;
+    }
+
+    for (const sourceCircuit of sourceCircuits.values()) {
+      const remaining = await this.deviceRowRepository.countByCircuit(sourceCircuit.id);
+      if (remaining === 0) {
+        await this.circuitRepository.update(sourceCircuit.id, {
+          sectionId: sourceCircuit.sectionId,
+          equipmentIdentifier: sourceCircuit.equipmentIdentifier,
+          displayName: sourceCircuit.displayName ?? undefined,
+          sortOrder: sourceCircuit.sortOrder,
+          protectionType: sourceCircuit.protectionType ?? undefined,
+          protectionRatedCurrent: sourceCircuit.protectionRatedCurrent ?? undefined,
+          protectionCharacteristic: sourceCircuit.protectionCharacteristic ?? undefined,
+          cableType: sourceCircuit.cableType ?? undefined,
+          cableCrossSection: sourceCircuit.cableCrossSection ?? undefined,
+          cableLength: sourceCircuit.cableLength ?? undefined,
+          rcdAssignment: sourceCircuit.rcdAssignment ?? undefined,
+          terminalDesignation: sourceCircuit.terminalDesignation ?? undefined,
+          voltage: sourceCircuit.voltage ?? undefined,
+          status: sourceCircuit.status ?? undefined,
+          isReserve: true,
+          remark: sourceCircuit.remark ?? undefined,
+        });
+      }
+    }
+
+    if (Boolean(targetCircuit.isReserve)) {
+      await this.circuitRepository.update(targetCircuit.id, {
+        sectionId: targetCircuit.sectionId,
+        equipmentIdentifier: targetCircuit.equipmentIdentifier,
+        displayName: targetCircuit.displayName ?? undefined,
+        sortOrder: targetCircuit.sortOrder,
+        protectionType: targetCircuit.protectionType ?? undefined,
+        protectionRatedCurrent: targetCircuit.protectionRatedCurrent ?? undefined,
+        protectionCharacteristic: targetCircuit.protectionCharacteristic ?? undefined,
+        cableType: targetCircuit.cableType ?? undefined,
+        cableCrossSection: targetCircuit.cableCrossSection ?? undefined,
+        cableLength: targetCircuit.cableLength ?? undefined,
+        rcdAssignment: targetCircuit.rcdAssignment ?? undefined,
+        terminalDesignation: targetCircuit.terminalDesignation ?? undefined,
+        voltage: targetCircuit.voltage ?? undefined,
+        status: targetCircuit.status ?? undefined,
+        isReserve: false,
+        remark: targetCircuit.remark ?? undefined,
+      });
+    }
+
+    return {
+      movedRowIds: rows.map((row) => row.id),
+      targetCircuitId: targetCircuit.id,
+      createdCircuitId: input.targetCircuitId ? undefined : targetCircuit.id,
+    };
+  }
+
   async getNextIdentifier(sectionId: string) {
     return this.numberingService.getNextIdentifier(sectionId);
   }