summaryrefslogtreecommitdiff
path: root/lib/soap/ecc
diff options
context:
space:
mode:
Diffstat (limited to 'lib/soap/ecc')
-rw-r--r--lib/soap/ecc/mapper/po-mapper.ts427
-rw-r--r--lib/soap/ecc/mapper/rfq-and-pr-mapper.ts429
-rw-r--r--lib/soap/ecc/send/cancel-rfq.ts346
-rw-r--r--lib/soap/ecc/send/create-po.ts417
-rw-r--r--lib/soap/ecc/send/pcr-confirm.ts682
-rw-r--r--lib/soap/ecc/send/rfq-info.ts469
6 files changed, 2770 insertions, 0 deletions
diff --git a/lib/soap/ecc/mapper/po-mapper.ts b/lib/soap/ecc/mapper/po-mapper.ts
new file mode 100644
index 00000000..a6363a87
--- /dev/null
+++ b/lib/soap/ecc/mapper/po-mapper.ts
@@ -0,0 +1,427 @@
+import { debugLog, debugSuccess, debugError } from '@/lib/debug-utils';
+import db from '@/db/db';
+import {
+ contracts,
+ contractItems,
+} from '@/db/schema/contract';
+import { projects } from '@/db/schema/projects';
+import { vendors } from '@/db/schema/vendors';
+import { items } from '@/db/schema/items';
+import {
+ ZMM_HD,
+ ZMM_DT,
+} from '@/db/schema/ECC/ecc';
+import { eq } from 'drizzle-orm';
+
+// ECC 데이터 타입 정의
+export type ECCPOHeader = typeof ZMM_HD.$inferInsert;
+export type ECCPODetail = typeof ZMM_DT.$inferInsert;
+
+// 비즈니스 테이블 데이터 타입 정의
+export type ContractData = typeof contracts.$inferInsert;
+export type ContractItemData = typeof contractItems.$inferInsert;
+
+// 처리된 PO 데이터 구조
+export interface ProcessedPOData {
+ header: ECCPOHeader;
+ details: ECCPODetail[];
+}
+
+/**
+ * ECC PO 헤더 데이터를 contracts 테이블로 매핑
+ */
+export async function mapECCPOHeaderToBusiness(
+ eccHeader: ECCPOHeader
+): Promise<ContractData> {
+ debugLog('ECC PO 헤더 매핑 시작', { ebeln: eccHeader.EBELN });
+
+ // projectId 찾기 (PSPID → projects.code 기반)
+ let projectId: number | null = null;
+ if (eccHeader.PSPID) {
+ try {
+ const project = await db.query.projects.findFirst({
+ where: eq(projects.code, eccHeader.PSPID),
+ });
+ if (project) {
+ projectId = project.id;
+ debugLog('프로젝트 ID 찾음', { pspid: eccHeader.PSPID, projectId });
+ } else {
+ debugError('프로젝트를 찾을 수 없음', { pspid: eccHeader.PSPID });
+ }
+ } catch (error) {
+ debugError('프로젝트 조회 중 오류', { pspid: eccHeader.PSPID, error });
+ }
+ }
+
+ // vendorId 찾기 (LIFNR 기반)
+ let vendorId: number | null = null;
+ if (eccHeader.LIFNR) {
+ try {
+ const vendor = await db.query.vendors.findFirst({
+ where: eq(vendors.vendorCode, eccHeader.LIFNR),
+ });
+ if (vendor) {
+ vendorId = vendor.id;
+ debugLog('벤더 ID 찾음', { lifnr: eccHeader.LIFNR, vendorId });
+ } else {
+ debugError('벤더를 찾을 수 없음', { lifnr: eccHeader.LIFNR });
+ }
+ } catch (error) {
+ debugError('벤더 조회 중 오류', { lifnr: eccHeader.LIFNR, error });
+ }
+ }
+
+ // 날짜 파싱 함수 (YYYYMMDD -> YYYY-MM-DD 문자열 형식)
+ const parseDate = (dateStr: string | null): string | null => {
+ if (!dateStr || dateStr.length !== 8) return null;
+ try {
+ const year = dateStr.substring(0, 4);
+ const month = dateStr.substring(4, 6);
+ const day = dateStr.substring(6, 8);
+ return `${year}-${month}-${day}`;
+ } catch (error) {
+ debugError('날짜 파싱 오류', { dateStr, error });
+ return null;
+ }
+ };
+
+ // 금액 파싱 함수
+ const parseAmount = (amountStr: string | null): string | null => {
+ if (!amountStr) return null;
+ try {
+ // 문자열을 숫자로 변환 후 다시 문자열로 (소수점 처리)
+ const num = parseFloat(amountStr);
+ return isNaN(num) ? null : num.toString();
+ } catch (error) {
+ debugError('금액 파싱 오류', { amountStr, error });
+ return null;
+ }
+ };
+
+ // 매핑
+ const mappedData: ContractData = {
+ projectId: projectId || 1, // TODO: 기본값 설정, 실제로는 유효한 projectId 필요
+ vendorId: vendorId || 1, // TODO: 기본값 설정, 실제로는 유효한 vendorId 필요
+ contractNo: eccHeader.EBELN || '',
+ contractName: eccHeader.ZTITLE || eccHeader.EBELN || '',
+ status: eccHeader.ZPO_CNFM_STAT || 'ACTIVE',
+ startDate: parseDate(eccHeader.ZPO_DT || null),
+ endDate: null, // ZMM_DT에서 가져와야 함
+ deliveryDate: null, // ZMM_DT에서 가져와야 함
+ paymentTerms: eccHeader.ZTERM || null,
+ deliveryTerms: eccHeader.INCO1 || null,
+ deliveryLocation: eccHeader.ZUNLD_PLC_CD || null,
+ currency: eccHeader.ZPO_CURR || 'KRW',
+ totalAmount: parseAmount(eccHeader.ZPO_AMT || null),
+ netTotal: parseAmount(eccHeader.ZPO_AMT || null),
+ remarks: eccHeader.ETC_2 || null,
+ // 기본값들
+ discount: null,
+ tax: null,
+ shippingFee: null,
+ partialShippingAllowed: false,
+ partialPaymentAllowed: false,
+ version: 1,
+ };
+
+ debugSuccess('ECC PO 헤더 매핑 완료', { ebeln: eccHeader.EBELN });
+ return mappedData;
+}
+
+/**
+ * ECC PO 상세 데이터를 contract_items 테이블로 매핑
+ */
+export async function mapECCPODetailToBusiness(
+ eccDetail: ECCPODetail,
+ contractId: number
+): Promise<ContractItemData> {
+ debugLog('ECC PO 상세 매핑 시작', {
+ ebeln: eccDetail.EBELN,
+ ebelp: eccDetail.EBELP,
+ matnr: eccDetail.MATNR,
+ });
+
+ // itemId 찾기 또는 생성 (MATNR 기반으로 items 테이블에서 조회/삽입)
+ let itemId: number | null = null;
+ if (eccDetail.MATNR) {
+ try {
+ // 1. 먼저 기존 아이템 조회
+ const item = await db.query.items.findFirst({
+ where: eq(items.itemCode, eccDetail.MATNR),
+ });
+
+ if (item) {
+ itemId = item.id;
+ debugLog('기존 아이템 ID 찾음', {
+ matnr: eccDetail.MATNR,
+ itemId,
+ packageCode: item.packageCode
+ });
+ } else {
+ // 2. 아이템이 없으면 새로 생성
+ debugLog('아이템이 없어서 새로 생성', { matnr: eccDetail.MATNR });
+
+ // 프로젝트 정보 설정
+ const projectNo = eccDetail.PSPID || 'DEFAULT';
+ const packageCode = 'AUTO_GENERATED'; // 기본값으로 설정
+
+ const newItemData = {
+ ProjectNo: projectNo,
+ itemCode: eccDetail.MATNR,
+ itemName: eccDetail.MAKTX || eccDetail.MATNR || 'Unknown Item',
+ packageCode: packageCode,
+ smCode: null, // SM 코드는 ECC 데이터에서 제공되지 않음
+ description: eccDetail.MAKTX || null,
+ parentItemCode: null,
+ itemLevel: null,
+ deleteFlag: 'N',
+ unitOfMeasure: null,
+ steelType: null,
+ gradeMaterial: null,
+ changeDate: null,
+ baseUnitOfMeasure: null,
+ };
+
+ const [insertedItem] = await db.insert(items).values(newItemData).returning({ id: items.id });
+ itemId = insertedItem.id;
+
+ debugSuccess('새 아이템 생성 완료', {
+ matnr: eccDetail.MATNR,
+ itemId,
+ projectNo,
+ itemName: newItemData.itemName
+ });
+ }
+ } catch (error) {
+ debugError('아이템 조회/생성 중 오류', { matnr: eccDetail.MATNR, error });
+ }
+ }
+
+ // 수량 파싱
+ const parseQuantity = (qtyStr: string | null): number => {
+ if (!qtyStr) return 1;
+ try {
+ const num = parseInt(qtyStr);
+ return isNaN(num) ? 1 : num;
+ } catch (error) {
+ debugError('수량 파싱 오류', { qtyStr, error });
+ return 1;
+ }
+ };
+
+ // 금액 파싱
+ const parseAmount = (amountStr: string | null): string | null => {
+ if (!amountStr) return null;
+ try {
+ const num = parseFloat(amountStr);
+ return isNaN(num) ? null : num.toString();
+ } catch (error) {
+ debugError('금액 파싱 오류', { amountStr, error });
+ return null;
+ }
+ };
+
+ // 세율 계산 (MWSKZ 기반)
+ const calculateTaxRate = (mwskz: string | null): string | null => {
+ if (!mwskz) return null;
+ // 일반적인 한국 세율 매핑 (실제 비즈니스 로직에 따라 조정 필요)
+ switch (mwskz) {
+ case '10':
+ return '10.00';
+ case '00':
+ return '0.00';
+ default:
+ return '10.00'; // 기본값
+ }
+ };
+
+ const quantity = parseQuantity(eccDetail.MENGE || null);
+ const unitPrice = parseAmount(eccDetail.NETPR || null);
+ const taxRate = calculateTaxRate(eccDetail.MWSKZ || null);
+ const totalLineAmount = parseAmount(eccDetail.NETWR || null);
+
+ // 세액 계산
+ let taxAmount: string | null = null;
+ if (unitPrice && taxRate) {
+ try {
+ const unitPriceNum = parseFloat(unitPrice);
+ const taxRateNum = parseFloat(taxRate);
+ const calculatedTaxAmount = (unitPriceNum * quantity * taxRateNum) / 100;
+ taxAmount = calculatedTaxAmount.toString();
+ } catch (error) {
+ debugError('세액 계산 오류', { unitPrice, taxRate, quantity, error });
+ }
+ }
+
+ // 매핑
+ const mappedData: ContractItemData = {
+ contractId,
+ itemId: itemId || 1, // TODO: 기본값 설정, 실제로는 유효한 itemId 필요
+ description: eccDetail.MAKTX || null,
+ quantity,
+ unitPrice,
+ taxRate,
+ taxAmount,
+ totalLineAmount,
+ remark: eccDetail.ZPO_RMK || null,
+ };
+
+ debugSuccess('ECC PO 상세 매핑 완료', {
+ ebeln: eccDetail.EBELN,
+ ebelp: eccDetail.EBELP,
+ itemId,
+ });
+ return mappedData;
+}
+
+/**
+ * ECC PO 데이터를 비즈니스 테이블로 일괄 매핑 및 저장
+ */
+export async function mapAndSaveECCPOData(
+ processedPOs: ProcessedPOData[]
+): Promise<{ success: boolean; message: string; processedCount: number }> {
+ debugLog('ECC PO 데이터 일괄 매핑 및 저장 시작', {
+ poCount: processedPOs.length,
+ });
+
+ try {
+ const result = await db.transaction(async (tx) => {
+ let processedCount = 0;
+
+ for (const poData of processedPOs) {
+ const { header, details } = poData;
+
+ try {
+ // 1. 헤더 매핑 및 저장
+ const contractData = await mapECCPOHeaderToBusiness(header);
+
+ // 중복 체크 (contractNo 기준)
+ const existingContract = await tx.query.contracts.findFirst({
+ where: eq(contracts.contractNo, contractData.contractNo),
+ });
+
+ let contractId: number;
+ if (existingContract) {
+ // 기존 계약 업데이트
+ await tx
+ .update(contracts)
+ .set({
+ ...contractData,
+ updatedAt: new Date(),
+ })
+ .where(eq(contracts.id, existingContract.id));
+ contractId = existingContract.id;
+ debugLog('기존 계약 업데이트', { contractNo: contractData.contractNo, contractId });
+ } else {
+ // 새 계약 생성
+ const [insertedContract] = await tx
+ .insert(contracts)
+ .values(contractData)
+ .returning({ id: contracts.id });
+ contractId = insertedContract.id;
+ debugLog('새 계약 생성', { contractNo: contractData.contractNo, contractId });
+ }
+
+ // 2. 기존 contract_items 삭제 (교체 방식)
+ await tx
+ .delete(contractItems)
+ .where(eq(contractItems.contractId, contractId));
+
+ // 3. 상세 매핑 및 저장
+ if (details.length > 0) {
+ const contractItemsData: ContractItemData[] = [];
+
+ for (const detail of details) {
+ const itemData = await mapECCPODetailToBusiness(detail, contractId);
+ contractItemsData.push(itemData);
+ }
+
+ // 일괄 삽입
+ await tx.insert(contractItems).values(contractItemsData);
+ debugLog('계약 아이템 저장 완료', {
+ contractId,
+ itemCount: contractItemsData.length
+ });
+ }
+
+ processedCount++;
+ } catch (error) {
+ debugError('PO 데이터 처리 중 오류', {
+ ebeln: header.EBELN,
+ error
+ });
+ // 개별 PO 처리 실패 시 해당 PO만 스킵하고 계속 진행
+ continue;
+ }
+ }
+
+ return { processedCount };
+ });
+
+ debugSuccess('ECC PO 데이터 일괄 처리 완료', {
+ processedCount: result.processedCount,
+ });
+
+ return {
+ success: true,
+ message: `${result.processedCount}개의 PO 데이터가 성공적으로 처리되었습니다.`,
+ processedCount: result.processedCount,
+ };
+ } catch (error) {
+ debugError('ECC PO 데이터 처리 중 오류 발생', error);
+ return {
+ success: false,
+ message:
+ error instanceof Error
+ ? error.message
+ : '알 수 없는 오류가 발생했습니다.',
+ processedCount: 0,
+ };
+ }
+}
+
+/**
+ * ECC PO 데이터 유효성 검증
+ */
+export function validateECCPOData(
+ processedPOs: ProcessedPOData[]
+): { isValid: boolean; errors: string[] } {
+ const errors: string[] = [];
+
+ for (const poData of processedPOs) {
+ const { header, details } = poData;
+
+ // 헤더 데이터 검증
+ if (!header.EBELN) {
+ errors.push(`필수 필드 누락: EBELN (구매오더번호)`);
+ }
+ if (!header.LIFNR) {
+ errors.push(`필수 필드 누락: LIFNR (VENDOR코드) - EBELN: ${header.EBELN}`);
+ }
+
+ // 상세 데이터 검증
+ for (const detail of details) {
+ if (!detail.EBELN) {
+ errors.push(`필수 필드 누락: EBELN (구매오더번호) - EBELP: ${detail.EBELP}`);
+ }
+ if (!detail.EBELP) {
+ errors.push(`필수 필드 누락: EBELP (구매오더품목번호) - EBELN: ${detail.EBELN}`);
+ }
+ if (!detail.MATNR) {
+ errors.push(`필수 필드 누락: MATNR (자재코드) - EBELN: ${detail.EBELN}, EBELP: ${detail.EBELP}`);
+ }
+ }
+
+ // 헤더와 상세 간의 관계 검증
+ for (const detail of details) {
+ if (detail.EBELN !== header.EBELN) {
+ errors.push(`헤더와 상세의 EBELN이 일치하지 않음: Header ${header.EBELN}, Detail ${detail.EBELN}`);
+ }
+ }
+ }
+
+ return {
+ isValid: errors.length === 0,
+ errors,
+ };
+}
diff --git a/lib/soap/ecc/mapper/rfq-and-pr-mapper.ts b/lib/soap/ecc/mapper/rfq-and-pr-mapper.ts
new file mode 100644
index 00000000..e2258a4c
--- /dev/null
+++ b/lib/soap/ecc/mapper/rfq-and-pr-mapper.ts
@@ -0,0 +1,429 @@
+import { debugLog, debugSuccess, debugError } from '@/lib/debug-utils';
+import db from '@/db/db';
+import {
+ procurementRfqs,
+ prItems,
+ procurementRfqDetails,
+} from '@/db/schema/procurementRFQ';
+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';
+
+// 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;
+
+/**
+ * 시리즈 판단: 관련 PR 아이템들의 PSPID를 기반으로 결정
+ * - 아이템이 1개 이하: null
+ * - 아이템이 2개 이상이고 PSPID가 모두 동일: "SS"
+ * - 아이템이 2개 이상이고 PSPID가 서로 다름: "||"
+ */
+function computeSeriesFromItems(items: ECCBidItem[]): string | null {
+ if (items.length <= 1) return null;
+
+ const normalize = (v: unknown): string | null => {
+ if (typeof v !== 'string') return null;
+ const trimmed = v.trim();
+ return trimmed.length > 0 ? trimmed : null;
+ };
+
+ const uniquePspids = new Set<string | null>(
+ items.map((it) => normalize(it.PSPID as string | null | undefined))
+ );
+
+ return uniquePspids.size === 1 ? 'SS' : '||';
+}
+
+/**
+ * PERNR(사번)을 기준으로 사용자 ID를 찾는 함수
+ */
+async function findUserIdByPernr(pernr: string): 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 });
+ return null;
+ }
+
+ const epId = employeeResult[0].epId;
+ debugLog('직원 epId 찾음', { pernr, epId });
+
+ // 2. users 테이블에서 epId로 사용자 ID 찾기
+ const userResult = await db
+ .select({ id: users.id })
+ .from(users)
+ .where(eq(users.epId, epId))
+ .limit(1);
+
+ if (userResult.length === 0) {
+ debugError('epId에 해당하는 사용자 정보를 찾을 수 없음', { epId });
+ return null;
+ }
+
+ const userId = userResult[0].id;
+ debugSuccess('사용자 ID 찾음', { pernr, epId, userId });
+ return userId;
+ } catch (error) {
+ debugError('사용자 ID 찾기 중 오류 발생', { pernr, error });
+ return null;
+ }
+}
+
+
+
+/**
+ * 담당자 찾는 함수 (Non-SAP 데이터를 기준으로 찾음)
+ * Puchasing Group을 CMCTB_CD 에서 CD_CLF='MMA070' 조건으로, CD=EKGRP 조건으로 찾으면, USR_DF_CHAR_9 컬럼이 담당자 사번임. 기준으로 유저를 넣어줄 예정임
+ */
+async function findInChargeUserIdByEKGRP(EKGRP: string | null): Promise<number | null> {
+ try {
+ debugLog('담당자 찾기 시작', { EKGRP });
+ // NonSAP에서 담당자 사번 찾기
+
+ const result = await oracleKnex
+ .select('USR_DF_CHAR_9')
+ .from('CMCTB_CD')
+ .where('CD_CLF', 'MMA070')
+ .andWhere('CD', EKGRP)
+ .limit(1);
+
+ if (result.length === 0) {
+ debugError('담당자 찾기 중 오류 발생', { EKGRP });
+ return null;
+ }
+
+ const employeeNumber = result[0].USR_DF_CHAR_9;
+
+ // 임시 : Knox API 기준으로 사번에 해당하는 userId 찾기 (nonsap에서 제공하는 유저테이블로 변경 예정)
+ const userId = await findUserIdByEmployeeNumber(employeeNumber);
+
+ debugSuccess('담당자 찾음', { EKGRP, userId });
+ return userId;
+ } catch (error) {
+ debugError('담당자 찾기 중 오류 발생', { EKGRP, error });
+ return null;
+ }
+}
+
+// *****************************mapping functions*********************************
+
+/**
+ * ECC RFQ 헤더 데이터를 비즈니스 테이블로 매핑
+ */
+export async function mapECCRfqHeaderToBusiness(
+ eccHeader: ECCBidHeader
+): Promise<ProcurementRfqData> {
+ debugLog('ECC RFQ 헤더 매핑 시작', { anfnr: eccHeader.ANFNR });
+
+ // 날짜 파싱 (실패시 현재 Date 들어감)
+ let interfacedAt: Date = new Date();
+
+ if (eccHeader.ZRFQ_TRS_DT != null && eccHeader.ZRFQ_TRS_TM != null) {
+ try {
+ // SAP 날짜 형식 (YYYYMMDD) 파싱
+ const dateStr = eccHeader.ZRFQ_TRS_DT;
+ if (dateStr.length === 8) {
+ const year = parseInt(dateStr.substring(0, 4));
+ const month = parseInt(dateStr.substring(4, 6)) - 1; // 0-based
+ const day = parseInt(dateStr.substring(6, 8));
+ const hour = parseInt(eccHeader.ZRFQ_TRS_TM.substring(0, 2));
+ const minute = parseInt(eccHeader.ZRFQ_TRS_TM.substring(2, 4));
+ const second = parseInt(eccHeader.ZRFQ_TRS_TM.substring(4, 6));
+ interfacedAt = new Date(year, month, day, hour, minute, second);
+ }
+ } catch (error) {
+ debugError('날짜 파싱 오류', {
+ date: eccHeader.ZRFQ_TRS_DT,
+ time: eccHeader.ZRFQ_TRS_TM,
+ error,
+ });
+ }
+ }
+
+ // 담당자 찾기
+ 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 값을 넣는다.
+
+ // 매핑
+ 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를 대상으로 하므로 넣어줄 필요 없음.
+ createdBy: inChargeUserId || 1,
+ updatedBy: inChargeUserId || 1,
+ };
+
+ debugSuccess('ECC RFQ 헤더 매핑 완료', { anfnr: eccHeader.ANFNR });
+ return mappedData;
+}
+
+/**
+ * ECC RFQ 아이템 데이터를 비즈니스 테이블로 매핑
+ */
+export function mapECCRfqItemToBusiness(
+ eccItem: ECCBidItem,
+ rfqId: number
+): PrItemData {
+ debugLog('ECC RFQ 아이템 매핑 시작', {
+ anfnr: eccItem.ANFNR,
+ anfps: eccItem.ANFPS,
+ });
+
+ // 날짜 파싱
+ let deliveryDate: Date | null = null;
+ if (eccItem.LFDAT) {
+ try {
+ const dateStr = eccItem.LFDAT;
+ if (dateStr.length === 8) {
+ const year = parseInt(dateStr.substring(0, 4));
+ const month = parseInt(dateStr.substring(4, 6)) - 1;
+ const day = parseInt(dateStr.substring(6, 8));
+ deliveryDate = new Date(year, month, day);
+ }
+ } catch (error) {
+ debugError('아이템 날짜 파싱 오류', { date: eccItem.LFDAT, error });
+ }
+ }
+
+ // 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 컬럼은 담당자 메모용으로 넣어줄 필요 없음.
+ };
+
+ debugSuccess('ECC RFQ 아이템 매핑 완료', {
+ rfqItem: eccItem.ANFPS,
+ materialCode: eccItem.MATNR,
+ });
+ return mappedData;
+}
+
+/**
+ * ECC 데이터를 비즈니스 테이블로 일괄 매핑 및 저장
+ */
+export async function mapAndSaveECCRfqData(
+ eccHeaders: ECCBidHeader[],
+ eccItems: ECCBidItem[]
+): Promise<{ success: boolean; message: string; processedCount: number }> {
+ debugLog('ECC 데이터 일괄 매핑 및 저장 시작', {
+ headerCount: eccHeaders.length,
+ itemCount: eccItems.length,
+ });
+
+ try {
+ const result = await db.transaction(async (tx) => {
+ // 1) 헤더별 관련 아이템 그룹핑 + 시리즈 계산 + 헤더 매핑을 병렬로 수행
+ 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);
+ rfqData.series = series;
+ return { rfqCode: rfqData.rfqCode, rfqData, relatedItems };
+ })
+ );
+
+ const rfqRecords = rfqGroups.map((g) => g.rfqData);
+
+ // 2) RFQ 다건 삽입 (중복은 무시). 반환된 레코드로 일부 ID 매핑
+ const inserted = await tx
+ .insert(procurementRfqs)
+ .values(rfqRecords)
+ .onConflictDoNothing()
+ .returning({ id: procurementRfqs.id, rfqCode: procurementRfqs.rfqCode });
+
+ const rfqCodeToId = new Map<string, number>();
+ for (const row of inserted) {
+ if (row.rfqCode) {
+ rfqCodeToId.set(row.rfqCode, row.id);
+ }
+ }
+
+ // 3) 반환되지 않은 기존 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));
+ for (const row of existing) {
+ if (row.rfqCode) {
+ rfqCodeToId.set(row.rfqCode, row.id);
+ }
+ }
+ }
+
+ // 4) 모든 아이템을 한 번에 생성할 데이터로 변환
+ const allItemsToInsert: PrItemData[] = [];
+ for (const group of rfqGroups) {
+ const rfqCode = group.rfqCode;
+ if (!rfqCode) continue;
+ const rfqId = rfqCodeToId.get(rfqCode);
+ if (!rfqId) {
+ debugError('RFQ ID 매핑 누락', { rfqCode });
+ throw new Error(`RFQ ID를 찾을 수 없습니다: ${rfqCode}`);
+ }
+
+ for (const eccItem of group.relatedItems) {
+ const itemData = mapECCRfqItemToBusiness(eccItem, rfqId);
+ allItemsToInsert.push(itemData);
+ }
+ }
+
+ // 5) 아이템 일괄 삽입 (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);
+ }
+
+ return { processedCount: rfqRecords.length };
+ });
+
+ debugSuccess('ECC 데이터 일괄 처리 완료', {
+ processedCount: result.processedCount,
+ });
+
+ return {
+ success: true,
+ message: `${result.processedCount}개의 RFQ 데이터가 성공적으로 처리되었습니다.`,
+ processedCount: result.processedCount,
+ };
+ } catch (error) {
+ debugError('ECC 데이터 처리 중 오류 발생', error);
+ return {
+ success: false,
+ message:
+ error instanceof Error
+ ? error.message
+ : '알 수 없는 오류가 발생했습니다.',
+ processedCount: 0,
+ };
+ }
+}
+
+/**
+ * ECC 데이터 유효성 검증
+ */
+export function validateECCRfqData(
+ eccHeaders: ECCBidHeader[],
+ eccItems: ECCBidItem[]
+): { isValid: boolean; errors: string[] } {
+ const errors: string[] = [];
+
+ // 헤더 데이터 검증
+ for (const header of eccHeaders) {
+ if (!header.ANFNR) {
+ errors.push(`필수 필드 누락: ANFNR (Bidding/RFQ Number)`);
+ }
+ if (!header.ZBSART) {
+ errors.push(
+ `필수 필드 누락: ZBSART (Bidding Type) - ANFNR: ${header.ANFNR}`
+ );
+ }
+ }
+
+ // 아이템 데이터 검증
+ for (const item of eccItems) {
+ if (!item.ANFNR) {
+ errors.push(
+ `필수 필드 누락: ANFNR (Bidding/RFQ Number) - Item: ${item.ANFPS}`
+ );
+ }
+ if (!item.ANFPS) {
+ errors.push(`필수 필드 누락: ANFPS (Item Number) - ANFNR: ${item.ANFNR}`);
+ }
+ if (!item.BANFN) {
+ errors.push(
+ `필수 필드 누락: BANFN (Purchase Requisition Number) - ANFNR: ${item.ANFNR}, ANFPS: ${item.ANFPS}`
+ );
+ }
+ if (!item.BANPO) {
+ errors.push(
+ `필수 필드 누락: BANPO (Item Number of Purchase Requisition) - ANFNR: ${item.ANFNR}, ANFPS: ${item.ANFPS}`
+ );
+ }
+ }
+
+ // 헤더와 아이템 간의 관계 검증
+ const headerAnfnrs = new Set(eccHeaders.map((h) => h.ANFNR));
+ const itemAnfnrs = new Set(eccItems.map((i) => i.ANFNR));
+
+ for (const anfnr of itemAnfnrs) {
+ if (!headerAnfnrs.has(anfnr)) {
+ errors.push(`아이템의 ANFNR이 헤더에 존재하지 않음: ${anfnr}`);
+ }
+ }
+
+ return {
+ isValid: errors.length === 0,
+ errors,
+ };
+}
diff --git a/lib/soap/ecc/send/cancel-rfq.ts b/lib/soap/ecc/send/cancel-rfq.ts
new file mode 100644
index 00000000..fcddddf8
--- /dev/null
+++ b/lib/soap/ecc/send/cancel-rfq.ts
@@ -0,0 +1,346 @@
+'use server'
+
+import { sendSoapXml, type SoapSendConfig, type SoapLogInfo, type SoapSendResult } from "@/lib/soap/sender";
+
+// ECC RFQ 취소 엔드포인트
+const ECC_CANCEL_RFQ_ENDPOINT = "http://shii8dvddb01.hec.serp.shi.samsung.net:50000/sap/xi/engine?type=entry&version=3.0&Sender.Service=P2038_D&Interface=http%3A%2F%2Fshi.samsung.co.kr%2FP2_MM%2FMMM%5EP2MM3016_SO";
+
+// RFQ 취소 요청 데이터 타입
+export interface CancelRFQRequest {
+ T_ANFNR: Array<{
+ ANFNR: string; // RFQ Number (M)
+ }>;
+}
+
+// RFQ 취소 응답 데이터 타입 (참고용)
+export interface CancelRFQResponse {
+ EV_TYPE?: string; // 응답 타입 (S: 성공, E: 에러)
+ EV_MESSAGE?: string; // 응답 메시지
+}
+
+// SOAP Body Content 생성 함수
+function createCancelRFQSoapBodyContent(rfqData: CancelRFQRequest): Record<string, unknown> {
+ return {
+ 'ns0:MT_P2MM3016_S': {
+ 'T_ANFNR': rfqData.T_ANFNR
+ }
+ };
+}
+
+// RFQ 데이터 검증 함수
+function validateCancelRFQData(rfqData: CancelRFQRequest): { isValid: boolean; errors: string[] } {
+ const errors: string[] = [];
+
+ // T_ANFNR 배열 검증
+ if (!rfqData.T_ANFNR || !Array.isArray(rfqData.T_ANFNR) || rfqData.T_ANFNR.length === 0) {
+ errors.push('T_ANFNR은 필수이며 최소 1개 이상의 RFQ 번호가 있어야 합니다.');
+ } else {
+ rfqData.T_ANFNR.forEach((item, index) => {
+ if (!item.ANFNR || typeof item.ANFNR !== 'string' || item.ANFNR.trim() === '') {
+ errors.push(`T_ANFNR[${index}].ANFNR은 필수입니다.`);
+ }
+ });
+ }
+
+ return {
+ isValid: errors.length === 0,
+ errors
+ };
+}
+
+// ECC로 RFQ 취소 SOAP XML 전송하는 함수
+async function sendCancelRFQToECC(rfqData: CancelRFQRequest): Promise<SoapSendResult> {
+ try {
+ // 데이터 검증
+ const validation = validateCancelRFQData(rfqData);
+ if (!validation.isValid) {
+ return {
+ success: false,
+ message: `데이터 검증 실패: ${validation.errors.join(', ')}`
+ };
+ }
+
+ // SOAP Body Content 생성
+ const soapBodyContent = createCancelRFQSoapBodyContent(rfqData);
+
+ // SOAP 전송 설정
+ const config: SoapSendConfig = {
+ endpoint: ECC_CANCEL_RFQ_ENDPOINT,
+ envelope: soapBodyContent,
+ soapAction: 'http://sap.com/xi/WebService/soap1.1',
+ timeout: 30000, // RFQ 취소는 30초 타임아웃
+ retryCount: 3,
+ retryDelay: 1000
+ };
+
+ // 로그 정보
+ const logInfo: SoapLogInfo = {
+ direction: 'OUTBOUND',
+ system: 'S-ERP ECC',
+ interface: 'IF_ECC_EVCP_CANCEL_RFQ'
+ };
+
+ const rfqNumbers = rfqData.T_ANFNR.map(item => item.ANFNR).join(', ');
+ console.log(`📤 RFQ 취소 요청 전송 시작 - RFQ Numbers: ${rfqNumbers}`);
+ console.log(`🔍 취소 대상 RFQ ${rfqData.T_ANFNR.length}개`);
+
+ // SOAP XML 전송
+ const result = await sendSoapXml(config, logInfo);
+
+ if (result.success) {
+ console.log(`✅ RFQ 취소 요청 전송 성공 - RFQ Numbers: ${rfqNumbers}`);
+ } else {
+ console.error(`❌ RFQ 취소 요청 전송 실패 - RFQ Numbers: ${rfqNumbers}, 오류: ${result.message}`);
+ }
+
+ return result;
+
+ } catch (error) {
+ console.error('❌ RFQ 취소 전송 중 오류 발생:', error);
+ return {
+ success: false,
+ message: error instanceof Error ? error.message : 'Unknown error'
+ };
+ }
+}
+
+// ========================================
+// 메인 RFQ 취소 서버 액션 함수들
+// ========================================
+
+// 단일 RFQ 취소 요청 처리
+export async function cancelRFQ(rfqNumber: string): Promise<{
+ success: boolean;
+ message: string;
+ responseData?: string;
+ rfqNumber?: string;
+}> {
+ try {
+ console.log(`🚀 RFQ 취소 요청 시작 - RFQ Number: ${rfqNumber}`);
+
+ const rfqData: CancelRFQRequest = {
+ T_ANFNR: [{
+ ANFNR: rfqNumber
+ }]
+ };
+
+ const result = await sendCancelRFQToECC(rfqData);
+
+ return {
+ success: result.success,
+ message: result.success ? 'RFQ 취소 요청이 성공적으로 전송되었습니다.' : result.message,
+ responseData: result.responseText,
+ rfqNumber
+ };
+
+ } catch (error) {
+ console.error('❌ RFQ 취소 요청 처리 실패:', error);
+ return {
+ success: false,
+ message: error instanceof Error ? error.message : 'Unknown error'
+ };
+ }
+}
+
+// 여러 RFQ 배치 취소 요청 처리
+export async function cancelMultipleRFQs(rfqNumbers: string[]): Promise<{
+ success: boolean;
+ message: string;
+ results?: Array<{ rfqNumber: string; success: boolean; error?: string }>;
+}> {
+ try {
+ console.log(`🚀 배치 RFQ 취소 요청 시작: ${rfqNumbers.length}개`);
+
+ // 모든 RFQ를 하나의 요청으로 처리
+ const rfqData: CancelRFQRequest = {
+ T_ANFNR: rfqNumbers.map(rfqNumber => ({ ANFNR: rfqNumber }))
+ };
+
+ const result = await sendCancelRFQToECC(rfqData);
+
+ // 결과 정리
+ const results = rfqNumbers.map(rfqNumber => ({
+ rfqNumber,
+ success: result.success,
+ error: result.success ? undefined : result.message
+ }));
+
+ const successCount = result.success ? rfqNumbers.length : 0;
+ const failCount = rfqNumbers.length - successCount;
+
+ console.log(`🎉 배치 RFQ 취소 완료: 성공 ${successCount}개, 실패 ${failCount}개`);
+
+ return {
+ success: result.success,
+ message: result.success
+ ? `배치 RFQ 취소 성공: ${successCount}개`
+ : `배치 RFQ 취소 실패: ${result.message}`,
+ results
+ };
+
+ } catch (error) {
+ console.error('❌ 배치 RFQ 취소 중 전체 오류 발생:', error);
+ return {
+ success: false,
+ message: error instanceof Error ? error.message : 'Unknown error'
+ };
+ }
+}
+
+// 개별 처리 방식의 배치 RFQ 취소 (각각 따로 전송)
+export async function cancelMultipleRFQsIndividually(rfqNumbers: string[]): Promise<{
+ success: boolean;
+ message: string;
+ results?: Array<{ rfqNumber: string; success: boolean; error?: string }>;
+}> {
+ try {
+ console.log(`🚀 개별 RFQ 취소 요청 시작: ${rfqNumbers.length}개`);
+
+ const results: Array<{ rfqNumber: string; success: boolean; error?: string }> = [];
+
+ for (const rfqNumber of rfqNumbers) {
+ try {
+ console.log(`📤 RFQ 취소 처리 중: ${rfqNumber}`);
+
+ const rfqData: CancelRFQRequest = {
+ T_ANFNR: [{ ANFNR: rfqNumber }]
+ };
+
+ const result = await sendCancelRFQToECC(rfqData);
+
+ if (result.success) {
+ console.log(`✅ RFQ 취소 성공: ${rfqNumber}`);
+ results.push({
+ rfqNumber,
+ success: true
+ });
+ } else {
+ console.error(`❌ RFQ 취소 실패: ${rfqNumber}, 오류: ${result.message}`);
+ results.push({
+ rfqNumber,
+ success: false,
+ error: result.message
+ });
+ }
+
+ // 개별 처리간 지연 (시스템 부하 방지)
+ if (rfqNumbers.length > 1) {
+ await new Promise(resolve => setTimeout(resolve, 500));
+ }
+
+ } catch (error) {
+ console.error(`❌ RFQ 취소 처리 실패: ${rfqNumber}`, error);
+ results.push({
+ rfqNumber,
+ success: false,
+ error: error instanceof Error ? error.message : 'Unknown error'
+ });
+ }
+ }
+
+ const successCount = results.filter(r => r.success).length;
+ const failCount = results.length - successCount;
+
+ console.log(`🎉 개별 RFQ 취소 완료: 성공 ${successCount}개, 실패 ${failCount}개`);
+
+ return {
+ success: failCount === 0,
+ message: `개별 RFQ 취소 완료: 성공 ${successCount}개, 실패 ${failCount}개`,
+ results
+ };
+
+ } catch (error) {
+ console.error('❌ 개별 RFQ 취소 중 전체 오류 발생:', error);
+ return {
+ success: false,
+ message: error instanceof Error ? error.message : 'Unknown error'
+ };
+ }
+}
+
+// 테스트용 RFQ 취소 함수 (샘플 데이터 포함)
+export async function cancelTestRFQ(): Promise<{
+ success: boolean;
+ message: string;
+ responseData?: string;
+ testData?: CancelRFQRequest;
+}> {
+ try {
+ console.log('🧪 테스트용 RFQ 취소 시작');
+
+ // 테스트용 샘플 데이터 생성
+ const testRFQData: CancelRFQRequest = {
+ T_ANFNR: [{
+ ANFNR: 'TEST_RFQ_001'
+ }]
+ };
+
+ const result = await sendCancelRFQToECC(testRFQData);
+
+ return {
+ success: result.success,
+ message: result.success ? '테스트 RFQ 취소가 성공적으로 전송되었습니다.' : result.message,
+ responseData: result.responseText,
+ testData: testRFQData
+ };
+
+ } catch (error) {
+ console.error('❌ 테스트 RFQ 취소 실패:', error);
+ return {
+ success: false,
+ message: error instanceof Error ? error.message : 'Unknown error'
+ };
+ }
+}
+
+// ========================================
+// 유틸리티 함수들
+// ========================================
+
+// RFQ 취소 데이터 생성 헬퍼 함수
+function createCancelRFQData(rfqNumbers: string[]): CancelRFQRequest {
+ return {
+ T_ANFNR: rfqNumbers.map(rfqNumber => ({ ANFNR: rfqNumber }))
+ };
+}
+
+// RFQ 번호 검증 함수
+function validateRFQNumber(rfqNumber: string): { isValid: boolean; error?: string } {
+ if (!rfqNumber || typeof rfqNumber !== 'string') {
+ return { isValid: false, error: 'RFQ 번호는 문자열이어야 합니다.' };
+ }
+
+ const trimmed = rfqNumber.trim();
+ if (trimmed === '') {
+ return { isValid: false, error: 'RFQ 번호는 비어있을 수 없습니다.' };
+ }
+
+ // 기본적인 길이 검증 (10자 제한 - WSDL에서 CHAR 10으로 정의)
+ if (trimmed.length > 10) {
+ return { isValid: false, error: 'RFQ 번호는 10자를 초과할 수 없습니다.' };
+ }
+
+ return { isValid: true };
+}
+
+// 여러 RFQ 번호 검증 함수
+function validateRFQNumbers(rfqNumbers: string[]): { isValid: boolean; errors: string[] } {
+ const errors: string[] = [];
+
+ if (!Array.isArray(rfqNumbers) || rfqNumbers.length === 0) {
+ errors.push('최소 1개 이상의 RFQ 번호가 필요합니다.');
+ return { isValid: false, errors };
+ }
+
+ rfqNumbers.forEach((rfqNumber, index) => {
+ const validation = validateRFQNumber(rfqNumber);
+ if (!validation.isValid) {
+ errors.push(`RFQ[${index}]: ${validation.error}`);
+ }
+ });
+
+ return {
+ isValid: errors.length === 0,
+ errors
+ };
+} \ No newline at end of file
diff --git a/lib/soap/ecc/send/create-po.ts b/lib/soap/ecc/send/create-po.ts
new file mode 100644
index 00000000..3bd28057
--- /dev/null
+++ b/lib/soap/ecc/send/create-po.ts
@@ -0,0 +1,417 @@
+'use server'
+
+import { sendSoapXml, type SoapSendConfig, type SoapLogInfo, type SoapSendResult } from "@/lib/soap/sender";
+import { getCurrentSAPDate, getCurrentSAPTime } from "@/lib/soap/utils";
+
+// ECC PO 생성 엔드포인트
+const ECC_PO_ENDPOINT = "http://shii8dvddb01.hec.serp.shi.samsung.net:50000/sap/xi/engine?type=entry&version=3.0&Sender.Service=P2038_D&Interface=http%3A%2F%2Fshi.samsung.co.kr%2FP2_MM%2FMMM%5EP2MM3015_SO";
+
+// PO 헤더 데이터 타입
+export interface POHeaderData {
+ ANFNR: string; // Bidding Number (M)
+ LIFNR: string; // Vendor Account Number (M)
+ ZPROC_IND: string; // Purchasing Processing State (M)
+ ANGNR?: string; // Bidding Number
+ WAERS: string; // Currency Key (M)
+ ZTERM: string; // Terms of Payment Key (M)
+ INCO1: string; // Incoterms (Part 1) (M)
+ INCO2: string; // Incoterms (Part 2) (M)
+ VSTEL?: string; // Shipping Point
+ LSTEL?: string; // loading Point
+ MWSKZ: string; // Tax on sales/purchases code (M)
+ LANDS: string; // Country for Tax (M)
+ ZRCV_DT: string; // Bidding Receive Date (M)
+ ZATTEN_IND: string; // Attendance Indicator (M)
+ IHRAN: string; // Bidding Submission Date (M)
+ TEXT?: string; // PO Header note
+ ZDLV_CNTLR?: string; // Delivery Controller
+ ZDLV_PRICE_T?: string; // 납품대금연동제대상여부
+ ZDLV_PRICE_NOTE?: string; // 연동제 노트
+}
+
+// PO 아이템 데이터 타입
+export interface POItemData {
+ ANFNR: string; // Bidding Number (M)
+ ANFPS: string; // Item Number of Bidding (M)
+ LIFNR: string; // Vendor Account Number (M)
+ NETPR: string; // Net Price (M)
+ PEINH: string; // Price Unit (M)
+ BPRME: string; // Order Unit of Measure (M)
+ NETWR: string; // Net Order Value (M)
+ BRTWR: string; // Gross Order Value (M)
+ LFDAT: string; // Item Delivery Date (M)
+ ZCON_NO_PO?: string; // PR Consolidation Number
+ EBELP?: string; // Series PO Item Seq
+}
+
+// PR 반환 데이터 타입
+export interface PRReturnData {
+ ANFNR: string; // PR Request Number (M)
+ ANFPS: string; // Item Number of PR Request (M)
+ EBELN: string; // Purchase Requisition Number (M)
+ EBELP: string; // Item Number of Purchase Requisition (M)
+ MSGTY: string; // Message Type (M)
+ MSGTXT?: string; // Message Text
+}
+
+// PO 생성 요청 데이터 타입
+export interface POCreateRequest {
+ T_Bidding_HEADER: POHeaderData[];
+ T_Bidding_ITEM: POItemData[];
+ T_PR_RETURN: PRReturnData[];
+ EV_ERDAT?: string; // Extract Date
+ EV_ERZET?: string; // Extract Time
+}
+
+
+
+
+
+// SOAP Body Content 생성 함수
+function createPOSoapBodyContent(poData: POCreateRequest): Record<string, unknown> {
+ return {
+ 'ns0:MT_P2MM3015_S': {
+ 'T_Bidding_HEADER': poData.T_Bidding_HEADER,
+ 'T_Bidding_ITEM': poData.T_Bidding_ITEM,
+ 'T_PR_RETURN': poData.T_PR_RETURN,
+ ...(poData.EV_ERDAT && { 'EV_ERDAT': poData.EV_ERDAT }),
+ ...(poData.EV_ERZET && { 'EV_ERZET': poData.EV_ERZET })
+ }
+ };
+}
+
+// PO 데이터 검증 함수
+function validatePOData(poData: POCreateRequest): { isValid: boolean; errors: string[] } {
+ const errors: string[] = [];
+
+ // 헤더 데이터 검증
+ if (!poData.T_Bidding_HEADER || poData.T_Bidding_HEADER.length === 0) {
+ errors.push('T_Bidding_HEADER는 필수입니다.');
+ } else {
+ poData.T_Bidding_HEADER.forEach((header, index) => {
+ const requiredFields = ['ANFNR', 'LIFNR', 'ZPROC_IND', 'WAERS', 'ZTERM', 'INCO1', 'INCO2', 'MWSKZ', 'LANDS', 'ZRCV_DT', 'ZATTEN_IND', 'IHRAN'];
+ requiredFields.forEach(field => {
+ if (!header[field as keyof POHeaderData]) {
+ errors.push(`T_Bidding_HEADER[${index}].${field}는 필수입니다.`);
+ }
+ });
+ });
+ }
+
+ // 아이템 데이터 검증
+ if (!poData.T_Bidding_ITEM || poData.T_Bidding_ITEM.length === 0) {
+ errors.push('T_Bidding_ITEM은 필수입니다.');
+ } else {
+ poData.T_Bidding_ITEM.forEach((item, index) => {
+ const requiredFields = ['ANFNR', 'ANFPS', 'LIFNR', 'NETPR', 'PEINH', 'BPRME', 'NETWR', 'BRTWR', 'LFDAT'];
+ requiredFields.forEach(field => {
+ if (!item[field as keyof POItemData]) {
+ errors.push(`T_Bidding_ITEM[${index}].${field}는 필수입니다.`);
+ }
+ });
+ });
+ }
+
+ // PR 반환 데이터 검증
+ if (!poData.T_PR_RETURN || poData.T_PR_RETURN.length === 0) {
+ errors.push('T_PR_RETURN은 필수입니다.');
+ } else {
+ poData.T_PR_RETURN.forEach((prReturn, index) => {
+ const requiredFields = ['ANFNR', 'ANFPS', 'EBELN', 'EBELP', 'MSGTY'];
+ requiredFields.forEach(field => {
+ if (!prReturn[field as keyof PRReturnData]) {
+ errors.push(`T_PR_RETURN[${index}].${field}는 필수입니다.`);
+ }
+ });
+ });
+ }
+
+ return {
+ isValid: errors.length === 0,
+ errors
+ };
+}
+
+// ECC로 PO 생성 SOAP XML 전송하는 함수
+async function sendPOToECC(poData: POCreateRequest): Promise<SoapSendResult> {
+ try {
+ // 데이터 검증
+ const validation = validatePOData(poData);
+ if (!validation.isValid) {
+ return {
+ success: false,
+ message: `데이터 검증 실패: ${validation.errors.join(', ')}`
+ };
+ }
+
+ // SOAP Body Content 생성
+ const soapBodyContent = createPOSoapBodyContent(poData);
+
+ // SOAP 전송 설정
+ const config: SoapSendConfig = {
+ endpoint: ECC_PO_ENDPOINT,
+ envelope: soapBodyContent,
+ soapAction: 'http://sap.com/xi/WebService/soap1.1',
+ timeout: 60000, // PO 생성은 60초 타임아웃
+ retryCount: 3,
+ retryDelay: 2000
+ };
+
+ // 로그 정보
+ const logInfo: SoapLogInfo = {
+ direction: 'OUTBOUND',
+ system: 'S-ERP ECC',
+ interface: 'IF_ECC_EVCP_PO_CREATE'
+ };
+
+ console.log(`📤 PO 생성 요청 전송 시작 - ANFNR: ${poData.T_Bidding_HEADER[0]?.ANFNR}`);
+ console.log(`🔍 헤더 ${poData.T_Bidding_HEADER.length}개, 아이템 ${poData.T_Bidding_ITEM.length}개, PR 반환 ${poData.T_PR_RETURN.length}개`);
+
+ // SOAP XML 전송
+ const result = await sendSoapXml(config, logInfo);
+
+ if (result.success) {
+ console.log(`✅ PO 생성 요청 전송 성공 - ANFNR: ${poData.T_Bidding_HEADER[0]?.ANFNR}`);
+ } else {
+ console.error(`❌ PO 생성 요청 전송 실패 - ANFNR: ${poData.T_Bidding_HEADER[0]?.ANFNR}, 오류: ${result.message}`);
+ }
+
+ return result;
+
+ } catch (error) {
+ console.error('❌ PO 생성 전송 중 오류 발생:', error);
+ return {
+ success: false,
+ message: error instanceof Error ? error.message : 'Unknown error'
+ };
+ }
+}
+
+// ========================================
+// 메인 PO 생성 및 전송 함수들
+// ========================================
+
+// 단일 PO 생성 요청 처리
+export async function createPurchaseOrder(poData: POCreateRequest): Promise<{
+ success: boolean;
+ message: string;
+ responseData?: string;
+ bidding_number?: string;
+}> {
+ try {
+ console.log(`🚀 PO 생성 요청 시작 - ANFNR: ${poData.T_Bidding_HEADER[0]?.ANFNR}`);
+
+ const result = await sendPOToECC(poData);
+
+ return {
+ success: result.success,
+ message: result.success ? 'PO 생성 요청이 성공적으로 전송되었습니다.' : result.message,
+ responseData: result.responseText,
+ bidding_number: poData.T_Bidding_HEADER[0]?.ANFNR
+ };
+
+ } catch (error) {
+ console.error('❌ PO 생성 요청 처리 실패:', error);
+ return {
+ success: false,
+ message: error instanceof Error ? error.message : 'Unknown error'
+ };
+ }
+}
+
+// 여러 PO 배치 생성 요청 처리
+export async function createMultiplePurchaseOrders(poDataList: POCreateRequest[]): Promise<{
+ success: boolean;
+ message: string;
+ results?: Array<{ bidding_number: string; success: boolean; error?: string }>;
+}> {
+ try {
+ console.log(`🚀 배치 PO 생성 요청 시작: ${poDataList.length}개`);
+
+ const results: Array<{ bidding_number: string; success: boolean; error?: string }> = [];
+
+ for (const poData of poDataList) {
+ try {
+ const bidding_number = poData.T_Bidding_HEADER[0]?.ANFNR || 'Unknown';
+ console.log(`📤 PO 생성 처리 중: ${bidding_number}`);
+
+ const result = await sendPOToECC(poData);
+
+ if (result.success) {
+ console.log(`✅ PO 생성 성공: ${bidding_number}`);
+ results.push({
+ bidding_number,
+ success: true
+ });
+ } else {
+ console.error(`❌ PO 생성 실패: ${bidding_number}, 오류: ${result.message}`);
+ results.push({
+ bidding_number,
+ success: false,
+ error: result.message
+ });
+ }
+
+ // 배치 처리간 지연 (시스템 부하 방지)
+ if (poDataList.length > 1) {
+ await new Promise(resolve => setTimeout(resolve, 1000));
+ }
+
+ } catch (error) {
+ const bidding_number = poData.T_Bidding_HEADER[0]?.ANFNR || 'Unknown';
+ console.error(`❌ PO 생성 처리 실패: ${bidding_number}`, error);
+ results.push({
+ bidding_number,
+ success: false,
+ error: error instanceof Error ? error.message : 'Unknown error'
+ });
+ }
+ }
+
+ const successCount = results.filter(r => r.success).length;
+ const failCount = results.length - successCount;
+
+ console.log(`🎉 배치 PO 생성 완료: 성공 ${successCount}개, 실패 ${failCount}개`);
+
+ return {
+ success: failCount === 0,
+ message: `배치 PO 생성 완료: 성공 ${successCount}개, 실패 ${failCount}개`,
+ results
+ };
+
+ } catch (error) {
+ console.error('❌ 배치 PO 생성 중 전체 오류 발생:', error);
+ return {
+ success: false,
+ message: error instanceof Error ? error.message : 'Unknown error'
+ };
+ }
+}
+
+// 테스트용 PO 생성 함수 (샘플 데이터 포함)
+export async function createTestPurchaseOrder(): Promise<{
+ success: boolean;
+ message: string;
+ responseData?: string;
+ testData?: POCreateRequest;
+}> {
+ try {
+ console.log('🧪 테스트용 PO 생성 시작');
+
+ // 테스트용 샘플 데이터 생성
+ const testPOData: POCreateRequest = {
+ T_Bidding_HEADER: [{
+ ANFNR: 'TEST001',
+ LIFNR: '1000000001',
+ ZPROC_IND: 'A',
+ ANGNR: 'TEST001',
+ WAERS: 'KRW',
+ ZTERM: '0001',
+ INCO1: 'FOB',
+ INCO2: 'Seoul, Korea',
+ VSTEL: '001',
+ LSTEL: '001',
+ MWSKZ: 'V0',
+ LANDS: 'KR',
+ ZRCV_DT: getCurrentSAPDate(),
+ ZATTEN_IND: 'Y',
+ IHRAN: getCurrentSAPDate(),
+ TEXT: 'Test PO Creation',
+ ZDLV_CNTLR: '001',
+ ZDLV_PRICE_T: 'N',
+ ZDLV_PRICE_NOTE: 'Test Note'
+ }],
+ T_Bidding_ITEM: [{
+ ANFNR: 'TEST001',
+ ANFPS: '00001',
+ LIFNR: '1000000001',
+ NETPR: '1000.00',
+ PEINH: '1',
+ BPRME: 'EA',
+ NETWR: '1000.00',
+ BRTWR: '1100.00',
+ LFDAT: getCurrentSAPDate(),
+ ZCON_NO_PO: 'CON001',
+ EBELP: '00001'
+ }],
+ T_PR_RETURN: [{
+ ANFNR: 'TEST001',
+ ANFPS: '00001',
+ EBELN: 'PR001',
+ EBELP: '00001',
+ MSGTY: 'S',
+ MSGTXT: 'Test message'
+ }],
+ EV_ERDAT: getCurrentSAPDate(),
+ EV_ERZET: getCurrentSAPTime()
+ };
+
+ const result = await sendPOToECC(testPOData);
+
+ return {
+ success: result.success,
+ message: result.success ? '테스트 PO 생성이 성공적으로 전송되었습니다.' : result.message,
+ responseData: result.responseText,
+ testData: testPOData
+ };
+
+ } catch (error) {
+ console.error('❌ 테스트 PO 생성 실패:', error);
+ return {
+ success: false,
+ message: error instanceof Error ? error.message : 'Unknown error'
+ };
+ }
+}
+
+// PO 생성 요청 상태 확인 함수 (향후 확장용)
+export async function checkPOCreationStatus(biddingNumber: string): Promise<{
+ success: boolean;
+ message: string;
+ status?: string;
+}> {
+ try {
+ console.log(`🔍 PO 생성 상태 확인: ${biddingNumber}`);
+
+ // 향후 ECC에서 상태 조회 API가 제공될 경우 구현
+ // 현재는 기본 응답만 반환
+
+ return {
+ success: true,
+ message: 'PO 생성 상태 확인 기능은 향후 구현 예정입니다.',
+ status: 'PENDING'
+ };
+
+ } catch (error) {
+ console.error('❌ PO 상태 확인 실패:', error);
+ return {
+ success: false,
+ message: error instanceof Error ? error.message : 'Unknown error'
+ };
+ }
+}
+
+// ========================================
+// 유틸리티 함수들
+// ========================================
+
+// PO 데이터 생성 헬퍼 함수
+function createPOData(
+ headers: POHeaderData[],
+ items: POItemData[],
+ prReturns: PRReturnData[],
+ options?: {
+ extractDate?: string;
+ extractTime?: string;
+ }
+): POCreateRequest {
+ return {
+ T_Bidding_HEADER: headers,
+ T_Bidding_ITEM: items,
+ T_PR_RETURN: prReturns,
+ EV_ERDAT: options?.extractDate || getCurrentSAPDate(),
+ EV_ERZET: options?.extractTime || getCurrentSAPTime()
+ };
+}
+
+// 날짜/시간 포맷 변환 함수들은 @/lib/soap/utils에서 import하여 사용
diff --git a/lib/soap/ecc/send/pcr-confirm.ts b/lib/soap/ecc/send/pcr-confirm.ts
new file mode 100644
index 00000000..7ac2d931
--- /dev/null
+++ b/lib/soap/ecc/send/pcr-confirm.ts
@@ -0,0 +1,682 @@
+
+'use server'
+
+import { sendSoapXml, type SoapSendConfig, type SoapLogInfo, type SoapSendResult } from "@/lib/soap/sender";
+
+// ECC PCR 확인 엔드포인트
+const ECC_PCR_CONFIRM_ENDPOINT = "http://shii8dvddb01.hec.serp.shi.samsung.net:50000/sap/xi/engine?type=entry&version=3.0&Sender.Service=P2038_D&Interface=http%3A%2F%2Fshi.samsung.co.kr%2FP2_MM%2FMMM%5EP2MM3019_SO";
+
+// PCR 확인 요청 데이터 타입
+export interface PCRConfirmRequest {
+ ZMM_PCR: Array<{
+ PCR_REQ: string; // PCR 요청번호 (M)
+ PCR_REQ_SEQ: string; // PCR 요청순번 (M)
+ PCR_DEC_DATE: string; // PCR 결정일 (M, YYYYMMDD)
+ EBELN: string; // 구매오더 (M)
+ EBELP: string; // 구매오더 품번 (M)
+ WAERS?: string; // PCR 통화
+ PCR_NETPR?: string; // PCR 단가
+ PEINH?: string; // Price Unit, 수량에 대한 PER 당 단가
+ PCR_NETWR?: string; // PCR 금액
+ PCR_STATUS: string; // PCR 상태 (M)
+ REJ_CD?: string; // Reject 코드
+ REJ_RSN?: string; // Reject 사유
+ CONFIRM_CD?: string; // Confirm 코드
+ CONFIRM_RSN?: string; // Confirm 사유
+ }>;
+}
+
+// PCR 확인 응답 데이터 타입 (참고용)
+export interface PCRConfirmResponse {
+ ZMM_RT?: Array<{
+ PCR_REQ: string; // PCR 요청번호
+ PCR_REQ_SEQ: string; // PCR 요청순번
+ EBELN: string; // 구매오더
+ EBELP: string; // 구매오더 품번
+ MSGTY?: string; // Message Type
+ MSGTXT?: string; // Message Text
+ }>;
+}
+
+// 보낼 때 ZMM_PCR 객체 안에 담아보내야 함
+// SEQ,Table,Field,M/O,Type,Size,Description
+// 1,ZMM_PCR,PCR_REQ,M,CHAR,10,PCR 요청번호
+// 2,ZMM_PCR,PCR_REQ_SEQ,M,NUMC,5,PCR 요청순번
+// 3,ZMM_PCR,PCR_DEC_DATE,M,DATS,8,PCR 결정일
+// 4,ZMM_PCR,EBELN,M,CHAR,10,구매오더
+// 5,ZMM_PCR,EBELP,M,NUMC,5,구매오더 품번
+// 6,ZMM_PCR,WAERS,,CUKY,5,PCR 통화
+// 7,ZMM_PCR,PCR_NETPR,,CURR,"13,2",PCR 단가
+// 8,ZMM_PCR,PEINH,,DEC,5,"Price Unit, 수량에 대한 PER 당 단가"
+// 9,ZMM_PCR,PCR_NETWR,,CURR,"13,2",PCR 금액
+// 10,ZMM_PCR,PCR_STATUS,M,CHAR,1,PCR 상태
+// 11,ZMM_PCR,REJ_CD,,CHAR,10,Reject 코드
+// 12,ZMM_PCR,REJ_RSN,,CHAR,50,Reject 사유
+// 13,ZMM_PCR,CONFIRM_CD,,CHAR,10,Confirm 코드
+// 14,ZMM_PCR,CONFIRM_RSN,,CHAR,50,Confirm 사유
+// 15,ZMM_RT,PCR_REQ,M,CHAR,10,PCR 요청번호 REPLY(NOT TO SEND)
+// 16,ZMM_RT,PCR_REQ_SEQ,M,NUMC,5,PCR 요청순번 REPLY(NOT TO SEND)
+// 17,ZMM_RT,EBELN,M,CHAR,10,구매오더 REPLY(NOT TO SEND)
+// 18,ZMM_RT,EBELP,M,NUMC,5,구매오더 품번 REPLY(NOT TO SEND)
+// 19,ZMM_RT,MSGTY,,CHAR,1,Message Type REPLY(NOT TO SEND)
+// 20,ZMM_RT,MSGTXT,,CHAR,100,Message Text REPLY(NOT TO SEND)
+
+// SOAP Body Content 생성 함수
+function createPCRConfirmSoapBodyContent(pcrData: PCRConfirmRequest): Record<string, unknown> {
+ return {
+ 'ns0:MT_P2MM3019_S': {
+ 'ZMM_PCR': pcrData.ZMM_PCR
+ }
+ };
+}
+
+// PCR 데이터 검증 함수
+function validatePCRConfirmData(pcrData: PCRConfirmRequest): { isValid: boolean; errors: string[] } {
+ const errors: string[] = [];
+
+ // ZMM_PCR 배열 검증
+ if (!pcrData.ZMM_PCR || !Array.isArray(pcrData.ZMM_PCR) || pcrData.ZMM_PCR.length === 0) {
+ errors.push('ZMM_PCR은 필수이며 최소 1개 이상의 PCR 데이터가 있어야 합니다.');
+ } else {
+ pcrData.ZMM_PCR.forEach((item, index) => {
+ // 필수 필드 검증
+ if (!item.PCR_REQ || typeof item.PCR_REQ !== 'string' || item.PCR_REQ.trim() === '') {
+ errors.push(`ZMM_PCR[${index}].PCR_REQ은 필수입니다.`);
+ } else if (item.PCR_REQ.length > 10) {
+ errors.push(`ZMM_PCR[${index}].PCR_REQ은 10자를 초과할 수 없습니다.`);
+ }
+
+ if (!item.PCR_REQ_SEQ || typeof item.PCR_REQ_SEQ !== 'string' || item.PCR_REQ_SEQ.trim() === '') {
+ errors.push(`ZMM_PCR[${index}].PCR_REQ_SEQ는 필수입니다.`);
+ } else if (item.PCR_REQ_SEQ.length > 5) {
+ errors.push(`ZMM_PCR[${index}].PCR_REQ_SEQ는 5자를 초과할 수 없습니다.`);
+ }
+
+ if (!item.PCR_DEC_DATE || typeof item.PCR_DEC_DATE !== 'string' || item.PCR_DEC_DATE.trim() === '') {
+ errors.push(`ZMM_PCR[${index}].PCR_DEC_DATE는 필수입니다.`);
+ } else if (!/^\d{8}$/.test(item.PCR_DEC_DATE)) {
+ errors.push(`ZMM_PCR[${index}].PCR_DEC_DATE는 YYYYMMDD 형식이어야 합니다.`);
+ }
+
+ if (!item.EBELN || typeof item.EBELN !== 'string' || item.EBELN.trim() === '') {
+ errors.push(`ZMM_PCR[${index}].EBELN은 필수입니다.`);
+ } else if (item.EBELN.length > 10) {
+ errors.push(`ZMM_PCR[${index}].EBELN은 10자를 초과할 수 없습니다.`);
+ }
+
+ if (!item.EBELP || typeof item.EBELP !== 'string' || item.EBELP.trim() === '') {
+ errors.push(`ZMM_PCR[${index}].EBELP는 필수입니다.`);
+ } else if (item.EBELP.length > 5) {
+ errors.push(`ZMM_PCR[${index}].EBELP는 5자를 초과할 수 없습니다.`);
+ }
+
+ if (!item.PCR_STATUS || typeof item.PCR_STATUS !== 'string' || item.PCR_STATUS.trim() === '') {
+ errors.push(`ZMM_PCR[${index}].PCR_STATUS는 필수입니다.`);
+ } else if (item.PCR_STATUS.length > 1) {
+ errors.push(`ZMM_PCR[${index}].PCR_STATUS는 1자를 초과할 수 없습니다.`);
+ }
+
+ // 선택 필드 길이 검증
+ if (item.WAERS && item.WAERS.length > 5) {
+ errors.push(`ZMM_PCR[${index}].WAERS는 5자를 초과할 수 없습니다.`);
+ }
+
+ if (item.REJ_CD && item.REJ_CD.length > 10) {
+ errors.push(`ZMM_PCR[${index}].REJ_CD는 10자를 초과할 수 없습니다.`);
+ }
+
+ if (item.REJ_RSN && item.REJ_RSN.length > 50) {
+ errors.push(`ZMM_PCR[${index}].REJ_RSN은 50자를 초과할 수 없습니다.`);
+ }
+
+ if (item.CONFIRM_CD && item.CONFIRM_CD.length > 10) {
+ errors.push(`ZMM_PCR[${index}].CONFIRM_CD는 10자를 초과할 수 없습니다.`);
+ }
+
+ if (item.CONFIRM_RSN && item.CONFIRM_RSN.length > 50) {
+ errors.push(`ZMM_PCR[${index}].CONFIRM_RSN은 50자를 초과할 수 없습니다.`);
+ }
+ });
+ }
+
+ return {
+ isValid: errors.length === 0,
+ errors
+ };
+}
+
+// ECC로 PCR 확인 SOAP XML 전송하는 함수
+async function sendPCRConfirmToECC(pcrData: PCRConfirmRequest): Promise<SoapSendResult> {
+ try {
+ // 데이터 검증
+ const validation = validatePCRConfirmData(pcrData);
+ if (!validation.isValid) {
+ return {
+ success: false,
+ message: `데이터 검증 실패: ${validation.errors.join(', ')}`
+ };
+ }
+
+ // SOAP Body Content 생성
+ const soapBodyContent = createPCRConfirmSoapBodyContent(pcrData);
+
+ // SOAP 전송 설정
+ const config: SoapSendConfig = {
+ endpoint: ECC_PCR_CONFIRM_ENDPOINT,
+ envelope: soapBodyContent,
+ soapAction: 'http://sap.com/xi/WebService/soap1.1',
+ timeout: 30000, // PCR 확인은 30초 타임아웃
+ retryCount: 3,
+ retryDelay: 1000
+ };
+
+ // 로그 정보
+ const logInfo: SoapLogInfo = {
+ direction: 'OUTBOUND',
+ system: 'S-ERP ECC',
+ interface: 'IF_ECC_EVCP_PCR_CONFIRM'
+ };
+
+ const pcrReqs = pcrData.ZMM_PCR.map(item => `${item.PCR_REQ}-${item.PCR_REQ_SEQ}`).join(', ');
+ console.log(`📤 PCR 확인 요청 전송 시작 - PCR Requests: ${pcrReqs}`);
+ console.log(`🔍 확인 대상 PCR ${pcrData.ZMM_PCR.length}개`);
+
+ // SOAP XML 전송
+ const result = await sendSoapXml(config, logInfo);
+
+ if (result.success) {
+ console.log(`✅ PCR 확인 요청 전송 성공 - PCR Requests: ${pcrReqs}`);
+ } else {
+ console.error(`❌ PCR 확인 요청 전송 실패 - PCR Requests: ${pcrReqs}, 오류: ${result.message}`);
+ }
+
+ return result;
+
+ } catch (error) {
+ console.error('❌ PCR 확인 전송 중 오류 발생:', error);
+ return {
+ success: false,
+ message: error instanceof Error ? error.message : 'Unknown error'
+ };
+ }
+}
+
+// ========================================
+// 메인 PCR 확인 서버 액션 함수들
+// ========================================
+
+// 단일 PCR 확인 요청 처리
+export async function confirmPCR(pcrItem: {
+ PCR_REQ: string;
+ PCR_REQ_SEQ: string;
+ PCR_DEC_DATE: string;
+ EBELN: string;
+ EBELP: string;
+ PCR_STATUS: string;
+ WAERS?: string;
+ PCR_NETPR?: string;
+ PEINH?: string;
+ PCR_NETWR?: string;
+ REJ_CD?: string;
+ REJ_RSN?: string;
+ CONFIRM_CD?: string;
+ CONFIRM_RSN?: string;
+}): Promise<{
+ success: boolean;
+ message: string;
+ responseData?: string;
+ pcrRequest?: string;
+}> {
+ try {
+ console.log(`🚀 PCR 확인 요청 시작 - PCR: ${pcrItem.PCR_REQ}-${pcrItem.PCR_REQ_SEQ}`);
+
+ const pcrData: PCRConfirmRequest = {
+ ZMM_PCR: [pcrItem]
+ };
+
+ const result = await sendPCRConfirmToECC(pcrData);
+
+ return {
+ success: result.success,
+ message: result.success ? 'PCR 확인 요청이 성공적으로 전송되었습니다.' : result.message,
+ responseData: result.responseText,
+ pcrRequest: `${pcrItem.PCR_REQ}-${pcrItem.PCR_REQ_SEQ}`
+ };
+
+ } catch (error) {
+ console.error('❌ PCR 확인 요청 처리 실패:', error);
+ return {
+ success: false,
+ message: error instanceof Error ? error.message : 'Unknown error'
+ };
+ }
+}
+
+// 여러 PCR 배치 확인 요청 처리
+export async function confirmMultiplePCRs(pcrItems: Array<{
+ PCR_REQ: string;
+ PCR_REQ_SEQ: string;
+ PCR_DEC_DATE: string;
+ EBELN: string;
+ EBELP: string;
+ PCR_STATUS: string;
+ WAERS?: string;
+ PCR_NETPR?: string;
+ PEINH?: string;
+ PCR_NETWR?: string;
+ REJ_CD?: string;
+ REJ_RSN?: string;
+ CONFIRM_CD?: string;
+ CONFIRM_RSN?: string;
+}>): Promise<{
+ success: boolean;
+ message: string;
+ results?: Array<{ pcrRequest: string; success: boolean; error?: string }>;
+}> {
+ try {
+ console.log(`🚀 배치 PCR 확인 요청 시작: ${pcrItems.length}개`);
+
+ // 모든 PCR을 하나의 요청으로 처리
+ const pcrData: PCRConfirmRequest = {
+ ZMM_PCR: pcrItems
+ };
+
+ const result = await sendPCRConfirmToECC(pcrData);
+
+ // 결과 정리
+ const results = pcrItems.map(item => ({
+ pcrRequest: `${item.PCR_REQ}-${item.PCR_REQ_SEQ}`,
+ success: result.success,
+ error: result.success ? undefined : result.message
+ }));
+
+ const successCount = result.success ? pcrItems.length : 0;
+ const failCount = pcrItems.length - successCount;
+
+ console.log(`🎉 배치 PCR 확인 완료: 성공 ${successCount}개, 실패 ${failCount}개`);
+
+ return {
+ success: result.success,
+ message: result.success
+ ? `배치 PCR 확인 성공: ${successCount}개`
+ : `배치 PCR 확인 실패: ${result.message}`,
+ results
+ };
+
+ } catch (error) {
+ console.error('❌ 배치 PCR 확인 중 전체 오류 발생:', error);
+ return {
+ success: false,
+ message: error instanceof Error ? error.message : 'Unknown error'
+ };
+ }
+}
+
+// 개별 처리 방식의 배치 PCR 확인 (각각 따로 전송)
+export async function confirmMultiplePCRsIndividually(pcrItems: Array<{
+ PCR_REQ: string;
+ PCR_REQ_SEQ: string;
+ PCR_DEC_DATE: string;
+ EBELN: string;
+ EBELP: string;
+ PCR_STATUS: string;
+ WAERS?: string;
+ PCR_NETPR?: string;
+ PEINH?: string;
+ PCR_NETWR?: string;
+ REJ_CD?: string;
+ REJ_RSN?: string;
+ CONFIRM_CD?: string;
+ CONFIRM_RSN?: string;
+}>): Promise<{
+ success: boolean;
+ message: string;
+ results?: Array<{ pcrRequest: string; success: boolean; error?: string }>;
+}> {
+ try {
+ console.log(`🚀 개별 PCR 확인 요청 시작: ${pcrItems.length}개`);
+
+ const results: Array<{ pcrRequest: string; success: boolean; error?: string }> = [];
+
+ for (const pcrItem of pcrItems) {
+ try {
+ const pcrRequest = `${pcrItem.PCR_REQ}-${pcrItem.PCR_REQ_SEQ}`;
+ console.log(`📤 PCR 확인 처리 중: ${pcrRequest}`);
+
+ const pcrData: PCRConfirmRequest = {
+ ZMM_PCR: [pcrItem]
+ };
+
+ const result = await sendPCRConfirmToECC(pcrData);
+
+ if (result.success) {
+ console.log(`✅ PCR 확인 성공: ${pcrRequest}`);
+ results.push({
+ pcrRequest,
+ success: true
+ });
+ } else {
+ console.error(`❌ PCR 확인 실패: ${pcrRequest}, 오류: ${result.message}`);
+ results.push({
+ pcrRequest,
+ success: false,
+ error: result.message
+ });
+ }
+
+ // 개별 처리간 지연 (시스템 부하 방지)
+ if (pcrItems.length > 1) {
+ await new Promise(resolve => setTimeout(resolve, 500));
+ }
+
+ } catch (error) {
+ const pcrRequest = `${pcrItem.PCR_REQ}-${pcrItem.PCR_REQ_SEQ}`;
+ console.error(`❌ PCR 확인 처리 실패: ${pcrRequest}`, error);
+ results.push({
+ pcrRequest,
+ success: false,
+ error: error instanceof Error ? error.message : 'Unknown error'
+ });
+ }
+ }
+
+ const successCount = results.filter(r => r.success).length;
+ const failCount = results.length - successCount;
+
+ console.log(`🎉 개별 PCR 확인 완료: 성공 ${successCount}개, 실패 ${failCount}개`);
+
+ return {
+ success: failCount === 0,
+ message: `개별 PCR 확인 완료: 성공 ${successCount}개, 실패 ${failCount}개`,
+ results
+ };
+
+ } catch (error) {
+ console.error('❌ 개별 PCR 확인 중 전체 오류 발생:', error);
+ return {
+ success: false,
+ message: error instanceof Error ? error.message : 'Unknown error'
+ };
+ }
+}
+
+// 테스트용 PCR 확인 함수 (샘플 데이터 포함)
+export async function confirmTestPCR(): Promise<{
+ success: boolean;
+ message: string;
+ responseData?: string;
+ testData?: PCRConfirmRequest;
+}> {
+ try {
+ console.log('🧪 테스트용 PCR 확인 시작');
+
+ // 테스트용 샘플 데이터 생성
+ const testPCRData: PCRConfirmRequest = {
+ ZMM_PCR: [{
+ PCR_REQ: 'TEST_PCR01',
+ PCR_REQ_SEQ: '00001',
+ PCR_DEC_DATE: '20241201',
+ EBELN: 'TEST_PO01',
+ EBELP: '00010',
+ PCR_STATUS: 'A',
+ WAERS: 'KRW',
+ PCR_NETPR: '1000.00',
+ PEINH: '1',
+ PCR_NETWR: '1000.00',
+ CONFIRM_CD: 'CONF',
+ CONFIRM_RSN: '테스트 확인'
+ }]
+ };
+
+ const result = await sendPCRConfirmToECC(testPCRData);
+
+ return {
+ success: result.success,
+ message: result.success ? '테스트 PCR 확인이 성공적으로 전송되었습니다.' : result.message,
+ responseData: result.responseText,
+ testData: testPCRData
+ };
+
+ } catch (error) {
+ console.error('❌ 테스트 PCR 확인 실패:', error);
+ return {
+ success: false,
+ message: error instanceof Error ? error.message : 'Unknown error'
+ };
+ }
+}
+
+// ========================================
+// 유틸리티 함수들
+// ========================================
+
+// PCR 확인 데이터 생성 헬퍼 함수
+function createPCRConfirmData(pcrItems: Array<{
+ PCR_REQ: string;
+ PCR_REQ_SEQ: string;
+ PCR_DEC_DATE: string;
+ EBELN: string;
+ EBELP: string;
+ PCR_STATUS: string;
+ WAERS?: string;
+ PCR_NETPR?: string;
+ PEINH?: string;
+ PCR_NETWR?: string;
+ REJ_CD?: string;
+ REJ_RSN?: string;
+ CONFIRM_CD?: string;
+ CONFIRM_RSN?: string;
+}>): PCRConfirmRequest {
+ return {
+ ZMM_PCR: pcrItems
+ };
+}
+
+// PCR 요청번호 검증 함수
+function validatePCRNumber(pcrReq: string): { isValid: boolean; error?: string } {
+ if (!pcrReq || typeof pcrReq !== 'string') {
+ return { isValid: false, error: 'PCR 요청번호는 문자열이어야 합니다.' };
+ }
+
+ const trimmed = pcrReq.trim();
+ if (trimmed === '') {
+ return { isValid: false, error: 'PCR 요청번호는 비어있을 수 없습니다.' };
+ }
+
+ // 기본적인 길이 검증 (10자 제한 - WSDL에서 CHAR 10으로 정의)
+ if (trimmed.length > 10) {
+ return { isValid: false, error: 'PCR 요청번호는 10자를 초과할 수 없습니다.' };
+ }
+
+ return { isValid: true };
+}
+
+// PCR 요청순번 검증 함수
+function validatePCRSequence(pcrReqSeq: string): { isValid: boolean; error?: string } {
+ if (!pcrReqSeq || typeof pcrReqSeq !== 'string') {
+ return { isValid: false, error: 'PCR 요청순번은 문자열이어야 합니다.' };
+ }
+
+ const trimmed = pcrReqSeq.trim();
+ if (trimmed === '') {
+ return { isValid: false, error: 'PCR 요청순번은 비어있을 수 없습니다.' };
+ }
+
+ // 숫자 형식 검증 (NUMC 5자리)
+ if (!/^\d{1,5}$/.test(trimmed)) {
+ return { isValid: false, error: 'PCR 요청순번은 1-5자리 숫자여야 합니다.' };
+ }
+
+ return { isValid: true };
+}
+
+// PCR 결정일 검증 함수
+function validatePCRDecisionDate(pcrDecDate: string): { isValid: boolean; error?: string } {
+ if (!pcrDecDate || typeof pcrDecDate !== 'string') {
+ return { isValid: false, error: 'PCR 결정일은 문자열이어야 합니다.' };
+ }
+
+ const trimmed = pcrDecDate.trim();
+ if (trimmed === '') {
+ return { isValid: false, error: 'PCR 결정일은 비어있을 수 없습니다.' };
+ }
+
+ // YYYYMMDD 형식 검증
+ if (!/^\d{8}$/.test(trimmed)) {
+ return { isValid: false, error: 'PCR 결정일은 YYYYMMDD 형식이어야 합니다.' };
+ }
+
+ // 날짜 유효성 검증
+ const year = parseInt(trimmed.substring(0, 4));
+ const month = parseInt(trimmed.substring(4, 6));
+ const day = parseInt(trimmed.substring(6, 8));
+
+ if (month < 1 || month > 12) {
+ return { isValid: false, error: 'PCR 결정일의 월이 올바르지 않습니다.' };
+ }
+
+ if (day < 1 || day > 31) {
+ return { isValid: false, error: 'PCR 결정일의 일이 올바르지 않습니다.' };
+ }
+
+ // 실제 날짜 검증
+ const date = new Date(year, month - 1, day);
+ if (date.getFullYear() !== year || date.getMonth() !== month - 1 || date.getDate() !== day) {
+ return { isValid: false, error: 'PCR 결정일이 유효하지 않은 날짜입니다.' };
+ }
+
+ return { isValid: true };
+}
+
+// PCR 상태 검증 함수
+function validatePCRStatus(pcrStatus: string): { isValid: boolean; error?: string } {
+ if (!pcrStatus || typeof pcrStatus !== 'string') {
+ return { isValid: false, error: 'PCR 상태는 문자열이어야 합니다.' };
+ }
+
+ const trimmed = pcrStatus.trim();
+ if (trimmed === '') {
+ return { isValid: false, error: 'PCR 상태는 비어있을 수 없습니다.' };
+ }
+
+ if (trimmed.length !== 1) {
+ return { isValid: false, error: 'PCR 상태는 1자리여야 합니다.' };
+ }
+
+ return { isValid: true };
+}
+
+// 구매오더 검증 함수
+function validatePurchaseOrder(ebeln: string): { isValid: boolean; error?: string } {
+ if (!ebeln || typeof ebeln !== 'string') {
+ return { isValid: false, error: '구매오더는 문자열이어야 합니다.' };
+ }
+
+ const trimmed = ebeln.trim();
+ if (trimmed === '') {
+ return { isValid: false, error: '구매오더는 비어있을 수 없습니다.' };
+ }
+
+ if (trimmed.length > 10) {
+ return { isValid: false, error: '구매오더는 10자를 초과할 수 없습니다.' };
+ }
+
+ return { isValid: true };
+}
+
+// 구매오더 품번 검증 함수
+function validatePurchaseOrderItem(ebelp: string): { isValid: boolean; error?: string } {
+ if (!ebelp || typeof ebelp !== 'string') {
+ return { isValid: false, error: '구매오더 품번은 문자열이어야 합니다.' };
+ }
+
+ const trimmed = ebelp.trim();
+ if (trimmed === '') {
+ return { isValid: false, error: '구매오더 품번은 비어있을 수 없습니다.' };
+ }
+
+ // 숫자 형식 검증 (NUMC 5자리)
+ if (!/^\d{1,5}$/.test(trimmed)) {
+ return { isValid: false, error: '구매오더 품번은 1-5자리 숫자여야 합니다.' };
+ }
+
+ return { isValid: true };
+}
+
+// 통화 검증 함수
+function validateCurrency(waers?: string): { isValid: boolean; error?: string } {
+ if (!waers) {
+ return { isValid: true }; // 선택 필드
+ }
+
+ if (typeof waers !== 'string') {
+ return { isValid: false, error: '통화는 문자열이어야 합니다.' };
+ }
+
+ const trimmed = waers.trim();
+ if (trimmed.length > 5) {
+ return { isValid: false, error: '통화는 5자를 초과할 수 없습니다.' };
+ }
+
+ return { isValid: true };
+}
+
+// 여러 PCR 아이템 검증 함수
+function validatePCRItems(pcrItems: Array<{
+ PCR_REQ: string;
+ PCR_REQ_SEQ: string;
+ PCR_DEC_DATE: string;
+ EBELN: string;
+ EBELP: string;
+ PCR_STATUS: string;
+ WAERS?: string;
+}>): { isValid: boolean; errors: string[] } {
+ const errors: string[] = [];
+
+ if (!Array.isArray(pcrItems) || pcrItems.length === 0) {
+ errors.push('최소 1개 이상의 PCR 아이템이 필요합니다.');
+ return { isValid: false, errors };
+ }
+
+ pcrItems.forEach((item, index) => {
+ const pcrReqValid = validatePCRNumber(item.PCR_REQ);
+ if (!pcrReqValid.isValid) {
+ errors.push(`PCR[${index}] 요청번호: ${pcrReqValid.error}`);
+ }
+
+ const pcrSeqValid = validatePCRSequence(item.PCR_REQ_SEQ);
+ if (!pcrSeqValid.isValid) {
+ errors.push(`PCR[${index}] 요청순번: ${pcrSeqValid.error}`);
+ }
+
+ const pcrDateValid = validatePCRDecisionDate(item.PCR_DEC_DATE);
+ if (!pcrDateValid.isValid) {
+ errors.push(`PCR[${index}] 결정일: ${pcrDateValid.error}`);
+ }
+
+ const eBelnValid = validatePurchaseOrder(item.EBELN);
+ if (!eBelnValid.isValid) {
+ errors.push(`PCR[${index}] 구매오더: ${eBelnValid.error}`);
+ }
+
+ const eBelpValid = validatePurchaseOrderItem(item.EBELP);
+ if (!eBelpValid.isValid) {
+ errors.push(`PCR[${index}] 구매오더품번: ${eBelpValid.error}`);
+ }
+
+ const statusValid = validatePCRStatus(item.PCR_STATUS);
+ if (!statusValid.isValid) {
+ errors.push(`PCR[${index}] 상태: ${statusValid.error}`);
+ }
+
+ const currencyValid = validateCurrency(item.WAERS);
+ if (!currencyValid.isValid) {
+ errors.push(`PCR[${index}] 통화: ${currencyValid.error}`);
+ }
+ });
+
+ return {
+ isValid: errors.length === 0,
+ errors
+ };
+}
diff --git a/lib/soap/ecc/send/rfq-info.ts b/lib/soap/ecc/send/rfq-info.ts
new file mode 100644
index 00000000..43fe821f
--- /dev/null
+++ b/lib/soap/ecc/send/rfq-info.ts
@@ -0,0 +1,469 @@
+'use server'
+
+/**
+ * RFQ(Request for Quotation) 정보 전송 시스템
+ *
+ * 기준 문서:
+ * - WSDL: IF_EVCP_ECC_RFQ_INFORMATION.wsdl
+ * - I/F 정의서: IF_EVCP_ECC_RFQ_INFORMATION.csv (송신측)
+ *
+ * 주요 구조:
+ * - T_RFQ_HEADER: RFQ 헤더 정보 (ANFNR, LIFNR, WAERS 등)
+ * - T_RFQ_ITEM: RFQ 아이템 정보 (ANFNR, ANFPS, NETPR 등)
+ *
+ * 주의사항:
+ * - EV_TYPE, EV_MESSAGE는 응답 전용 필드 (송신시 사용 안함)
+ * - 필수 필드(M)와 선택 필드(O) 구분 적용
+ */
+
+import { sendSoapXml, type SoapSendConfig, type SoapLogInfo, type SoapSendResult } from "@/lib/soap/sender";
+import { getCurrentSAPDate } from "@/lib/soap/utils";
+
+// ECC RFQ 정보 전송 엔드포인트
+const ECC_RFQ_ENDPOINT = "http://shii8dvddb01.hec.serp.shi.samsung.net:50000/sap/xi/engine?type=entry&version=3.0&Sender.Service=P2038_D&Interface=http%3A%2F%2Fshi.samsung.co.kr%2FP2_MM%2FMMM%5EP2MM3014_SO";
+
+// RFQ 헤더 데이터 타입
+export interface RFQHeaderData {
+ ANFNR: string; // RFQ Number (필수) - CHAR(10)
+ LIFNR: string; // Vendor's account number (필수) - CHAR(10)
+ WAERS: string; // Currency Key (필수) - CUKY(5)
+ ZTERM: string; // Terms of Payment Key (필수) - CHAR(4)
+ INCO1: string; // Incoterms (Part 1) (필수) - CHAR(3)
+ INCO2: string; // Incoterms (Part 2) (필수) - CHAR(28)
+ MWSKZ: string; // Tax on Sales/Purchases Code (필수) - CHAR(2)
+ LANDS: string; // Country for Tax Return (필수) - CHAR(3)
+ VSTEL?: string; // Place of Shipping (선택) - CHAR(3)
+ LSTEL?: string; // Place of Destination (선택) - CHAR(3)
+}
+
+// RFQ 아이템 데이터 타입
+export interface RFQItemData {
+ ANFNR: string; // RFQ Number (필수) - CHAR(10)
+ ANFPS: string; // Item Number of RFQ (필수) - NUMC(5,0)
+ NETPR: string; // Net Price in Purchasing Document (in Document Currency) (필수) - CURR(11,2)
+ NETWR: string; // Net Order Value in PO Currency (필수) - CURR(13,2)
+ BRTWR: string; // Gross order value in PO currency (필수) - CURR(13,2)
+ LFDAT?: string; // Item delivery date (선택) - DATS(8)
+}
+
+// RFQ 정보 전송 요청 데이터 타입
+export interface RFQInfoRequest {
+ T_RFQ_HEADER: RFQHeaderData[];
+ T_RFQ_ITEM: RFQItemData[];
+}
+
+// RFQ 응답 데이터 타입 (WSDL P2MM3014_S_response 기준)
+// 주의: CSV 정의서에 따르면 EV_TYPE, EV_MESSAGE는 "수신측 응답으로 보낼 내용이 아님"
+export interface RFQInfoResponse {
+ EV_TYPE?: string; // Message Type - CHAR(1) (응답 전용, 송신시 사용 안함)
+ EV_MESSAGE?: string; // Message Text - CHAR(100) (응답 전용, 송신시 사용 안함)
+}
+
+// SOAP Body Content 생성 함수
+function createRFQSoapBodyContent(rfqData: RFQInfoRequest): Record<string, unknown> {
+ return {
+ 'ns0:MT_P2MM3014_S': {
+ 'T_RFQ_HEADER': rfqData.T_RFQ_HEADER,
+ 'T_RFQ_ITEM': rfqData.T_RFQ_ITEM
+ }
+ };
+}
+
+
+
+// RFQ 데이터 기본 검증 함수 (필수 필드만 확인)
+function validateRFQData(rfqData: RFQInfoRequest): { isValid: boolean; errors: string[] } {
+ const errors: string[] = [];
+
+ // 헤더 데이터 검증
+ if (!rfqData.T_RFQ_HEADER || rfqData.T_RFQ_HEADER.length === 0) {
+ errors.push('T_RFQ_HEADER는 필수입니다.');
+ } else {
+ rfqData.T_RFQ_HEADER.forEach((header, index) => {
+ // 필수 필드 존재 여부만 검증
+ const requiredFields = ['ANFNR', 'LIFNR', 'WAERS', 'ZTERM', 'INCO1', 'INCO2', 'MWSKZ', 'LANDS'];
+ requiredFields.forEach(field => {
+ if (!header[field as keyof RFQHeaderData]) {
+ errors.push(`T_RFQ_HEADER[${index}].${field}는 필수입니다.`);
+ }
+ });
+ });
+ }
+
+ // 아이템 데이터 검증
+ if (!rfqData.T_RFQ_ITEM || rfqData.T_RFQ_ITEM.length === 0) {
+ errors.push('T_RFQ_ITEM은 필수입니다.');
+ } else {
+ rfqData.T_RFQ_ITEM.forEach((item, index) => {
+ // 필수 필드 존재 여부만 검증
+ const requiredFields = ['ANFNR', 'ANFPS', 'NETPR', 'NETWR', 'BRTWR'];
+ requiredFields.forEach(field => {
+ if (!item[field as keyof RFQItemData]) {
+ errors.push(`T_RFQ_ITEM[${index}].${field}는 필수입니다.`);
+ }
+ });
+ });
+ }
+
+ // RFQ 번호 일관성 검증
+ if (rfqData.T_RFQ_HEADER.length > 0 && rfqData.T_RFQ_ITEM.length > 0) {
+ const headerRFQNumbers = new Set(rfqData.T_RFQ_HEADER.map(h => h.ANFNR));
+ const itemRFQNumbers = new Set(rfqData.T_RFQ_ITEM.map(i => i.ANFNR));
+
+ for (const itemRFQ of itemRFQNumbers) {
+ if (!headerRFQNumbers.has(itemRFQ)) {
+ errors.push(`T_RFQ_ITEM의 ANFNR '${itemRFQ}'에 해당하는 T_RFQ_HEADER가 없습니다.`);
+ }
+ }
+ }
+
+ return {
+ isValid: errors.length === 0,
+ errors
+ };
+}
+
+// ECC로 RFQ 정보 SOAP XML 전송하는 함수
+async function sendRFQToECC(rfqData: RFQInfoRequest): Promise<SoapSendResult> {
+ try {
+ // 데이터 검증
+ const validation = validateRFQData(rfqData);
+ if (!validation.isValid) {
+ return {
+ success: false,
+ message: `데이터 검증 실패: ${validation.errors.join(', ')}`
+ };
+ }
+
+ // SOAP Body Content 생성
+ const soapBodyContent = createRFQSoapBodyContent(rfqData);
+
+ // SOAP 전송 설정
+ const config: SoapSendConfig = {
+ endpoint: ECC_RFQ_ENDPOINT,
+ envelope: soapBodyContent,
+ soapAction: 'http://sap.com/xi/WebService/soap1.1',
+ timeout: 60000, // RFQ 정보 전송은 60초 타임아웃
+ retryCount: 3,
+ retryDelay: 2000
+ };
+
+ // 로그 정보
+ const logInfo: SoapLogInfo = {
+ direction: 'OUTBOUND',
+ system: 'S-ERP ECC',
+ interface: 'IF_EVCP_ECC_RFQ_INFORMATION'
+ };
+
+ console.log(`📤 RFQ 정보 전송 시작 - ANFNR: ${rfqData.T_RFQ_HEADER[0]?.ANFNR}`);
+ console.log(`🔍 헤더 ${rfqData.T_RFQ_HEADER.length}개, 아이템 ${rfqData.T_RFQ_ITEM.length}개`);
+
+ // SOAP XML 전송
+ const result = await sendSoapXml(config, logInfo);
+
+ if (result.success) {
+ console.log(`✅ RFQ 정보 전송 성공 - ANFNR: ${rfqData.T_RFQ_HEADER[0]?.ANFNR}`);
+ } else {
+ console.error(`❌ RFQ 정보 전송 실패 - ANFNR: ${rfqData.T_RFQ_HEADER[0]?.ANFNR}, 오류: ${result.message}`);
+ }
+
+ return result;
+
+ } catch (error) {
+ console.error('❌ RFQ 정보 전송 중 오류 발생:', error);
+ return {
+ success: false,
+ message: error instanceof Error ? error.message : 'Unknown error'
+ };
+ }
+}
+
+// ========================================
+// 메인 RFQ 정보 전송 함수들
+// ========================================
+
+// 단일 RFQ 정보 전송 처리
+export async function sendRFQInformation(rfqData: RFQInfoRequest): Promise<{
+ success: boolean;
+ message: string;
+ responseData?: string;
+ rfq_number?: string;
+}> {
+ try {
+ console.log(`🚀 RFQ 정보 전송 요청 시작 - ANFNR: ${rfqData.T_RFQ_HEADER[0]?.ANFNR}`);
+
+ const result = await sendRFQToECC(rfqData);
+
+ return {
+ success: result.success,
+ message: result.success ? 'RFQ 정보가 성공적으로 전송되었습니다.' : result.message,
+ responseData: result.responseText,
+ rfq_number: rfqData.T_RFQ_HEADER[0]?.ANFNR
+ };
+
+ } catch (error) {
+ console.error('❌ RFQ 정보 전송 처리 실패:', error);
+ return {
+ success: false,
+ message: error instanceof Error ? error.message : 'Unknown error'
+ };
+ }
+}
+
+// 여러 RFQ 배치 정보 전송 처리
+export async function sendMultipleRFQInformation(rfqDataList: RFQInfoRequest[]): Promise<{
+ success: boolean;
+ message: string;
+ results?: Array<{ rfq_number: string; success: boolean; error?: string }>;
+}> {
+ try {
+ console.log(`🚀 배치 RFQ 정보 전송 시작: ${rfqDataList.length}개`);
+
+ const results: Array<{ rfq_number: string; success: boolean; error?: string }> = [];
+
+ for (const rfqData of rfqDataList) {
+ try {
+ const rfq_number = rfqData.T_RFQ_HEADER[0]?.ANFNR || 'Unknown';
+ console.log(`📤 RFQ 정보 처리 중: ${rfq_number}`);
+
+ const result = await sendRFQToECC(rfqData);
+
+ if (result.success) {
+ console.log(`✅ RFQ 정보 전송 성공: ${rfq_number}`);
+ results.push({
+ rfq_number,
+ success: true
+ });
+ } else {
+ console.error(`❌ RFQ 정보 전송 실패: ${rfq_number}, 오류: ${result.message}`);
+ results.push({
+ rfq_number,
+ success: false,
+ error: result.message
+ });
+ }
+
+ // 배치 처리간 지연 (시스템 부하 방지)
+ if (rfqDataList.length > 1) {
+ await new Promise(resolve => setTimeout(resolve, 1000));
+ }
+
+ } catch (error) {
+ const rfq_number = rfqData.T_RFQ_HEADER[0]?.ANFNR || 'Unknown';
+ console.error(`❌ RFQ 정보 처리 실패: ${rfq_number}`, error);
+ results.push({
+ rfq_number,
+ success: false,
+ error: error instanceof Error ? error.message : 'Unknown error'
+ });
+ }
+ }
+
+ const successCount = results.filter(r => r.success).length;
+ const failCount = results.length - successCount;
+
+ console.log(`🎉 배치 RFQ 정보 전송 완료: 성공 ${successCount}개, 실패 ${failCount}개`);
+
+ return {
+ success: failCount === 0,
+ message: `배치 RFQ 정보 전송 완료: 성공 ${successCount}개, 실패 ${failCount}개`,
+ results
+ };
+
+ } catch (error) {
+ console.error('❌ 배치 RFQ 정보 전송 중 전체 오류 발생:', error);
+ return {
+ success: false,
+ message: error instanceof Error ? error.message : 'Unknown error'
+ };
+ }
+}
+
+// 테스트용 RFQ 정보 전송 함수 (샘플 데이터 포함)
+export async function sendTestRFQInformation(): Promise<{
+ success: boolean;
+ message: string;
+ responseData?: string;
+ testData?: RFQInfoRequest;
+}> {
+ try {
+ console.log('🧪 테스트용 RFQ 정보 전송 시작');
+
+ // 테스트용 샘플 데이터 생성
+ const testRFQData: RFQInfoRequest = {
+ T_RFQ_HEADER: [{
+ ANFNR: 'RFQ0000001', // CHAR(10) - RFQ Number
+ LIFNR: '1000000001', // CHAR(10) - Vendor's account number
+ WAERS: 'KRW', // CUKY(5) - Currency Key
+ ZTERM: '0001', // CHAR(4) - Terms of Payment Key
+ INCO1: 'FOB', // CHAR(3) - Incoterms (Part 1)
+ INCO2: 'Seoul, Korea', // CHAR(28) - Incoterms (Part 2)
+ MWSKZ: 'V0', // CHAR(2) - Tax on Sales/Purchases Code
+ LANDS: 'KR', // CHAR(3) - Country for Tax Return
+ VSTEL: '001', // CHAR(3) - Place of Shipping (선택)
+ LSTEL: '001' // CHAR(3) - Place of Destination (선택)
+ }],
+ T_RFQ_ITEM: [{
+ ANFNR: 'RFQ0000001', // CHAR(10) - RFQ Number
+ ANFPS: '00001', // NUMC(5,0) - Item Number of RFQ
+ NETPR: '1000.00', // CURR(11,2) - Net Price in Purchasing Document
+ NETWR: '1000.00', // CURR(13,2) - Net Order Value in PO Currency
+ BRTWR: '1100.00', // CURR(13,2) - Gross order value in PO currency
+ LFDAT: getCurrentSAPDate() // DATS(8) - Item delivery date (선택)
+ }]
+ };
+
+ const result = await sendRFQToECC(testRFQData);
+
+ return {
+ success: result.success,
+ message: result.success ? '테스트 RFQ 정보가 성공적으로 전송되었습니다.' : result.message,
+ responseData: result.responseText,
+ testData: testRFQData
+ };
+
+ } catch (error) {
+ console.error('❌ 테스트 RFQ 정보 전송 실패:', error);
+ return {
+ success: false,
+ message: error instanceof Error ? error.message : 'Unknown error'
+ };
+ }
+}
+
+// RFQ 정보 전송 상태 확인 함수 (향후 확장용)
+export async function checkRFQInformationStatus(rfqNumber: string): Promise<{
+ success: boolean;
+ message: string;
+ status?: string;
+}> {
+ try {
+ console.log(`🔍 RFQ 정보 전송 상태 확인: ${rfqNumber}`);
+
+ // 향후 ECC에서 상태 조회 API가 제공될 경우 구현
+ // 현재는 기본 응답만 반환
+
+ return {
+ success: true,
+ message: 'RFQ 정보 전송 상태 확인 기능은 향후 구현 예정입니다.',
+ status: 'PENDING'
+ };
+
+ } catch (error) {
+ console.error('❌ RFQ 상태 확인 실패:', error);
+ return {
+ success: false,
+ message: error instanceof Error ? error.message : 'Unknown error'
+ };
+ }
+}
+
+// ========================================
+// 유틸리티 함수들
+// ========================================
+
+// RFQ 데이터 생성 헬퍼 함수
+function createRFQData(
+ headers: RFQHeaderData[],
+ items: RFQItemData[]
+): RFQInfoRequest {
+ return {
+ T_RFQ_HEADER: headers,
+ T_RFQ_ITEM: items
+ };
+}
+
+// RFQ 헤더 데이터 생성 헬퍼 함수
+function createRFQHeader(
+ rfqNumber: string, // ANFNR - CHAR(10)
+ vendorNumber: string, // LIFNR - CHAR(10)
+ currency: string = 'KRW', // WAERS - CUKY(5)
+ paymentTerms: string = '0001', // ZTERM - CHAR(4)
+ incoterms1: string = 'FOB', // INCO1 - CHAR(3)
+ incoterms2: string = 'Seoul, Korea', // INCO2 - CHAR(28)
+ taxCode: string = 'V0', // MWSKZ - CHAR(2)
+ countryForTax: string = 'KR', // LANDS - CHAR(3) (Country for Tax Return)
+ options?: {
+ shippingPlace?: string; // VSTEL - CHAR(3) (Place of Shipping)
+ destinationPlace?: string; // LSTEL - CHAR(3) (Place of Destination)
+ }
+): RFQHeaderData {
+ return {
+ ANFNR: rfqNumber,
+ LIFNR: vendorNumber,
+ WAERS: currency,
+ ZTERM: paymentTerms,
+ INCO1: incoterms1,
+ INCO2: incoterms2,
+ MWSKZ: taxCode,
+ LANDS: countryForTax,
+ VSTEL: options?.shippingPlace,
+ LSTEL: options?.destinationPlace
+ };
+}
+
+// RFQ 아이템 데이터 생성 헬퍼 함수
+function createRFQItem(
+ rfqNumber: string, // ANFNR - CHAR(10)
+ itemNumber: string, // ANFPS - NUMC(5,0)
+ netPrice: string, // NETPR - CURR(11,2) Net Price in Purchasing Document (in Document Currency)
+ netOrderValue: string, // NETWR - CURR(13,2) Net Order Value in PO Currency
+ grossOrderValue: string, // BRTWR - CURR(13,2) Gross order value in PO currency
+ deliveryDate?: string // LFDAT - DATS(8) Item delivery date (선택)
+): RFQItemData {
+ return {
+ ANFNR: rfqNumber,
+ ANFPS: itemNumber,
+ NETPR: netPrice,
+ NETWR: netOrderValue,
+ BRTWR: grossOrderValue,
+ LFDAT: deliveryDate
+ };
+}
+
+// RFQ 번호 기준으로 헤더와 아이템 매칭 검증
+function validateRFQMatching(headers: RFQHeaderData[], items: RFQItemData[]): {
+ isValid: boolean;
+ errors: string[];
+ orphanItems: string[];
+} {
+ const errors: string[] = [];
+ const orphanItems: string[] = [];
+
+ const headerRFQNumbers = new Set(headers.map(h => h.ANFNR));
+
+ for (const item of items) {
+ if (!headerRFQNumbers.has(item.ANFNR)) {
+ orphanItems.push(item.ANFNR);
+ errors.push(`RFQ 아이템 '${item.ANFNR}-${item.ANFPS}'에 해당하는 헤더가 없습니다.`);
+ }
+ }
+
+ return {
+ isValid: errors.length === 0,
+ errors,
+ orphanItems
+ };
+}
+
+// RFQ 데이터 요약 정보 생성
+function getRFQDataSummary(rfqData: RFQInfoRequest): {
+ rfqNumbers: string[];
+ totalHeaders: number;
+ totalItems: number;
+ itemsPerRFQ: Record<string, number>;
+} {
+ const rfqNumbers = [...new Set(rfqData.T_RFQ_HEADER.map(h => h.ANFNR))];
+ const itemsPerRFQ: Record<string, number> = {};
+
+ for (const rfqNumber of rfqNumbers) {
+ itemsPerRFQ[rfqNumber] = rfqData.T_RFQ_ITEM.filter(i => i.ANFNR === rfqNumber).length;
+ }
+
+ return {
+ rfqNumbers,
+ totalHeaders: rfqData.T_RFQ_HEADER.length,
+ totalItems: rfqData.T_RFQ_ITEM.length,
+ itemsPerRFQ
+ };
+}
generated by cgit v1.2.3 (git 2.39.1) at 2025-12-07 16:34:10 +0000