876 lines
24 KiB
TypeScript
876 lines
24 KiB
TypeScript
import { Response } from "express";
|
||
import https from "https";
|
||
import axios, { AxiosRequestConfig } from "axios";
|
||
import { logger } from "../utils/logger";
|
||
import { AuthenticatedRequest } from "../middleware/authMiddleware";
|
||
import { DashboardService } from "../services/DashboardService";
|
||
import {
|
||
CreateDashboardRequest,
|
||
UpdateDashboardRequest,
|
||
DashboardListQuery,
|
||
} from "../types/dashboard";
|
||
import { PostgreSQLService } from "../database/PostgreSQLService";
|
||
import { ExternalRestApiConnectionService } from "../services/externalRestApiConnectionService";
|
||
|
||
/**
|
||
* 대시보드 컨트롤러
|
||
* - REST API 엔드포인트 처리
|
||
* - 요청 검증 및 응답 포맷팅
|
||
*/
|
||
export class DashboardController {
|
||
/**
|
||
* 대시보드 생성
|
||
* POST /api/dashboards
|
||
*/
|
||
async createDashboard(
|
||
req: AuthenticatedRequest,
|
||
res: Response
|
||
): Promise<void> {
|
||
try {
|
||
const userId = req.user?.userId;
|
||
const companyCode = req.user?.companyCode;
|
||
|
||
if (!userId) {
|
||
res.status(401).json({
|
||
success: false,
|
||
message: "인증이 필요합니다.",
|
||
});
|
||
return;
|
||
}
|
||
|
||
const {
|
||
title,
|
||
description,
|
||
elements,
|
||
isPublic = false,
|
||
tags,
|
||
category,
|
||
settings,
|
||
}: CreateDashboardRequest = req.body;
|
||
|
||
// 유효성 검증
|
||
if (!title || title.trim().length === 0) {
|
||
res.status(400).json({
|
||
success: false,
|
||
message: "대시보드 제목이 필요합니다.",
|
||
});
|
||
return;
|
||
}
|
||
|
||
if (!elements || !Array.isArray(elements)) {
|
||
res.status(400).json({
|
||
success: false,
|
||
message: "대시보드 요소 데이터가 필요합니다.",
|
||
});
|
||
return;
|
||
}
|
||
|
||
// 제목 길이 체크
|
||
if (title.length > 200) {
|
||
res.status(400).json({
|
||
success: false,
|
||
message: "제목은 200자를 초과할 수 없습니다.",
|
||
});
|
||
return;
|
||
}
|
||
|
||
// 설명 길이 체크
|
||
if (description && description.length > 1000) {
|
||
res.status(400).json({
|
||
success: false,
|
||
message: "설명은 1000자를 초과할 수 없습니다.",
|
||
});
|
||
return;
|
||
}
|
||
|
||
const dashboardData: CreateDashboardRequest = {
|
||
title: title.trim(),
|
||
description: description?.trim(),
|
||
isPublic,
|
||
elements,
|
||
tags,
|
||
category,
|
||
settings,
|
||
};
|
||
|
||
// console.log('대시보드 생성 시작:', { title: dashboardData.title, userId, elementsCount: elements.length });
|
||
|
||
const savedDashboard = await DashboardService.createDashboard(
|
||
dashboardData,
|
||
userId,
|
||
companyCode
|
||
);
|
||
|
||
// console.log('대시보드 생성 성공:', { id: savedDashboard.id, title: savedDashboard.title });
|
||
|
||
res.status(201).json({
|
||
success: true,
|
||
data: savedDashboard,
|
||
message: "대시보드가 성공적으로 생성되었습니다.",
|
||
});
|
||
} catch (error: any) {
|
||
// console.error('Dashboard creation error:', {
|
||
// message: error?.message,
|
||
// stack: error?.stack,
|
||
// error
|
||
// });
|
||
res.status(500).json({
|
||
success: false,
|
||
message: error?.message || "대시보드 생성 중 오류가 발생했습니다.",
|
||
error:
|
||
process.env.NODE_ENV === "development" ? error?.message : undefined,
|
||
});
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 대시보드 목록 조회
|
||
* GET /api/dashboards
|
||
*/
|
||
async getDashboards(req: AuthenticatedRequest, res: Response): Promise<void> {
|
||
try {
|
||
const userId = req.user?.userId;
|
||
const companyCode = req.user?.companyCode;
|
||
|
||
const query: DashboardListQuery = {
|
||
page: parseInt(req.query.page as string) || 1,
|
||
limit: Math.min(parseInt(req.query.limit as string) || 20, 100), // 최대 100개
|
||
search: req.query.search as string,
|
||
category: req.query.category as string,
|
||
isPublic:
|
||
req.query.isPublic === "true"
|
||
? true
|
||
: req.query.isPublic === "false"
|
||
? false
|
||
: undefined,
|
||
createdBy: req.query.createdBy as string,
|
||
};
|
||
|
||
// 페이지 번호 유효성 검증
|
||
if (query.page! < 1) {
|
||
res.status(400).json({
|
||
success: false,
|
||
message: "페이지 번호는 1 이상이어야 합니다.",
|
||
});
|
||
return;
|
||
}
|
||
|
||
const result = await DashboardService.getDashboards(
|
||
query,
|
||
userId,
|
||
companyCode
|
||
);
|
||
|
||
res.json({
|
||
success: true,
|
||
data: result.dashboards,
|
||
pagination: result.pagination,
|
||
});
|
||
} catch (error) {
|
||
// console.error('Dashboard list error:', error);
|
||
res.status(500).json({
|
||
success: false,
|
||
message: "대시보드 목록 조회 중 오류가 발생했습니다.",
|
||
error:
|
||
process.env.NODE_ENV === "development"
|
||
? (error as Error).message
|
||
: undefined,
|
||
});
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 대시보드 상세 조회
|
||
* GET /api/dashboards/:id
|
||
*/
|
||
async getDashboard(req: AuthenticatedRequest, res: Response): Promise<void> {
|
||
try {
|
||
const { id } = req.params;
|
||
const userId = req.user?.userId;
|
||
const companyCode = req.user?.companyCode;
|
||
|
||
if (!id) {
|
||
res.status(400).json({
|
||
success: false,
|
||
message: "대시보드 ID가 필요합니다.",
|
||
});
|
||
return;
|
||
}
|
||
|
||
const dashboard = await DashboardService.getDashboardById(
|
||
id,
|
||
userId,
|
||
companyCode
|
||
);
|
||
|
||
if (!dashboard) {
|
||
res.status(404).json({
|
||
success: false,
|
||
message: "대시보드를 찾을 수 없거나 접근 권한이 없습니다.",
|
||
});
|
||
return;
|
||
}
|
||
|
||
// 조회수 증가 (본인이 만든 대시보드가 아닌 경우에만)
|
||
if (userId && dashboard.createdBy !== userId) {
|
||
await DashboardService.incrementViewCount(id);
|
||
}
|
||
|
||
res.json({
|
||
success: true,
|
||
data: dashboard,
|
||
});
|
||
} catch (error) {
|
||
// console.error('Dashboard get error:', error);
|
||
res.status(500).json({
|
||
success: false,
|
||
message: "대시보드 조회 중 오류가 발생했습니다.",
|
||
error:
|
||
process.env.NODE_ENV === "development"
|
||
? (error as Error).message
|
||
: undefined,
|
||
});
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 대시보드 수정
|
||
* PUT /api/dashboards/:id
|
||
*/
|
||
async updateDashboard(
|
||
req: AuthenticatedRequest,
|
||
res: Response
|
||
): Promise<void> {
|
||
try {
|
||
const { id } = req.params;
|
||
const userId = req.user?.userId;
|
||
|
||
if (!userId) {
|
||
res.status(401).json({
|
||
success: false,
|
||
message: "인증이 필요합니다.",
|
||
});
|
||
return;
|
||
}
|
||
|
||
if (!id) {
|
||
res.status(400).json({
|
||
success: false,
|
||
message: "대시보드 ID가 필요합니다.",
|
||
});
|
||
return;
|
||
}
|
||
|
||
const updateData: UpdateDashboardRequest = req.body;
|
||
|
||
// 유효성 검증
|
||
if (updateData.title !== undefined) {
|
||
if (
|
||
typeof updateData.title !== "string" ||
|
||
updateData.title.trim().length === 0
|
||
) {
|
||
res.status(400).json({
|
||
success: false,
|
||
message: "올바른 제목을 입력해주세요.",
|
||
});
|
||
return;
|
||
}
|
||
if (updateData.title.length > 200) {
|
||
res.status(400).json({
|
||
success: false,
|
||
message: "제목은 200자를 초과할 수 없습니다.",
|
||
});
|
||
return;
|
||
}
|
||
updateData.title = updateData.title.trim();
|
||
}
|
||
|
||
if (
|
||
updateData.description !== undefined &&
|
||
updateData.description &&
|
||
updateData.description.length > 1000
|
||
) {
|
||
res.status(400).json({
|
||
success: false,
|
||
message: "설명은 1000자를 초과할 수 없습니다.",
|
||
});
|
||
return;
|
||
}
|
||
|
||
const updatedDashboard = await DashboardService.updateDashboard(
|
||
id,
|
||
updateData,
|
||
userId
|
||
);
|
||
|
||
if (!updatedDashboard) {
|
||
res.status(404).json({
|
||
success: false,
|
||
message: "대시보드를 찾을 수 없거나 수정 권한이 없습니다.",
|
||
});
|
||
return;
|
||
}
|
||
|
||
res.json({
|
||
success: true,
|
||
data: updatedDashboard,
|
||
message: "대시보드가 성공적으로 수정되었습니다.",
|
||
});
|
||
} catch (error) {
|
||
// console.error('Dashboard update error:', error);
|
||
|
||
if ((error as Error).message.includes("권한이 없습니다")) {
|
||
res.status(403).json({
|
||
success: false,
|
||
message: (error as Error).message,
|
||
});
|
||
return;
|
||
}
|
||
|
||
res.status(500).json({
|
||
success: false,
|
||
message: "대시보드 수정 중 오류가 발생했습니다.",
|
||
error:
|
||
process.env.NODE_ENV === "development"
|
||
? (error as Error).message
|
||
: undefined,
|
||
});
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 대시보드 삭제
|
||
* DELETE /api/dashboards/:id
|
||
*/
|
||
async deleteDashboard(
|
||
req: AuthenticatedRequest,
|
||
res: Response
|
||
): Promise<void> {
|
||
try {
|
||
const { id } = req.params;
|
||
const userId = req.user?.userId;
|
||
|
||
if (!userId) {
|
||
res.status(401).json({
|
||
success: false,
|
||
message: "인증이 필요합니다.",
|
||
});
|
||
return;
|
||
}
|
||
|
||
if (!id) {
|
||
res.status(400).json({
|
||
success: false,
|
||
message: "대시보드 ID가 필요합니다.",
|
||
});
|
||
return;
|
||
}
|
||
|
||
const deleted = await DashboardService.deleteDashboard(id, userId);
|
||
|
||
if (!deleted) {
|
||
res.status(404).json({
|
||
success: false,
|
||
message: "대시보드를 찾을 수 없거나 삭제 권한이 없습니다.",
|
||
});
|
||
return;
|
||
}
|
||
|
||
res.json({
|
||
success: true,
|
||
message: "대시보드가 성공적으로 삭제되었습니다.",
|
||
});
|
||
} catch (error) {
|
||
// console.error('Dashboard delete error:', error);
|
||
res.status(500).json({
|
||
success: false,
|
||
message: "대시보드 삭제 중 오류가 발생했습니다.",
|
||
error:
|
||
process.env.NODE_ENV === "development"
|
||
? (error as Error).message
|
||
: undefined,
|
||
});
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 내 대시보드 목록 조회
|
||
* GET /api/dashboards/my
|
||
*/
|
||
async getMyDashboards(
|
||
req: AuthenticatedRequest,
|
||
res: Response
|
||
): Promise<void> {
|
||
try {
|
||
const userId = req.user?.userId;
|
||
|
||
if (!userId) {
|
||
res.status(401).json({
|
||
success: false,
|
||
message: "인증이 필요합니다.",
|
||
});
|
||
return;
|
||
}
|
||
|
||
const companyCode = req.user?.companyCode;
|
||
|
||
const query: DashboardListQuery = {
|
||
page: parseInt(req.query.page as string) || 1,
|
||
limit: Math.min(parseInt(req.query.limit as string) || 20, 100),
|
||
search: req.query.search as string,
|
||
category: req.query.category as string,
|
||
// createdBy 제거 - 회사 대시보드 전체 표시
|
||
};
|
||
|
||
const result = await DashboardService.getDashboards(
|
||
query,
|
||
userId,
|
||
companyCode
|
||
);
|
||
|
||
res.json({
|
||
success: true,
|
||
data: result.dashboards,
|
||
pagination: result.pagination,
|
||
});
|
||
} catch (error) {
|
||
// console.error('My dashboards error:', error);
|
||
res.status(500).json({
|
||
success: false,
|
||
message: "내 대시보드 목록 조회 중 오류가 발생했습니다.",
|
||
error:
|
||
process.env.NODE_ENV === "development"
|
||
? (error as Error).message
|
||
: undefined,
|
||
});
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 쿼리 실행 (SELECT만)
|
||
* POST /api/dashboards/execute-query
|
||
*/
|
||
async executeQuery(req: AuthenticatedRequest, res: Response): Promise<void> {
|
||
try {
|
||
// 개발용으로 인증 체크 제거
|
||
// const userId = req.user?.userId;
|
||
// if (!userId) {
|
||
// res.status(401).json({
|
||
// success: false,
|
||
// message: '인증이 필요합니다.'
|
||
// });
|
||
// return;
|
||
// }
|
||
|
||
const { query } = req.body;
|
||
|
||
// 유효성 검증
|
||
if (!query || typeof query !== "string" || query.trim().length === 0) {
|
||
res.status(400).json({
|
||
success: false,
|
||
message: "쿼리가 필요합니다.",
|
||
});
|
||
return;
|
||
}
|
||
|
||
// SQL 인젝션 방지를 위한 기본적인 검증
|
||
const trimmedQuery = query.trim().toLowerCase();
|
||
if (!trimmedQuery.startsWith("select")) {
|
||
res.status(400).json({
|
||
success: false,
|
||
message: "SELECT 쿼리만 허용됩니다.",
|
||
});
|
||
return;
|
||
}
|
||
|
||
// 쿼리 실행
|
||
const result = await PostgreSQLService.query(query.trim());
|
||
|
||
// 결과 변환
|
||
const columns = result.fields?.map((field) => field.name) || [];
|
||
const rows = result.rows || [];
|
||
|
||
res.status(200).json({
|
||
success: true,
|
||
data: {
|
||
columns,
|
||
rows,
|
||
rowCount: rows.length,
|
||
},
|
||
message: "쿼리가 성공적으로 실행되었습니다.",
|
||
});
|
||
} catch (error) {
|
||
// console.error('Query execution error:', error);
|
||
res.status(500).json({
|
||
success: false,
|
||
message: "쿼리 실행 중 오류가 발생했습니다.",
|
||
error:
|
||
process.env.NODE_ENV === "development"
|
||
? (error as Error).message
|
||
: "쿼리 실행 오류",
|
||
});
|
||
}
|
||
}
|
||
|
||
/**
|
||
* DML 쿼리 실행 (INSERT, UPDATE, DELETE)
|
||
* POST /api/dashboards/execute-dml
|
||
*/
|
||
async executeDML(req: AuthenticatedRequest, res: Response): Promise<void> {
|
||
try {
|
||
const { query } = req.body;
|
||
|
||
// 유효성 검증
|
||
if (!query || typeof query !== "string" || query.trim().length === 0) {
|
||
res.status(400).json({
|
||
success: false,
|
||
message: "쿼리가 필요합니다.",
|
||
});
|
||
return;
|
||
}
|
||
|
||
// SQL 인젝션 방지를 위한 기본적인 검증
|
||
const trimmedQuery = query.trim().toLowerCase();
|
||
const allowedCommands = ["insert", "update", "delete"];
|
||
const isAllowed = allowedCommands.some((cmd) =>
|
||
trimmedQuery.startsWith(cmd)
|
||
);
|
||
|
||
if (!isAllowed) {
|
||
res.status(400).json({
|
||
success: false,
|
||
message: "INSERT, UPDATE, DELETE 쿼리만 허용됩니다.",
|
||
});
|
||
return;
|
||
}
|
||
|
||
// 위험한 명령어 차단
|
||
const dangerousPatterns = [
|
||
/drop\s+table/i,
|
||
/drop\s+database/i,
|
||
/truncate/i,
|
||
/alter\s+table/i,
|
||
/create\s+table/i,
|
||
];
|
||
|
||
if (dangerousPatterns.some((pattern) => pattern.test(query))) {
|
||
res.status(403).json({
|
||
success: false,
|
||
message: "허용되지 않는 쿼리입니다.",
|
||
});
|
||
return;
|
||
}
|
||
|
||
// 쿼리 실행
|
||
const result = await PostgreSQLService.query(query.trim());
|
||
|
||
res.status(200).json({
|
||
success: true,
|
||
data: {
|
||
rowCount: result.rowCount || 0,
|
||
command: result.command,
|
||
},
|
||
message: "쿼리가 성공적으로 실행되었습니다.",
|
||
});
|
||
} catch (error) {
|
||
console.error("DML execution error:", error);
|
||
res.status(500).json({
|
||
success: false,
|
||
message: "쿼리 실행 중 오류가 발생했습니다.",
|
||
error:
|
||
process.env.NODE_ENV === "development"
|
||
? (error as Error).message
|
||
: "쿼리 실행 오류",
|
||
});
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 외부 API 프록시 (CORS 우회용)
|
||
* POST /api/dashboards/fetch-external-api
|
||
*/
|
||
async fetchExternalApi(
|
||
req: AuthenticatedRequest,
|
||
res: Response
|
||
): Promise<void> {
|
||
try {
|
||
const {
|
||
url,
|
||
method = "GET",
|
||
headers = {},
|
||
queryParams = {},
|
||
body,
|
||
externalConnectionId, // 프론트엔드에서 선택된 커넥션 ID를 전달받아야 함
|
||
} = req.body;
|
||
|
||
if (!url || typeof url !== "string") {
|
||
res.status(400).json({
|
||
success: false,
|
||
message: "URL이 필요합니다.",
|
||
});
|
||
return;
|
||
}
|
||
|
||
// 쿼리 파라미터 추가
|
||
const urlObj = new URL(url);
|
||
Object.entries(queryParams).forEach(([key, value]) => {
|
||
if (key && value) {
|
||
urlObj.searchParams.append(key, String(value));
|
||
}
|
||
});
|
||
|
||
// Axios 요청 설정
|
||
const requestConfig: AxiosRequestConfig = {
|
||
url: urlObj.toString(),
|
||
method: method.toUpperCase(),
|
||
headers: {
|
||
"Content-Type": "application/json",
|
||
Accept: "application/json",
|
||
...headers,
|
||
},
|
||
timeout: 60000, // 60초 타임아웃
|
||
validateStatus: () => true, // 모든 상태 코드 허용 (에러도 응답으로 처리)
|
||
};
|
||
|
||
// 연결 정보 (응답에 포함용)
|
||
let connectionInfo: { saveToHistory?: boolean } | null = null;
|
||
|
||
// 외부 커넥션 ID가 있는 경우, 해당 커넥션의 인증 정보(DB 토큰 등)를 적용
|
||
if (externalConnectionId) {
|
||
try {
|
||
// 사용자 회사 코드가 있으면 사용하고, 없으면 '*' (최고 관리자)로 시도
|
||
let companyCode = req.user?.companyCode;
|
||
|
||
if (!companyCode) {
|
||
companyCode = "*";
|
||
}
|
||
|
||
// 커넥션 로드
|
||
const connectionResult =
|
||
await ExternalRestApiConnectionService.getConnectionById(
|
||
Number(externalConnectionId),
|
||
companyCode
|
||
);
|
||
|
||
if (connectionResult.success && connectionResult.data) {
|
||
const connection = connectionResult.data;
|
||
|
||
// 연결 정보 저장 (응답에 포함)
|
||
connectionInfo = {
|
||
saveToHistory: connection.save_to_history === "Y",
|
||
};
|
||
|
||
// 인증 헤더 생성 (DB 토큰 등)
|
||
const authHeaders =
|
||
await ExternalRestApiConnectionService.getAuthHeaders(
|
||
connection.auth_type,
|
||
connection.auth_config,
|
||
connection.company_code
|
||
);
|
||
|
||
// 기존 헤더에 인증 헤더 병합
|
||
requestConfig.headers = {
|
||
...requestConfig.headers,
|
||
...authHeaders,
|
||
};
|
||
|
||
// API Key가 Query Param인 경우 처리
|
||
if (
|
||
connection.auth_type === "api-key" &&
|
||
connection.auth_config?.keyLocation === "query" &&
|
||
connection.auth_config?.keyName &&
|
||
connection.auth_config?.keyValue
|
||
) {
|
||
const currentUrl = new URL(requestConfig.url!);
|
||
currentUrl.searchParams.append(
|
||
connection.auth_config.keyName,
|
||
connection.auth_config.keyValue
|
||
);
|
||
requestConfig.url = currentUrl.toString();
|
||
}
|
||
}
|
||
} catch (connError) {
|
||
logger.error(
|
||
`외부 커넥션(${externalConnectionId}) 정보 로드 및 인증 적용 실패:`,
|
||
connError
|
||
);
|
||
}
|
||
}
|
||
|
||
// Body 처리
|
||
if (body) {
|
||
requestConfig.data = body;
|
||
}
|
||
|
||
// TLS 인증서 검증 예외 처리 (thiratis.com 등 내부망/레거시 API 대응)
|
||
// ExternalRestApiConnectionService와 동일한 로직 적용
|
||
const bypassDomains = ["thiratis.com"];
|
||
const hostname = urlObj.hostname;
|
||
const shouldBypassTls = bypassDomains.some((domain) =>
|
||
hostname.includes(domain)
|
||
);
|
||
|
||
if (shouldBypassTls) {
|
||
requestConfig.httpsAgent = new https.Agent({
|
||
rejectUnauthorized: false,
|
||
});
|
||
}
|
||
|
||
// 기상청 API 등 EUC-KR 인코딩을 사용하는 경우 arraybuffer로 받아서 디코딩
|
||
const isKmaApi = urlObj.hostname.includes("kma.go.kr");
|
||
if (isKmaApi) {
|
||
requestConfig.responseType = "arraybuffer";
|
||
}
|
||
|
||
const response = await axios(requestConfig);
|
||
|
||
if (response.status >= 400) {
|
||
throw new Error(
|
||
`외부 API 오류: ${response.status} ${response.statusText}`
|
||
);
|
||
}
|
||
|
||
let data = response.data;
|
||
const contentType = response.headers["content-type"];
|
||
|
||
// 기상청 API 인코딩 처리 (UTF-8 우선, 실패 시 EUC-KR)
|
||
if (isKmaApi && Buffer.isBuffer(data)) {
|
||
const iconv = require("iconv-lite");
|
||
const buffer = Buffer.from(data);
|
||
const utf8Text = buffer.toString("utf-8");
|
||
|
||
// UTF-8로 정상 디코딩되었는지 확인
|
||
if (
|
||
utf8Text.includes("특보") ||
|
||
utf8Text.includes("경보") ||
|
||
utf8Text.includes("주의보") ||
|
||
(utf8Text.includes("#START7777") && !utf8Text.includes("<22>"))
|
||
) {
|
||
data = { text: utf8Text, contentType, encoding: "utf-8" };
|
||
} else {
|
||
// EUC-KR로 디코딩
|
||
const eucKrText = iconv.decode(buffer, "EUC-KR");
|
||
data = { text: eucKrText, contentType, encoding: "euc-kr" };
|
||
}
|
||
}
|
||
// 텍스트 응답인 경우 포맷팅
|
||
else if (typeof data === "string") {
|
||
data = { text: data, contentType };
|
||
}
|
||
|
||
res.status(200).json({
|
||
success: true,
|
||
data,
|
||
connectionInfo, // 외부 연결 정보 (saveToHistory 등)
|
||
});
|
||
} catch (error: any) {
|
||
const status = error.response?.status || 500;
|
||
const message = error.response?.statusText || error.message;
|
||
|
||
logger.error("외부 API 호출 오류:", {
|
||
message,
|
||
status,
|
||
data: error.response?.data,
|
||
});
|
||
|
||
res.status(500).json({
|
||
success: false,
|
||
message: "외부 API 호출 중 오류가 발생했습니다.",
|
||
error:
|
||
process.env.NODE_ENV === "development"
|
||
? message
|
||
: "외부 API 호출 오류",
|
||
});
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 테이블 스키마 조회 (날짜 컬럼 감지용)
|
||
* POST /api/dashboards/table-schema
|
||
*/
|
||
async getTableSchema(
|
||
req: AuthenticatedRequest,
|
||
res: Response
|
||
): Promise<void> {
|
||
try {
|
||
const { tableName } = req.body;
|
||
|
||
if (!tableName || typeof tableName !== "string") {
|
||
res.status(400).json({
|
||
success: false,
|
||
message: "테이블명이 필요합니다.",
|
||
});
|
||
return;
|
||
}
|
||
|
||
// 테이블명 검증 (SQL 인젝션 방지)
|
||
if (!/^[a-z_][a-z0-9_]*$/i.test(tableName)) {
|
||
res.status(400).json({
|
||
success: false,
|
||
message: "유효하지 않은 테이블명입니다.",
|
||
});
|
||
return;
|
||
}
|
||
|
||
// PostgreSQL information_schema에서 컬럼 정보 조회
|
||
const query = `
|
||
SELECT
|
||
column_name,
|
||
data_type,
|
||
udt_name
|
||
FROM information_schema.columns
|
||
WHERE table_name = $1
|
||
ORDER BY ordinal_position
|
||
`;
|
||
|
||
const result = await PostgreSQLService.query(query, [
|
||
tableName.toLowerCase(),
|
||
]);
|
||
|
||
// 날짜/시간 타입 컬럼 필터링
|
||
const dateColumns = result.rows
|
||
.filter((row: any) => {
|
||
const dataType = row.data_type?.toLowerCase();
|
||
const udtName = row.udt_name?.toLowerCase();
|
||
return (
|
||
dataType === "timestamp" ||
|
||
dataType === "timestamp without time zone" ||
|
||
dataType === "timestamp with time zone" ||
|
||
dataType === "date" ||
|
||
dataType === "time" ||
|
||
dataType === "time without time zone" ||
|
||
dataType === "time with time zone" ||
|
||
udtName === "timestamp" ||
|
||
udtName === "timestamptz" ||
|
||
udtName === "date" ||
|
||
udtName === "time" ||
|
||
udtName === "timetz"
|
||
);
|
||
})
|
||
.map((row: any) => row.column_name);
|
||
|
||
res.status(200).json({
|
||
success: true,
|
||
data: {
|
||
tableName,
|
||
columns: result.rows.map((row: any) => ({
|
||
name: row.column_name,
|
||
type: row.data_type,
|
||
udtName: row.udt_name,
|
||
})),
|
||
dateColumns,
|
||
},
|
||
});
|
||
} catch (error) {
|
||
res.status(500).json({
|
||
success: false,
|
||
message: "테이블 스키마 조회 중 오류가 발생했습니다.",
|
||
error:
|
||
process.env.NODE_ENV === "development"
|
||
? (error as Error).message
|
||
: "스키마 조회 오류",
|
||
});
|
||
}
|
||
}
|
||
}
|