(김준회) Knox 임직원 기준으로 users 테이블 upsert 처리 (cron-job과 동기식 처리)

1 files changed, 121 insertions, 23 deletions

diff --git a/lib/knox-sync/organization-sync-service.ts b/lib/knox-sync/organization-sync-service.ts
index 0b77174b..8ce9c0ca 100644
--- a/lib/knox-sync/organization-sync-service.ts
+++ b/lib/knox-sync/organization-sync-service.ts
@@ -10,7 +10,7 @@ import {
 import { sql } from 'drizzle-orm';
 
 // 동기화 대상 회사 코드 (쉼표로 구분된 ENV)
-const COMPANIES = (process.env.KNOX_COMPANY_CODES || 'P2')
+const COMPANIES = (process.env.KNOX_COMPANY_CODES || 'D60')
   .split(',')
   .map((c) => c.trim())
   .filter(Boolean);
@@ -21,9 +21,26 @@ const CRON_STRING = process.env.KNOX_ORGANIZATION_SYNC_CRON || '15 4 * * *';
 // 애플리케이션 기동 시 최초 한 번 실행 여부
 const DO_FIRST_RUN = process.env.KNOX_ORGANIZATION_SYNC_FIRST_RUN === 'true';
 
+// API 호출 제한 설정 (환경변수로 제어 가능)
+const DAILY_API_LIMIT = parseInt(process.env.KNOX_API_DAILY_LIMIT || '100');
+const RATE_LIMIT_PER_MINUTE = parseInt(process.env.KNOX_API_RATE_LIMIT || '1000');
+const API_CALL_DELAY_MS = Math.max(
+  parseInt(process.env.KNOX_API_CALL_DELAY_MS || '100'),
+  Math.ceil(60000 / RATE_LIMIT_PER_MINUTE) // 분당 제한에서 자동 계산
+);
+
+// Knox API 시간대 제한 강제 적용 여부 (테스트용)
+const FORCE_TIME_LIMIT = process.env.KNOX_API_FORCE_LIMIT === 'true';
+
+// API 호출 제한을 위한 지연 함수 (분당 1000건 제한 준수)
+const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
+
 async function upsertOrganizations(orgs: Organization[]) {
   if (!orgs.length) return;
 
+  console.log(`[KNOX-SYNC] ${orgs.length}개 조직 정보 업서트 시작`);
+  const startTime = Date.now();
+
   const rows = orgs.map((o) => ({
     companyCode: o.companyCode,
     departmentCode: o.departmentCode,
@@ -86,47 +103,128 @@ async function upsertOrganizations(orgs: Organization[]) {
         updatedAt: sql.raw('CURRENT_TIMESTAMP'),
       },
     });
+
+  const endTime = Date.now();
+  console.log(`[KNOX-SYNC] ${orgs.length}개 조직 정보 업서트 완료 (소요시간: ${endTime - startTime}ms)`);
+}
+
+/**
+ * 회사별 조직 동기화 - 최적화된 버전
+ * Knox API 가이드에 따라 첫 번째 호출은 페이지 없이 최대 2,000건 조회
+ * 그보다 많은 경우에만 페이징 처리하여 API 호출 수 최소화
+ */
+async function syncOrganizationsByCompany(companyCode: string): Promise<number> {
+  let totalApiCalls = 0;
+  let totalOrganizations = 0;
+  
+  try {
+    console.log(`[KNOX-SYNC] ${companyCode}: 조직 동기화 시작`);
+
+    // 첫 번째 호출: 페이지 없이 최대 2,000건까지 조회 (Knox API 가이드 기준)
+    const firstResp = await searchOrganizations({ companyCode });
+    totalApiCalls++;
+
+    if (firstResp.result === 'success') {
+      await upsertOrganizations(firstResp.organizations);
+      totalOrganizations += firstResp.organizations.length;
+      
+      console.log(
+        `[KNOX-SYNC] ${companyCode}: 첫 번째 조회 완료 - 총 ${firstResp.totalCount}개 중 ${firstResp.organizations.length}개 처리 (${firstResp.totalPage} 페이지)`
+      );
+
+      // 2,000개를 초과하는 경우 나머지 페이지 처리
+      if (firstResp.totalPage > 1) {
+        console.log(`[KNOX-SYNC] ${companyCode}: ${firstResp.totalPage - 1}개 추가 페이지 처리 시작`);
+        
+        for (let page = 2; page <= firstResp.totalPage; page++) {
+          // Rate limiting을 위한 지연
+          await delay(API_CALL_DELAY_MS);
+
+          const resp = await searchOrganizations({ companyCode, page: String(page) });
+          totalApiCalls++;
+
+          if (resp.result === 'success') {
+            await upsertOrganizations(resp.organizations);
+            totalOrganizations += resp.organizations.length;
+            
+            console.log(
+              `[KNOX-SYNC] ${companyCode}: ${page}/${resp.totalPage} 페이지 처리 완료 (${resp.organizations.length}개, 누적: ${totalOrganizations}개)`
+            );
+          } else {
+            console.warn(`[KNOX-SYNC] ${companyCode}: 페이지 ${page} 조회 실패`);
+            break;
+          }
+        }
+      }
+
+      console.log(`[KNOX-SYNC] ${companyCode}: 완료 - ${totalOrganizations}개 조직, API 호출 ${totalApiCalls}회`);
+    } else {
+      console.warn(`[KNOX-SYNC] ${companyCode}: 첫 번째 조회 실패`);
+    }
+  } catch (err) {
+    console.error(
+      `[KNOX-SYNC] ${companyCode}: 동기화 오류 (API 호출 ${totalApiCalls}회)`,
+      err
+    );
+  }
+
+  return totalApiCalls;
 }
 
 export async function syncKnoxOrganizations(): Promise<void> {
-  console.log('[KNOX-SYNC] 조직 동기화 시작');
+  console.log('[KNOX-SYNC] Knox 조직 동기화 시작');
+  console.log(`[KNOX-SYNC] 대상 회사: ${COMPANIES.join(', ')}`);
+  
+  let totalApiCalls = 0;
+  const startTime = Date.now();
 
+  // 각 회사별 순차 처리로 API 호출 제한 준수
   for (const companyCode of COMPANIES) {
-    try {
-      let page = 1;
-      let totalPage = 1;
-      do {
-        const resp = await searchOrganizations({ companyCode, page: String(page) });
-
-        if (resp.result === 'success') {
-          await upsertOrganizations(resp.organizations);
-          totalPage = resp.totalPage;
-          console.log(
-            `[KNOX-SYNC] 조직 동기화 ${companyCode} ${page}/${totalPage} 페이지 처리`
-          );
-        } else {
-          console.warn(`[KNOX-SYNC] 조직 동기화 실패: ${companyCode} page ${page}`);
-          break;
-        }
+    const apiCalls = await syncOrganizationsByCompany(companyCode);
+    totalApiCalls += apiCalls;
 
-        page += 1;
-      } while (page <= totalPage);
-    } catch (err) {
-      console.error(`[KNOX-SYNC] 조직 동기화 오류 (company ${companyCode})`, err);
+    // 일일 호출 제한(100건) 근접 시 경고
+    if (totalApiCalls >= DAILY_API_LIMIT - 10) {
+      console.warn(`[KNOX-SYNC] ⚠️ API 호출 ${totalApiCalls}회 - 일일 제한(${DAILY_API_LIMIT}건) 근접!`);
+    }
+    
+    // 일일 제한 초과 방지
+    if (totalApiCalls >= DAILY_API_LIMIT) {
+      console.error(`[KNOX-SYNC] 🚨 일일 API 호출 제한(${DAILY_API_LIMIT}건) 초과로 중단`);
+      break;
     }
   }
 
-  console.log('[KNOX-SYNC] 조직 동기화 완료');
+  const duration = Math.round((Date.now() - startTime) / 1000);
+  console.log(`[KNOX-SYNC] 조직 동기화 완료 - 총 ${totalApiCalls}회 API 호출, ${duration}초 소요`);
 }
 
 export async function startKnoxOrganizationSyncScheduler() {
+  // 환경 변수에 따라 실행시 즉시 실행 여부 결정 (없으면 false)
   if (DO_FIRST_RUN) {
+    // 현재 시간이 주간이면 경고 메시지 또는 실행 중단 (Knox API 가이드 권장사항)
+    const currentHour = new Date().getHours();
+    if (currentHour >= 6 && currentHour < 22) {
+      if (FORCE_TIME_LIMIT) {
+        console.error('[KNOX-SYNC] 🚨 주간 시간대(06:00-22:00) 대량 호출 금지 - 야간에 실행하세요');
+        console.log('[KNOX-SYNC] 💡 테스트용 실행을 원하면 KNOX_API_FORCE_LIMIT 환경변수를 제거하세요');
+        return;
+      } else {
+        console.warn('[KNOX-SYNC] ⚠️ 주간 시간대 대량 호출 - Knox Portal과 사전 협의 권장 (테스트 모드)');
+      }
+    }
+    
     syncKnoxOrganizations().catch(console.error);
   }
 
+  // CRON JOB 등록
   cron.schedule(CRON_STRING, () => {
     syncKnoxOrganizations().catch(console.error);
   });
 
   console.log(`[KNOX-SYNC] 조직 동기화 스케줄러 등록 (${CRON_STRING})`);
+  console.log(`[KNOX-SYNC] API 제한사항: 분당 ${RATE_LIMIT_PER_MINUTE}건, 일일 ${DAILY_API_LIMIT}건`);
+  console.log(`[KNOX-SYNC] 호출 간격: ${API_CALL_DELAY_MS}ms`);
+  console.log(`[KNOX-SYNC] Knox API 권장: 대량 호출 시 야간(22시 이후) 실행`);
+  console.log(`[KNOX-SYNC] 시간대 제한 강제 적용: ${FORCE_TIME_LIMIT ? '활성화' : '비활성화 (테스트 모드)'}`);
 } 
\ No newline at end of file