427 lines
14 KiB
TypeScript
427 lines
14 KiB
TypeScript
import { apiClient } from "./client";
|
|
import {
|
|
ScreenDefinition,
|
|
CreateScreenRequest,
|
|
UpdateScreenRequest,
|
|
PaginatedResponse,
|
|
ScreenTemplate,
|
|
LayoutData,
|
|
} from "@/types/screen";
|
|
|
|
// 화면 정의 관련 API
|
|
export const screenApi = {
|
|
// 화면 목록 조회
|
|
getScreens: async (params: {
|
|
page?: number;
|
|
size?: number;
|
|
companyCode?: string;
|
|
searchTerm?: string;
|
|
}): Promise<PaginatedResponse<ScreenDefinition>> => {
|
|
const response = await apiClient.get("/screen-management/screens", { params });
|
|
const raw = response.data || {};
|
|
const items: any[] = (raw.data ?? raw.items ?? []) as any[];
|
|
const mapped: ScreenDefinition[] = items.map((it) => ({
|
|
...it,
|
|
// 문자열로 온 날짜를 Date 객체로 변환 (이미 Date이면 그대로 유지)
|
|
createdDate: it.createdDate ? new Date(it.createdDate) : undefined,
|
|
updatedDate: it.updatedDate ? new Date(it.updatedDate) : undefined,
|
|
}));
|
|
|
|
const page = raw.page ?? params.page ?? 1;
|
|
const size = raw.size ?? params.size ?? mapped.length;
|
|
const total = raw.total ?? mapped.length;
|
|
const totalPages = raw.totalPages ?? Math.max(1, Math.ceil(total / (size || 1)));
|
|
|
|
return { data: mapped, total, page, size, totalPages };
|
|
},
|
|
|
|
// 화면 상세 조회
|
|
getScreen: async (screenId: number): Promise<ScreenDefinition> => {
|
|
const response = await apiClient.get(`/screen-management/screens/${screenId}`);
|
|
const raw = response.data?.data || response.data;
|
|
return {
|
|
...raw,
|
|
createdDate: raw?.createdDate ? new Date(raw.createdDate) : undefined,
|
|
updatedDate: raw?.updatedDate ? new Date(raw.updatedDate) : undefined,
|
|
} as ScreenDefinition;
|
|
},
|
|
|
|
// 화면에 할당된 메뉴 조회
|
|
getScreenMenu: async (screenId: number): Promise<{ menuObjid: number; menuName?: string } | null> => {
|
|
const response = await apiClient.get(`/screen-management/screens/${screenId}/menu`);
|
|
return response.data?.data || null;
|
|
},
|
|
|
|
// 화면 생성
|
|
createScreen: async (screenData: CreateScreenRequest): Promise<ScreenDefinition> => {
|
|
const response = await apiClient.post("/screen-management/screens", screenData);
|
|
return response.data.data;
|
|
},
|
|
|
|
// 화면 코드 자동 생성 (회사코드 + 순번)
|
|
generateScreenCode: async (companyCode: string): Promise<string> => {
|
|
const response = await apiClient.get(`/screen-management/generate-screen-code/${companyCode}`);
|
|
return response.data.data.screenCode;
|
|
},
|
|
|
|
// 여러 개의 화면 코드 일괄 생성
|
|
generateMultipleScreenCodes: async (companyCode: string, count: number): Promise<string[]> => {
|
|
const response = await apiClient.post("/screen-management/generate-screen-codes", {
|
|
companyCode,
|
|
count,
|
|
});
|
|
return response.data.data.screenCodes;
|
|
},
|
|
|
|
// 화면 수정
|
|
updateScreen: async (screenId: number, screenData: UpdateScreenRequest): Promise<ScreenDefinition> => {
|
|
const response = await apiClient.put(`/screen-management/screens/${screenId}`, screenData);
|
|
return response.data.data;
|
|
},
|
|
|
|
// 화면 정보 수정 (메타데이터만)
|
|
updateScreenInfo: async (
|
|
screenId: number,
|
|
data: { screenName: string; description?: string; isActive: string },
|
|
): Promise<void> => {
|
|
await apiClient.put(`/screen-management/screens/${screenId}/info`, data);
|
|
},
|
|
|
|
// 화면 의존성 체크
|
|
checkScreenDependencies: async (
|
|
screenId: number,
|
|
): Promise<{
|
|
hasDependencies: boolean;
|
|
dependencies: Array<{
|
|
screenId: number;
|
|
screenName: string;
|
|
screenCode: string;
|
|
componentId: string;
|
|
componentType: string;
|
|
referenceType: string;
|
|
}>;
|
|
}> => {
|
|
const response = await apiClient.get(`/screen-management/screens/${screenId}/dependencies`);
|
|
return response.data;
|
|
},
|
|
|
|
// 화면 삭제 (휴지통으로 이동)
|
|
deleteScreen: async (screenId: number, deleteReason?: string, force?: boolean): Promise<void> => {
|
|
await apiClient.delete(`/screen-management/screens/${screenId}`, {
|
|
data: { deleteReason, force },
|
|
});
|
|
},
|
|
|
|
// 휴지통 화면 목록 조회
|
|
getDeletedScreens: async (params: {
|
|
page?: number;
|
|
size?: number;
|
|
}): Promise<
|
|
PaginatedResponse<ScreenDefinition & { deletedDate?: Date; deletedBy?: string; deleteReason?: string }>
|
|
> => {
|
|
const response = await apiClient.get("/screen-management/screens/trash/list", { params });
|
|
const raw = response.data || {};
|
|
const items: any[] = (raw.data ?? raw.items ?? []) as any[];
|
|
const mapped = items.map((it) => ({
|
|
...it,
|
|
createdDate: it.createdDate ? new Date(it.createdDate) : undefined,
|
|
updatedDate: it.updatedDate ? new Date(it.updatedDate) : undefined,
|
|
deletedDate: it.deletedDate ? new Date(it.deletedDate) : undefined,
|
|
}));
|
|
|
|
const page = raw.page ?? params.page ?? 1;
|
|
const size = raw.size ?? params.size ?? mapped.length;
|
|
const total = raw.total ?? mapped.length;
|
|
const totalPages = raw.totalPages ?? Math.max(1, Math.ceil(total / (size || 1)));
|
|
|
|
return { data: mapped, total, page, size, totalPages };
|
|
},
|
|
|
|
// 휴지통 화면 일괄 영구 삭제
|
|
bulkPermanentDeleteScreens: async (
|
|
screenIds: number[],
|
|
): Promise<{
|
|
deletedCount: number;
|
|
skippedCount: number;
|
|
errors: Array<{ screenId: number; error: string }>;
|
|
}> => {
|
|
const response = await apiClient.delete("/screen-management/screens/trash/bulk", {
|
|
data: { screenIds },
|
|
});
|
|
return response.data.result;
|
|
},
|
|
|
|
// 화면 복원 (휴지통에서 복원)
|
|
restoreScreen: async (screenId: number): Promise<void> => {
|
|
await apiClient.post(`/screen-management/screens/${screenId}/restore`);
|
|
},
|
|
|
|
// 화면 영구 삭제
|
|
permanentDeleteScreen: async (screenId: number): Promise<void> => {
|
|
await apiClient.delete(`/screen-management/screens/${screenId}/permanent`);
|
|
},
|
|
|
|
// 화면 레이아웃 저장
|
|
saveLayout: async (screenId: number, layoutData: LayoutData): Promise<void> => {
|
|
await apiClient.post(`/screen-management/screens/${screenId}/layout`, layoutData);
|
|
},
|
|
|
|
// 화면 레이아웃 저장 (ScreenDesigner_new.tsx용)
|
|
saveScreenLayout: async (screenId: number, layoutData: LayoutData): Promise<ApiResponse<void>> => {
|
|
const response = await apiClient.post(`/screen-management/screens/${screenId}/layout`, layoutData);
|
|
return response.data;
|
|
},
|
|
|
|
// 화면 레이아웃 조회
|
|
getLayout: async (screenId: number): Promise<LayoutData> => {
|
|
const response = await apiClient.get(`/screen-management/screens/${screenId}/layout`);
|
|
return response.data.data;
|
|
},
|
|
|
|
// 연결된 모달 화면 감지
|
|
detectLinkedModals: async (
|
|
screenId: number
|
|
): Promise<Array<{ screenId: number; screenName: string; screenCode: string }>> => {
|
|
const response = await apiClient.get(`/screen-management/screens/${screenId}/linked-modals`);
|
|
return response.data.data || [];
|
|
},
|
|
|
|
// 화면명 중복 체크
|
|
checkDuplicateScreenName: async (companyCode: string, screenName: string): Promise<boolean> => {
|
|
const response = await apiClient.post("/screen-management/screens/check-duplicate-name", {
|
|
companyCode,
|
|
screenName,
|
|
});
|
|
return response.data.data.isDuplicate || false;
|
|
},
|
|
|
|
// 화면 복사 (화면정보 + 레이아웃 모두 복사)
|
|
copyScreen: async (
|
|
sourceScreenId: number,
|
|
copyData: {
|
|
screenName: string;
|
|
screenCode: string;
|
|
description?: string;
|
|
},
|
|
): Promise<ScreenDefinition> => {
|
|
const response = await apiClient.post(`/screen-management/screens/${sourceScreenId}/copy`, copyData);
|
|
return response.data.data;
|
|
},
|
|
|
|
// 메인 화면 + 모달 화면들 일괄 복사
|
|
copyScreenWithModals: async (
|
|
sourceScreenId: number,
|
|
copyData: {
|
|
targetCompanyCode?: string; // 최고 관리자 전용: 다른 회사로 복사
|
|
mainScreen: {
|
|
screenName: string;
|
|
screenCode: string;
|
|
description?: string;
|
|
};
|
|
modalScreens: Array<{
|
|
sourceScreenId: number;
|
|
screenName: string;
|
|
screenCode: string;
|
|
}>;
|
|
}
|
|
): Promise<{
|
|
mainScreen: ScreenDefinition;
|
|
modalScreens: ScreenDefinition[];
|
|
}> => {
|
|
const response = await apiClient.post(
|
|
`/screen-management/screens/${sourceScreenId}/copy-with-modals`,
|
|
copyData
|
|
);
|
|
return response.data.data;
|
|
},
|
|
};
|
|
|
|
// 템플릿 관련 API
|
|
export const templateApi = {
|
|
// 템플릿 목록 조회
|
|
getTemplates: async (params: {
|
|
companyCode?: string;
|
|
templateType?: string;
|
|
isPublic?: boolean;
|
|
}): Promise<ScreenTemplate[]> => {
|
|
const response = await apiClient.get("/screen-management/templates", { params });
|
|
return response.data.data;
|
|
},
|
|
|
|
// 템플릿 상세 조회
|
|
getTemplate: async (templateId: number): Promise<ScreenTemplate> => {
|
|
const response = await apiClient.get(`/screen-management/templates/${templateId}`);
|
|
return response.data.data;
|
|
},
|
|
|
|
// 템플릿 생성
|
|
createTemplate: async (templateData: Partial<ScreenTemplate>): Promise<ScreenTemplate> => {
|
|
const response = await apiClient.post("/screen-management/templates", templateData);
|
|
return response.data.data;
|
|
},
|
|
|
|
// 템플릿 수정
|
|
updateTemplate: async (templateId: number, templateData: Partial<ScreenTemplate>): Promise<ScreenTemplate> => {
|
|
const response = await apiClient.put(`/screen-management/templates/${templateId}`, templateData);
|
|
return response.data.data;
|
|
},
|
|
|
|
// 템플릿 삭제
|
|
deleteTemplate: async (templateId: number): Promise<void> => {
|
|
await apiClient.delete(`/screen-management/templates/${templateId}`);
|
|
},
|
|
};
|
|
|
|
// 테이블 타입 관련 API
|
|
export const tableTypeApi = {
|
|
// 테이블 목록 조회
|
|
getTables: async (): Promise<
|
|
Array<{ tableName: string; displayName: string; description: string; columnCount: string }>
|
|
> => {
|
|
const response = await apiClient.get("/table-management/tables");
|
|
return response.data.data;
|
|
},
|
|
|
|
// 테이블 라벨 조회
|
|
getTableLabel: async (tableName: string): Promise<{ tableLabel?: string; description?: string }> => {
|
|
try {
|
|
const response = await apiClient.get(`/table-management/tables/${tableName}/labels`);
|
|
return response.data.data || {};
|
|
} catch (error) {
|
|
// 라벨이 없으면 빈 객체 반환
|
|
return {};
|
|
}
|
|
},
|
|
|
|
// 테이블 컬럼 정보 조회 (모든 컬럼)
|
|
getColumns: async (tableName: string): Promise<any[]> => {
|
|
const response = await apiClient.get(`/table-management/tables/${tableName}/columns?size=1000`);
|
|
// 새로운 API 응답 구조에 맞게 수정: { columns, total, page, size, totalPages }
|
|
const data = response.data.data || response.data;
|
|
return data.columns || data || [];
|
|
},
|
|
|
|
// 컬럼 입력 타입 정보 조회
|
|
getColumnInputTypes: async (tableName: string): Promise<any[]> => {
|
|
const response = await apiClient.get(`/table-management/tables/${tableName}/web-types`);
|
|
return response.data.data || [];
|
|
},
|
|
|
|
// 컬럼 웹 타입 설정
|
|
setColumnWebType: async (
|
|
tableName: string,
|
|
columnName: string,
|
|
webType: string,
|
|
detailSettings?: Record<string, any>,
|
|
inputType?: "direct" | "auto",
|
|
): Promise<void> => {
|
|
await apiClient.put(`/table-management/tables/${tableName}/columns/${columnName}/web-type`, {
|
|
webType,
|
|
detailSettings,
|
|
inputType,
|
|
});
|
|
},
|
|
|
|
// 테이블 데이터 조회 (페이지네이션 + 검색)
|
|
getTableData: async (
|
|
tableName: string,
|
|
params: {
|
|
page?: number;
|
|
size?: number;
|
|
search?: Record<string, any>; // 검색 조건
|
|
sortBy?: string;
|
|
sortOrder?: "asc" | "desc";
|
|
} = {},
|
|
): Promise<{
|
|
data: Record<string, any>[];
|
|
total: number;
|
|
page: number;
|
|
size: number;
|
|
totalPages: number;
|
|
}> => {
|
|
// 🔒 멀티테넌시: company_code 자동 필터링 활성화
|
|
const requestBody = {
|
|
...params,
|
|
autoFilter: {
|
|
enabled: true,
|
|
filterColumn: "company_code",
|
|
userField: "companyCode",
|
|
},
|
|
};
|
|
|
|
const response = await apiClient.post(`/table-management/tables/${tableName}/data`, requestBody);
|
|
const raw = response.data?.data || response.data;
|
|
|
|
return {
|
|
data: raw.data || [],
|
|
total: raw.total || 0,
|
|
page: raw.page || params.page || 1,
|
|
size: raw.size || params.size || 10,
|
|
totalPages: raw.totalPages || Math.ceil((raw.total || 0) / (params.size || 10)),
|
|
};
|
|
},
|
|
|
|
// 데이터 추가
|
|
addTableData: async (tableName: string, data: Record<string, any>): Promise<void> => {
|
|
await apiClient.post(`/table-management/tables/${tableName}/add`, data);
|
|
},
|
|
|
|
// 데이터 수정
|
|
editTableData: async (
|
|
tableName: string,
|
|
originalData: Record<string, any>,
|
|
updatedData: Record<string, any>,
|
|
): Promise<void> => {
|
|
await apiClient.put(`/table-management/tables/${tableName}/edit`, {
|
|
originalData,
|
|
updatedData,
|
|
});
|
|
},
|
|
|
|
// 데이터 삭제 (단일 또는 다중)
|
|
deleteTableData: async (tableName: string, data: Record<string, any>[] | { ids: string[] }): Promise<void> => {
|
|
await apiClient.delete(`/table-management/tables/${tableName}/delete`, { data });
|
|
},
|
|
|
|
// 🆕 단일 레코드 조회 (자동 입력용)
|
|
getTableRecord: async (
|
|
tableName: string,
|
|
filterColumn: string,
|
|
filterValue: any,
|
|
displayColumn: string,
|
|
): Promise<{ value: any; record: Record<string, any> }> => {
|
|
const response = await apiClient.post(`/table-management/tables/${tableName}/record`, {
|
|
filterColumn,
|
|
filterValue,
|
|
displayColumn,
|
|
});
|
|
return response.data.data;
|
|
},
|
|
};
|
|
|
|
// 메뉴-화면 할당 관련 API
|
|
export const menuScreenApi = {
|
|
// 화면을 메뉴에 할당
|
|
assignScreenToMenu: async (screenId: number, menuObjid: number, displayOrder?: number): Promise<void> => {
|
|
await apiClient.post(`/screen-management/screens/${screenId}/assign-menu`, {
|
|
menuObjid,
|
|
displayOrder,
|
|
});
|
|
},
|
|
|
|
// 메뉴별 할당된 화면 목록 조회
|
|
getScreensByMenu: async (menuObjid: number): Promise<ScreenDefinition[]> => {
|
|
const response = await apiClient.get(`/screen-management/menus/${menuObjid}/screens`);
|
|
return response.data.data.map((screen: any) => ({
|
|
...screen,
|
|
createdDate: screen.createdDate ? new Date(screen.createdDate) : new Date(),
|
|
updatedDate: screen.updatedDate ? new Date(screen.updatedDate) : new Date(),
|
|
}));
|
|
},
|
|
|
|
// 화면-메뉴 할당 해제
|
|
unassignScreenFromMenu: async (screenId: number, menuObjid: number): Promise<void> => {
|
|
await apiClient.delete(`/screen-management/screens/${screenId}/menus/${menuObjid}`);
|
|
},
|
|
};
|