(김준회) knox 임직원, 조직도, 직급 동기화 로직 수정 (delete & insert) 및 시간당 호출제한 반영, SSO 운영 변경 대응 (버튼 텍스트에 Stage 인 경우에만 Stage 표시), 부서 트리뷰에서 '하위' 뱃지 제거

1 files changed, 112 insertions, 115 deletions

diff --git a/lib/knox-sync/employee-sync-service.ts b/lib/knox-sync/employee-sync-service.ts
index 282c493b..3e8b048e 100644
--- a/lib/knox-sync/employee-sync-service.ts
+++ b/lib/knox-sync/employee-sync-service.ts
@@ -3,6 +3,7 @@
 import * as cron from 'node-cron';
 import db from '@/db/db';
 import { employee as employeeTable } from '@/db/schema/knox/employee';
+import { title as titleTable } from '@/db/schema/knox/titles';
 import { users, type UserDomainType } from '@/db/schema/users';
 import { departmentDomainAssignments } from '@/db/schema/departmentDomainAssignments';
 import {
@@ -10,32 +11,22 @@ import {
   Employee,
 } from '@/lib/knox-api/employee/employee';
 import { sql, eq, and, ne } from 'drizzle-orm';
-
-// 동기화 대상 회사 코드 (쉼표로 구분된 ENV)
-const COMPANIES = (process.env.KNOX_COMPANY_CODES || 'D60')
-  .split(',')
-  .map((c) => c.trim())
-  .filter(Boolean);
+import {
+  KNOX_COMPANIES,
+  delay,
+  API_CALL_DELAY_MS,
+  checkTimeRestriction,
+  checkApiLimitStatus,
+  initializeApiTracker,
+  logSyncStart,
+  logSyncComplete,
+  logSchedulerInfo,
+} from './common';
 
 const CRON_STRING = process.env.KNOX_EMPLOYEE_SYNC_CRON || '0 4 * * *';
-
 const DO_FIRST_RUN = process.env.KNOX_EMPLOYEE_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 upsertEmployees(employees: Employee[]) {
+async function insertEmployees(employees: Employee[]) {
   if (!employees.length) return;
 
   const rows = employees.map((e) => ({
@@ -76,89 +67,119 @@ async function upsertEmployees(employees: Employee[]) {
     titleSortOrder: e.titleSortOrder,
   }));
 
-  await db
-    .insert(employeeTable)
-    .values(rows)
-    .onConflictDoUpdate({
-      target: employeeTable.epId,
-      set: {
-        fullName: sql.raw('excluded.full_name'),
-        givenName: sql.raw('excluded.given_name'),
-        sirName: sql.raw('excluded.sir_name'),
-        companyCode: sql.raw('excluded.company_code'),
-        companyName: sql.raw('excluded.company_name'),
-        departmentCode: sql.raw('excluded.department_code'),
-        departmentName: sql.raw('excluded.department_name'),
-        titleCode: sql.raw('excluded.title_code'),
-        titleName: sql.raw('excluded.title_name'),
-        emailAddress: sql.raw('excluded.email_address'),
-        mobile: sql.raw('excluded.mobile'),
-        employeeStatus: sql.raw('excluded.employee_status'),
-        employeeType: sql.raw('excluded.employee_type'),
-        accountStatus: sql.raw('excluded.account_status'),
-        securityLevel: sql.raw('excluded.security_level'),
-        preferredLanguage: sql.raw('excluded.preferred_language'),
-        description: sql.raw('excluded.description'),
-        raw: sql.raw('excluded.raw'),
-        updatedAt: sql.raw('CURRENT_TIMESTAMP'),
-      },
-    });
+  await db.insert(employeeTable).values(rows);
 }
 
 /**
- * 회사별 임직원 동기화 - 최적화된 버전
- * 부서별 개별 호출 대신 회사 코드만으로 전체 조회하여 API 호출 수 최소화
+ * 회사별 기존 임직원 데이터 삭제
+ */
+async function deleteExistingEmployees(companyCode: string): Promise<number> {
+  const result = await db
+    .delete(employeeTable)
+    .where(eq(employeeTable.companyCode, companyCode));
+  
+  const deletedCount = result.rowCount || 0;
+  console.log(`[KNOX-SYNC] ${companyCode}: 기존 임직원 데이터 ${deletedCount}건 삭제 완료`);
+  return deletedCount;
+}
+
+/**
+ * 회사별 임직원 동기화 - 직급별 조회 방식 (Delete-Insert)
+ * 기존 데이터를 모두 삭제한 후 새로운 데이터를 삽입하여 삭제된 데이터 문제 해결
  */
 async function syncEmployeesByCompany(companyCode: string): Promise<number> {
-  let totalApiCalls = 0;
+  let currentApiCalls = 0;
   let totalEmployees = 0;
+  let currentDelay = API_CALL_DELAY_MS;
   
   try {
-    let page = 1;
-    let totalPage = 1;
+    console.log(`[KNOX-SYNC] ${companyCode}: 임직원 동기화 시작 (Delete-Insert 방식)`);
 
-    console.log(`[KNOX-SYNC] ${companyCode}: 임직원 동기화 시작`);
+    // 1단계: 기존 데이터 삭제
+    await deleteExistingEmployees(companyCode);
 
-    do {
-      // Rate limiting을 위한 지연
-      if (totalApiCalls > 0) {
-        await delay(API_CALL_DELAY_MS);
-      }
+    // 2단계: 내부 DB에서 해당 회사의 직급 목록 조회 (이미 동기화된 데이터 활용)
+    console.log(`[KNOX-SYNC] ${companyCode}: 내부 DB에서 직급 목록 조회 중...`);
+    
+    const titles = await db
+      .select({
+        titleCode: titleTable.titleCode,
+        titleName: titleTable.titleName,
+        sortOrder: titleTable.sortOrder,
+      })
+      .from(titleTable)
+      .where(eq(titleTable.companyCode, companyCode))
+      .orderBy(titleTable.sortOrder);
 
-      const resp = await searchEmployees({
-        companyCode,
-        page: String(page),
-        resultType: 'basic',
-      });
-      totalApiCalls++;
-
-      if (resp.result === 'success') {
-        await upsertEmployees(resp.employees);
-        totalPage = resp.totalPage;
-        totalEmployees += resp.employees.length;
+    console.log(`[KNOX-SYNC] ${companyCode}: 총 ${titles.length}개 직급 발견`);
+
+    if (titles.length === 0) {
+      console.warn(`[KNOX-SYNC] ${companyCode}: 직급 정보가 없습니다. 직급 동기화를 먼저 실행해주세요.`);
+      return 0;
+    }
+
+    // 3단계: 각 직급별로 임직원 조회
+    for (const title of titles) {
+      let empPage = 1;
+      let empTotalPage = 1;
+      let titleEmployeeCount = 0;
+
+      do {
+        // 동적 delay 적용
+        if (currentApiCalls > 0) {
+          await delay(currentDelay);
+        }
+
+        const empResp = await searchEmployees({
+          companyCode,
+          titleCode: title.titleCode,
+          page: String(empPage),
+          resultType: 'basic',
+        });
         
+        // API 제한 체크 및 delay 조절
+        const limitStatus = checkApiLimitStatus(1);
+        currentDelay = limitStatus.recommendedDelay;
+        currentApiCalls++;
+
+        if (empResp.result === 'success') {
+          await insertEmployees(empResp.employees);
+          empTotalPage = empResp.totalPage;
+          totalEmployees += empResp.employees.length;
+          titleEmployeeCount += empResp.employees.length;
+          
+          if (empResp.employees.length > 0) {
+            console.log(
+              `[KNOX-SYNC] ${companyCode}: ${title.titleName}(${title.titleCode}) ${empPage}/${empTotalPage} 페이지 완료 (${empResp.employees.length}명)`
+            );
+          }
+        } else {
+          console.warn(
+            `[KNOX-SYNC] ${companyCode}: ${title.titleName}(${title.titleCode}) 페이지 ${empPage} 조회 실패`
+          );
+          break;
+        }
+
+        empPage += 1;
+      } while (empPage <= empTotalPage);
+
+      // 직급별 완료 로그 (임직원이 있는 경우만)
+      if (titleEmployeeCount > 0) {
         console.log(
-          `[KNOX-SYNC] ${companyCode}: ${page}/${totalPage} 페이지 처리 완료 (${resp.employees.length}명, 누적: ${totalEmployees}명)`
-        );
-      } else {
-        console.warn(
-          `[KNOX-SYNC] ${companyCode}: 페이지 ${page} 조회 실패`
+          `[KNOX-SYNC] ${companyCode}: ${title.titleName}(${title.titleCode}) 완료 - ${titleEmployeeCount}명`
         );
-        break;
       }
+    }
 
-      page += 1;
-    } while (page <= totalPage);
-
-    console.log(`[KNOX-SYNC] ${companyCode}: 완료 - ${totalEmployees}명, API 호출 ${totalApiCalls}회`);
+    console.log(`[KNOX-SYNC] ${companyCode}: 완료 - ${totalEmployees}명, API 호출 ${currentApiCalls}회`);
   } catch (err) {
     console.error(
-      `[KNOX-SYNC] ${companyCode}: 동기화 오류 (API 호출 ${totalApiCalls}회)`,
+      `[KNOX-SYNC] ${companyCode}: 동기화 오류 (API 호출 ${currentApiCalls}회)`,
       err
     );
   }
 
-  return totalApiCalls;
+  return currentApiCalls;
 }
 
 /**
@@ -300,32 +321,20 @@ async function syncEmployeesToUsers(): Promise<void> {
 }
 
 export async function syncKnoxEmployees(): Promise<void> {
-  console.log('[KNOX-SYNC] Knox 임직원 동기화 시작');
-  console.log(`[KNOX-SYNC] 대상 회사: ${COMPANIES.join(', ')}`);
+  logSyncStart('임직원');
+  initializeApiTracker(); // API 추적기 초기화
   
   let totalApiCalls = 0;
   const startTime = Date.now();
 
   try {
-    // 각 회사별 순차 처리로 API 호출 제한 준수
-    for (const companyCode of COMPANIES) {
+    // 각 회사별 순차 처리
+    for (const companyCode of KNOX_COMPANIES) {
       const apiCalls = await syncEmployeesByCompany(companyCode);
       totalApiCalls += apiCalls;
-
-      // 일일 호출 제한(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;
-      }
     }
 
-    const duration = Math.round((Date.now() - startTime) / 1000);
-    console.log(`[KNOX-SYNC] 임직원 동기화 완료 - 총 ${totalApiCalls}회 API 호출, ${duration}초 소요`);
+    logSyncComplete('임직원', totalApiCalls, startTime);
 
     // Knox Employee 동기화 완료 후 Users 테이블 동기화 실행
     await syncEmployeesToUsers();
@@ -339,16 +348,8 @@ export async function syncKnoxEmployees(): Promise<void> {
 export async function startKnoxEmployeeSyncScheduler() {
   // 환경 변수에 따라 실행시 즉시 실행 여부 결정 (없으면 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과 사전 협의 권장 (테스트 모드)');
-      }
+    if (!checkTimeRestriction()) {
+      return;
     }
     
     syncKnoxEmployees().catch(console.error);
@@ -359,9 +360,5 @@ export async function startKnoxEmployeeSyncScheduler() {
     syncKnoxEmployees().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 ? '활성화' : '비활성화 (테스트 모드)'}`);
+  logSchedulerInfo('임직원', CRON_STRING);
 }