leistungsbilanz-ts/src/db/repositories/circuit-device-row.repository.ts

import crypto from "node:crypto";
import { and, asc, eq, inArray } from "drizzle-orm";
import { db } from "../client.js";
import { circuitDeviceRows } from "../schema/circuit-device-rows.js";
import { circuitLists } from "../schema/circuit-lists.js";
import { circuits } from "../schema/circuits.js";
import { distributionBoards } from "../schema/distribution-boards.js";
import {
  toCircuitDeviceRowCreateValues,
  toCircuitDeviceRowUpdateValues,
  type CircuitDeviceRowCreateInput,
  type CircuitDeviceRowUpdateInput,
} from "./circuit-device-row.persistence.js";
export type {
  CircuitDeviceRowCreateInput,
  CircuitDeviceRowUpdateInput,
} from "./circuit-device-row.persistence.js";
export { toCircuitDeviceRowCreateValues } from "./circuit-device-row.persistence.js";

export class CircuitDeviceRowRepository {
  async findById(rowId: string) {
    const [row] = await db.select().from(circuitDeviceRows).where(eq(circuitDeviceRows.id, rowId)).limit(1);
    return row ?? null;
  }

  async countByCircuit(circuitId: string) {
    const rows = await db.select({ id: circuitDeviceRows.id }).from(circuitDeviceRows).where(eq(circuitDeviceRows.circuitId, circuitId));
    return rows.length;
  }

  async listByCircuitList(circuitIds: string[]) {
    if (!circuitIds.length) {
      return [];
    }
    return db
      .select()
      .from(circuitDeviceRows)
      .where(inArray(circuitDeviceRows.circuitId, circuitIds))
      .orderBy(asc(circuitDeviceRows.sortOrder));
  }

  async listLinkedByProjectDevice(projectId: string, projectDeviceId: string) {
    return db
      .select({
        id: circuitDeviceRows.id,
        circuitId: circuitDeviceRows.circuitId,
        linkedProjectDeviceId: circuitDeviceRows.linkedProjectDeviceId,
        legacyConsumerId: circuitDeviceRows.legacyConsumerId,
        sortOrder: circuitDeviceRows.sortOrder,
        name: circuitDeviceRows.name,
        displayName: circuitDeviceRows.displayName,
        phaseType: circuitDeviceRows.phaseType,
        connectionKind: circuitDeviceRows.connectionKind,
        costGroup: circuitDeviceRows.costGroup,
        category: circuitDeviceRows.category,
        level: circuitDeviceRows.level,
        roomId: circuitDeviceRows.roomId,
        roomNumberSnapshot: circuitDeviceRows.roomNumberSnapshot,
        roomNameSnapshot: circuitDeviceRows.roomNameSnapshot,
        quantity: circuitDeviceRows.quantity,
        powerPerUnit: circuitDeviceRows.powerPerUnit,
        simultaneityFactor: circuitDeviceRows.simultaneityFactor,
        cosPhi: circuitDeviceRows.cosPhi,
        remark: circuitDeviceRows.remark,
        overriddenFields: circuitDeviceRows.overriddenFields,
        equipmentIdentifier: circuits.equipmentIdentifier,
        circuitDisplayName: circuits.displayName,
        circuitListId: circuitLists.id,
        circuitListName: circuitLists.name,
        distributionBoardId: distributionBoards.id,
        distributionBoardName: distributionBoards.name,
      })
      .from(circuitDeviceRows)
      .innerJoin(circuits, eq(circuitDeviceRows.circuitId, circuits.id))
      .innerJoin(circuitLists, eq(circuits.circuitListId, circuitLists.id))
      .innerJoin(distributionBoards, eq(circuitLists.distributionBoardId, distributionBoards.id))
      .where(
        and(
          eq(circuitDeviceRows.linkedProjectDeviceId, projectDeviceId),
          eq(circuitLists.projectId, projectId)
        )
      )
      .orderBy(asc(distributionBoards.name), asc(circuits.equipmentIdentifier), asc(circuitDeviceRows.sortOrder));
  }

  async create(input: CircuitDeviceRowCreateInput) {
    const id = crypto.randomUUID();
    await db.insert(circuitDeviceRows).values(toCircuitDeviceRowCreateValues(id, input));
    return id;
  }

  async update(
    rowId: string,
    input: CircuitDeviceRowUpdateInput
  ) {
    await db
      .update(circuitDeviceRows)
      .set(toCircuitDeviceRowUpdateValues(input))
      .where(eq(circuitDeviceRows.id, rowId));
  }

  async delete(rowId: string) {
    await db.delete(circuitDeviceRows).where(eq(circuitDeviceRows.id, rowId));
  }

  async moveToCircuit(rowId: string, targetCircuitId: string, sortOrder: number) {
    await db
      .update(circuitDeviceRows)
      .set({
        circuitId: targetCircuitId,
        sortOrder,
      })
      .where(eq(circuitDeviceRows.id, rowId));
  }

}