(김준회) RFQ 인터페이스 처리, 변수명 오타 수정(VendorPossibleMaterials), 협력업체 관리페이지 구매요구사항 반영

1 files changed, 282 insertions, 132 deletions

diff --git a/lib/soap/ecc/mapper/rfq-and-pr-mapper.ts b/lib/soap/ecc/mapper/rfq-and-pr-mapper.ts
index e2258a4c..e8697bae 100644
--- a/lib/soap/ecc/mapper/rfq-and-pr-mapper.ts
+++ b/lib/soap/ecc/mapper/rfq-and-pr-mapper.ts
@@ -1,31 +1,25 @@
 import { debugLog, debugSuccess, debugError } from '@/lib/debug-utils';
 import db from '@/db/db';
 import {
-  procurementRfqs,
-  prItems,
-  procurementRfqDetails,
-} from '@/db/schema/procurementRFQ';
+  rfqsLast,
+  rfqPrItems,
+} from '@/db/schema/rfqLast';
 import {
   PR_INFORMATION_T_BID_HEADER,
   PR_INFORMATION_T_BID_ITEM,
 } from '@/db/schema/ECC/ecc';
 import { users } from '@/db/schema';
-import { employee } from '@/db/schema/knox/employee';
-import { eq, inArray } from 'drizzle-orm';
-
-// NON-SAP 데이터 처리
-import { oracleKnex } from '@/lib/oracle-db/db';
-import { findUserIdByEmployeeNumber } from '../../../users/knox-service';
+import { projects } from '@/db/schema/projects';
+import { MATERIAL_MASTER_PART_MATL } from '@/db/schema/MDG/mdg';
+import { eq, inArray, max, sql } from 'drizzle-orm';
 
 // ECC 데이터 타입 정의
 export type ECCBidHeader = typeof PR_INFORMATION_T_BID_HEADER.$inferInsert;
 export type ECCBidItem = typeof PR_INFORMATION_T_BID_ITEM.$inferInsert;
 
 // 비즈니스 테이블 데이터 타입 정의
-export type ProcurementRfqData = typeof procurementRfqs.$inferInsert;
-export type PrItemData = typeof prItems.$inferInsert;
-export type ProcurementRfqDetailData =
-  typeof procurementRfqDetails.$inferInsert;
+export type RfqLastData = typeof rfqsLast.$inferInsert;
+export type RfqPrItemData = typeof rfqPrItems.$inferInsert;
 
 /**
  * 시리즈 판단: 관련 PR 아이템들의 PSPID를 기반으로 결정
@@ -50,81 +44,173 @@ function computeSeriesFromItems(items: ECCBidItem[]): string | null {
 }
 
 /**
- * PERNR(사번)을 기준으로 사용자 ID를 찾는 함수
+ * 담당자 찾는 함수 (userCode 기반으로 직접 조회)
+ * EKGRP(구매그룹코드)를 users 테이블의 userCode와 매칭하여 사용자 찾기
  */
-async function findUserIdByPernr(pernr: string): Promise<number | null> {
+async function findInChargeUserIdByEKGRP(EKGRP: string | null): Promise<number | null> {
   try {
-    debugLog('PERNR로 사용자 ID 찾기 시작', { pernr });
-
-    // 현재 users 테이블에 사번을 따로 저장하지 않으므로 knox 기준으로 사번 --> epId --> user.id 순으로 찾기
-    // 1. employee 테이블에서 employeeNumber로 epId 찾기
-    const employeeResult = await db
-      .select({ epId: employee.epId })
-      .from(employee)
-      .where(eq(employee.employeeNumber, pernr))
-      .limit(1);
-
-    if (employeeResult.length === 0) {
-      debugError('사번에 해당하는 직원 정보를 찾을 수 없음', { pernr });
+    debugLog('담당자 찾기 시작', { EKGRP });
+    
+    if (!EKGRP) {
+      debugError('EKGRP가 null 또는 undefined', { EKGRP });
       return null;
     }
 
-    const epId = employeeResult[0].epId;
-    debugLog('직원 epId 찾음', { pernr, epId });
-
-    // 2. users 테이블에서 epId로 사용자 ID 찾기
+    // users 테이블에서 userCode로 직접 조회
     const userResult = await db
       .select({ id: users.id })
       .from(users)
-      .where(eq(users.epId, epId))
+      .where(eq(users.userCode, EKGRP))
       .limit(1);
 
     if (userResult.length === 0) {
-      debugError('epId에 해당하는 사용자 정보를 찾을 수 없음', { epId });
+      debugError('EKGRP에 해당하는 사용자를 찾을 수 없음', { EKGRP });
       return null;
     }
 
     const userId = userResult[0].id;
-    debugSuccess('사용자 ID 찾음', { pernr, epId, userId });
+    debugSuccess('담당자 찾음', { EKGRP, userId });
     return userId;
   } catch (error) {
-    debugError('사용자 ID 찾기 중 오류 발생', { pernr, error });
+    debugError('담당자 찾기 중 오류 발생', { EKGRP, error });
     return null;
   }
 }
 
-
+/**
+ * RFQ 코드 생성 함수 (배치 처리용)
+ * 형식: RFQ{EKGRP}{00001}
+ * 동일한 EKGRP의 여러 RFQ가 동시에 처리될 때 중복 방지
+ */
+async function generateRfqCodes(eccHeaders: ECCBidHeader[]): Promise<Map<string, string>> {
+  try {
+    debugLog('RFQ 코드 배치 생성 시작', { headerCount: eccHeaders.length });
+    
+    const rfqCodeMap = new Map<string, string>();
+    
+    // EKGRP별로 그룹핑
+    const ekgrpGroups = new Map<string, ECCBidHeader[]>();
+    for (const header of eccHeaders) {
+      const ekgrp = header.EKGRP || 'UNKNOWN';
+      if (!ekgrpGroups.has(ekgrp)) {
+        ekgrpGroups.set(ekgrp, []);
+      }
+      ekgrpGroups.get(ekgrp)!.push(header);
+    }
+    
+    // EKGRP별로 순차 처리
+    for (const [ekgrp, headers] of ekgrpGroups) {
+      // 해당 EKGRP의 현재 최대 시퀀스 조회
+      const maxResult = await db
+        .select({ 
+          maxRfqCode: max(rfqsLast.rfqCode)
+        })
+        .from(rfqsLast)
+        .where(eq(rfqsLast.picCode, ekgrp));
+
+      let nextSeq = 1;
+      if (maxResult[0]?.maxRfqCode) {
+        const prefix = `RFQ${ekgrp}`;
+        const currentCode = maxResult[0].maxRfqCode;
+        if (currentCode.startsWith(prefix)) {
+          const seqPart = currentCode.substring(prefix.length);
+          const currentSeq = parseInt(seqPart, 10);
+          if (!isNaN(currentSeq)) {
+            nextSeq = currentSeq + 1;
+          }
+        }
+      }
+      
+      // 동일 EKGRP 내에서 순차적으로 코드 생성
+      for (const header of headers) {
+        const seqString = nextSeq.toString().padStart(5, '0');
+        const rfqCode = `RFQ${ekgrp}${seqString}`;
+        rfqCodeMap.set(header.ANFNR, rfqCode);
+        nextSeq++; // 다음 시퀀스로 증가
+      }
+    }
+    
+    debugSuccess('RFQ 코드 배치 생성 완료', { 
+      totalCodes: rfqCodeMap.size,
+      ekgrpCount: ekgrpGroups.size 
+    });
+    return rfqCodeMap;
+  } catch (error) {
+    debugError('RFQ 코드 배치 생성 중 오류 발생', { error });
+    
+    // 오류 발생시 폴백: ANFNR 기반 코드 생성
+    const fallbackMap = new Map<string, string>();
+    eccHeaders.forEach((header, index) => {
+      const ekgrp = header.EKGRP || 'UNKNOWN';
+      const seqString = (index + 1).toString().padStart(5, '0');
+      fallbackMap.set(header.ANFNR, `RFQ${ekgrp}${seqString}`);
+    });
+    return fallbackMap;
+  }
+}
 
 /**
- * 담당자 찾는 함수 (Non-SAP 데이터를 기준으로 찾음)
- * Puchasing Group을 CMCTB_CD 에서 CD_CLF='MMA070' 조건으로, CD=EKGRP 조건으로 찾으면, USR_DF_CHAR_9 컬럼이 담당자 사번임. 기준으로 유저를 넣어줄 예정임
+ * 프로젝트 ID 찾기 함수
+ * 첫번째 PR Item의 PSPID와 projects.code 매칭
  */
-async function findInChargeUserIdByEKGRP(EKGRP: string | null): Promise<number | null> {
+async function findProjectIdByPSPID(PSPID: string | null): Promise<number | null> {
   try {
-    debugLog('담당자 찾기 시작', { EKGRP });
-    // NonSAP에서 담당자 사번 찾기
+    debugLog('프로젝트 ID 찾기 시작', { PSPID });
+    
+    if (!PSPID) {
+      debugError('PSPID가 null 또는 undefined', { PSPID });
+      return null;
+    }
 
-    const result = await oracleKnex
-      .select('USR_DF_CHAR_9')
-      .from('CMCTB_CD')
-      .where('CD_CLF', 'MMA070')
-      .andWhere('CD', EKGRP)
+    const projectResult = await db
+      .select({ id: projects.id })
+      .from(projects)
+      .where(eq(projects.code, PSPID))
       .limit(1);
 
-    if (result.length === 0) {
-      debugError('담당자 찾기 중 오류 발생', { EKGRP });
+    if (projectResult.length === 0) {
+      debugError('PSPID에 해당하는 프로젝트를 찾을 수 없음', { PSPID });
+      return null;
+    }
+
+    const projectId = projectResult[0].id;
+    debugSuccess('프로젝트 ID 찾음', { PSPID, projectId });
+    return projectId;
+  } catch (error) {
+    debugError('프로젝트 ID 찾기 중 오류 발생', { PSPID, error });
+    return null;
+  }
+}
+
+/**
+ * 자재명 조회 함수
+ * MATNR을 기반으로 MDG 테이블에서 ZZNAME 조회
+ */
+async function findMaterialNameByMATNR(MATNR: string | null): Promise<string | null> {
+  try {
+    debugLog('자재명 조회 시작', { MATNR });
+    
+    if (!MATNR) {
+      debugError('MATNR이 null 또는 undefined', { MATNR });
       return null;
     }
 
-    const employeeNumber = result[0].USR_DF_CHAR_9;
+    const materialResult = await db
+      .select({ ZZNAME: MATERIAL_MASTER_PART_MATL.ZZNAME })
+      .from(MATERIAL_MASTER_PART_MATL)
+      .where(eq(MATERIAL_MASTER_PART_MATL.MATNR, MATNR))
+      .limit(1);
 
-    // 임시 : Knox API 기준으로 사번에 해당하는 userId 찾기 (nonsap에서 제공하는 유저테이블로 변경 예정)
-    const userId = await findUserIdByEmployeeNumber(employeeNumber);
+    if (materialResult.length === 0) {
+      debugError('MATNR에 해당하는 자재를 찾을 수 없음', { MATNR });
+      return null;
+    }
 
-    debugSuccess('담당자 찾음', { EKGRP, userId });
-    return userId;
+    const materialName = materialResult[0].ZZNAME;
+    debugSuccess('자재명 조회 완료', { MATNR, materialName });
+    return materialName;
   } catch (error) {
-    debugError('담당자 찾기 중 오류 발생', { EKGRP, error });
+    debugError('자재명 조회 중 오류 발생', { MATNR, error });
     return null;
   }
 }
@@ -132,13 +218,19 @@ async function findInChargeUserIdByEKGRP(EKGRP: string | null): Promise<number |
 // *****************************mapping functions*********************************
 
 /**
- * ECC RFQ 헤더 데이터를 비즈니스 테이블로 매핑
+ * ECC RFQ 헤더 데이터를 rfqsLast 테이블로 매핑
+ * 매핑 규칙에 따라 첫번째 PR Item 정보로 헤더 필드들을 채움
  */
-export async function mapECCRfqHeaderToBusiness(
-  eccHeader: ECCBidHeader
-): Promise<ProcurementRfqData> {
-  debugLog('ECC RFQ 헤더 매핑 시작', { anfnr: eccHeader.ANFNR });
-
+export async function mapECCRfqHeaderToRfqLast(
+  eccHeader: ECCBidHeader,
+  eccItems: ECCBidItem[],
+  rfqCode: string
+): Promise<RfqLastData> {
+  debugLog('ECC RFQ 헤더 매핑 시작', { anfnr: eccHeader.ANFNR, rfqCode });
+
+  // 첫번째 PR Item 가져오기 (관련 아이템들 중 첫번째)
+  const firstItem = eccItems.find(item => item.ANFNR === eccHeader.ANFNR);
+  
   // 날짜 파싱 (실패시 현재 Date 들어감)
   let interfacedAt: Date = new Date();
 
@@ -166,44 +258,72 @@ export async function mapECCRfqHeaderToBusiness(
 
   // 담당자 찾기
   const inChargeUserId = await findInChargeUserIdByEKGRP(eccHeader.EKGRP || null);
-
-  // 시리즈는 3가지의 케이스만 온다고 가정한다. (다른 케이스는 잘못된 것)
-  // 케이스 1. 한 RFQ에서 PR Item이 여러 개고, PSPID 값이 모두 같은 경우 => series 값은 "SS"
-  // 케이스 2. 한 RFQ에서 PR Item이 여러 개고, PSPID 값이 여러개인 경우 => series 값은 "||""
-  // 케이스 3. 한 RFQ에서 PR Item이 하나인 경우 => seires 값은 null
-  // 만약 위 케이스에 모두 속하지 않는 경우 케이스 3처럼 null 값을 넣는다.
+  
+  // 첫번째 PR Item 기반으로 projectId, itemCode, itemName 설정
+  let projectId: number | null = null;
+  let itemCode: string | null = null;
+  let itemName: string | null = null;
+  let prNumber: string | null = null;
+  
+  if (firstItem) {
+    // projectId: 첫번째 PR Item의 PSPID와 projects.code 매칭
+    projectId = await findProjectIdByPSPID(firstItem.PSPID || null);
+    
+    // itemCode: 첫번째 PR Item의 MATKL
+    itemCode = firstItem.MATKL || null;
+    
+    // itemName: 첫번째 PR Item의 MATNR로 MDG에서 ZZNAME 조회
+    itemName = await findMaterialNameByMATNR(firstItem.MATNR || null);
+    
+    // prNumber: 첫번째 PR의 ZREQ_FN 값
+    prNumber = firstItem.ZREQ_FN || null;
+  }
 
   // 매핑
-  const mappedData: ProcurementRfqData = {
-    rfqCode: eccHeader.ANFNR, // rfqCode=rfqNumber(ANFNR), 혼선이 있을 수 있으나 ECC에는 rfqCode라는 게 별도로 없음. rfqCode=rfqNumber
-    projectId: null, // PR 아이템 처리 후 업데이트. (로직은 추후 작성)
-    series: null, // PR 아이템 처리 후 업데이트. (로직은 추후 작성)
-    // itemGroup: null, // 대표 자재그룹: PR 아이템 처리 후 업데이트. (로직은 추후 작성)
-    itemCode: null, // 대표 자재코드: PR 아이템 처리 후 업데이트. (로직은 추후 작성)
-    itemName: null, // 대표 자재명: PR 아이템 처리 후 업데이트. (로직은 추후 작성)
-    dueDate: null, // eVCP에서 사용하는 컬럼이므로 불필요.
-    rfqSendDate: null, // eVCP에서 사용하는 컬럼이므로 불필요.
-    createdAt: interfacedAt,
-    status: 'RFQ Created', // eVCP에서 사용하는 컬럼, 기본값 RFQ Created 처리
-    rfqSealedYn: false, // eVCP에서 사용하는 컬럼, 기본값 false 처리
-    picCode: eccHeader.EKGRP || null, // Purchasing Group을 PIC로 사용 (구매측 임직원과 연계된 코드임)
-    remark: null, // remark 컬럼은 담당자 메모용으로 넣어줄 필요 없음.
-    sentBy: null, // 보내기 전의 RFQ를 대상으로 하므로 넣어줄 필요 없음.
+  const mappedData: RfqLastData = {
+    rfqCode, // 생성된 RFQ 코드
+    ANFNR: eccHeader.ANFNR,
+    projectId, // 첫번째 PR Item의 PSPID로 찾은 프로젝트 ID
+    series: null, // PR 아이템 처리 후 업데이트 
+    itemCode, // 첫번째 PR Item의 MATKL
+    itemName, // 첫번째 PR Item의 MATNR로 조회한 자재명
+    dueDate: null, // ECC에서 제공되지 않음
+    rfqSendDate: null, // ECC에서 제공되지 않음
+    status: 'RFQ 생성', // 한글 상태로 변경
+    rfqSealedYn: false,
+    EngPicName: null, // ECC에서 제공되지 않음
+    packageNo: null, // ECC에서 제공되지 않음
+    packageName: null, // ECC에서 제공되지 않음
+    remark: null,
+    pic: inChargeUserId, // 담당자 ID
+    picCode: eccHeader.EKGRP || null, // 구매그룹코드
+    picName: null, // 담당자명은 별도 조회 필요
+    sentBy: null,
     createdBy: inChargeUserId || 1,
     updatedBy: inChargeUserId || 1,
+    createdAt: interfacedAt,
+    // 새 필드들
+    rfqType: 'ECC', // ECC에서 온 데이터임을 표시
+    rfqTitle: null,
+    projectCompany: null,
+    projectFlag: null,
+    projectSite: null,
+    smCode: null,
+    prNumber, // 첫번째 PR의 ZREQ_FN 값
+    prIssueDate: interfacedAt, // 수신시점의 날짜
   };
 
-  debugSuccess('ECC RFQ 헤더 매핑 완료', { anfnr: eccHeader.ANFNR });
+  debugSuccess('ECC RFQ 헤더 매핑 완료', { anfnr: eccHeader.ANFNR, rfqCode });
   return mappedData;
 }
 
 /**
- * ECC RFQ 아이템 데이터를 비즈니스 테이블로 매핑
+ * ECC RFQ 아이템 데이터를 rfqPrItems 테이블로 매핑
  */
-export function mapECCRfqItemToBusiness(
+export function mapECCRfqItemToRfqPrItem(
   eccItem: ECCBidItem,
   rfqId: number
-): PrItemData {
+): RfqPrItemData {
   debugLog('ECC RFQ 아이템 매핑 시작', {
     anfnr: eccItem.ANFNR,
     anfps: eccItem.ANFPS,
@@ -225,34 +345,31 @@ export function mapECCRfqItemToBusiness(
     }
   }
 
-  // TODO: 시리즈인 경우 EBELP(Series PO Item Seq) 를 참조하는 로직 필요? 이 컬럼의 의미 확인 필요
-
-
-  const mappedData: PrItemData = {
-    procurementRfqsId: rfqId, // PR Item의 부모 RFQ ID [ok]
-    rfqItem: eccItem.ANFPS || null, // itemNo [ok]
-    prItem: eccItem.BANPO || null, // ECC PR No [ok]
-    prNo: eccItem.BANFN || null, // ECC PR No [ok]
-    materialCode: eccItem.MATNR || null, // ECC Material Number [ok]
-    materialCategory: eccItem.MATKL || null, // ECC Material Group [ok]
-    acc: eccItem.SAKTO || null, // ECC G/L Account Number [ok]
-    materialDescription: eccItem.TXZ01 || null, // ECC Short Text [ok] // TODO: 자재 테이블 참조해서 자재명 넣어주기 ?
-    size: null, // ECC에서 해당 정보 없음 // TODO: 이시원 프로에게 확인
-    deliveryDate, // ECC PR Delivery Date (parsed)
-    quantity: eccItem.MENGE ? Number(eccItem.MENGE) : null, // ECC PR Quantity [ok]
-    uom: eccItem.MEINS || null, // ECC PR UOM [ok]
-    grossWeight: eccItem.BRGEW ? Number(eccItem.BRGEW) : null, // ECC PR Gross Weight [ok]
-    gwUom: eccItem.GEWEI || null, // ECC PR Gross Weight UOM [ok]
-    specNo: null, // ECC에서 해당 정보 없음, TODO: 이시원 프로 - material 참조해서 넣어주는건지, PR 마다 고유한건지 확인
-    specUrl: null, // ECC에서 해당 정보 없음, TODO: 이시원 프로에게 material 참조해서 넣어주는건지, PR 마다 고유한건지 확인
-    trackingNo: null, // TODO: 이시원 프로에게 확인 필요. I/F 정의서 어느 항목인지 추정 불가
-    majorYn: false, // 기본값 false 할당, 필요시 eVCP에서 수정
-    projectDef: eccItem.PSPID || null, // Project Key 로 처리. // TODO: 프로젝트 테이블 참조해 코드로 처리하기
-    projectSc: null, // ECC에서 해당 정보 없음  // TODO: pspid 기준으로 찾아 넣어주기
-    projectKl: null, // ECC에서 해당 정보 없음  // TODO: pspid 기준으로 찾아 넣어주기
-    projectLc: null, // ECC에서 해당 정보 없음  // TODO: pspid 기준으로 찾아 넣어주기
-    projectDl: null, // ECC에서 해당 정보 없음  // TODO: pspid 기준으로 찾아 넣어주기
-    remark: null, // remark 컬럼은 담당자 메모용으로 넣어줄 필요 없음.
+  const mappedData: RfqPrItemData = {
+    rfqsLastId: rfqId, // 부모 RFQ ID
+    rfqItem: eccItem.ANFPS || null, // RFQ Item 번호
+    prItem: eccItem.BANPO || null, // PR Item 번호
+    prNo: eccItem.BANFN || null, // PR 번호
+    materialCode: eccItem.MATNR || null, // 자재코드
+    materialCategory: eccItem.MATKL || null, // 자재그룹
+    acc: eccItem.SAKTO || null, // G/L 계정
+    materialDescription: eccItem.TXZ01 || null, // 자재 설명
+    size: null, // ECC에서 제공되지 않음
+    deliveryDate, // 납기일
+    quantity: eccItem.MENGE ? Number(eccItem.MENGE) : null, // 수량
+    uom: eccItem.MEINS || null, // 단위
+    grossWeight: eccItem.BRGEW ? Number(eccItem.BRGEW) : null, // 총중량
+    gwUom: eccItem.GEWEI || null, // 중량단위
+    specNo: null, // ECC에서 제공되지 않음
+    specUrl: null, // ECC에서 제공되지 않음
+    trackingNo: null, // ECC에서 제공되지 않음
+    majorYn: false, // 기본값 false
+    projectDef: eccItem.PSPID || null, // 프로젝트 정의
+    projectSc: null, // ECC에서 제공되지 않음
+    projectKl: null, // ECC에서 제공되지 않음
+    projectLc: null, // ECC에서 제공되지 않음
+    projectDl: null, // ECC에서 제공되지 않음
+    remark: null,
   };
 
   debugSuccess('ECC RFQ 아이템 매핑 완료', {
@@ -263,25 +380,43 @@ export function mapECCRfqItemToBusiness(
 }
 
 /**
- * ECC 데이터를 비즈니스 테이블로 일괄 매핑 및 저장
+ * ECC 데이터를 rfqsLast/rfqPrItems 테이블로 일괄 매핑 및 저장
+ */
+/**
+ * 기존 함수명 호환성 유지 - 새 테이블로 리다이렉트
  */
 export async function mapAndSaveECCRfqData(
   eccHeaders: ECCBidHeader[],
   eccItems: ECCBidItem[]
 ): Promise<{ success: boolean; message: string; processedCount: number }> {
-  debugLog('ECC 데이터 일괄 매핑 및 저장 시작', {
+  return mapAndSaveECCRfqDataToRfqLast(eccHeaders, eccItems);
+}
+
+/**
+ * ECC 데이터를 rfqsLast/rfqPrItems 테이블로 일괄 매핑 및 저장
+ */
+export async function mapAndSaveECCRfqDataToRfqLast(
+  eccHeaders: ECCBidHeader[],
+  eccItems: ECCBidItem[]
+): Promise<{ success: boolean; message: string; processedCount: number }> {
+  debugLog('ECC 데이터 일괄 매핑 및 저장 시작 (rfqsLast)', {
     headerCount: eccHeaders.length,
     itemCount: eccItems.length,
   });
 
   try {
     const result = await db.transaction(async (tx) => {
-      // 1) 헤더별 관련 아이템 그룹핑 + 시리즈 계산 + 헤더 매핑을 병렬로 수행
+      // 1) RFQ 코드 배치 생성 (중복 방지)
+      const rfqCodeMap = await generateRfqCodes(eccHeaders);
+      
+      // 2) 헤더별 관련 아이템 그룹핑 + 시리즈 계산 + 헤더 매핑을 병렬로 수행
       const rfqGroups = await Promise.all(
         eccHeaders.map(async (eccHeader) => {
           const relatedItems = eccItems.filter((item) => item.ANFNR === eccHeader.ANFNR);
           const series = computeSeriesFromItems(relatedItems);
-          const rfqData = await mapECCRfqHeaderToBusiness(eccHeader);
+          const rfqCode = rfqCodeMap.get(eccHeader.ANFNR) || `RFQ${eccHeader.EKGRP || 'UNKNOWN'}00001`;
+          // 헤더 매핑 시 아이템 정보와 생성된 RFQ 코드 전달
+          const rfqData = await mapECCRfqHeaderToRfqLast(eccHeader, relatedItems, rfqCode);
           rfqData.series = series;
           return { rfqCode: rfqData.rfqCode, rfqData, relatedItems };
         })
@@ -289,12 +424,27 @@ export async function mapAndSaveECCRfqData(
 
       const rfqRecords = rfqGroups.map((g) => g.rfqData);
 
-      // 2) RFQ 다건 삽입 (중복은 무시). 반환된 레코드로 일부 ID 매핑
+      // 3) RFQ 다건 삽입 (중복은 무시). 반환된 레코드로 일부 ID 매핑
+      // ANFNR 기반으로 중복 방지 (ECC에서 오는 실제 비즈니스 키)
       const inserted = await tx
-        .insert(procurementRfqs)
+        .insert(rfqsLast)
         .values(rfqRecords)
-        .onConflictDoNothing()
-        .returning({ id: procurementRfqs.id, rfqCode: procurementRfqs.rfqCode });
+        .onConflictDoUpdate({
+          target: rfqsLast.ANFNR,
+          set: {
+            updatedAt: new Date(),
+            // ANFNR이 같으면 기존 데이터를 업데이트
+            projectId: sql`EXCLUDED.project_id`,
+            series: sql`EXCLUDED.series`,
+            itemCode: sql`EXCLUDED.item_code`,
+            itemName: sql`EXCLUDED.item_name`,
+            picCode: sql`EXCLUDED.pic_code`,
+            pic: sql`EXCLUDED.pic`,
+            prNumber: sql`EXCLUDED.pr_number`,
+            prIssueDate: sql`EXCLUDED.pr_issue_date`,
+          }
+        })
+        .returning({ id: rfqsLast.id, rfqCode: rfqsLast.rfqCode });
 
       const rfqCodeToId = new Map<string, number>();
       for (const row of inserted) {
@@ -303,16 +453,16 @@ export async function mapAndSaveECCRfqData(
         }
       }
 
-      // 3) 반환되지 않은 기존 RFQ 들의 ID 조회하여 매핑 보완
+      // 4) 모든 RFQ 코드에 대한 ID 매핑 보완 (업데이트된 경우 포함)
       const allCodes = rfqRecords
         .map((r) => r.rfqCode)
         .filter((c): c is string => typeof c === 'string' && c.length > 0);
       const missingCodes = allCodes.filter((c) => !rfqCodeToId.has(c));
       if (missingCodes.length > 0) {
         const existing = await tx
-          .select({ id: procurementRfqs.id, rfqCode: procurementRfqs.rfqCode })
-          .from(procurementRfqs)
-          .where(inArray(procurementRfqs.rfqCode, missingCodes));
+          .select({ id: rfqsLast.id, rfqCode: rfqsLast.rfqCode })
+          .from(rfqsLast)
+          .where(inArray(rfqsLast.rfqCode, missingCodes));
         for (const row of existing) {
           if (row.rfqCode) {
             rfqCodeToId.set(row.rfqCode, row.id);
@@ -320,8 +470,8 @@ export async function mapAndSaveECCRfqData(
         }
       }
 
-      // 4) 모든 아이템을 한 번에 생성할 데이터로 변환
-      const allItemsToInsert: PrItemData[] = [];
+      // 5) 모든 아이템을 한 번에 생성할 데이터로 변환
+      const allItemsToInsert: RfqPrItemData[] = [];
       for (const group of rfqGroups) {
         const rfqCode = group.rfqCode;
         if (!rfqCode) continue;
@@ -332,22 +482,22 @@ export async function mapAndSaveECCRfqData(
         }
 
         for (const eccItem of group.relatedItems) {
-          const itemData = mapECCRfqItemToBusiness(eccItem, rfqId);
+          const itemData = mapECCRfqItemToRfqPrItem(eccItem, rfqId);
           allItemsToInsert.push(itemData);
         }
       }
 
-      // 5) 아이템 일괄 삽입 (chunk 처리로 파라미터 제한 회피)
+      // 6) 아이템 일괄 삽입 (chunk 처리로 파라미터 제한 회피)
       const ITEM_CHUNK_SIZE = 1000;
       for (let i = 0; i < allItemsToInsert.length; i += ITEM_CHUNK_SIZE) {
         const chunk = allItemsToInsert.slice(i, i + ITEM_CHUNK_SIZE);
-        await tx.insert(prItems).values(chunk);
+        await tx.insert(rfqPrItems).values(chunk);
       }
 
       return { processedCount: rfqRecords.length };
     });
 
-    debugSuccess('ECC 데이터 일괄 처리 완료', {
+    debugSuccess('ECC 데이터 일괄 처리 완료 (rfqsLast)', {
       processedCount: result.processedCount,
     });