Merge remote-tracking branch 'upstream/main'

backend-node/src/app.ts

@@ -143,6 +143,7 @@ import processWorkStandardRoutes from "./routes/processWorkStandardRoutes"; //
 import aiAssistantProxy from "./routes/aiAssistantProxy"; // AI 어시스턴트 API 프록시 (같은 포트로 서비스)
 import auditLogRoutes from "./routes/auditLogRoutes"; // 통합 변경 이력
 import moldRoutes from "./routes/moldRoutes"; // 금형 관리
+import shippingPlanRoutes from "./routes/shippingPlanRoutes"; // 출하계획 관리
 import { BatchSchedulerService } from "./services/batchSchedulerService";
 // import collectionRoutes from "./routes/collectionRoutes"; // 임시 주석
 // import batchRoutes from "./routes/batchRoutes"; // 임시 주석
@@ -335,6 +336,7 @@ app.use("/api/category-tree", categoryTreeRoutes); // 카테고리 트리 (테
 app.use("/api/process-work-standard", processWorkStandardRoutes); // 공정 작업기준
 app.use("/api/audit-log", auditLogRoutes); // 통합 변경 이력
 app.use("/api/mold", moldRoutes); // 금형 관리
+app.use("/api/shipping-plan", shippingPlanRoutes); // 출하계획 관리
 app.use("/api", screenEmbeddingRoutes); // 화면 임베딩 및 데이터 전달
 app.use("/api/ai/v1", aiAssistantProxy); // AI 어시스턴트 (동일 서비스 내 프록시 → AI 서비스 포트)
 app.use("/api/vehicle", vehicleTripRoutes); // 차량 운행 이력 관리

backend-node/src/controllers/shippingPlanController.ts

@@ -0,0 +1,459 @@
+/**
+ * 출하계획 컨트롤러
+ *
+ * 수주 마스터(sales_order_mng, INTEGER id) 또는
+ * 수주 디테일(sales_order_detail, UUID id) 양쪽에서 호출 가능.
+ *
+ * ID 포맷으로 소스 테이블 자동 감지 → JOIN으로 완전한 정보 조합
+ */
+
+import { Response } from "express";
+import { AuthenticatedRequest } from "../types/auth";
+import { getPool } from "../database/db";
+import { logger } from "../utils/logger";
+
+// UUID 포맷 감지 (하이픈 포함 36자)
+const isUUID = (val: string) =>
+  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+    val
+  );
+
+type SourceTable = "master" | "detail";
+
+interface NormalizedOrder {
+  sourceId: string; // 원본 ID (master: 정수, detail: UUID)
+  masterId: number | null;
+  detailId: string | null;
+  orderNo: string;
+  partCode: string;
+  partName: string;
+  partnerCode: string;
+  partnerName: string;
+  dueDate: string;
+  orderQty: number;
+  shipQty: number;
+  balanceQty: number;
+}
+
+// ─── 소스 테이블 감지 ───
+
+function detectSource(ids: string[]): SourceTable {
+  if (ids.length === 0) return "detail";
+  return ids.every((id) => isUUID(id)) ? "detail" : "master";
+}
+
+// ─── 수주 정보 정규화 (마스터/디테일 양쪽 JOIN) ───
+
+async function getNormalizedOrders(
+  companyCode: string,
+  ids: string[],
+  source: SourceTable
+): Promise<NormalizedOrder[]> {
+  const pool = getPool();
+
+  if (source === "detail") {
+    // 디테일 기준 → 마스터 JOIN (order_no), 거래처 JOIN (customer_mng)
+    // item_info는 LATERAL로 1건만 매칭 (item_number 중복 대비)
+    const res = await pool.query(
+      `SELECT
+        d.id AS detail_id,
+        m.id AS master_id,
+        d.order_no,
+        d.part_code,
+        COALESCE(d.part_name, i.item_name, d.part_code) AS part_name,
+        COALESCE(d.delivery_partner_code, m.partner_id, '') AS partner_code,
+        COALESCE(c.customer_name, d.delivery_partner_code, m.partner_id, '') AS partner_name,
+        COALESCE(d.due_date, m.due_date::text, '') AS due_date,
+        COALESCE(NULLIF(d.qty,'')::numeric, m.order_qty, 0) AS order_qty,
+        COALESCE(NULLIF(d.ship_qty,'')::numeric, m.ship_qty, 0) AS ship_qty,
+        COALESCE(NULLIF(d.balance_qty,'')::numeric, m.balance_qty, 0) AS balance_qty
+       FROM sales_order_detail d
+       LEFT JOIN sales_order_mng m
+         ON d.order_no = m.order_no AND d.company_code = m.company_code
+       LEFT JOIN LATERAL (
+         SELECT item_name FROM item_info
+         WHERE item_number = d.part_code AND company_code = d.company_code
+         LIMIT 1
+       ) i ON true
+       LEFT JOIN customer_mng c
+         ON COALESCE(d.delivery_partner_code, m.partner_id) = c.customer_code
+         AND d.company_code = c.company_code
+       WHERE d.company_code = $1
+         AND d.id = ANY($2::text[])`,
+      [companyCode, ids]
+    );
+
+    return res.rows.map((r) => ({
+      sourceId: r.detail_id,
+      masterId: r.master_id,
+      detailId: r.detail_id,
+      orderNo: r.order_no || "",
+      partCode: r.part_code || "",
+      partName: r.part_name || "",
+      partnerCode: r.partner_code || "",
+      partnerName: r.partner_name || "",
+      dueDate: r.due_date || "",
+      orderQty: Number(r.order_qty || 0),
+      shipQty: Number(r.ship_qty || 0),
+      balanceQty: Number(r.balance_qty || 0),
+    }));
+  } else {
+    // 마스터 기준 → 거래처 JOIN
+    const numericIds = ids.map(Number).filter((n) => !isNaN(n));
+    // item_info는 LATERAL로 1건만 매칭 (item_number 중복 대비)
+    const res = await pool.query(
+      `SELECT
+        m.id AS master_id,
+        NULL AS detail_id,
+        m.order_no,
+        m.part_code,
+        COALESCE(m.part_name, i.item_name, m.part_code, '') AS part_name,
+        COALESCE(m.partner_id, '') AS partner_code,
+        COALESCE(c.customer_name, m.partner_id, '') AS partner_name,
+        COALESCE(m.due_date::text, '') AS due_date,
+        COALESCE(m.order_qty, 0) AS order_qty,
+        COALESCE(m.ship_qty, 0) AS ship_qty,
+        COALESCE(m.balance_qty, 0) AS balance_qty
+       FROM sales_order_mng m
+       LEFT JOIN LATERAL (
+         SELECT item_name FROM item_info
+         WHERE item_number = m.part_code AND company_code = m.company_code
+         LIMIT 1
+       ) i ON true
+       LEFT JOIN customer_mng c
+         ON m.partner_id = c.customer_code AND m.company_code = c.company_code
+       WHERE m.company_code = $1
+         AND m.id = ANY($2::int[])`,
+      [companyCode, numericIds]
+    );
+
+    return res.rows.map((r) => ({
+      sourceId: String(r.master_id),
+      masterId: r.master_id,
+      detailId: null,
+      orderNo: r.order_no || "",
+      partCode: r.part_code || "",
+      partName: r.part_name || "",
+      partnerCode: r.partner_code || "",
+      partnerName: r.partner_name || "",
+      dueDate: r.due_date || "",
+      orderQty: Number(r.order_qty || 0),
+      shipQty: Number(r.ship_qty || 0),
+      balanceQty: Number(r.balance_qty || 0),
+    }));
+  }
+}
+
+// ─── 품목별 집계 + 기존 출하계획 조회 ───
+
+export async function getAggregate(req: AuthenticatedRequest, res: Response) {
+  try {
+    const companyCode = req.user!.companyCode;
+    const { ids } = req.query;
+
+    if (!ids) {
+      return res
+        .status(400)
+        .json({ success: false, message: "ids 파라미터가 필요합니다" });
+    }
+
+    const idList = (ids as string).split(",").filter(Boolean);
+    if (idList.length === 0) {
+      return res
+        .status(400)
+        .json({ success: false, message: "유효한 ID가 필요합니다" });
+    }
+
+    const source = detectSource(idList);
+    logger.info("출하계획 집계 조회", {
+      companyCode,
+      source,
+      idCount: idList.length,
+    });
+
+    // 1) 정규화된 수주 정보 조회 (JOIN 포함)
+    const orders = await getNormalizedOrders(companyCode, idList, source);
+
+    if (orders.length === 0) {
+      return res
+        .status(404)
+        .json({ success: false, message: "해당 수주를 찾을 수 없습니다" });
+    }
+
+    // 2) 품목별 그룹핑
+    const partCodeMap = new Map<string, NormalizedOrder[]>();
+    for (const order of orders) {
+      const key = order.partCode || "UNKNOWN";
+      if (!partCodeMap.has(key)) partCodeMap.set(key, []);
+      partCodeMap.get(key)!.push(order);
+    }
+
+    const pool = getPool();
+    const result: Record<string, any> = {};
+
+    for (const [partCode, partOrders] of partCodeMap) {
+      // 총수주잔량: 선택된 수주들의 balance_qty 합
+      const totalBalance = partOrders.reduce(
+        (s, o) => s + (o.balanceQty > 0 ? o.balanceQty : o.orderQty - o.shipQty),
+        0
+      );
+
+      // 기존 출하계획 조회 (detail_id 또는 sales_order_id 기준)
+      let existingPlans: any[] = [];
+      if (source === "detail") {
+        const planDetailIds = partOrders
+          .map((o) => o.detailId)
+          .filter(Boolean);
+        if (planDetailIds.length > 0) {
+          const planRes = await pool.query(
+            `SELECT id, detail_id, sales_order_id, plan_qty, plan_date,
+                    shipment_plan_no, status
+             FROM shipment_plan
+             WHERE company_code = $1 AND detail_id = ANY($2::text[])
+             ORDER BY created_date DESC`,
+            [companyCode, planDetailIds]
+          );
+          existingPlans = planRes.rows.map((r) => ({
+            id: r.id,
+            sourceId: r.detail_id,
+            planQty: Number(r.plan_qty || 0),
+            planDate: r.plan_date,
+            shipmentPlanNo: r.shipment_plan_no,
+            status: r.status,
+          }));
+        }
+      } else {
+        const planMasterIds = partOrders
+          .map((o) => o.masterId)
+          .filter((id): id is number => id != null);
+        if (planMasterIds.length > 0) {
+          const planRes = await pool.query(
+            `SELECT id, sales_order_id, detail_id, plan_qty, plan_date,
+                    shipment_plan_no, status
+             FROM shipment_plan
+             WHERE company_code = $1 AND sales_order_id = ANY($2::int[])
+             ORDER BY created_date DESC`,
+            [companyCode, planMasterIds]
+          );
+          existingPlans = planRes.rows.map((r) => ({
+            id: r.id,
+            sourceId: String(r.sales_order_id),
+            planQty: Number(r.plan_qty || 0),
+            planDate: r.plan_date,
+            shipmentPlanNo: r.shipment_plan_no,
+            status: r.status,
+          }));
+        }
+      }
+
+      const totalPlanQty = existingPlans.reduce((s, p) => s + p.planQty, 0);
+
+      // 현재고
+      const stockRes = await pool.query(
+        `SELECT COALESCE(SUM(current_qty::numeric), 0) AS current_stock
+         FROM inventory_stock
+         WHERE company_code = $1 AND item_code = $2`,
+        [companyCode, partCode]
+      );
+      const currentStock = Number(stockRes.rows[0]?.current_stock || 0);
+
+      // 생산중수량
+      const prodRes = await pool.query(
+        `SELECT COALESCE(SUM(plan_qty - COALESCE(completed_qty, 0)), 0) AS in_production
+         FROM production_plan_mng
+         WHERE company_code = $1
+           AND item_code = $2
+           AND status IN ('in_progress', 'planned')`,
+        [companyCode, partCode]
+      );
+      const inProductionQty = Number(prodRes.rows[0]?.in_production || 0);
+
+      result[partCode] = {
+        totalBalance,
+        totalPlanQty,
+        currentStock,
+        availableStock: currentStock - totalPlanQty,
+        inProductionQty,
+        existingPlans,
+        orders: partOrders.map((o) => ({
+          sourceId: o.sourceId,
+          orderNo: o.orderNo,
+          partCode: o.partCode,
+          partName: o.partName,
+          partnerName: o.partnerName,
+          dueDate: o.dueDate,
+          orderQty: o.orderQty,
+          shipQty: o.shipQty,
+          balanceQty: o.balanceQty,
+        })),
+      };
+    }
+
+    logger.info("출하계획 집계 조회 완료", {
+      companyCode,
+      source,
+      partCodes: Array.from(partCodeMap.keys()),
+      orderCount: orders.length,
+    });
+
+    return res.json({ success: true, data: result, source });
+  } catch (error: any) {
+    logger.error("출하계획 집계 조회 실패", {
+      error: error.message,
+      stack: error.stack,
+    });
+    return res.status(500).json({ success: false, message: error.message });
+  }
+}
+
+// ─── 출하계획 일괄 저장 ───
+
+export async function batchSave(req: AuthenticatedRequest, res: Response) {
+  try {
+    const companyCode = req.user!.companyCode;
+    const userId = req.user!.userId;
+    const { plans, source } = req.body;
+
+    if (!Array.isArray(plans) || plans.length === 0) {
+      return res.status(400).json({
+        success: false,
+        message: "저장할 출하계획 데이터가 필요합니다",
+      });
+    }
+
+    // source 자동 감지 (프론트에서 전달, 또는 ID 포맷으로 추론)
+    const detectedSource: SourceTable =
+      source || detectSource(plans.map((p: any) => String(p.sourceId)));
+
+    const pool = getPool();
+    const client = await pool.connect();
+
+    try {
+      await client.query("BEGIN");
+      const savedPlans = [];
+
+      for (const plan of plans) {
+        const { sourceId, planQty, planDate } = plan;
+        if (!sourceId || !planQty || planQty <= 0) continue;
+        const planDateValue = planDate || null;
+
+        if (detectedSource === "detail") {
+          // 디테일 소스: detail_id로 저장
+          const detailCheck = await client.query(
+            `SELECT d.id, d.order_no, d.part_code, d.qty, d.ship_qty, d.balance_qty,
+                    m.id AS master_id
+             FROM sales_order_detail d
+             LEFT JOIN sales_order_mng m
+               ON d.order_no = m.order_no AND d.company_code = m.company_code
+             WHERE d.id = $1 AND d.company_code = $2`,
+            [sourceId, companyCode]
+          );
+
+          if (detailCheck.rowCount === 0) {
+            throw new Error(`수주상세 ${sourceId}을 찾을 수 없습니다`);
+          }
+
+          const detail = detailCheck.rows[0];
+          const qty = Number(detail.qty || 0);
+          const shipQty = Number(detail.ship_qty || 0);
+          const balanceQty = detail.balance_qty
+            ? Number(detail.balance_qty)
+            : qty - shipQty;
+
+          if (balanceQty > 0 && planQty > balanceQty) {
+            throw new Error(
+              `수주번호 ${detail.order_no}: 출하계획량(${planQty})이 미출하량(${balanceQty})을 초과합니다`
+            );
+          }
+
+          const insertRes = await client.query(
+            `INSERT INTO shipment_plan
+              (company_code, detail_id, sales_order_id, plan_qty, plan_date, status, created_by)
+             VALUES ($1, $2, $3, $4, COALESCE($5::date, CURRENT_DATE), 'READY', $6)
+             RETURNING *`,
+            [companyCode, sourceId, detail.master_id, planQty, planDateValue, userId]
+          );
+          savedPlans.push(insertRes.rows[0]);
+
+          // detail ship_qty 업데이트
+          await client.query(
+            `UPDATE sales_order_detail
+             SET ship_qty = (COALESCE(NULLIF(ship_qty,'')::numeric, 0) + $1)::text,
+                 balance_qty = (COALESCE(NULLIF(qty,'')::numeric, 0)
+                   - COALESCE(NULLIF(ship_qty,'')::numeric, 0) - $1)::text,
+                 updated_date = NOW()
+             WHERE id = $2 AND company_code = $3`,
+            [planQty, sourceId, companyCode]
+          );
+        } else {
+          // 마스터 소스: sales_order_id로 저장
+          const masterId = Number(sourceId);
+          const masterCheck = await client.query(
+            `SELECT id, order_no, order_qty, ship_qty, balance_qty
+             FROM sales_order_mng
+             WHERE id = $1 AND company_code = $2`,
+            [masterId, companyCode]
+          );
+
+          if (masterCheck.rowCount === 0) {
+            throw new Error(`수주 ID ${masterId}을 찾을 수 없습니다`);
+          }
+
+          const master = masterCheck.rows[0];
+          const balanceQty = Number(master.balance_qty || 0);
+
+          if (balanceQty > 0 && planQty > balanceQty) {
+            throw new Error(
+              `수주번호 ${master.order_no}: 출하계획량(${planQty})이 미출하량(${balanceQty})을 초과합니다`
+            );
+          }
+
+          const insertRes = await client.query(
+            `INSERT INTO shipment_plan
+              (company_code, sales_order_id, plan_qty, plan_date, status, created_by)
+             VALUES ($1, $2, $3, COALESCE($4::date, CURRENT_DATE), 'READY', $5)
+             RETURNING *`,
+            [companyCode, masterId, planQty, planDateValue, userId]
+          );
+          savedPlans.push(insertRes.rows[0]);
+
+          // 마스터 ship_qty 업데이트
+          await client.query(
+            `UPDATE sales_order_mng
+             SET ship_qty = COALESCE(ship_qty, 0) + $1,
+                 balance_qty = COALESCE(order_qty, 0) - COALESCE(ship_qty, 0) - $1,
+                 updated_date = NOW()
+             WHERE id = $2 AND company_code = $3`,
+            [planQty, masterId, companyCode]
+          );
+        }
+      }
+
+      await client.query("COMMIT");
+
+      logger.info("출하계획 일괄 저장 완료", {
+        companyCode,
+        source: detectedSource,
+        savedCount: savedPlans.length,
+        userId,
+      });
+
+      return res.json({
+        success: true,
+        message: `${savedPlans.length}건 저장 완료`,
+        data: savedPlans,
+      });
+    } catch (txError) {
+      await client.query("ROLLBACK");
+      throw txError;
+    } finally {
+      client.release();
+    }
+  } catch (error: any) {
+    logger.error("출하계획 일괄 저장 실패", {
+      error: error.message,
+      stack: error.stack,
+    });
+    return res.status(500).json({ success: false, message: error.message });
+  }
+}

backend-node/src/routes/shippingPlanRoutes.ts

@@ -0,0 +1,19 @@
+/**
+ * 출하계획 라우트
+ */
+
+import { Router } from "express";
+import { authenticateToken } from "../middleware/authMiddleware";
+import * as shippingPlanController from "../controllers/shippingPlanController";
+
+const router = Router();
+
+router.use(authenticateToken);
+
+// 품목별 집계 + 기존 출하계획 조회
+router.get("/aggregate", shippingPlanController.getAggregate);
+
+// 출하계획 일괄 저장
+router.post("/batch", shippingPlanController.batchSave);
+
+export default router;

backend-node/src/services/nodeFlowExecutionService.ts

@@ -952,13 +952,20 @@ export class NodeFlowExecutionService {
       }
 
       const schemaPrefix = schema ? `${schema}.` : "";
+
+      // WHERE 조건에서 field 값 조회를 위해 컨텍스트 데이터 전달
+      // sourceData(저장된 폼 데이터) + buttonContext(인증 정보) 병합
+      const contextForWhere = {
+        ...(context.buttonContext || {}),
+        ...(context.sourceData?.[0] || {}),
+      };
       const whereResult = whereConditions
-        ? this.buildWhereClause(whereConditions)
+        ? this.buildWhereClause(whereConditions, contextForWhere)
         : { clause: "", values: [] };
 
       const sql = `SELECT * FROM ${schemaPrefix}${tableName} ${whereResult.clause}`;
 
-      logger.info(`📊 테이블 전체 데이터 조회 SQL: ${sql}`);
+      logger.info(`📊 테이블 전체 데이터 조회 SQL: ${sql}`, { values: whereResult.values });
 
       const result = await query(sql, whereResult.values);