521 lines
15 KiB
TypeScript
521 lines
15 KiB
TypeScript
import { PrismaClient } from "@prisma/client";
|
|
|
|
const prisma = new PrismaClient();
|
|
|
|
export interface ControlCondition {
|
|
id: string;
|
|
type: "condition" | "group-start" | "group-end";
|
|
field?: string;
|
|
value?: any;
|
|
operator?: "=" | "!=" | ">" | "<" | ">=" | "<=" | "LIKE" | "IN";
|
|
dataType?: "string" | "number" | "date" | "boolean";
|
|
logicalOperator?: "AND" | "OR";
|
|
groupId?: string;
|
|
groupLevel?: number;
|
|
}
|
|
|
|
export interface ControlAction {
|
|
id: string;
|
|
name: string;
|
|
actionType: "insert" | "update" | "delete";
|
|
conditions: ControlCondition[];
|
|
fieldMappings: {
|
|
sourceField?: string;
|
|
sourceTable?: string;
|
|
targetField: string;
|
|
targetTable: string;
|
|
defaultValue?: any;
|
|
}[];
|
|
splitConfig?: {
|
|
delimiter?: string;
|
|
sourceField?: string;
|
|
targetField?: string;
|
|
};
|
|
}
|
|
|
|
export interface ControlPlan {
|
|
id: string;
|
|
sourceTable: string;
|
|
actions: ControlAction[];
|
|
}
|
|
|
|
export interface ControlRule {
|
|
id: string;
|
|
triggerType: "insert" | "update" | "delete";
|
|
conditions: ControlCondition[];
|
|
}
|
|
|
|
export class DataflowControlService {
|
|
/**
|
|
* 제어관리 실행 메인 함수
|
|
*/
|
|
async executeDataflowControl(
|
|
diagramId: number,
|
|
relationshipId: string,
|
|
triggerType: "insert" | "update" | "delete",
|
|
sourceData: Record<string, any>,
|
|
tableName: string
|
|
): Promise<{
|
|
success: boolean;
|
|
message: string;
|
|
executedActions?: any[];
|
|
errors?: string[];
|
|
}> {
|
|
try {
|
|
console.log(`🎯 제어관리 실행 시작:`, {
|
|
diagramId,
|
|
relationshipId,
|
|
triggerType,
|
|
sourceData,
|
|
tableName,
|
|
});
|
|
|
|
// 관계도 정보 조회
|
|
const diagram = await prisma.dataflow_diagrams.findUnique({
|
|
where: { diagram_id: diagramId },
|
|
});
|
|
|
|
if (!diagram) {
|
|
return {
|
|
success: false,
|
|
message: `관계도를 찾을 수 없습니다. (ID: ${diagramId})`,
|
|
};
|
|
}
|
|
|
|
// 제어 규칙과 실행 계획 추출
|
|
const controlRules = (diagram.control as unknown as ControlRule[]) || [];
|
|
const executionPlans = (diagram.plan as unknown as ControlPlan[]) || [];
|
|
|
|
console.log(`📋 제어 규칙:`, controlRules);
|
|
console.log(`📋 실행 계획:`, executionPlans);
|
|
|
|
// 해당 관계의 제어 규칙 찾기
|
|
const targetRule = controlRules.find(
|
|
(rule) => rule.id === relationshipId && rule.triggerType === triggerType
|
|
);
|
|
|
|
if (!targetRule) {
|
|
console.log(
|
|
`⚠️ 해당 관계의 제어 규칙을 찾을 수 없습니다: ${relationshipId}`
|
|
);
|
|
return {
|
|
success: true,
|
|
message: "해당 관계의 제어 규칙이 없습니다.",
|
|
};
|
|
}
|
|
|
|
// 제어 조건 검증
|
|
const conditionResult = await this.evaluateConditions(
|
|
targetRule.conditions,
|
|
sourceData
|
|
);
|
|
|
|
console.log(`🔍 조건 검증 결과:`, conditionResult);
|
|
|
|
if (!conditionResult.satisfied) {
|
|
return {
|
|
success: true,
|
|
message: `제어 조건을 만족하지 않습니다: ${conditionResult.reason}`,
|
|
};
|
|
}
|
|
|
|
// 실행 계획 찾기
|
|
const targetPlan = executionPlans.find(
|
|
(plan) => plan.id === relationshipId
|
|
);
|
|
|
|
if (!targetPlan) {
|
|
return {
|
|
success: true,
|
|
message: "실행할 계획이 없습니다.",
|
|
};
|
|
}
|
|
|
|
// 액션 실행
|
|
const executedActions = [];
|
|
const errors = [];
|
|
|
|
for (const action of targetPlan.actions) {
|
|
try {
|
|
console.log(`⚡ 액션 실행: ${action.name} (${action.actionType})`);
|
|
|
|
// 액션 조건 검증 (있는 경우)
|
|
if (action.conditions && action.conditions.length > 0) {
|
|
const actionConditionResult = await this.evaluateConditions(
|
|
action.conditions,
|
|
sourceData
|
|
);
|
|
|
|
if (!actionConditionResult.satisfied) {
|
|
console.log(
|
|
`⚠️ 액션 조건 미충족: ${actionConditionResult.reason}`
|
|
);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
const actionResult = await this.executeAction(action, sourceData);
|
|
executedActions.push({
|
|
actionId: action.id,
|
|
actionName: action.name,
|
|
result: actionResult,
|
|
});
|
|
} catch (error) {
|
|
console.error(`❌ 액션 실행 오류: ${action.name}`, error);
|
|
errors.push(
|
|
`액션 '${action.name}' 실행 오류: ${error instanceof Error ? error.message : String(error)}`
|
|
);
|
|
}
|
|
}
|
|
|
|
return {
|
|
success: true,
|
|
message: `제어관리 실행 완료. ${executedActions.length}개 액션 실행됨.`,
|
|
executedActions,
|
|
errors: errors.length > 0 ? errors : undefined,
|
|
};
|
|
} catch (error) {
|
|
console.error("❌ 제어관리 실행 오류:", error);
|
|
return {
|
|
success: false,
|
|
message: `제어관리 실행 중 오류 발생: ${error instanceof Error ? error.message : String(error)}`,
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 조건 평가
|
|
*/
|
|
private async evaluateConditions(
|
|
conditions: ControlCondition[],
|
|
data: Record<string, any>
|
|
): Promise<{ satisfied: boolean; reason?: string }> {
|
|
if (!conditions || conditions.length === 0) {
|
|
return { satisfied: true };
|
|
}
|
|
|
|
try {
|
|
// 조건을 SQL WHERE 절로 변환
|
|
const whereClause = this.buildWhereClause(conditions, data);
|
|
console.log(`🔍 생성된 WHERE 절:`, whereClause);
|
|
|
|
// 간단한 조건 평가 (실제로는 더 복잡한 로직 필요)
|
|
for (const condition of conditions) {
|
|
if (condition.type === "condition" && condition.field) {
|
|
const fieldValue = data[condition.field];
|
|
const conditionValue = condition.value;
|
|
|
|
console.log(
|
|
`🔍 조건 평가: ${condition.field} ${condition.operator} ${conditionValue} (실제값: ${fieldValue})`
|
|
);
|
|
|
|
const result = this.evaluateSingleCondition(
|
|
fieldValue,
|
|
condition.operator || "=",
|
|
conditionValue,
|
|
condition.dataType || "string"
|
|
);
|
|
|
|
if (!result) {
|
|
return {
|
|
satisfied: false,
|
|
reason: `조건 미충족: ${condition.field} ${condition.operator} ${conditionValue}`,
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
return { satisfied: true };
|
|
} catch (error) {
|
|
console.error("조건 평가 오류:", error);
|
|
return {
|
|
satisfied: false,
|
|
reason: `조건 평가 오류: ${error instanceof Error ? error.message : String(error)}`,
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 단일 조건 평가
|
|
*/
|
|
private evaluateSingleCondition(
|
|
fieldValue: any,
|
|
operator: string,
|
|
conditionValue: any,
|
|
dataType: string
|
|
): boolean {
|
|
// 타입 변환
|
|
let actualValue = fieldValue;
|
|
let expectedValue = conditionValue;
|
|
|
|
if (dataType === "number") {
|
|
actualValue = parseFloat(fieldValue) || 0;
|
|
expectedValue = parseFloat(conditionValue) || 0;
|
|
} else if (dataType === "string") {
|
|
actualValue = String(fieldValue || "");
|
|
expectedValue = String(conditionValue || "");
|
|
}
|
|
|
|
// 연산자별 평가
|
|
switch (operator) {
|
|
case "=":
|
|
return actualValue === expectedValue;
|
|
case "!=":
|
|
return actualValue !== expectedValue;
|
|
case ">":
|
|
return actualValue > expectedValue;
|
|
case "<":
|
|
return actualValue < expectedValue;
|
|
case ">=":
|
|
return actualValue >= expectedValue;
|
|
case "<=":
|
|
return actualValue <= expectedValue;
|
|
case "LIKE":
|
|
return String(actualValue).includes(String(expectedValue));
|
|
default:
|
|
console.warn(`지원되지 않는 연산자: ${operator}`);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* WHERE 절 생성 (복잡한 그룹 조건 처리)
|
|
*/
|
|
private buildWhereClause(
|
|
conditions: ControlCondition[],
|
|
data: Record<string, any>
|
|
): string {
|
|
// 실제로는 더 복잡한 그룹 처리 로직이 필요
|
|
// 현재는 간단한 AND/OR 처리만 구현
|
|
const clauses = [];
|
|
|
|
for (const condition of conditions) {
|
|
if (condition.type === "condition") {
|
|
const clause = `${condition.field} ${condition.operator} '${condition.value}'`;
|
|
clauses.push(clause);
|
|
}
|
|
}
|
|
|
|
return clauses.join(" AND ");
|
|
}
|
|
|
|
/**
|
|
* 액션 실행
|
|
*/
|
|
private async executeAction(
|
|
action: ControlAction,
|
|
sourceData: Record<string, any>
|
|
): Promise<any> {
|
|
console.log(`🚀 액션 실행: ${action.actionType}`, action);
|
|
|
|
switch (action.actionType) {
|
|
case "insert":
|
|
return await this.executeInsertAction(action, sourceData);
|
|
case "update":
|
|
return await this.executeUpdateAction(action, sourceData);
|
|
case "delete":
|
|
return await this.executeDeleteAction(action, sourceData);
|
|
default:
|
|
throw new Error(`지원되지 않는 액션 타입: ${action.actionType}`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* INSERT 액션 실행
|
|
*/
|
|
private async executeInsertAction(
|
|
action: ControlAction,
|
|
sourceData: Record<string, any>
|
|
): Promise<any> {
|
|
const results = [];
|
|
|
|
for (const mapping of action.fieldMappings) {
|
|
const { targetTable, targetField, defaultValue, sourceField } = mapping;
|
|
|
|
// 삽입할 데이터 준비
|
|
const insertData: Record<string, any> = {};
|
|
|
|
if (sourceField && sourceData[sourceField]) {
|
|
insertData[targetField] = sourceData[sourceField];
|
|
} else if (defaultValue !== undefined) {
|
|
insertData[targetField] = defaultValue;
|
|
}
|
|
|
|
// 동적으로 테이블 컬럼 정보 조회하여 기본 필드 추가
|
|
await this.addDefaultFieldsForTable(targetTable, insertData);
|
|
|
|
console.log(`📝 INSERT 실행: ${targetTable}.${targetField}`, insertData);
|
|
|
|
try {
|
|
// 동적 테이블 INSERT 실행
|
|
const result = await prisma.$executeRawUnsafe(
|
|
`
|
|
INSERT INTO ${targetTable} (${Object.keys(insertData).join(", ")})
|
|
VALUES (${Object.keys(insertData)
|
|
.map((_, index) => `$${index + 1}`)
|
|
.join(", ")})
|
|
`,
|
|
...Object.values(insertData)
|
|
);
|
|
|
|
results.push({
|
|
table: targetTable,
|
|
field: targetField,
|
|
data: insertData,
|
|
result,
|
|
});
|
|
|
|
console.log(`✅ INSERT 성공: ${targetTable}.${targetField}`);
|
|
} catch (error) {
|
|
console.error(`❌ INSERT 실패: ${targetTable}.${targetField}`, error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
return results;
|
|
}
|
|
|
|
/**
|
|
* UPDATE 액션 실행
|
|
*/
|
|
private async executeUpdateAction(
|
|
action: ControlAction,
|
|
sourceData: Record<string, any>
|
|
): Promise<any> {
|
|
// UPDATE 로직 구현
|
|
console.log("UPDATE 액션 실행 (미구현)");
|
|
return { message: "UPDATE 액션은 아직 구현되지 않았습니다." };
|
|
}
|
|
|
|
/**
|
|
* DELETE 액션 실행
|
|
*/
|
|
private async executeDeleteAction(
|
|
action: ControlAction,
|
|
sourceData: Record<string, any>
|
|
): Promise<any> {
|
|
// DELETE 로직 구현
|
|
console.log("DELETE 액션 실행 (미구현)");
|
|
return { message: "DELETE 액션은 아직 구현되지 않았습니다." };
|
|
}
|
|
|
|
/**
|
|
* 테이블의 컬럼 정보를 동적으로 조회하여 기본 필드 추가
|
|
*/
|
|
private async addDefaultFieldsForTable(
|
|
tableName: string,
|
|
insertData: Record<string, any>
|
|
): Promise<void> {
|
|
try {
|
|
// 테이블의 컬럼 정보 조회
|
|
const columns = await prisma.$queryRawUnsafe<
|
|
Array<{ column_name: string; data_type: string; is_nullable: string }>
|
|
>(
|
|
`
|
|
SELECT column_name, data_type, is_nullable
|
|
FROM information_schema.columns
|
|
WHERE table_name = $1
|
|
ORDER BY ordinal_position
|
|
`,
|
|
tableName
|
|
);
|
|
|
|
console.log(`📋 ${tableName} 테이블 컬럼 정보:`, columns);
|
|
|
|
const currentDate = new Date();
|
|
|
|
// 일반적인 타임스탬프 필드들 확인 및 추가
|
|
const timestampFields = [
|
|
{
|
|
names: ["created_at", "create_date", "reg_date", "regdate"],
|
|
value: currentDate,
|
|
},
|
|
{
|
|
names: ["updated_at", "update_date", "mod_date", "moddate"],
|
|
value: currentDate,
|
|
},
|
|
];
|
|
|
|
for (const fieldGroup of timestampFields) {
|
|
for (const fieldName of fieldGroup.names) {
|
|
const column = columns.find(
|
|
(col) => col.column_name.toLowerCase() === fieldName.toLowerCase()
|
|
);
|
|
if (column && !insertData[column.column_name]) {
|
|
// 해당 컬럼이 존재하고 아직 값이 설정되지 않은 경우
|
|
if (
|
|
column.data_type.includes("timestamp") ||
|
|
column.data_type.includes("date")
|
|
) {
|
|
insertData[column.column_name] = fieldGroup.value;
|
|
console.log(
|
|
`📅 기본 타임스탬프 필드 추가: ${column.column_name} = ${fieldGroup.value}`
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 필수 필드 중 값이 없는 경우 기본값 설정
|
|
for (const column of columns) {
|
|
if (column.is_nullable === "NO" && !insertData[column.column_name]) {
|
|
// NOT NULL 필드인데 값이 없는 경우 기본값 설정
|
|
const defaultValue = this.getDefaultValueForColumn(column);
|
|
if (defaultValue !== null) {
|
|
insertData[column.column_name] = defaultValue;
|
|
console.log(
|
|
`🔧 필수 필드 기본값 설정: ${column.column_name} = ${defaultValue}`
|
|
);
|
|
}
|
|
}
|
|
}
|
|
} catch (error) {
|
|
console.error(`❌ ${tableName} 테이블 컬럼 정보 조회 실패:`, error);
|
|
// 에러가 발생해도 INSERT는 계속 진행 (기본 필드 없이)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 컬럼 타입에 따른 기본값 반환
|
|
*/
|
|
private getDefaultValueForColumn(column: {
|
|
column_name: string;
|
|
data_type: string;
|
|
}): any {
|
|
const dataType = column.data_type.toLowerCase();
|
|
const columnName = column.column_name.toLowerCase();
|
|
|
|
// 컬럼명 기반 기본값
|
|
if (columnName.includes("status")) {
|
|
return "Y"; // 상태 필드는 보통 'Y'
|
|
}
|
|
if (columnName.includes("type")) {
|
|
return "default"; // 타입 필드는 'default'
|
|
}
|
|
|
|
// 데이터 타입 기반 기본값
|
|
if (
|
|
dataType.includes("varchar") ||
|
|
dataType.includes("text") ||
|
|
dataType.includes("char")
|
|
) {
|
|
return ""; // 문자열은 빈 문자열
|
|
}
|
|
if (
|
|
dataType.includes("int") ||
|
|
dataType.includes("numeric") ||
|
|
dataType.includes("decimal")
|
|
) {
|
|
return 0; // 숫자는 0
|
|
}
|
|
if (dataType.includes("bool")) {
|
|
return false; // 불린은 false
|
|
}
|
|
if (dataType.includes("timestamp") || dataType.includes("date")) {
|
|
return new Date(); // 날짜는 현재 시간
|
|
}
|
|
|
|
return null; // 기본값을 설정할 수 없는 경우
|
|
}
|
|
}
|