887 lines
29 KiB
TypeScript
887 lines
29 KiB
TypeScript
/**
|
|
* 마스터-디테일 엑셀 처리 서비스
|
|
*
|
|
* 분할 패널 화면의 마스터-디테일 구조를 자동 감지하고
|
|
* 엑셀 다운로드/업로드 시 JOIN 및 그룹화 처리를 수행합니다.
|
|
*/
|
|
|
|
import { query, queryOne, transaction, getPool } from "../database/db";
|
|
import { logger } from "../utils/logger";
|
|
|
|
// ================================
|
|
// 인터페이스 정의
|
|
// ================================
|
|
|
|
/**
|
|
* 마스터-디테일 관계 정보
|
|
*/
|
|
export interface MasterDetailRelation {
|
|
masterTable: string;
|
|
detailTable: string;
|
|
masterKeyColumn: string; // 마스터 테이블의 키 컬럼 (예: order_no)
|
|
detailFkColumn: string; // 디테일 테이블의 FK 컬럼 (예: order_no)
|
|
masterColumns: ColumnInfo[];
|
|
detailColumns: ColumnInfo[];
|
|
}
|
|
|
|
/**
|
|
* 컬럼 정보
|
|
*/
|
|
export interface ColumnInfo {
|
|
name: string;
|
|
label: string;
|
|
inputType: string;
|
|
isFromMaster: boolean;
|
|
}
|
|
|
|
/**
|
|
* 분할 패널 설정
|
|
*/
|
|
export interface SplitPanelConfig {
|
|
leftPanel: {
|
|
tableName: string;
|
|
columns: Array<{ name: string; label: string; width?: number }>;
|
|
};
|
|
rightPanel: {
|
|
tableName: string;
|
|
columns: Array<{ name: string; label: string; width?: number }>;
|
|
relation?: {
|
|
type: string;
|
|
foreignKey?: string;
|
|
leftColumn?: string;
|
|
// 복합키 지원 (새로운 방식)
|
|
keys?: Array<{
|
|
leftColumn: string;
|
|
rightColumn: string;
|
|
}>;
|
|
};
|
|
};
|
|
}
|
|
|
|
/**
|
|
* 엑셀 다운로드 결과
|
|
*/
|
|
export interface ExcelDownloadData {
|
|
headers: string[]; // 컬럼 라벨들
|
|
columns: string[]; // 컬럼명들
|
|
data: Record<string, any>[];
|
|
masterColumns: string[]; // 마스터 컬럼 목록
|
|
detailColumns: string[]; // 디테일 컬럼 목록
|
|
joinKey: string; // 조인 키
|
|
}
|
|
|
|
/**
|
|
* 엑셀 업로드 결과
|
|
*/
|
|
export interface ExcelUploadResult {
|
|
success: boolean;
|
|
masterInserted: number;
|
|
masterUpdated: number;
|
|
detailInserted: number;
|
|
detailDeleted: number;
|
|
errors: string[];
|
|
}
|
|
|
|
// ================================
|
|
// 서비스 클래스
|
|
// ================================
|
|
|
|
class MasterDetailExcelService {
|
|
|
|
/**
|
|
* 화면 ID로 분할 패널 설정 조회
|
|
*/
|
|
async getSplitPanelConfig(screenId: number): Promise<SplitPanelConfig | null> {
|
|
try {
|
|
logger.info(`분할 패널 설정 조회: screenId=${screenId}`);
|
|
|
|
// screen_layouts에서 split-panel-layout 컴포넌트 찾기
|
|
const result = await queryOne<any>(
|
|
`SELECT properties->>'componentConfig' as config
|
|
FROM screen_layouts
|
|
WHERE screen_id = $1
|
|
AND component_type = 'component'
|
|
AND properties->>'componentType' = 'split-panel-layout'
|
|
LIMIT 1`,
|
|
[screenId]
|
|
);
|
|
|
|
if (!result || !result.config) {
|
|
logger.info(`분할 패널 없음: screenId=${screenId}`);
|
|
return null;
|
|
}
|
|
|
|
const config = typeof result.config === "string"
|
|
? JSON.parse(result.config)
|
|
: result.config;
|
|
|
|
logger.info(`분할 패널 설정 발견:`, {
|
|
leftTable: config.leftPanel?.tableName,
|
|
rightTable: config.rightPanel?.tableName,
|
|
relation: config.rightPanel?.relation,
|
|
});
|
|
|
|
return {
|
|
leftPanel: config.leftPanel,
|
|
rightPanel: config.rightPanel,
|
|
};
|
|
} catch (error: any) {
|
|
logger.error(`분할 패널 설정 조회 실패: ${error.message}`);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* column_labels에서 Entity 관계 정보 조회
|
|
* 디테일 테이블에서 마스터 테이블을 참조하는 컬럼 찾기
|
|
*/
|
|
async getEntityRelation(
|
|
detailTable: string,
|
|
masterTable: string
|
|
): Promise<{ detailFkColumn: string; masterKeyColumn: string } | null> {
|
|
try {
|
|
logger.info(`Entity 관계 조회: ${detailTable} -> ${masterTable}`);
|
|
|
|
const result = await queryOne<any>(
|
|
`SELECT column_name, reference_column
|
|
FROM column_labels
|
|
WHERE table_name = $1
|
|
AND input_type = 'entity'
|
|
AND reference_table = $2
|
|
LIMIT 1`,
|
|
[detailTable, masterTable]
|
|
);
|
|
|
|
if (!result) {
|
|
logger.warn(`Entity 관계 없음: ${detailTable} -> ${masterTable}`);
|
|
return null;
|
|
}
|
|
|
|
logger.info(`Entity 관계 발견: ${detailTable}.${result.column_name} -> ${masterTable}.${result.reference_column}`);
|
|
|
|
return {
|
|
detailFkColumn: result.column_name,
|
|
masterKeyColumn: result.reference_column,
|
|
};
|
|
} catch (error: any) {
|
|
logger.error(`Entity 관계 조회 실패: ${error.message}`);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 테이블의 컬럼 라벨 정보 조회
|
|
*/
|
|
async getColumnLabels(tableName: string): Promise<Map<string, string>> {
|
|
try {
|
|
const result = await query<any>(
|
|
`SELECT column_name, column_label
|
|
FROM column_labels
|
|
WHERE table_name = $1`,
|
|
[tableName]
|
|
);
|
|
|
|
const labelMap = new Map<string, string>();
|
|
for (const row of result) {
|
|
labelMap.set(row.column_name, row.column_label || row.column_name);
|
|
}
|
|
|
|
return labelMap;
|
|
} catch (error: any) {
|
|
logger.error(`컬럼 라벨 조회 실패: ${error.message}`);
|
|
return new Map();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 마스터-디테일 관계 정보 조합
|
|
*/
|
|
async getMasterDetailRelation(
|
|
screenId: number
|
|
): Promise<MasterDetailRelation | null> {
|
|
try {
|
|
// 1. 분할 패널 설정 조회
|
|
const splitPanel = await this.getSplitPanelConfig(screenId);
|
|
if (!splitPanel) {
|
|
return null;
|
|
}
|
|
|
|
const masterTable = splitPanel.leftPanel.tableName;
|
|
const detailTable = splitPanel.rightPanel.tableName;
|
|
|
|
if (!masterTable || !detailTable) {
|
|
logger.warn("마스터 또는 디테일 테이블명 없음");
|
|
return null;
|
|
}
|
|
|
|
// 2. 분할 패널의 relation 정보가 있으면 우선 사용
|
|
// 🔥 keys 배열을 우선 사용 (새로운 복합키 지원 방식)
|
|
let masterKeyColumn: string | undefined;
|
|
let detailFkColumn: string | undefined;
|
|
|
|
const relationKeys = splitPanel.rightPanel.relation?.keys;
|
|
if (relationKeys && relationKeys.length > 0) {
|
|
// keys 배열에서 첫 번째 키 사용
|
|
masterKeyColumn = relationKeys[0].leftColumn;
|
|
detailFkColumn = relationKeys[0].rightColumn;
|
|
logger.info(`keys 배열에서 관계 정보 사용: ${masterKeyColumn} -> ${detailFkColumn}`);
|
|
} else {
|
|
// 하위 호환성: 기존 leftColumn/foreignKey 사용
|
|
masterKeyColumn = splitPanel.rightPanel.relation?.leftColumn;
|
|
detailFkColumn = splitPanel.rightPanel.relation?.foreignKey;
|
|
}
|
|
|
|
// 3. relation 정보가 없으면 column_labels에서 Entity 관계 조회
|
|
if (!masterKeyColumn || !detailFkColumn) {
|
|
const entityRelation = await this.getEntityRelation(detailTable, masterTable);
|
|
if (entityRelation) {
|
|
masterKeyColumn = entityRelation.masterKeyColumn;
|
|
detailFkColumn = entityRelation.detailFkColumn;
|
|
}
|
|
}
|
|
|
|
if (!masterKeyColumn || !detailFkColumn) {
|
|
logger.warn("조인 키 정보를 찾을 수 없음");
|
|
return null;
|
|
}
|
|
|
|
// 4. 컬럼 라벨 정보 조회
|
|
const masterLabels = await this.getColumnLabels(masterTable);
|
|
const detailLabels = await this.getColumnLabels(detailTable);
|
|
|
|
// 5. 마스터 컬럼 정보 구성
|
|
const masterColumns: ColumnInfo[] = splitPanel.leftPanel.columns.map(col => ({
|
|
name: col.name,
|
|
label: masterLabels.get(col.name) || col.label || col.name,
|
|
inputType: "text",
|
|
isFromMaster: true,
|
|
}));
|
|
|
|
// 6. 디테일 컬럼 정보 구성 (FK 컬럼 제외)
|
|
const detailColumns: ColumnInfo[] = splitPanel.rightPanel.columns
|
|
.filter(col => col.name !== detailFkColumn) // FK 컬럼 제외
|
|
.map(col => ({
|
|
name: col.name,
|
|
label: detailLabels.get(col.name) || col.label || col.name,
|
|
inputType: "text",
|
|
isFromMaster: false,
|
|
}));
|
|
|
|
logger.info(`마스터-디테일 관계 구성 완료:`, {
|
|
masterTable,
|
|
detailTable,
|
|
masterKeyColumn,
|
|
detailFkColumn,
|
|
masterColumnCount: masterColumns.length,
|
|
detailColumnCount: detailColumns.length,
|
|
});
|
|
|
|
return {
|
|
masterTable,
|
|
detailTable,
|
|
masterKeyColumn,
|
|
detailFkColumn,
|
|
masterColumns,
|
|
detailColumns,
|
|
};
|
|
} catch (error: any) {
|
|
logger.error(`마스터-디테일 관계 조회 실패: ${error.message}`);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 마스터-디테일 JOIN 데이터 조회 (엑셀 다운로드용)
|
|
*/
|
|
async getJoinedData(
|
|
relation: MasterDetailRelation,
|
|
companyCode: string,
|
|
filters?: Record<string, any>
|
|
): Promise<ExcelDownloadData> {
|
|
try {
|
|
const { masterTable, detailTable, masterKeyColumn, detailFkColumn, masterColumns, detailColumns } = relation;
|
|
|
|
// 조인 컬럼과 일반 컬럼 분리
|
|
// 조인 컬럼 형식: "테이블명.컬럼명" (예: customer_mng.customer_name)
|
|
const entityJoins: Array<{
|
|
refTable: string;
|
|
refColumn: string;
|
|
sourceColumn: string;
|
|
alias: string;
|
|
displayColumn: string;
|
|
}> = [];
|
|
|
|
// SELECT 절 구성
|
|
const selectParts: string[] = [];
|
|
let aliasIndex = 0;
|
|
|
|
// 마스터 컬럼 처리
|
|
for (const col of masterColumns) {
|
|
if (col.name.includes(".")) {
|
|
// 조인 컬럼: 테이블명.컬럼명
|
|
const [refTable, displayColumn] = col.name.split(".");
|
|
const alias = `ej${aliasIndex++}`;
|
|
|
|
// column_labels에서 FK 컬럼 찾기
|
|
const fkColumn = await this.findForeignKeyColumn(masterTable, refTable);
|
|
if (fkColumn) {
|
|
entityJoins.push({
|
|
refTable,
|
|
refColumn: fkColumn.referenceColumn,
|
|
sourceColumn: fkColumn.sourceColumn,
|
|
alias,
|
|
displayColumn,
|
|
});
|
|
selectParts.push(`${alias}."${displayColumn}" AS "${col.name}"`);
|
|
} else {
|
|
// FK를 못 찾으면 NULL로 처리
|
|
selectParts.push(`NULL AS "${col.name}"`);
|
|
}
|
|
} else {
|
|
// 일반 컬럼
|
|
selectParts.push(`m."${col.name}"`);
|
|
}
|
|
}
|
|
|
|
// 디테일 컬럼 처리
|
|
for (const col of detailColumns) {
|
|
if (col.name.includes(".")) {
|
|
// 조인 컬럼: 테이블명.컬럼명
|
|
const [refTable, displayColumn] = col.name.split(".");
|
|
const alias = `ej${aliasIndex++}`;
|
|
|
|
// column_labels에서 FK 컬럼 찾기
|
|
const fkColumn = await this.findForeignKeyColumn(detailTable, refTable);
|
|
if (fkColumn) {
|
|
entityJoins.push({
|
|
refTable,
|
|
refColumn: fkColumn.referenceColumn,
|
|
sourceColumn: fkColumn.sourceColumn,
|
|
alias,
|
|
displayColumn,
|
|
});
|
|
selectParts.push(`${alias}."${displayColumn}" AS "${col.name}"`);
|
|
} else {
|
|
selectParts.push(`NULL AS "${col.name}"`);
|
|
}
|
|
} else {
|
|
// 일반 컬럼
|
|
selectParts.push(`d."${col.name}"`);
|
|
}
|
|
}
|
|
|
|
const selectClause = selectParts.join(", ");
|
|
|
|
// 엔티티 조인 절 구성
|
|
const entityJoinClauses = entityJoins.map(ej =>
|
|
`LEFT JOIN "${ej.refTable}" ${ej.alias} ON m."${ej.sourceColumn}" = ${ej.alias}."${ej.refColumn}"`
|
|
).join("\n ");
|
|
|
|
// WHERE 절 구성
|
|
const whereConditions: string[] = [];
|
|
const params: any[] = [];
|
|
let paramIndex = 1;
|
|
|
|
// 회사 코드 필터 (최고 관리자 제외)
|
|
if (companyCode && companyCode !== "*") {
|
|
whereConditions.push(`m.company_code = $${paramIndex}`);
|
|
params.push(companyCode);
|
|
paramIndex++;
|
|
}
|
|
|
|
// 추가 필터 적용
|
|
if (filters) {
|
|
for (const [key, value] of Object.entries(filters)) {
|
|
if (value !== undefined && value !== null && value !== "") {
|
|
// 조인 컬럼인지 확인
|
|
if (key.includes(".")) continue;
|
|
// 마스터 테이블 컬럼인지 확인
|
|
const isMasterCol = masterColumns.some(c => c.name === key);
|
|
const tableAlias = isMasterCol ? "m" : "d";
|
|
whereConditions.push(`${tableAlias}."${key}" = $${paramIndex}`);
|
|
params.push(value);
|
|
paramIndex++;
|
|
}
|
|
}
|
|
}
|
|
|
|
const whereClause = whereConditions.length > 0
|
|
? `WHERE ${whereConditions.join(" AND ")}`
|
|
: "";
|
|
|
|
// JOIN 쿼리 실행
|
|
const sql = `
|
|
SELECT ${selectClause}
|
|
FROM "${masterTable}" m
|
|
LEFT JOIN "${detailTable}" d
|
|
ON m."${masterKeyColumn}" = d."${detailFkColumn}"
|
|
AND m.company_code = d.company_code
|
|
${entityJoinClauses}
|
|
${whereClause}
|
|
ORDER BY m."${masterKeyColumn}", d.id
|
|
`;
|
|
|
|
logger.info(`마스터-디테일 JOIN 쿼리:`, { sql, params });
|
|
|
|
const data = await query<any>(sql, params);
|
|
|
|
// 헤더 및 컬럼 정보 구성
|
|
const headers = [...masterColumns.map(c => c.label), ...detailColumns.map(c => c.label)];
|
|
const columns = [...masterColumns.map(c => c.name), ...detailColumns.map(c => c.name)];
|
|
|
|
logger.info(`마스터-디테일 데이터 조회 완료: ${data.length}행`);
|
|
|
|
return {
|
|
headers,
|
|
columns,
|
|
data,
|
|
masterColumns: masterColumns.map(c => c.name),
|
|
detailColumns: detailColumns.map(c => c.name),
|
|
joinKey: masterKeyColumn,
|
|
};
|
|
} catch (error: any) {
|
|
logger.error(`마스터-디테일 데이터 조회 실패: ${error.message}`);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 특정 테이블에서 참조 테이블로의 FK 컬럼 찾기
|
|
*/
|
|
private async findForeignKeyColumn(
|
|
sourceTable: string,
|
|
referenceTable: string
|
|
): Promise<{ sourceColumn: string; referenceColumn: string } | null> {
|
|
try {
|
|
const result = await query<{ column_name: string; reference_column: string }>(
|
|
`SELECT column_name, reference_column
|
|
FROM column_labels
|
|
WHERE table_name = $1
|
|
AND reference_table = $2
|
|
AND input_type = 'entity'
|
|
LIMIT 1`,
|
|
[sourceTable, referenceTable]
|
|
);
|
|
|
|
if (result.length > 0) {
|
|
return {
|
|
sourceColumn: result[0].column_name,
|
|
referenceColumn: result[0].reference_column,
|
|
};
|
|
}
|
|
return null;
|
|
} catch (error) {
|
|
logger.error(`FK 컬럼 조회 실패: ${sourceTable} -> ${referenceTable}`, error);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 마스터-디테일 데이터 업로드 (엑셀 업로드용)
|
|
*
|
|
* 처리 로직:
|
|
* 1. 엑셀 데이터를 마스터 키로 그룹화
|
|
* 2. 각 그룹의 첫 번째 행에서 마스터 데이터 추출 → UPSERT
|
|
* 3. 해당 마스터 키의 기존 디테일 삭제
|
|
* 4. 새 디테일 데이터 INSERT
|
|
*/
|
|
async uploadJoinedData(
|
|
relation: MasterDetailRelation,
|
|
data: Record<string, any>[],
|
|
companyCode: string,
|
|
userId?: string
|
|
): Promise<ExcelUploadResult> {
|
|
const result: ExcelUploadResult = {
|
|
success: false,
|
|
masterInserted: 0,
|
|
masterUpdated: 0,
|
|
detailInserted: 0,
|
|
detailDeleted: 0,
|
|
errors: [],
|
|
};
|
|
|
|
const pool = getPool();
|
|
const client = await pool.connect();
|
|
|
|
try {
|
|
await client.query("BEGIN");
|
|
|
|
const { masterTable, detailTable, masterKeyColumn, detailFkColumn, masterColumns, detailColumns } = relation;
|
|
|
|
// 1. 데이터를 마스터 키로 그룹화
|
|
const groupedData = new Map<string, Record<string, any>[]>();
|
|
|
|
for (const row of data) {
|
|
const masterKey = row[masterKeyColumn];
|
|
if (!masterKey) {
|
|
result.errors.push(`마스터 키(${masterKeyColumn}) 값이 없는 행이 있습니다.`);
|
|
continue;
|
|
}
|
|
|
|
if (!groupedData.has(masterKey)) {
|
|
groupedData.set(masterKey, []);
|
|
}
|
|
groupedData.get(masterKey)!.push(row);
|
|
}
|
|
|
|
logger.info(`데이터 그룹화 완료: ${groupedData.size}개 마스터 그룹`);
|
|
|
|
// 2. 각 그룹 처리
|
|
for (const [masterKey, rows] of groupedData.entries()) {
|
|
try {
|
|
// 2a. 마스터 데이터 추출 (첫 번째 행에서)
|
|
const masterData: Record<string, any> = {};
|
|
for (const col of masterColumns) {
|
|
if (rows[0][col.name] !== undefined) {
|
|
masterData[col.name] = rows[0][col.name];
|
|
}
|
|
}
|
|
|
|
// 회사 코드, 작성자 추가
|
|
masterData.company_code = companyCode;
|
|
if (userId) {
|
|
masterData.writer = userId;
|
|
}
|
|
|
|
// 2b. 마스터 UPSERT
|
|
const existingMaster = await client.query(
|
|
`SELECT id FROM "${masterTable}" WHERE "${masterKeyColumn}" = $1 AND company_code = $2`,
|
|
[masterKey, companyCode]
|
|
);
|
|
|
|
if (existingMaster.rows.length > 0) {
|
|
// UPDATE
|
|
const updateCols = Object.keys(masterData)
|
|
.filter(k => k !== masterKeyColumn && k !== "id")
|
|
.map((k, i) => `"${k}" = $${i + 1}`);
|
|
const updateValues = Object.keys(masterData)
|
|
.filter(k => k !== masterKeyColumn && k !== "id")
|
|
.map(k => masterData[k]);
|
|
|
|
if (updateCols.length > 0) {
|
|
await client.query(
|
|
`UPDATE "${masterTable}"
|
|
SET ${updateCols.join(", ")}, updated_date = NOW()
|
|
WHERE "${masterKeyColumn}" = $${updateValues.length + 1} AND company_code = $${updateValues.length + 2}`,
|
|
[...updateValues, masterKey, companyCode]
|
|
);
|
|
}
|
|
result.masterUpdated++;
|
|
} else {
|
|
// INSERT
|
|
const insertCols = Object.keys(masterData);
|
|
const insertPlaceholders = insertCols.map((_, i) => `$${i + 1}`);
|
|
const insertValues = insertCols.map(k => masterData[k]);
|
|
|
|
await client.query(
|
|
`INSERT INTO "${masterTable}" (${insertCols.map(c => `"${c}"`).join(", ")}, created_date)
|
|
VALUES (${insertPlaceholders.join(", ")}, NOW())`,
|
|
insertValues
|
|
);
|
|
result.masterInserted++;
|
|
}
|
|
|
|
// 2c. 기존 디테일 삭제
|
|
const deleteResult = await client.query(
|
|
`DELETE FROM "${detailTable}" WHERE "${detailFkColumn}" = $1 AND company_code = $2`,
|
|
[masterKey, companyCode]
|
|
);
|
|
result.detailDeleted += deleteResult.rowCount || 0;
|
|
|
|
// 2d. 새 디테일 INSERT
|
|
for (const row of rows) {
|
|
const detailData: Record<string, any> = {};
|
|
|
|
// FK 컬럼 추가
|
|
detailData[detailFkColumn] = masterKey;
|
|
detailData.company_code = companyCode;
|
|
if (userId) {
|
|
detailData.writer = userId;
|
|
}
|
|
|
|
// 디테일 컬럼 데이터 추출
|
|
for (const col of detailColumns) {
|
|
if (row[col.name] !== undefined) {
|
|
detailData[col.name] = row[col.name];
|
|
}
|
|
}
|
|
|
|
const insertCols = Object.keys(detailData);
|
|
const insertPlaceholders = insertCols.map((_, i) => `$${i + 1}`);
|
|
const insertValues = insertCols.map(k => detailData[k]);
|
|
|
|
await client.query(
|
|
`INSERT INTO "${detailTable}" (${insertCols.map(c => `"${c}"`).join(", ")}, created_date)
|
|
VALUES (${insertPlaceholders.join(", ")}, NOW())`,
|
|
insertValues
|
|
);
|
|
result.detailInserted++;
|
|
}
|
|
} catch (error: any) {
|
|
result.errors.push(`마스터 키 ${masterKey} 처리 실패: ${error.message}`);
|
|
logger.error(`마스터 키 ${masterKey} 처리 실패:`, error);
|
|
}
|
|
}
|
|
|
|
await client.query("COMMIT");
|
|
result.success = result.errors.length === 0 || result.masterInserted + result.masterUpdated > 0;
|
|
|
|
logger.info(`마스터-디테일 업로드 완료:`, {
|
|
masterInserted: result.masterInserted,
|
|
masterUpdated: result.masterUpdated,
|
|
detailInserted: result.detailInserted,
|
|
detailDeleted: result.detailDeleted,
|
|
errors: result.errors.length,
|
|
});
|
|
|
|
} catch (error: any) {
|
|
await client.query("ROLLBACK");
|
|
result.errors.push(`트랜잭션 실패: ${error.message}`);
|
|
logger.error(`마스터-디테일 업로드 트랜잭션 실패:`, error);
|
|
} finally {
|
|
client.release();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* 마스터-디테일 간단 모드 업로드
|
|
*
|
|
* 마스터 정보는 UI에서 선택하고, 엑셀은 디테일 데이터만 포함
|
|
* 채번 규칙을 통해 마스터 키 자동 생성
|
|
*
|
|
* @param screenId 화면 ID
|
|
* @param detailData 디테일 데이터 배열
|
|
* @param masterFieldValues UI에서 선택한 마스터 필드 값
|
|
* @param numberingRuleId 채번 규칙 ID (optional)
|
|
* @param companyCode 회사 코드
|
|
* @param userId 사용자 ID
|
|
* @param afterUploadFlowId 업로드 후 실행할 노드 플로우 ID (optional, 하위 호환성)
|
|
* @param afterUploadFlows 업로드 후 실행할 노드 플로우 배열 (optional)
|
|
*/
|
|
async uploadSimple(
|
|
screenId: number,
|
|
detailData: Record<string, any>[],
|
|
masterFieldValues: Record<string, any>,
|
|
numberingRuleId: string | undefined,
|
|
companyCode: string,
|
|
userId: string,
|
|
afterUploadFlowId?: string,
|
|
afterUploadFlows?: Array<{ flowId: string; order: number }>
|
|
): Promise<{
|
|
success: boolean;
|
|
masterInserted: number;
|
|
detailInserted: number;
|
|
generatedKey: string;
|
|
errors: string[];
|
|
controlResult?: any;
|
|
}> {
|
|
const result: {
|
|
success: boolean;
|
|
masterInserted: number;
|
|
detailInserted: number;
|
|
generatedKey: string;
|
|
errors: string[];
|
|
controlResult?: any;
|
|
} = {
|
|
success: false,
|
|
masterInserted: 0,
|
|
detailInserted: 0,
|
|
generatedKey: "",
|
|
errors: [] as string[],
|
|
};
|
|
|
|
const pool = getPool();
|
|
const client = await pool.connect();
|
|
|
|
try {
|
|
await client.query("BEGIN");
|
|
|
|
// 1. 마스터-디테일 관계 정보 조회
|
|
const relation = await this.getMasterDetailRelation(screenId);
|
|
if (!relation) {
|
|
throw new Error("마스터-디테일 관계 정보를 찾을 수 없습니다.");
|
|
}
|
|
|
|
const { masterTable, detailTable, masterKeyColumn, detailFkColumn } = relation;
|
|
|
|
// 2. 채번 처리
|
|
let generatedKey: string;
|
|
|
|
if (numberingRuleId) {
|
|
// 채번 규칙으로 키 생성
|
|
generatedKey = await this.generateNumberWithRule(client, numberingRuleId, companyCode);
|
|
} else {
|
|
// 채번 규칙 없으면 마스터 필드에서 키 값 사용
|
|
generatedKey = masterFieldValues[masterKeyColumn];
|
|
if (!generatedKey) {
|
|
throw new Error(`마스터 키(${masterKeyColumn}) 값이 필요합니다.`);
|
|
}
|
|
}
|
|
|
|
result.generatedKey = generatedKey;
|
|
logger.info(`채번 결과: ${generatedKey}`);
|
|
|
|
// 3. 마스터 레코드 생성
|
|
const masterData: Record<string, any> = {
|
|
...masterFieldValues,
|
|
[masterKeyColumn]: generatedKey,
|
|
company_code: companyCode,
|
|
writer: userId,
|
|
};
|
|
|
|
// 마스터 컬럼명 목록 구성
|
|
const masterCols = Object.keys(masterData).filter(k => masterData[k] !== undefined);
|
|
const masterPlaceholders = masterCols.map((_, i) => `$${i + 1}`);
|
|
const masterValues = masterCols.map(k => masterData[k]);
|
|
|
|
await client.query(
|
|
`INSERT INTO "${masterTable}" (${masterCols.map(c => `"${c}"`).join(", ")}, created_date)
|
|
VALUES (${masterPlaceholders.join(", ")}, NOW())`,
|
|
masterValues
|
|
);
|
|
result.masterInserted = 1;
|
|
logger.info(`마스터 레코드 생성: ${masterTable}, key=${generatedKey}`);
|
|
|
|
// 4. 디테일 레코드들 생성
|
|
for (const row of detailData) {
|
|
try {
|
|
const detailRowData: Record<string, any> = {
|
|
...row,
|
|
[detailFkColumn]: generatedKey,
|
|
company_code: companyCode,
|
|
writer: userId,
|
|
};
|
|
|
|
// 빈 값 필터링 및 id 제외
|
|
const detailCols = Object.keys(detailRowData).filter(k =>
|
|
k !== "id" &&
|
|
detailRowData[k] !== undefined &&
|
|
detailRowData[k] !== null &&
|
|
detailRowData[k] !== ""
|
|
);
|
|
const detailPlaceholders = detailCols.map((_, i) => `$${i + 1}`);
|
|
const detailValues = detailCols.map(k => detailRowData[k]);
|
|
|
|
await client.query(
|
|
`INSERT INTO "${detailTable}" (${detailCols.map(c => `"${c}"`).join(", ")}, created_date)
|
|
VALUES (${detailPlaceholders.join(", ")}, NOW())`,
|
|
detailValues
|
|
);
|
|
result.detailInserted++;
|
|
} catch (error: any) {
|
|
result.errors.push(`디테일 행 처리 실패: ${error.message}`);
|
|
logger.error(`디테일 행 처리 실패:`, error);
|
|
}
|
|
}
|
|
|
|
await client.query("COMMIT");
|
|
result.success = result.errors.length === 0 || result.detailInserted > 0;
|
|
|
|
logger.info(`마스터-디테일 간단 모드 업로드 완료:`, {
|
|
masterInserted: result.masterInserted,
|
|
detailInserted: result.detailInserted,
|
|
generatedKey: result.generatedKey,
|
|
errors: result.errors.length,
|
|
});
|
|
|
|
// 업로드 후 제어 실행 (단일 또는 다중)
|
|
const flowsToExecute = afterUploadFlows && afterUploadFlows.length > 0
|
|
? afterUploadFlows // 다중 제어
|
|
: afterUploadFlowId
|
|
? [{ flowId: afterUploadFlowId, order: 1 }] // 단일 (하위 호환성)
|
|
: [];
|
|
|
|
if (flowsToExecute.length > 0 && result.success) {
|
|
try {
|
|
const { NodeFlowExecutionService } = await import("./nodeFlowExecutionService");
|
|
|
|
// 마스터 데이터를 제어에 전달
|
|
const masterData = {
|
|
...masterFieldValues,
|
|
[relation!.masterKeyColumn]: result.generatedKey,
|
|
company_code: companyCode,
|
|
};
|
|
|
|
const controlResults: any[] = [];
|
|
|
|
// 순서대로 제어 실행
|
|
for (const flow of flowsToExecute.sort((a, b) => a.order - b.order)) {
|
|
logger.info(`업로드 후 제어 실행: flowId=${flow.flowId}, order=${flow.order}`);
|
|
|
|
const controlResult = await NodeFlowExecutionService.executeFlow(
|
|
parseInt(flow.flowId),
|
|
{
|
|
sourceData: [masterData],
|
|
dataSourceType: "formData",
|
|
buttonId: "excel-upload-button",
|
|
screenId: screenId,
|
|
userId: userId,
|
|
companyCode: companyCode,
|
|
formData: masterData,
|
|
}
|
|
);
|
|
|
|
controlResults.push({
|
|
flowId: flow.flowId,
|
|
order: flow.order,
|
|
success: controlResult.success,
|
|
message: controlResult.message,
|
|
executedNodes: controlResult.nodes?.length || 0,
|
|
});
|
|
}
|
|
|
|
result.controlResult = {
|
|
success: controlResults.every(r => r.success),
|
|
executedFlows: controlResults.length,
|
|
results: controlResults,
|
|
};
|
|
|
|
logger.info(`업로드 후 제어 실행 완료: ${controlResults.length}개 실행`, result.controlResult);
|
|
} catch (controlError: any) {
|
|
logger.error(`업로드 후 제어 실행 실패:`, controlError);
|
|
result.controlResult = {
|
|
success: false,
|
|
message: `제어 실행 실패: ${controlError.message}`,
|
|
};
|
|
}
|
|
}
|
|
|
|
} catch (error: any) {
|
|
await client.query("ROLLBACK");
|
|
result.errors.push(`트랜잭션 실패: ${error.message}`);
|
|
logger.error(`마스터-디테일 간단 모드 업로드 실패:`, error);
|
|
} finally {
|
|
client.release();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* 채번 규칙으로 번호 생성 (기존 numberingRuleService 사용)
|
|
*/
|
|
private async generateNumberWithRule(
|
|
client: any,
|
|
ruleId: string,
|
|
companyCode: string
|
|
): Promise<string> {
|
|
try {
|
|
// 기존 numberingRuleService를 사용하여 코드 할당
|
|
const { numberingRuleService } = await import("./numberingRuleService");
|
|
const generatedCode = await numberingRuleService.allocateCode(ruleId, companyCode);
|
|
|
|
logger.info(`채번 생성 (numberingRuleService): rule=${ruleId}, result=${generatedCode}`);
|
|
|
|
return generatedCode;
|
|
} catch (error: any) {
|
|
logger.error(`채번 생성 실패: rule=${ruleId}, error=${error.message}`);
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
|
|
export const masterDetailExcelService = new MasterDetailExcelService();
|
|
|