1126 lines
31 KiB
TypeScript
1126 lines
31 KiB
TypeScript
import { PrismaClient } from "@prisma/client";
|
|
import { logger } from "../utils/logger";
|
|
|
|
const prisma = new PrismaClient();
|
|
|
|
// 테이블 관계 생성 데이터 타입
|
|
interface CreateTableRelationshipData {
|
|
diagramId?: number; // 기존 관계도에 추가하는 경우
|
|
relationshipName: string;
|
|
fromTableName: string;
|
|
fromColumnName: string;
|
|
toTableName: string;
|
|
toColumnName: string;
|
|
relationshipType: string;
|
|
connectionType: string;
|
|
companyCode: string;
|
|
settings: any;
|
|
createdBy: string;
|
|
}
|
|
|
|
// 테이블 관계 수정 데이터 타입
|
|
interface UpdateTableRelationshipData {
|
|
relationshipName?: string;
|
|
fromTableName?: string;
|
|
fromColumnName?: string;
|
|
toTableName?: string;
|
|
toColumnName?: string;
|
|
relationshipType?: string;
|
|
connectionType?: string;
|
|
settings?: any;
|
|
updatedBy: string;
|
|
}
|
|
|
|
export class DataflowService {
|
|
/**
|
|
* 테이블 관계 생성
|
|
*/
|
|
async createTableRelationship(data: CreateTableRelationshipData) {
|
|
try {
|
|
logger.info("DataflowService: 테이블 관계 생성 시작", data);
|
|
|
|
// diagram_id 결정 로직
|
|
let diagramId = data.diagramId;
|
|
|
|
if (!diagramId) {
|
|
// 새로운 관계도인 경우, 새로운 diagram_id 생성
|
|
// 현재 최대 diagram_id + 1
|
|
const maxDiagramId = await prisma.table_relationships.findFirst({
|
|
where: {
|
|
company_code: data.companyCode,
|
|
},
|
|
orderBy: {
|
|
diagram_id: "desc",
|
|
},
|
|
select: {
|
|
diagram_id: true,
|
|
},
|
|
});
|
|
|
|
diagramId = (maxDiagramId?.diagram_id || 0) + 1;
|
|
}
|
|
|
|
// 중복 관계 확인 (같은 diagram_id 내에서)
|
|
const existingRelationship = await prisma.table_relationships.findFirst({
|
|
where: {
|
|
diagram_id: diagramId,
|
|
from_table_name: data.fromTableName,
|
|
from_column_name: data.fromColumnName,
|
|
to_table_name: data.toTableName,
|
|
to_column_name: data.toColumnName,
|
|
company_code: data.companyCode,
|
|
is_active: "Y",
|
|
},
|
|
});
|
|
|
|
if (existingRelationship) {
|
|
throw new Error(
|
|
`이미 존재하는 관계입니다: ${data.fromTableName}.${data.fromColumnName} → ${data.toTableName}.${data.toColumnName}`
|
|
);
|
|
}
|
|
|
|
// 새 관계 생성
|
|
const relationship = await prisma.table_relationships.create({
|
|
data: {
|
|
diagram_id: diagramId,
|
|
relationship_name: data.relationshipName,
|
|
from_table_name: data.fromTableName,
|
|
from_column_name: data.fromColumnName,
|
|
to_table_name: data.toTableName,
|
|
to_column_name: data.toColumnName,
|
|
relationship_type: data.relationshipType,
|
|
connection_type: data.connectionType,
|
|
company_code: data.companyCode,
|
|
settings: data.settings,
|
|
created_by: data.createdBy,
|
|
updated_by: data.createdBy,
|
|
},
|
|
});
|
|
|
|
logger.info(
|
|
`DataflowService: 테이블 관계 생성 완료 - ID: ${relationship.relationship_id}, Diagram ID: ${relationship.diagram_id}`
|
|
);
|
|
return relationship;
|
|
} catch (error) {
|
|
logger.error("DataflowService: 테이블 관계 생성 실패", error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 회사별 테이블 관계 목록 조회
|
|
*/
|
|
async getTableRelationships(companyCode: string) {
|
|
try {
|
|
logger.info(
|
|
`DataflowService: 테이블 관계 목록 조회 시작 - 회사코드: ${companyCode}`
|
|
);
|
|
|
|
// 관리자는 모든 회사의 관계를 볼 수 있음
|
|
const whereCondition: any = {
|
|
is_active: "Y",
|
|
};
|
|
|
|
if (companyCode !== "*") {
|
|
whereCondition.company_code = companyCode;
|
|
}
|
|
|
|
const relationships = await prisma.table_relationships.findMany({
|
|
where: whereCondition,
|
|
orderBy: {
|
|
created_date: "desc",
|
|
},
|
|
});
|
|
|
|
logger.info(
|
|
`DataflowService: 테이블 관계 목록 조회 완료 - ${relationships.length}개`
|
|
);
|
|
return relationships;
|
|
} catch (error) {
|
|
logger.error("DataflowService: 테이블 관계 목록 조회 실패", error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 특정 테이블 관계 조회
|
|
*/
|
|
async getTableRelationship(relationshipId: number, companyCode: string) {
|
|
try {
|
|
logger.info(
|
|
`DataflowService: 테이블 관계 조회 시작 - ID: ${relationshipId}, 회사코드: ${companyCode}`
|
|
);
|
|
|
|
const whereCondition: any = {
|
|
relationship_id: relationshipId,
|
|
is_active: "Y",
|
|
};
|
|
|
|
// 관리자가 아닌 경우 회사코드 제한
|
|
if (companyCode !== "*") {
|
|
whereCondition.company_code = companyCode;
|
|
}
|
|
|
|
const relationship = await prisma.table_relationships.findFirst({
|
|
where: whereCondition,
|
|
});
|
|
|
|
if (relationship) {
|
|
logger.info(
|
|
`DataflowService: 테이블 관계 조회 완료 - ID: ${relationshipId}`
|
|
);
|
|
} else {
|
|
logger.warn(
|
|
`DataflowService: 테이블 관계를 찾을 수 없음 - ID: ${relationshipId}`
|
|
);
|
|
}
|
|
|
|
return relationship;
|
|
} catch (error) {
|
|
logger.error("DataflowService: 테이블 관계 조회 실패", error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 테이블 관계 수정
|
|
*/
|
|
async updateTableRelationship(
|
|
relationshipId: number,
|
|
updateData: UpdateTableRelationshipData,
|
|
companyCode: string
|
|
) {
|
|
try {
|
|
logger.info(
|
|
`DataflowService: 테이블 관계 수정 시작 - ID: ${relationshipId}`,
|
|
updateData
|
|
);
|
|
|
|
// 기존 관계 확인
|
|
const existingRelationship = await this.getTableRelationship(
|
|
relationshipId,
|
|
companyCode
|
|
);
|
|
if (!existingRelationship) {
|
|
return null;
|
|
}
|
|
|
|
// 관계 수정
|
|
const relationship = await prisma.table_relationships.update({
|
|
where: {
|
|
relationship_id: relationshipId,
|
|
},
|
|
data: {
|
|
...updateData,
|
|
updated_date: new Date(),
|
|
},
|
|
});
|
|
|
|
logger.info(
|
|
`DataflowService: 테이블 관계 수정 완료 - ID: ${relationshipId}`
|
|
);
|
|
return relationship;
|
|
} catch (error) {
|
|
logger.error("DataflowService: 테이블 관계 수정 실패", error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 테이블 관계 삭제 (소프트 삭제)
|
|
*/
|
|
async deleteTableRelationship(relationshipId: number, companyCode: string) {
|
|
try {
|
|
logger.info(
|
|
`DataflowService: 테이블 관계 삭제 시작 - ID: ${relationshipId}, 회사코드: ${companyCode}`
|
|
);
|
|
|
|
// 기존 관계 확인
|
|
const existingRelationship = await this.getTableRelationship(
|
|
relationshipId,
|
|
companyCode
|
|
);
|
|
if (!existingRelationship) {
|
|
return false;
|
|
}
|
|
|
|
// 소프트 삭제 (is_active = 'N')
|
|
await prisma.table_relationships.update({
|
|
where: {
|
|
relationship_id: relationshipId,
|
|
},
|
|
data: {
|
|
is_active: "N",
|
|
updated_date: new Date(),
|
|
},
|
|
});
|
|
|
|
logger.info(
|
|
`DataflowService: 테이블 관계 삭제 완료 - ID: ${relationshipId}`
|
|
);
|
|
return true;
|
|
} catch (error) {
|
|
logger.error("DataflowService: 테이블 관계 삭제 실패", error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 특정 테이블과 관련된 모든 관계 조회
|
|
*/
|
|
async getRelationshipsByTable(tableName: string, companyCode: string) {
|
|
try {
|
|
logger.info(
|
|
`DataflowService: 테이블별 관계 조회 시작 - 테이블: ${tableName}, 회사코드: ${companyCode}`
|
|
);
|
|
|
|
const whereCondition: any = {
|
|
OR: [{ from_table_name: tableName }, { to_table_name: tableName }],
|
|
is_active: "Y",
|
|
};
|
|
|
|
// 관리자가 아닌 경우 회사코드 제한
|
|
if (companyCode !== "*") {
|
|
whereCondition.company_code = companyCode;
|
|
}
|
|
|
|
const relationships = await prisma.table_relationships.findMany({
|
|
where: whereCondition,
|
|
orderBy: {
|
|
created_date: "desc",
|
|
},
|
|
});
|
|
|
|
logger.info(
|
|
`DataflowService: 테이블별 관계 조회 완료 - ${relationships.length}개`
|
|
);
|
|
return relationships;
|
|
} catch (error) {
|
|
logger.error("DataflowService: 테이블별 관계 조회 실패", error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 연결 타입별 관계 조회
|
|
*/
|
|
async getRelationshipsByConnectionType(
|
|
connectionType: string,
|
|
companyCode: string
|
|
) {
|
|
try {
|
|
logger.info(
|
|
`DataflowService: 연결타입별 관계 조회 시작 - 타입: ${connectionType}, 회사코드: ${companyCode}`
|
|
);
|
|
|
|
const whereCondition: any = {
|
|
connection_type: connectionType,
|
|
is_active: "Y",
|
|
};
|
|
|
|
// 관리자가 아닌 경우 회사코드 제한
|
|
if (companyCode !== "*") {
|
|
whereCondition.company_code = companyCode;
|
|
}
|
|
|
|
const relationships = await prisma.table_relationships.findMany({
|
|
where: whereCondition,
|
|
orderBy: {
|
|
created_date: "desc",
|
|
},
|
|
});
|
|
|
|
logger.info(
|
|
`DataflowService: 연결타입별 관계 조회 완료 - ${relationships.length}개`
|
|
);
|
|
return relationships;
|
|
} catch (error) {
|
|
logger.error("DataflowService: 연결타입별 관계 조회 실패", error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 관계 통계 조회
|
|
*/
|
|
async getRelationshipStats(companyCode: string) {
|
|
try {
|
|
logger.info(
|
|
`DataflowService: 관계 통계 조회 시작 - 회사코드: ${companyCode}`
|
|
);
|
|
|
|
const whereCondition: any = {
|
|
is_active: "Y",
|
|
};
|
|
|
|
// 관리자가 아닌 경우 회사코드 제한
|
|
if (companyCode !== "*") {
|
|
whereCondition.company_code = companyCode;
|
|
}
|
|
|
|
// 전체 관계 수
|
|
const totalCount = await prisma.table_relationships.count({
|
|
where: whereCondition,
|
|
});
|
|
|
|
// 관계 타입별 통계
|
|
const relationshipTypeStats = await prisma.table_relationships.groupBy({
|
|
by: ["relationship_type"],
|
|
where: whereCondition,
|
|
_count: {
|
|
relationship_id: true,
|
|
},
|
|
});
|
|
|
|
// 연결 타입별 통계
|
|
const connectionTypeStats = await prisma.table_relationships.groupBy({
|
|
by: ["connection_type"],
|
|
where: whereCondition,
|
|
_count: {
|
|
relationship_id: true,
|
|
},
|
|
});
|
|
|
|
const stats = {
|
|
totalCount,
|
|
relationshipTypeStats: relationshipTypeStats.map((stat) => ({
|
|
type: stat.relationship_type,
|
|
count: stat._count.relationship_id,
|
|
})),
|
|
connectionTypeStats: connectionTypeStats.map((stat) => ({
|
|
type: stat.connection_type,
|
|
count: stat._count.relationship_id,
|
|
})),
|
|
};
|
|
|
|
logger.info(`DataflowService: 관계 통계 조회 완료`, stats);
|
|
return stats;
|
|
} catch (error) {
|
|
logger.error("DataflowService: 관계 통계 조회 실패", error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
// ==================== 데이터 중계 관리 ====================
|
|
|
|
/**
|
|
* 데이터 관계 연결 생성
|
|
*/
|
|
async createDataLink(linkData: {
|
|
relationshipId: number;
|
|
fromTableName: string;
|
|
fromColumnName: string;
|
|
toTableName: string;
|
|
toColumnName: string;
|
|
connectionType: string;
|
|
companyCode: string;
|
|
bridgeData?: any;
|
|
createdBy: string;
|
|
}) {
|
|
try {
|
|
logger.info(
|
|
`DataflowService: 데이터 연결 생성 시작 - 관계ID: ${linkData.relationshipId}`
|
|
);
|
|
|
|
const bridge = await prisma.data_relationship_bridge.create({
|
|
data: {
|
|
relationship_id: linkData.relationshipId,
|
|
from_table_name: linkData.fromTableName,
|
|
from_column_name: linkData.fromColumnName,
|
|
to_table_name: linkData.toTableName,
|
|
to_column_name: linkData.toColumnName,
|
|
connection_type: linkData.connectionType,
|
|
company_code: linkData.companyCode,
|
|
bridge_data: linkData.bridgeData || {},
|
|
created_by: linkData.createdBy,
|
|
},
|
|
});
|
|
|
|
logger.info(
|
|
`DataflowService: 데이터 연결 생성 완료 - Bridge ID: ${bridge.bridge_id}`
|
|
);
|
|
return bridge;
|
|
} catch (error) {
|
|
logger.error("DataflowService: 데이터 연결 생성 실패", error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 관계별 연결된 데이터 조회
|
|
*/
|
|
async getLinkedDataByRelationship(
|
|
relationshipId: number,
|
|
companyCode: string
|
|
) {
|
|
try {
|
|
logger.info(
|
|
`DataflowService: 관계별 연결 데이터 조회 시작 - 관계ID: ${relationshipId}`
|
|
);
|
|
|
|
const whereCondition: any = {
|
|
relationship_id: relationshipId,
|
|
is_active: "Y",
|
|
};
|
|
|
|
// 관리자가 아닌 경우 회사코드 제한
|
|
if (companyCode !== "*") {
|
|
whereCondition.company_code = companyCode;
|
|
}
|
|
|
|
const linkedData = await prisma.data_relationship_bridge.findMany({
|
|
where: whereCondition,
|
|
orderBy: { created_at: "desc" },
|
|
include: {
|
|
relationship: {
|
|
select: {
|
|
relationship_name: true,
|
|
relationship_type: true,
|
|
connection_type: true,
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
logger.info(
|
|
`DataflowService: 관계별 연결 데이터 조회 완료 - ${linkedData.length}건`
|
|
);
|
|
return linkedData;
|
|
} catch (error) {
|
|
logger.error("DataflowService: 관계별 연결 데이터 조회 실패", error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 특정 테이블의 연결된 데이터 조회
|
|
*/
|
|
async getLinkedDataByTable(
|
|
tableName: string,
|
|
keyValue?: string,
|
|
companyCode?: string
|
|
) {
|
|
try {
|
|
logger.info(
|
|
`DataflowService: 테이블별 연결 데이터 조회 시작 - 테이블: ${tableName}`
|
|
);
|
|
|
|
const whereCondition: any = {
|
|
OR: [{ from_table_name: tableName }, { to_table_name: tableName }],
|
|
is_active: "Y",
|
|
};
|
|
|
|
// keyValue 파라미터는 더 이상 사용하지 않음 (key_value 필드 제거됨)
|
|
|
|
// 회사코드 필터링
|
|
if (companyCode && companyCode !== "*") {
|
|
whereCondition.company_code = companyCode;
|
|
}
|
|
|
|
const linkedData = await prisma.data_relationship_bridge.findMany({
|
|
where: whereCondition,
|
|
orderBy: { created_at: "desc" },
|
|
include: {
|
|
relationship: {
|
|
select: {
|
|
relationship_name: true,
|
|
relationship_type: true,
|
|
connection_type: true,
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
logger.info(
|
|
`DataflowService: 테이블별 연결 데이터 조회 완료 - ${linkedData.length}건`
|
|
);
|
|
return linkedData;
|
|
} catch (error) {
|
|
logger.error("DataflowService: 테이블별 연결 데이터 조회 실패", error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 데이터 연결 수정
|
|
*/
|
|
async updateDataLink(
|
|
bridgeId: number,
|
|
updateData: {
|
|
bridgeData?: any;
|
|
updatedBy: string;
|
|
},
|
|
companyCode: string
|
|
) {
|
|
try {
|
|
logger.info(
|
|
`DataflowService: 데이터 연결 수정 시작 - Bridge ID: ${bridgeId}`
|
|
);
|
|
|
|
const whereCondition: any = {
|
|
bridge_id: bridgeId,
|
|
is_active: "Y",
|
|
};
|
|
|
|
// 관리자가 아닌 경우 회사코드 제한
|
|
if (companyCode !== "*") {
|
|
whereCondition.company_code = companyCode;
|
|
}
|
|
|
|
const updatedBridge = await prisma.data_relationship_bridge.update({
|
|
where: whereCondition,
|
|
data: {
|
|
...updateData,
|
|
updated_at: new Date(),
|
|
},
|
|
});
|
|
|
|
logger.info(
|
|
`DataflowService: 데이터 연결 수정 완료 - Bridge ID: ${bridgeId}`
|
|
);
|
|
return updatedBridge;
|
|
} catch (error) {
|
|
logger.error("DataflowService: 데이터 연결 수정 실패", error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 데이터 연결 삭제 (소프트 삭제)
|
|
*/
|
|
async deleteDataLink(
|
|
bridgeId: number,
|
|
companyCode: string,
|
|
deletedBy: string
|
|
) {
|
|
try {
|
|
logger.info(
|
|
`DataflowService: 데이터 연결 삭제 시작 - Bridge ID: ${bridgeId}`
|
|
);
|
|
|
|
const whereCondition: any = {
|
|
bridge_id: bridgeId,
|
|
is_active: "Y",
|
|
};
|
|
|
|
// 관리자가 아닌 경우 회사코드 제한
|
|
if (companyCode !== "*") {
|
|
whereCondition.company_code = companyCode;
|
|
}
|
|
|
|
await prisma.data_relationship_bridge.update({
|
|
where: whereCondition,
|
|
data: {
|
|
is_active: "N",
|
|
updated_at: new Date(),
|
|
updated_by: deletedBy,
|
|
},
|
|
});
|
|
|
|
logger.info(
|
|
`DataflowService: 데이터 연결 삭제 완료 - Bridge ID: ${bridgeId}`
|
|
);
|
|
return true;
|
|
} catch (error) {
|
|
logger.error("DataflowService: 데이터 연결 삭제 실패", error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 관계 삭제 시 연결된 모든 데이터도 삭제
|
|
*/
|
|
async deleteAllLinkedDataByRelationship(
|
|
relationshipId: number,
|
|
companyCode: string,
|
|
deletedBy: string
|
|
) {
|
|
try {
|
|
logger.info(
|
|
`DataflowService: 관계별 모든 데이터 연결 삭제 시작 - 관계ID: ${relationshipId}`
|
|
);
|
|
|
|
const whereCondition: any = {
|
|
relationship_id: relationshipId,
|
|
is_active: "Y",
|
|
};
|
|
|
|
// 관리자가 아닌 경우 회사코드 제한
|
|
if (companyCode !== "*") {
|
|
whereCondition.company_code = companyCode;
|
|
}
|
|
|
|
const result = await prisma.data_relationship_bridge.updateMany({
|
|
where: whereCondition,
|
|
data: {
|
|
is_active: "N",
|
|
updated_at: new Date(),
|
|
updated_by: deletedBy,
|
|
},
|
|
});
|
|
|
|
logger.info(
|
|
`DataflowService: 관계별 모든 데이터 연결 삭제 완료 - ${result.count}건`
|
|
);
|
|
return result.count;
|
|
} catch (error) {
|
|
logger.error("DataflowService: 관계별 모든 데이터 연결 삭제 실패", error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
// ==================== 테이블 데이터 조회 ====================
|
|
|
|
/**
|
|
* 테이블 실제 데이터 조회 (페이징)
|
|
*/
|
|
async getTableData(
|
|
tableName: string,
|
|
page: number = 1,
|
|
limit: number = 10,
|
|
search: string = "",
|
|
searchColumn: string = "",
|
|
companyCode: string = "*"
|
|
) {
|
|
try {
|
|
logger.info(`DataflowService: 테이블 데이터 조회 시작 - ${tableName}`);
|
|
|
|
// 테이블 존재 여부 확인 (정보 스키마 사용)
|
|
const tableExists = await prisma.$queryRaw`
|
|
SELECT table_name
|
|
FROM information_schema.tables
|
|
WHERE table_name = ${tableName.toLowerCase()}
|
|
AND table_schema = 'public'
|
|
`;
|
|
|
|
if (
|
|
!tableExists ||
|
|
(Array.isArray(tableExists) && tableExists.length === 0)
|
|
) {
|
|
throw new Error(`테이블 '${tableName}'이 존재하지 않습니다.`);
|
|
}
|
|
|
|
// 전체 데이터 개수 조회
|
|
let totalCountQuery = `SELECT COUNT(*) as total FROM "${tableName}"`;
|
|
let dataQuery = `SELECT * FROM "${tableName}"`;
|
|
|
|
// 검색 조건 추가
|
|
if (search && searchColumn) {
|
|
const whereCondition = `WHERE "${searchColumn}" ILIKE '%${search}%'`;
|
|
totalCountQuery += ` ${whereCondition}`;
|
|
dataQuery += ` ${whereCondition}`;
|
|
}
|
|
|
|
// 페이징 처리
|
|
const offset = (page - 1) * limit;
|
|
dataQuery += ` ORDER BY 1 LIMIT ${limit} OFFSET ${offset}`;
|
|
|
|
// 실제 쿼리 실행
|
|
const [totalResult, dataResult] = await Promise.all([
|
|
prisma.$queryRawUnsafe(totalCountQuery),
|
|
prisma.$queryRawUnsafe(dataQuery),
|
|
]);
|
|
|
|
const total =
|
|
Array.isArray(totalResult) && totalResult.length > 0
|
|
? Number((totalResult[0] as any).total)
|
|
: 0;
|
|
|
|
const data = Array.isArray(dataResult) ? dataResult : [];
|
|
|
|
const result = {
|
|
data,
|
|
pagination: {
|
|
page,
|
|
limit,
|
|
total,
|
|
totalPages: Math.ceil(total / limit),
|
|
hasNext: page < Math.ceil(total / limit),
|
|
hasPrev: page > 1,
|
|
},
|
|
};
|
|
|
|
logger.info(
|
|
`DataflowService: 테이블 데이터 조회 완료 - ${tableName}, 총 ${total}건 중 ${data.length}건 조회`
|
|
);
|
|
|
|
return result;
|
|
} catch (error) {
|
|
logger.error(
|
|
`DataflowService: 테이블 데이터 조회 실패 - ${tableName}`,
|
|
error
|
|
);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 관계도 그룹 목록 조회 (diagram_id별로 그룹화)
|
|
*/
|
|
async getDataFlowDiagrams(
|
|
companyCode: string,
|
|
page: number = 1,
|
|
size: number = 20,
|
|
searchTerm: string = ""
|
|
) {
|
|
try {
|
|
logger.info(
|
|
`DataflowService: 관계도 목록 조회 시작 - ${companyCode}, page: ${page}, size: ${size}, search: ${searchTerm}`
|
|
);
|
|
|
|
// diagram_id별로 그룹화하여 조회
|
|
const whereCondition = {
|
|
company_code: companyCode,
|
|
is_active: "Y",
|
|
...(searchTerm && {
|
|
OR: [
|
|
{
|
|
relationship_name: {
|
|
contains: searchTerm,
|
|
mode: "insensitive" as any,
|
|
},
|
|
},
|
|
{
|
|
from_table_name: {
|
|
contains: searchTerm,
|
|
mode: "insensitive" as any,
|
|
},
|
|
},
|
|
{
|
|
to_table_name: {
|
|
contains: searchTerm,
|
|
mode: "insensitive" as any,
|
|
},
|
|
},
|
|
],
|
|
}),
|
|
};
|
|
|
|
// diagram_id별로 그룹화된 데이터 조회
|
|
const relationships = await prisma.table_relationships.findMany({
|
|
where: whereCondition,
|
|
select: {
|
|
relationship_id: true,
|
|
diagram_id: true,
|
|
relationship_name: true,
|
|
from_table_name: true,
|
|
to_table_name: true,
|
|
connection_type: true,
|
|
relationship_type: true,
|
|
created_date: true,
|
|
created_by: true,
|
|
updated_date: true,
|
|
updated_by: true,
|
|
},
|
|
orderBy: [{ diagram_id: "asc" }, { created_date: "desc" }],
|
|
});
|
|
|
|
// diagram_id별로 그룹화
|
|
const diagramMap = new Map<number, any>();
|
|
|
|
relationships.forEach((rel) => {
|
|
const diagramId = rel.diagram_id;
|
|
|
|
if (!diagramMap.has(diagramId)) {
|
|
diagramMap.set(diagramId, {
|
|
diagramId: diagramId,
|
|
diagramName: rel.relationship_name, // 첫 번째 관계의 이름을 사용
|
|
connectionType: rel.connection_type,
|
|
relationshipType: rel.relationship_type,
|
|
tableCount: new Set<string>(),
|
|
relationshipCount: 0,
|
|
createdAt: rel.created_date,
|
|
createdBy: rel.created_by,
|
|
updatedAt: rel.updated_date,
|
|
updatedBy: rel.updated_by,
|
|
tables: [],
|
|
});
|
|
}
|
|
|
|
const diagram = diagramMap.get(diagramId);
|
|
diagram.tableCount.add(rel.from_table_name);
|
|
diagram.tableCount.add(rel.to_table_name);
|
|
diagram.relationshipCount++;
|
|
|
|
// 최신 업데이트 시간 유지
|
|
if (rel.updated_date && rel.updated_date > diagram.updatedAt) {
|
|
diagram.updatedAt = rel.updated_date;
|
|
diagram.updatedBy = rel.updated_by;
|
|
}
|
|
});
|
|
|
|
// Set을 배열로 변환하고 테이블 개수 계산
|
|
const diagrams = Array.from(diagramMap.values()).map((diagram) => ({
|
|
...diagram,
|
|
tableCount: diagram.tableCount.size,
|
|
tables: Array.from(diagram.tableCount),
|
|
}));
|
|
|
|
// 페이징 처리
|
|
const total = diagrams.length;
|
|
const startIndex = (page - 1) * size;
|
|
const endIndex = startIndex + size;
|
|
const paginatedDiagrams = diagrams.slice(startIndex, endIndex);
|
|
|
|
const result = {
|
|
diagrams: paginatedDiagrams,
|
|
total,
|
|
page,
|
|
size,
|
|
totalPages: Math.ceil(total / size),
|
|
hasNext: page < Math.ceil(total / size),
|
|
hasPrev: page > 1,
|
|
};
|
|
|
|
logger.info(
|
|
`DataflowService: 관계도 목록 조회 완료 - 총 ${total}개 관계도 중 ${paginatedDiagrams.length}개 조회`
|
|
);
|
|
|
|
return result;
|
|
} catch (error) {
|
|
logger.error("DataflowService: 관계도 목록 조회 실패", error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 특정 관계도의 모든 관계 조회
|
|
*/
|
|
async getDiagramRelationships(companyCode: string, diagramName: string) {
|
|
try {
|
|
logger.info(
|
|
`DataflowService: 관계도 관계 조회 시작 - ${companyCode}, diagram: ${diagramName}`
|
|
);
|
|
|
|
const relationships = await prisma.table_relationships.findMany({
|
|
where: {
|
|
company_code: companyCode,
|
|
relationship_name: diagramName,
|
|
is_active: "Y",
|
|
},
|
|
orderBy: {
|
|
created_date: "asc",
|
|
},
|
|
});
|
|
|
|
logger.info(
|
|
`DataflowService: 관계도 관계 조회 완료 - ${diagramName}, ${relationships.length}개 관계`
|
|
);
|
|
|
|
return relationships;
|
|
} catch (error) {
|
|
logger.error(
|
|
`DataflowService: 관계도 관계 조회 실패 - ${diagramName}`,
|
|
error
|
|
);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 관계도 복사 (diagram_id 기반)
|
|
*/
|
|
async copyDiagram(
|
|
companyCode: string,
|
|
originalDiagramName: string
|
|
): Promise<string> {
|
|
try {
|
|
logger.info(`DataflowService: 관계도 복사 시작 - ${originalDiagramName}`);
|
|
|
|
// 원본 관계도의 모든 관계 조회
|
|
const originalRelationships = await prisma.table_relationships.findMany({
|
|
where: {
|
|
company_code: companyCode,
|
|
relationship_name: originalDiagramName,
|
|
is_active: "Y",
|
|
},
|
|
});
|
|
|
|
if (originalRelationships.length === 0) {
|
|
throw new Error("복사할 관계도를 찾을 수 없습니다.");
|
|
}
|
|
|
|
// 새로운 관계도 이름 생성 (중복 검사)
|
|
let newDiagramName = `${originalDiagramName} (1)`;
|
|
let counter = 1;
|
|
|
|
while (true) {
|
|
const existingDiagram = await prisma.table_relationships.findFirst({
|
|
where: {
|
|
company_code: companyCode,
|
|
relationship_name: newDiagramName,
|
|
is_active: "Y",
|
|
},
|
|
});
|
|
|
|
if (!existingDiagram) {
|
|
break;
|
|
}
|
|
|
|
counter++;
|
|
newDiagramName = `${originalDiagramName} (${counter})`;
|
|
}
|
|
|
|
// 새로운 diagram_id 생성
|
|
const maxDiagramId = await prisma.table_relationships.findFirst({
|
|
where: {
|
|
company_code: companyCode,
|
|
},
|
|
orderBy: {
|
|
diagram_id: "desc",
|
|
},
|
|
select: {
|
|
diagram_id: true,
|
|
},
|
|
});
|
|
|
|
const newDiagramId = (maxDiagramId?.diagram_id || 0) + 1;
|
|
|
|
// 트랜잭션으로 모든 관계 복사
|
|
const copiedRelationships = await prisma.$transaction(
|
|
originalRelationships.map((rel) =>
|
|
prisma.table_relationships.create({
|
|
data: {
|
|
diagram_id: newDiagramId,
|
|
relationship_name: newDiagramName,
|
|
from_table_name: rel.from_table_name,
|
|
from_column_name: rel.from_column_name,
|
|
to_table_name: rel.to_table_name,
|
|
to_column_name: rel.to_column_name,
|
|
relationship_type: rel.relationship_type,
|
|
connection_type: rel.connection_type,
|
|
settings: rel.settings as any,
|
|
company_code: rel.company_code,
|
|
is_active: "Y",
|
|
created_by: rel.created_by,
|
|
updated_by: rel.updated_by,
|
|
},
|
|
})
|
|
)
|
|
);
|
|
|
|
logger.info(
|
|
`DataflowService: 관계도 복사 완료 - ${originalDiagramName} → ${newDiagramName} (diagram_id: ${newDiagramId}), ${copiedRelationships.length}개 관계 복사`
|
|
);
|
|
|
|
return newDiagramName;
|
|
} catch (error) {
|
|
logger.error(
|
|
`DataflowService: 관계도 복사 실패 - ${originalDiagramName}`,
|
|
error
|
|
);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 관계도 삭제
|
|
*/
|
|
async deleteDiagram(
|
|
companyCode: string,
|
|
diagramName: string
|
|
): Promise<number> {
|
|
try {
|
|
logger.info(`DataflowService: 관계도 삭제 시작 - ${diagramName}`);
|
|
|
|
// 관계도의 모든 관계 삭제 (하드 삭제)
|
|
const deleteResult = await prisma.table_relationships.deleteMany({
|
|
where: {
|
|
company_code: companyCode,
|
|
relationship_name: diagramName,
|
|
},
|
|
});
|
|
|
|
logger.info(
|
|
`DataflowService: 관계도 삭제 완료 - ${diagramName}, ${deleteResult.count}개 관계 삭제`
|
|
);
|
|
|
|
return deleteResult.count;
|
|
} catch (error) {
|
|
logger.error(`DataflowService: 관계도 삭제 실패 - ${diagramName}`, error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* diagram_id로 해당 관계도의 모든 관계 조회
|
|
*/
|
|
async getDiagramRelationshipsByDiagramId(
|
|
companyCode: string,
|
|
diagramId: number
|
|
) {
|
|
try {
|
|
logger.info(
|
|
`DataflowService: diagram_id로 관계도 관계 조회 - ${diagramId}`
|
|
);
|
|
|
|
// diagram_id로 모든 관계 조회
|
|
const relationships = await prisma.table_relationships.findMany({
|
|
where: {
|
|
diagram_id: diagramId,
|
|
company_code: companyCode,
|
|
is_active: "Y",
|
|
},
|
|
orderBy: [{ relationship_id: "asc" }],
|
|
});
|
|
|
|
logger.info(
|
|
`DataflowService: diagram_id로 관계도 관계 조회 완료 - ${relationships.length}개 관계`
|
|
);
|
|
|
|
return relationships.map((rel) => ({
|
|
...rel,
|
|
settings: rel.settings as any,
|
|
}));
|
|
} catch (error) {
|
|
logger.error(
|
|
`DataflowService: diagram_id로 관계도 관계 조회 실패 - ${diagramId}`,
|
|
error
|
|
);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* relationship_id로 해당 관계도의 모든 관계 조회 (하위 호환성 유지)
|
|
*/
|
|
async getDiagramRelationshipsByRelationshipId(
|
|
companyCode: string,
|
|
relationshipId: number
|
|
) {
|
|
try {
|
|
logger.info(
|
|
`DataflowService: relationship_id로 관계도 관계 조회 - ${relationshipId}`
|
|
);
|
|
|
|
// 먼저 해당 relationship_id의 diagram_id를 찾음
|
|
const targetRelationship = await prisma.table_relationships.findFirst({
|
|
where: {
|
|
relationship_id: relationshipId,
|
|
company_code: companyCode,
|
|
is_active: "Y",
|
|
},
|
|
select: {
|
|
diagram_id: true,
|
|
},
|
|
});
|
|
|
|
if (!targetRelationship) {
|
|
throw new Error("해당 관계 ID를 찾을 수 없습니다.");
|
|
}
|
|
|
|
// diagram_id로 모든 관계 조회
|
|
return this.getDiagramRelationshipsByDiagramId(
|
|
companyCode,
|
|
targetRelationship.diagram_id
|
|
);
|
|
} catch (error) {
|
|
logger.error(
|
|
`DataflowService: relationship_id로 관계도 관계 조회 실패 - ${relationshipId}`,
|
|
error
|
|
);
|
|
throw error;
|
|
}
|
|
}
|
|
}
|