배치관리시스템 (DB, RestAPI)

backend-node/src/controllers/batchManagementController.ts

@@ -6,6 +6,7 @@ import { AuthenticatedRequest } from "../types/auth";
 import { BatchManagementService, BatchConnectionInfo, BatchTableInfo, BatchColumnInfo } from "../services/batchManagementService";
 import { BatchService } from "../services/batchService";
 import { BatchSchedulerService } from "../services/batchSchedulerService";
+import { BatchExternalDbService } from "../services/batchExternalDbService";
 import { CreateBatchConfigRequest, BatchConfig } from "../types/batchTypes";
 
 export class BatchManagementController {
@@ -132,6 +133,40 @@ export class BatchManagementController {
     }
   }
 
+  /**
+   * 특정 배치 설정 조회
+   * GET /api/batch-management/batch-configs/:id
+   */
+  static async getBatchConfigById(req: AuthenticatedRequest, res: Response) {
+    try {
+      const { id } = req.params;
+      console.log("🔍 배치 설정 조회 요청:", id);
+      
+      const result = await BatchService.getBatchConfigById(Number(id));
+      
+      if (!result.success) {
+        return res.status(404).json({
+          success: false,
+          message: result.message || "배치 설정을 찾을 수 없습니다."
+        });
+      }
+      
+      console.log("📋 조회된 배치 설정:", result.data);
+      
+      return res.json({
+        success: true,
+        data: result.data
+      });
+    } catch (error) {
+      console.error("❌ 배치 설정 조회 오류:", error);
+      return res.status(500).json({
+        success: false,
+        message: "배치 설정 조회에 실패했습니다.",
+        error: error instanceof Error ? error.message : "알 수 없는 오류"
+      });
+    }
+  }
+
   /**
    * 배치 설정 목록 조회
    * GET /api/batch-management/batch-configs
@@ -228,32 +263,131 @@ export class BatchManagementController {
               const firstMapping = mappings[0];
               console.log(`테이블 처리 시작: ${tableKey} -> ${mappings.length}개 컬럼 매핑`);
               
-              // FROM 테이블에서 매핑된 컬럼들만 조회
-              const fromColumns = mappings.map(m => m.from_column_name);
-              const fromData = await BatchService.getDataFromTableWithColumns(
-                firstMapping.from_table_name,
-                fromColumns,
-                firstMapping.from_connection_type as 'internal' | 'external',
-                firstMapping.from_connection_id || undefined
-              );
+              let fromData: any[] = [];
+              
+              // FROM 데이터 조회 (DB 또는 REST API)
+              if (firstMapping.from_connection_type === 'restapi') {
+                // REST API에서 데이터 조회
+                console.log(`REST API에서 데이터 조회: ${firstMapping.from_api_url}${firstMapping.from_table_name}`);
+                console.log(`API 설정:`, {
+                  url: firstMapping.from_api_url,
+                  key: firstMapping.from_api_key ? '***' : 'null',
+                  method: firstMapping.from_api_method,
+                  endpoint: firstMapping.from_table_name
+                });
+                
+                try {
+                  const apiResult = await BatchExternalDbService.getDataFromRestApi(
+                    firstMapping.from_api_url!,
+                    firstMapping.from_api_key!,
+                    firstMapping.from_table_name,
+                    firstMapping.from_api_method as 'GET' | 'POST' | 'PUT' | 'DELETE' || 'GET',
+                    mappings.map(m => m.from_column_name)
+                  );
+                  
+                  console.log(`API 조회 결과:`, {
+                    success: apiResult.success,
+                    dataCount: apiResult.data ? apiResult.data.length : 0,
+                    message: apiResult.message
+                  });
+                  
+                  if (apiResult.success && apiResult.data) {
+                    fromData = apiResult.data;
+                  } else {
+                    throw new Error(`REST API 데이터 조회 실패: ${apiResult.message}`);
+                  }
+                } catch (error) {
+                  console.error(`REST API 조회 오류:`, error);
+                  throw error;
+                }
+              } else {
+                // DB에서 데이터 조회
+                const fromColumns = mappings.map(m => m.from_column_name);
+                fromData = await BatchService.getDataFromTableWithColumns(
+                  firstMapping.from_table_name,
+                  fromColumns,
+                  firstMapping.from_connection_type as 'internal' | 'external',
+                  firstMapping.from_connection_id || undefined
+                );
+              }
+              
               totalRecords += fromData.length;
 
               // 컬럼 매핑 적용하여 TO 테이블 형식으로 변환
               const mappedData = fromData.map(row => {
                 const mappedRow: any = {};
                 for (const mapping of mappings) {
-                  mappedRow[mapping.to_column_name] = row[mapping.from_column_name];
+                  // DB → REST API 배치인지 확인
+                  if (firstMapping.to_connection_type === 'restapi' && mapping.to_api_body) {
+                    // DB → REST API: 원본 컬럼명을 키로 사용 (템플릿 처리용)
+                    mappedRow[mapping.from_column_name] = row[mapping.from_column_name];
+                  } else {
+                    // 기존 로직: to_column_name을 키로 사용
+                    mappedRow[mapping.to_column_name] = row[mapping.from_column_name];
+                  }
                 }
                 return mappedRow;
               });
 
-              // TO 테이블에 데이터 삽입
-              const insertResult = await BatchService.insertDataToTable(
-                firstMapping.to_table_name,
-                mappedData,
-                firstMapping.to_connection_type as 'internal' | 'external',
-                firstMapping.to_connection_id || undefined
-              );
+              // TO 테이블에 데이터 삽입 (DB 또는 REST API)
+              let insertResult: { successCount: number; failedCount: number };
+              
+              if (firstMapping.to_connection_type === 'restapi') {
+                // REST API로 데이터 전송
+                console.log(`REST API로 데이터 전송: ${firstMapping.to_api_url}${firstMapping.to_table_name}`);
+                
+                // DB → REST API 배치인지 확인 (to_api_body가 있으면 템플릿 기반)
+                const hasTemplate = mappings.some(m => m.to_api_body);
+                
+                if (hasTemplate) {
+                  // 템플릿 기반 REST API 전송 (DB → REST API 배치)
+                  const templateBody = firstMapping.to_api_body || '{}';
+                  console.log(`템플릿 기반 REST API 전송, Request Body 템플릿: ${templateBody}`);
+                  
+                  // URL 경로 컬럼 찾기 (PUT/DELETE용)
+                  const urlPathColumn = mappings.find(m => m.to_column_name === 'URL_PATH_PARAM')?.from_column_name;
+                  
+                  const apiResult = await BatchExternalDbService.sendDataToRestApiWithTemplate(
+                    firstMapping.to_api_url!,
+                    firstMapping.to_api_key!,
+                    firstMapping.to_table_name,
+                    firstMapping.to_api_method as 'POST' | 'PUT' | 'DELETE' || 'POST',
+                    templateBody,
+                    mappedData,
+                    urlPathColumn
+                  );
+                  
+                  if (apiResult.success && apiResult.data) {
+                    insertResult = apiResult.data;
+                  } else {
+                    throw new Error(`템플릿 기반 REST API 데이터 전송 실패: ${apiResult.message}`);
+                  }
+                } else {
+                  // 기존 REST API 전송 (REST API → DB 배치)
+                  const apiResult = await BatchExternalDbService.sendDataToRestApi(
+                    firstMapping.to_api_url!,
+                    firstMapping.to_api_key!,
+                    firstMapping.to_table_name,
+                    firstMapping.to_api_method as 'POST' | 'PUT' || 'POST',
+                    mappedData
+                  );
+                  
+                  if (apiResult.success && apiResult.data) {
+                    insertResult = apiResult.data;
+                  } else {
+                    throw new Error(`REST API 데이터 전송 실패: ${apiResult.message}`);
+                  }
+                }
+              } else {
+                // DB에 데이터 삽입
+                insertResult = await BatchService.insertDataToTable(
+                  firstMapping.to_table_name,
+                  mappedData,
+                  firstMapping.to_connection_type as 'internal' | 'external',
+                  firstMapping.to_connection_id || undefined
+                );
+              }
+              
               successRecords += insertResult.successCount;
               failedRecords += insertResult.failedCount;
 
@@ -342,4 +476,144 @@ export class BatchManagementController {
       });
     }
   }
+
+  /**
+   * REST API 데이터 미리보기
+   */
+  static async previewRestApiData(req: AuthenticatedRequest, res: Response) {
+    try {
+      const { apiUrl, apiKey, endpoint, method = 'GET' } = req.body;
+
+      if (!apiUrl || !apiKey || !endpoint) {
+        return res.status(400).json({
+          success: false,
+          message: "API URL, API Key, 엔드포인트는 필수입니다."
+        });
+      }
+
+      // RestApiConnector 사용하여 데이터 조회
+      const { RestApiConnector } = await import('../database/RestApiConnector');
+      
+      const connector = new RestApiConnector({
+        baseUrl: apiUrl,
+        apiKey: apiKey,
+        timeout: 30000
+      });
+
+      // 연결 테스트
+      await connector.connect();
+
+      // 데이터 조회 (최대 5개만) - GET 메서드만 지원
+      const result = await connector.executeQuery(endpoint, method);
+      console.log(`[previewRestApiData] executeQuery 결과:`, {
+        rowCount: result.rowCount,
+        rowsLength: result.rows ? result.rows.length : 'undefined',
+        firstRow: result.rows && result.rows.length > 0 ? result.rows[0] : 'no data'
+      });
+      
+      const data = result.rows.slice(0, 5); // 최대 5개 샘플만
+      console.log(`[previewRestApiData] 슬라이스된 데이터:`, data);
+
+      if (data.length > 0) {
+        // 첫 번째 객체에서 필드명 추출
+        const fields = Object.keys(data[0]);
+        console.log(`[previewRestApiData] 추출된 필드:`, fields);
+        
+        return res.json({
+          success: true,
+          data: {
+            fields: fields,
+            samples: data,
+            totalCount: result.rowCount || data.length
+          },
+          message: `${fields.length}개 필드, ${result.rowCount || data.length}개 레코드를 조회했습니다.`
+        });
+      } else {
+        return res.json({
+          success: true,
+          data: {
+            fields: [],
+            samples: [],
+            totalCount: 0
+          },
+          message: "API에서 데이터를 가져올 수 없습니다."
+        });
+      }
+    } catch (error) {
+      console.error("REST API 미리보기 오류:", error);
+      return res.status(500).json({
+        success: false,
+        message: "REST API 데이터 미리보기 중 오류가 발생했습니다.",
+        error: error instanceof Error ? error.message : "알 수 없는 오류"
+      });
+    }
+  }
+
+  /**
+   * REST API 배치 설정 저장
+   */
+  static async saveRestApiBatch(req: AuthenticatedRequest, res: Response) {
+    try {
+      const { 
+        batchName, 
+        batchType, 
+        cronSchedule, 
+        description, 
+        apiMappings 
+      } = req.body;
+
+      if (!batchName || !batchType || !cronSchedule || !apiMappings || apiMappings.length === 0) {
+        return res.status(400).json({
+          success: false,
+          message: "필수 필드가 누락되었습니다."
+        });
+      }
+
+      console.log("REST API 배치 저장 요청:", {
+        batchName,
+        batchType,
+        cronSchedule,
+        description,
+        apiMappings
+      });
+
+      // BatchService를 사용하여 배치 설정 저장
+      const batchConfig: CreateBatchConfigRequest = {
+        batchName: batchName,
+        description: description || '',
+        cronSchedule: cronSchedule,
+        mappings: apiMappings
+      };
+
+      const result = await BatchService.createBatchConfig(batchConfig);
+
+      if (result.success && result.data) {
+        // 스케줄러에 자동 등록 ✅
+        try {
+          await BatchSchedulerService.scheduleBatchConfig(result.data);
+          console.log(`✅ 새로운 배치가 스케줄러에 등록되었습니다: ${batchName} (ID: ${result.data.id})`);
+        } catch (schedulerError) {
+          console.error(`❌ 스케줄러 등록 실패: ${batchName}`, schedulerError);
+          // 스케줄러 등록 실패해도 배치 저장은 성공으로 처리
+        }
+
+        return res.json({
+          success: true,
+          message: "REST API 배치가 성공적으로 저장되었습니다.",
+          data: result.data
+        });
+      } else {
+        return res.status(500).json({
+          success: false,
+          message: result.message || "배치 저장에 실패했습니다."
+        });
+      }
+    } catch (error) {
+      console.error("REST API 배치 저장 오류:", error);
+      return res.status(500).json({
+        success: false,
+        message: "배치 저장 중 오류가 발생했습니다."
+      });
+    }
+  }
 }