ERP-node/backend-node/src/routes/externalCallConfigRoutes.ts

import express, { Request, Response } from "express";
import externalCallConfigService, {
  ExternalCallConfigFilter,
} from "../services/externalCallConfigService";
import { logger } from "../utils/logger";
import { authenticateToken } from "../middleware/authMiddleware";

const router = express.Router();

// 모든 라우트에 인증 미들웨어 적용
router.use(authenticateToken);

/**
 * 외부 호출 설정 목록 조회
 * GET /api/external-call-configs
 */
router.get("/", async (req: Request, res: Response) => {
  try {
    const filter: ExternalCallConfigFilter = {
      company_code: req.query.company_code as string,
      call_type: req.query.call_type as string,
      api_type: req.query.api_type as string,
      is_active: (req.query.is_active as string) || "Y",
      search: req.query.search as string,
    };

    const configs = await externalCallConfigService.getConfigs(filter);

    return res.json({
      success: true,
      data: configs,
      message: `외부 호출 설정 ${configs.length}개 조회 완료`,
    });
  } catch (error) {
    logger.error("외부 호출 설정 목록 조회 API 오류:", error);
    return res.status(500).json({
      success: false,
      message:
        error instanceof Error
          ? error.message
          : "외부 호출 설정 목록 조회 실패",
      errorCode: "EXTERNAL_CALL_CONFIG_LIST_ERROR",
    });
  }
});

/**
 * 외부 호출 설정 단일 조회
 * GET /api/external-call-configs/:id
 */
router.get("/:id", async (req: Request, res: Response) => {
  try {
    const id = parseInt(req.params.id);
    if (isNaN(id)) {
      return res.status(400).json({
        success: false,
        message: "유효하지 않은 설정 ID입니다.",
        errorCode: "INVALID_CONFIG_ID",
      });
    }

    const config = await externalCallConfigService.getConfigById(id);
    if (!config) {
      return res.status(404).json({
        success: false,
        message: "외부 호출 설정을 찾을 수 없습니다.",
        errorCode: "CONFIG_NOT_FOUND",
      });
    }

    return res.json({
      success: true,
      data: config,
      message: "외부 호출 설정 조회 완료",
    });
  } catch (error) {
    logger.error("외부 호출 설정 조회 API 오류:", error);
    return res.status(500).json({
      success: false,
      message:
        error instanceof Error ? error.message : "외부 호출 설정 조회 실패",
      errorCode: "EXTERNAL_CALL_CONFIG_GET_ERROR",
    });
  }
});

/**
 * 외부 호출 설정 생성
 * POST /api/external-call-configs
 */
router.post("/", async (req: Request, res: Response) => {
  try {
    const {
      config_name,
      call_type,
      api_type,
      config_data,
      description,
      company_code,
    } = req.body;

    // 필수 필드 검증
    if (!config_name || !call_type || !config_data) {
      return res.status(400).json({
        success: false,
        message:
          "필수 필드가 누락되었습니다. (config_name, call_type, config_data)",
        errorCode: "MISSING_REQUIRED_FIELDS",
      });
    }

    // 사용자 정보 가져오기
    const userInfo = (req as any).user;
    const userId = userInfo?.userId || "SYSTEM";

    const newConfig = await externalCallConfigService.createConfig({
      config_name,
      call_type,
      api_type,
      config_data,
      description,
      company_code: company_code || "*",
      created_by: userId,
      updated_by: userId,
    });

    return res.status(201).json({
      success: true,
      data: newConfig,
      message: "외부 호출 설정이 성공적으로 생성되었습니다.",
    });
  } catch (error) {
    logger.error("외부 호출 설정 생성 API 오류:", error);
    return res.status(500).json({
      success: false,
      message:
        error instanceof Error ? error.message : "외부 호출 설정 생성 실패",
      errorCode: "EXTERNAL_CALL_CONFIG_CREATE_ERROR",
    });
  }
});

/**
 * 외부 호출 설정 수정
 * PUT /api/external-call-configs/:id
 */
router.put("/:id", async (req: Request, res: Response) => {
  try {
    const id = parseInt(req.params.id);
    if (isNaN(id)) {
      return res.status(400).json({
        success: false,
        message: "유효하지 않은 설정 ID입니다.",
        errorCode: "INVALID_CONFIG_ID",
      });
    }

    // 사용자 정보 가져오기
    const userInfo = (req as any).user;
    const userId = userInfo?.userId || "SYSTEM";

    const updatedConfig = await externalCallConfigService.updateConfig(id, {
      ...req.body,
      updated_by: userId,
    });

    return res.json({
      success: true,
      data: updatedConfig,
      message: "외부 호출 설정이 성공적으로 수정되었습니다.",
    });
  } catch (error) {
    logger.error("외부 호출 설정 수정 API 오류:", error);
    return res.status(500).json({
      success: false,
      message:
        error instanceof Error ? error.message : "외부 호출 설정 수정 실패",
      errorCode: "EXTERNAL_CALL_CONFIG_UPDATE_ERROR",
    });
  }
});

/**
 * 외부 호출 설정 삭제 (논리 삭제)
 * DELETE /api/external-call-configs/:id
 */
router.delete("/:id", async (req: Request, res: Response) => {
  try {
    const id = parseInt(req.params.id);
    if (isNaN(id)) {
      return res.status(400).json({
        success: false,
        message: "유효하지 않은 설정 ID입니다.",
        errorCode: "INVALID_CONFIG_ID",
      });
    }

    // 사용자 정보 가져오기
    const userInfo = (req as any).user;
    const userId = userInfo?.userId || "SYSTEM";

    await externalCallConfigService.deleteConfig(id, userId);

    return res.json({
      success: true,
      message: "외부 호출 설정이 성공적으로 삭제되었습니다.",
    });
  } catch (error) {
    logger.error("외부 호출 설정 삭제 API 오류:", error);
    return res.status(500).json({
      success: false,
      message:
        error instanceof Error ? error.message : "외부 호출 설정 삭제 실패",
      errorCode: "EXTERNAL_CALL_CONFIG_DELETE_ERROR",
    });
  }
});

/**
 * 외부 호출 설정 테스트
 * POST /api/external-call-configs/:id/test
 */
router.post("/:id/test", async (req: Request, res: Response) => {
  try {
    const id = parseInt(req.params.id);
    if (isNaN(id)) {
      return res.status(400).json({
        success: false,
        message: "유효하지 않은 설정 ID입니다.",
        errorCode: "INVALID_CONFIG_ID",
      });
    }

    const testResult = await externalCallConfigService.testConfig(id);

    return res.json({
      success: testResult.success,
      message: testResult.message,
      data: testResult,
    });
  } catch (error) {
    logger.error("외부 호출 설정 테스트 API 오류:", error);
    return res.status(500).json({
      success: false,
      message:
        error instanceof Error ? error.message : "외부 호출 설정 테스트 실패",
      errorCode: "EXTERNAL_CALL_CONFIG_TEST_ERROR",
    });
  }
});

export default router;