925 lines
33 KiB
TypeScript
925 lines
33 KiB
TypeScript
/**
|
|
* 작업자 화면 서버 액션
|
|
* API 연동 (2025-12-26 초기, 2026-02-06 options + step-progress 확장)
|
|
*
|
|
* WorkOrders API를 호출하고 WorkerScreen에 맞는 형식으로 변환
|
|
*/
|
|
|
|
'use server';
|
|
|
|
|
|
import { executeServerAction } from '@/lib/api/execute-server-action';
|
|
import { buildApiUrl } from '@/lib/api/query-params';
|
|
import type { WorkOrder, WorkOrderStatus } from '../ProductionDashboard/types';
|
|
import type { WorkItemData, WorkStepData, ProcessTab } from './types';
|
|
|
|
// ===== API 타입 =====
|
|
interface WorkOrderApiItem {
|
|
id: number;
|
|
work_order_no: string;
|
|
project_name: string | null;
|
|
process_id: number | null;
|
|
process?: {
|
|
id: number;
|
|
process_name: string;
|
|
process_code: string;
|
|
department?: string | null;
|
|
options?: {
|
|
needs_inspection?: boolean;
|
|
needs_work_log?: boolean;
|
|
} | null;
|
|
};
|
|
/** @deprecated process_id + process relation 사용 */
|
|
process_type?: 'screen' | 'slat' | 'bending';
|
|
status: 'unassigned' | 'pending' | 'waiting' | 'in_progress' | 'completed' | 'shipped';
|
|
scheduled_date: string | null;
|
|
memo: string | null;
|
|
created_at: string;
|
|
sales_order?: {
|
|
id: number;
|
|
order_no: string;
|
|
item?: { id: number; code: string; name: string } | null;
|
|
client?: { id: number; name: string };
|
|
client_contact?: string;
|
|
options?: { manager_name?: string; [key: string]: unknown };
|
|
root_nodes_count?: number;
|
|
};
|
|
team_id?: number | null;
|
|
team?: { id: number; name: string } | null;
|
|
assignee?: { id: number; name: string };
|
|
assignees?: { id: number; user_id: number; user?: { id: number; name: string } }[];
|
|
items?: {
|
|
id: number;
|
|
item_name: string;
|
|
item_id?: number | null;
|
|
item?: { id: number; code: string; name: string } | null;
|
|
quantity: number;
|
|
specification?: string | null;
|
|
options?: Record<string, unknown> | null;
|
|
source_order_item?: {
|
|
id: number;
|
|
order_node_id: number | null;
|
|
floor_code?: string | null;
|
|
symbol_code?: string | null;
|
|
node?: { id: number; name: string; code: string } | null;
|
|
} | null;
|
|
material_inputs?: {
|
|
id: number;
|
|
stock_lot_id: number;
|
|
item_id: number;
|
|
qty: number;
|
|
input_by: number | null;
|
|
input_at: string | null;
|
|
stock_lot?: { id: number; lot_no: string } | null;
|
|
item?: { id: number; code: string; name: string; unit: string } | null;
|
|
}[];
|
|
}[];
|
|
}
|
|
|
|
// ===== 상태 변환 =====
|
|
function mapApiStatus(status: WorkOrderApiItem['status']): WorkOrderStatus {
|
|
switch (status) {
|
|
case 'in_progress':
|
|
return 'inProgress';
|
|
case 'completed':
|
|
case 'shipped':
|
|
return 'completed';
|
|
default:
|
|
return 'waiting';
|
|
}
|
|
}
|
|
|
|
// ===== API → WorkOrder 변환 =====
|
|
function transformToWorkerScreenFormat(api: WorkOrderApiItem): WorkOrder {
|
|
const totalQuantity = (api.items || []).reduce((sum, item) => sum + Number(item.quantity), 0);
|
|
const productCode = (api.items?.[0]?.options?.product_code as string) || api.sales_order?.item?.code || '-';
|
|
const productName = (api.items?.[0]?.options?.product_name as string) || api.items?.[0]?.item_name || '-';
|
|
|
|
// 납기일 계산 (지연 여부)
|
|
const dueDate = api.scheduled_date || '';
|
|
const today = new Date();
|
|
today.setHours(0, 0, 0, 0);
|
|
const due = dueDate ? new Date(dueDate) : null;
|
|
const isDelayed = due ? due < today : false;
|
|
const delayDays = due && isDelayed
|
|
? Math.ceil((today.getTime() - due.getTime()) / (1000 * 60 * 60 * 24))
|
|
: undefined;
|
|
|
|
// process relation → processCode/processName 매핑
|
|
// 신규: process relation 사용, 폴백: deprecated process_type 필드
|
|
const rawProcessName = api.process?.process_name || '';
|
|
const rawProcessCode = api.process?.process_code || '';
|
|
|
|
// 한글 공정명 → 탭 키 매핑 (필터링에 사용)
|
|
const nameToTab: Record<string, { code: string; name: string }> = {
|
|
'스크린': { code: 'screen', name: '스크린' },
|
|
'슬랫': { code: 'slat', name: '슬랫' },
|
|
'절곡': { code: 'bending', name: '절곡' },
|
|
};
|
|
|
|
// 1차: process relation의 process_name으로 매핑
|
|
let processInfo = Object.entries(nameToTab).find(
|
|
([key]) => rawProcessName.includes(key)
|
|
)?.[1];
|
|
|
|
// 2차: deprecated process_type 폴백
|
|
if (!processInfo && api.process_type) {
|
|
const legacyMap: Record<string, { code: string; name: string }> = {
|
|
screen: { code: 'screen', name: '스크린' },
|
|
slat: { code: 'slat', name: '슬랫' },
|
|
bending: { code: 'bending', name: '절곡' },
|
|
};
|
|
processInfo = legacyMap[api.process_type];
|
|
}
|
|
|
|
// 3차: 그래도 없으면 원시값 사용
|
|
if (!processInfo) {
|
|
processInfo = { code: rawProcessCode || 'unknown', name: rawProcessName || '알수없음' };
|
|
}
|
|
|
|
// 아이템을 개소(order_node_id)별로 그룹핑 (floor_code/symbol_code는 표시용)
|
|
const nodeMap = new Map<string, { nodeId: number | null; nodeName: string; items: typeof api.items }>();
|
|
for (const item of (api.items || [])) {
|
|
const nodeId = item.source_order_item?.order_node_id ?? null;
|
|
const floorCode = item.source_order_item?.floor_code;
|
|
const symbolCode = item.source_order_item?.symbol_code;
|
|
const floorLabel = [floorCode, symbolCode].filter(v => v && v !== '-').join('/');
|
|
const nodeName = floorLabel || item.source_order_item?.node?.name || '미지정';
|
|
const key = nodeId != null ? String(nodeId) : (floorLabel || `unassigned-${item.id}`);
|
|
if (!nodeMap.has(key)) {
|
|
nodeMap.set(key, { nodeId, nodeName, items: [] });
|
|
}
|
|
nodeMap.get(key)!.items!.push(item);
|
|
}
|
|
|
|
const nodeGroups = Array.from(nodeMap.values()).map((g) => ({
|
|
nodeId: g.nodeId,
|
|
nodeName: g.nodeName,
|
|
items: (g.items || []).map((it) => ({
|
|
id: it.id,
|
|
itemCode: it.item?.code || null,
|
|
itemName: it.item_name,
|
|
quantity: Number(it.quantity),
|
|
specification: it.specification,
|
|
options: it.options,
|
|
materialInputs: (it.material_inputs || []).map((mi) => ({
|
|
id: mi.id,
|
|
stockLotId: mi.stock_lot_id,
|
|
lotNo: mi.stock_lot?.lot_no || null,
|
|
itemId: mi.item_id,
|
|
materialName: mi.item?.name || null,
|
|
qty: Number(mi.qty),
|
|
unit: mi.item?.unit || 'EA',
|
|
})),
|
|
})),
|
|
totalQuantity: (g.items || []).reduce((sum, it) => sum + Number(it.quantity), 0),
|
|
}));
|
|
|
|
return {
|
|
id: String(api.id),
|
|
orderNo: api.work_order_no,
|
|
productCode,
|
|
productName,
|
|
processCode: processInfo.code,
|
|
processName: processInfo.name,
|
|
client: api.sales_order?.client?.name || '-',
|
|
projectName: api.project_name || '-',
|
|
assignees: api.assignees?.length
|
|
? api.assignees.map((a) => a.user?.name || '').filter(Boolean)
|
|
: api.assignee ? [api.assignee.name] : [],
|
|
quantity: totalQuantity,
|
|
shutterCount: nodeGroups.length || api.sales_order?.root_nodes_count || 0,
|
|
dueDate,
|
|
priority: 5, // 기본 우선순위
|
|
status: mapApiStatus(api.status),
|
|
isUrgent: false, // 긴급 여부는 별도 필드 필요
|
|
isDelayed,
|
|
delayDays,
|
|
instruction: api.memo || undefined,
|
|
salesOrderNo: api.sales_order?.order_no || undefined,
|
|
salesManager: api.sales_order?.options?.manager_name as string || undefined,
|
|
managerPhone: api.sales_order?.client_contact || undefined,
|
|
teamId: api.team_id ?? null,
|
|
teamName: api.team?.name || undefined,
|
|
processDepartment: api.process?.department || undefined,
|
|
scheduledDate: api.scheduled_date || undefined,
|
|
createdAt: api.created_at,
|
|
processOptions: {
|
|
needsInspection: api.process?.options?.needs_inspection ?? false,
|
|
needsWorkLog: api.process?.options?.needs_work_log ?? false,
|
|
},
|
|
nodeGroups,
|
|
};
|
|
}
|
|
|
|
const API_URL = process.env.NEXT_PUBLIC_API_URL;
|
|
|
|
// ===== 내 작업 목록 조회 =====
|
|
export async function getMyWorkOrders(): Promise<{
|
|
success: boolean;
|
|
data: WorkOrder[];
|
|
error?: string;
|
|
}> {
|
|
interface PaginatedWO { data: WorkOrderApiItem[] }
|
|
const result = await executeServerAction<PaginatedWO>({
|
|
url: `${API_URL}/api/v1/work-orders?per_page=100&worker_screen=1`,
|
|
errorMessage: '작업 목록 조회에 실패했습니다.',
|
|
});
|
|
if (!result.success || !result.data) return { success: false, data: [], error: result.error };
|
|
const workOrders = (result.data.data || [])
|
|
.filter((item) => !['completed', 'shipped'].includes(item.status))
|
|
.map(transformToWorkerScreenFormat);
|
|
return { success: true, data: workOrders };
|
|
}
|
|
|
|
// ===== 작업 완료 처리 =====
|
|
export async function completeWorkOrder(
|
|
id: string,
|
|
materials?: { materialId: number; quantity: number; lotNo?: string }[]
|
|
): Promise<{ success: boolean; lotNo?: string; error?: string }> {
|
|
const result = await executeServerAction({
|
|
url: `${API_URL}/api/v1/work-orders/${id}/status`,
|
|
method: 'PATCH',
|
|
body: { status: 'completed', materials },
|
|
errorMessage: '작업 완료 처리에 실패했습니다.',
|
|
});
|
|
if (!result.success) return { success: false, error: result.error };
|
|
// 백엔드에서 생성한 실제 LOT 번호 사용
|
|
const lotNo = (result.data as { lot_no?: string })?.lot_no;
|
|
return { success: true, lotNo };
|
|
}
|
|
|
|
// ===== 자재 목록 조회 (로트 기준) =====
|
|
export interface MaterialForInput {
|
|
stockLotId: number | null; // StockLot ID (null이면 재고 없음)
|
|
itemId: number;
|
|
lotNo: string | null; // 실제 입고 로트번호
|
|
materialCode: string;
|
|
materialName: string;
|
|
specification: string;
|
|
unit: string;
|
|
requiredQty: number; // 필요 수량
|
|
lotAvailableQty: number; // 로트별 가용 수량
|
|
fifoRank: number;
|
|
// dynamic_bom 추가 필드 (절곡 세부품목용)
|
|
workOrderItemId?: number; // 개소(작업지시품목) ID
|
|
lotPrefix?: string; // LOT prefix (RS, RM 등)
|
|
partType?: string; // 파트 타입 (finish, body 등)
|
|
category?: string; // 카테고리 (guideRail, bottomBar 등)
|
|
}
|
|
|
|
export async function getMaterialsForWorkOrder(
|
|
workOrderId: string
|
|
): Promise<{
|
|
success: boolean;
|
|
data: MaterialForInput[];
|
|
error?: string;
|
|
}> {
|
|
interface MaterialApiItem {
|
|
stock_lot_id: number | null; item_id: number; lot_no: string | null;
|
|
material_code: string; material_name: string; specification: string;
|
|
unit: string; required_qty: number; lot_available_qty: number; fifo_rank: number;
|
|
// dynamic_bom 추가 필드
|
|
work_order_item_id?: number; lot_prefix?: string; part_type?: string; category?: string;
|
|
}
|
|
const result = await executeServerAction<MaterialApiItem[]>({
|
|
url: `${API_URL}/api/v1/work-orders/${workOrderId}/materials`,
|
|
errorMessage: '자재 목록 조회에 실패했습니다.',
|
|
});
|
|
if (!result.success || !result.data) return { success: false, data: [], error: result.error };
|
|
return {
|
|
success: true,
|
|
data: result.data.map((item) => ({
|
|
stockLotId: item.stock_lot_id, itemId: item.item_id, lotNo: item.lot_no,
|
|
materialCode: item.material_code, materialName: item.material_name,
|
|
specification: item.specification ?? '', unit: item.unit,
|
|
requiredQty: item.required_qty, lotAvailableQty: item.lot_available_qty, fifoRank: item.fifo_rank,
|
|
workOrderItemId: item.work_order_item_id, lotPrefix: item.lot_prefix,
|
|
partType: item.part_type, category: item.category,
|
|
})),
|
|
};
|
|
}
|
|
|
|
// ===== 자재 투입 등록 (로트별 수량) =====
|
|
export async function registerMaterialInput(
|
|
workOrderId: string,
|
|
inputs: { stock_lot_id: number; qty: number; work_order_item_id?: number }[]
|
|
): Promise<{ success: boolean; error?: string }> {
|
|
const result = await executeServerAction({
|
|
url: `${API_URL}/api/v1/work-orders/${workOrderId}/material-inputs`,
|
|
method: 'POST',
|
|
body: { inputs },
|
|
errorMessage: '자재 투입 등록에 실패했습니다.',
|
|
});
|
|
return { success: result.success, error: result.error };
|
|
}
|
|
|
|
// ===== 개소별 자재 목록 조회 =====
|
|
export interface MaterialForItemInput extends MaterialForInput {
|
|
alreadyInputted: number; // 이미 투입된 수량
|
|
remainingRequiredQty: number; // 남은 필요 수량
|
|
lotInputtedQty: number; // 해당 LOT의 기투입 수량
|
|
bomGroupKey?: string; // BOM 엔트리별 고유 그룹키 (category+partType 기반)
|
|
}
|
|
|
|
export async function getMaterialsForItem(
|
|
workOrderId: string,
|
|
itemId: number
|
|
): Promise<{
|
|
success: boolean;
|
|
data: MaterialForItemInput[];
|
|
error?: string;
|
|
}> {
|
|
interface MaterialItemApiItem {
|
|
stock_lot_id: number | null; item_id: number; lot_no: string | null;
|
|
material_code: string; material_name: string; specification: string;
|
|
unit: string; bom_qty: number; required_qty: number;
|
|
already_inputted: number; remaining_required_qty: number; lot_inputted_qty: number;
|
|
lot_available_qty: number; fifo_rank: number;
|
|
lot_qty: number; lot_reserved_qty: number;
|
|
receipt_date: string | null; supplier: string | null;
|
|
// dynamic_bom 추가 필드
|
|
work_order_item_id?: number; lot_prefix?: string; part_type?: string; category?: string;
|
|
bom_group_key?: string;
|
|
}
|
|
const result = await executeServerAction<MaterialItemApiItem[]>({
|
|
url: `${API_URL}/api/v1/work-orders/${workOrderId}/items/${itemId}/materials`,
|
|
errorMessage: '개소별 자재 목록 조회에 실패했습니다.',
|
|
});
|
|
if (!result.success || !result.data) return { success: false, data: [], error: result.error };
|
|
return {
|
|
success: true,
|
|
data: result.data.map((item) => ({
|
|
stockLotId: item.stock_lot_id, itemId: item.item_id, lotNo: item.lot_no,
|
|
materialCode: item.material_code, materialName: item.material_name,
|
|
specification: item.specification ?? '', unit: item.unit,
|
|
requiredQty: item.required_qty, lotAvailableQty: item.lot_available_qty,
|
|
fifoRank: item.fifo_rank,
|
|
alreadyInputted: item.already_inputted,
|
|
remainingRequiredQty: item.remaining_required_qty,
|
|
lotInputtedQty: item.lot_inputted_qty ?? 0,
|
|
workOrderItemId: item.work_order_item_id, lotPrefix: item.lot_prefix,
|
|
partType: item.part_type, category: item.category,
|
|
bomGroupKey: item.bom_group_key,
|
|
})),
|
|
};
|
|
}
|
|
|
|
// ===== 개소별 자재 투입 등록 =====
|
|
export async function registerMaterialInputForItem(
|
|
workOrderId: string,
|
|
itemId: number,
|
|
inputs: { stock_lot_id: number; qty: number; bom_group_key?: string }[],
|
|
replace = false
|
|
): Promise<{ success: boolean; error?: string }> {
|
|
const result = await executeServerAction({
|
|
url: `${API_URL}/api/v1/work-orders/${workOrderId}/items/${itemId}/material-inputs`,
|
|
method: 'POST',
|
|
body: { inputs, replace },
|
|
errorMessage: '개소별 자재 투입 등록에 실패했습니다.',
|
|
});
|
|
return { success: result.success, error: result.error };
|
|
}
|
|
|
|
// ===== 개소별 자재 투입 이력 조회 =====
|
|
export interface MaterialInputHistoryItem {
|
|
id: number;
|
|
stockLotId: number;
|
|
lotNo: string | null;
|
|
itemId: number;
|
|
materialCode: string | null;
|
|
materialName: string | null;
|
|
qty: number;
|
|
unit: string;
|
|
inputBy: number | null;
|
|
inputByName: string | null;
|
|
inputAt: string | null;
|
|
}
|
|
|
|
export async function getMaterialInputsForItem(
|
|
workOrderId: string,
|
|
itemId: number
|
|
): Promise<{
|
|
success: boolean;
|
|
data: MaterialInputHistoryItem[];
|
|
error?: string;
|
|
}> {
|
|
interface HistoryApiItem {
|
|
id: number; stock_lot_id: number; lot_no: string | null;
|
|
item_id: number; material_code: string | null; material_name: string | null;
|
|
qty: number; unit: string;
|
|
input_by: number | null; input_by_name: string | null; input_at: string | null;
|
|
}
|
|
const result = await executeServerAction<HistoryApiItem[]>({
|
|
url: `${API_URL}/api/v1/work-orders/${workOrderId}/items/${itemId}/material-inputs`,
|
|
errorMessage: '개소별 투입 이력 조회에 실패했습니다.',
|
|
});
|
|
if (!result.success || !result.data) return { success: false, data: [], error: result.error };
|
|
return {
|
|
success: true,
|
|
data: result.data.map((item) => ({
|
|
id: item.id, stockLotId: item.stock_lot_id, lotNo: item.lot_no,
|
|
itemId: item.item_id, materialCode: item.material_code,
|
|
materialName: item.material_name, qty: item.qty, unit: item.unit,
|
|
inputBy: item.input_by, inputByName: item.input_by_name, inputAt: item.input_at,
|
|
})),
|
|
};
|
|
}
|
|
|
|
// ===== 자재 투입 삭제 (재고 복원) =====
|
|
export async function deleteMaterialInput(
|
|
workOrderId: string,
|
|
inputId: number
|
|
): Promise<{ success: boolean; error?: string }> {
|
|
const result = await executeServerAction({
|
|
url: `${API_URL}/api/v1/work-orders/${workOrderId}/material-inputs/${inputId}`,
|
|
method: 'DELETE',
|
|
errorMessage: '자재 투입 삭제에 실패했습니다.',
|
|
});
|
|
return { success: result.success, error: result.error };
|
|
}
|
|
|
|
// ===== 자재 투입 수량 수정 =====
|
|
export async function updateMaterialInput(
|
|
workOrderId: string,
|
|
inputId: number,
|
|
qty: number
|
|
): Promise<{ success: boolean; data?: { id: number; qty: number; changed: boolean }; error?: string }> {
|
|
const result = await executeServerAction<{ id: number; qty: number; changed: boolean }>({
|
|
url: `${API_URL}/api/v1/work-orders/${workOrderId}/material-inputs/${inputId}`,
|
|
method: 'PATCH',
|
|
body: { qty },
|
|
errorMessage: '자재 투입 수정에 실패했습니다.',
|
|
});
|
|
return { success: result.success, data: result.data, error: result.error };
|
|
}
|
|
|
|
// ===== 이슈 보고 =====
|
|
export async function reportIssue(
|
|
workOrderId: string,
|
|
data: {
|
|
title: string;
|
|
description?: string;
|
|
priority?: 'low' | 'medium' | 'high';
|
|
}
|
|
): Promise<{ success: boolean; error?: string }> {
|
|
const result = await executeServerAction({
|
|
url: `${API_URL}/api/v1/work-orders/${workOrderId}/issues`,
|
|
method: 'POST',
|
|
body: data,
|
|
errorMessage: '이슈 보고에 실패했습니다.',
|
|
});
|
|
return { success: result.success, error: result.error };
|
|
}
|
|
|
|
// ===== 공정 단계 조회 =====
|
|
export interface ProcessStepItem {
|
|
id: string;
|
|
itemNo: string;
|
|
location: string;
|
|
isPriority: boolean;
|
|
spec: string;
|
|
material: string;
|
|
lot: string;
|
|
}
|
|
|
|
export interface ProcessStep {
|
|
id: string;
|
|
stepNo: number;
|
|
name: string;
|
|
isInspection?: boolean;
|
|
completed: number;
|
|
total: number;
|
|
items: ProcessStepItem[];
|
|
}
|
|
|
|
export async function getProcessSteps(
|
|
workOrderId: string
|
|
): Promise<{
|
|
success: boolean;
|
|
data: ProcessStep[];
|
|
error?: string;
|
|
}> {
|
|
interface StepApiItem {
|
|
id: number; step_no: number; name: string; is_inspection?: boolean;
|
|
completed: number; total: number;
|
|
items?: { id: number; item_no: string; location: string; is_priority: boolean; spec: string; material: string; lot: string }[];
|
|
}
|
|
const result = await executeServerAction<StepApiItem[]>({
|
|
url: `${API_URL}/api/v1/work-orders/${workOrderId}/process-steps`,
|
|
errorMessage: '공정 단계 조회에 실패했습니다.',
|
|
});
|
|
if (!result.success || !result.data) return { success: false, data: [], error: result.error };
|
|
return {
|
|
success: true,
|
|
data: result.data.map((step) => ({
|
|
id: String(step.id), stepNo: step.step_no, name: step.name,
|
|
isInspection: step.is_inspection, completed: step.completed, total: step.total,
|
|
items: (step.items || []).map((item) => ({
|
|
id: String(item.id), itemNo: item.item_no, location: item.location,
|
|
isPriority: item.is_priority, spec: item.spec, material: item.material, lot: item.lot,
|
|
})),
|
|
})),
|
|
};
|
|
}
|
|
|
|
// ===== 검사 요청 =====
|
|
export async function requestInspection(
|
|
workOrderId: string,
|
|
stepId: string
|
|
): Promise<{ success: boolean; error?: string }> {
|
|
const result = await executeServerAction({
|
|
url: `${API_URL}/api/v1/work-orders/${workOrderId}/process-steps/${stepId}/inspection-request`,
|
|
method: 'POST',
|
|
body: {},
|
|
errorMessage: '검사 요청에 실패했습니다.',
|
|
});
|
|
return { success: result.success, error: result.error };
|
|
}
|
|
|
|
// ===== 공정 단계 진행 현황 조회 =====
|
|
export interface StepProgressItem {
|
|
id: number;
|
|
process_step_id: number;
|
|
work_order_item_id: number | null;
|
|
step_code: string;
|
|
step_name: string;
|
|
sort_order: number;
|
|
needs_inspection: boolean;
|
|
connection_type: string | null;
|
|
completion_type: string | null;
|
|
status: string;
|
|
is_completed: boolean;
|
|
completed_at: string | null;
|
|
completed_by: number | null;
|
|
}
|
|
|
|
export async function getStepProgress(
|
|
workOrderId: string
|
|
): Promise<{
|
|
success: boolean;
|
|
data: StepProgressItem[];
|
|
error?: string;
|
|
}> {
|
|
const result = await executeServerAction<StepProgressItem[]>({
|
|
url: `${API_URL}/api/v1/work-orders/${workOrderId}/step-progress`,
|
|
errorMessage: '단계 진행 조회에 실패했습니다.',
|
|
});
|
|
if (!result.success || !result.data) return { success: false, data: [], error: result.error };
|
|
return { success: true, data: result.data };
|
|
}
|
|
|
|
// ===== 공정 단계 완료 토글 =====
|
|
export async function toggleStepProgress(
|
|
workOrderId: string,
|
|
progressId: number
|
|
): Promise<{ success: boolean; data?: StepProgressItem; error?: string }> {
|
|
const result = await executeServerAction<StepProgressItem>({
|
|
url: `${API_URL}/api/v1/work-orders/${workOrderId}/step-progress/${progressId}/toggle`,
|
|
method: 'PATCH',
|
|
errorMessage: '단계 토글에 실패했습니다.',
|
|
});
|
|
return { success: result.success, data: result.data, error: result.error };
|
|
}
|
|
|
|
// ===== 작업지시 상세 조회 (items + options 포함) =====
|
|
export async function getWorkOrderDetail(
|
|
workOrderId: string
|
|
): Promise<{
|
|
success: boolean;
|
|
data: WorkItemData[];
|
|
error?: string;
|
|
}> {
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
const result = await executeServerAction<any>({
|
|
url: `${API_URL}/api/v1/work-orders/${workOrderId}`,
|
|
errorMessage: '작업지시 상세 조회에 실패했습니다.',
|
|
});
|
|
if (!result.success || !result.data) return { success: false, data: [], error: result.error };
|
|
|
|
const wo = result.data;
|
|
const processName = (wo.process?.process_name || '').toLowerCase();
|
|
const processType: ProcessTab =
|
|
processName.includes('스크린') ? 'screen' :
|
|
processName.includes('슬랫') ? 'slat' :
|
|
processName.includes('절곡') ? 'bending' : 'screen';
|
|
|
|
const items: WorkItemData[] = (wo.items || []).map((item: {
|
|
id: number; item_name: string; specification: string | null;
|
|
quantity: string; unit: string | null; status: string;
|
|
sort_order: number; options: Record<string, unknown> | null;
|
|
}, index: number) => {
|
|
const opts = item.options || {};
|
|
const stepProgressList = wo.step_progress || [];
|
|
const processSteps = wo.process?.steps || [];
|
|
|
|
let steps: WorkStepData[];
|
|
if (stepProgressList.length > 0) {
|
|
steps = stepProgressList
|
|
.filter((sp: { work_order_item_id: number | null }) => !sp.work_order_item_id || sp.work_order_item_id === item.id)
|
|
.map((sp: {
|
|
id: number;
|
|
process_step: {
|
|
step_name: string; step_code: string;
|
|
needs_inspection?: boolean; connection_type?: string; completion_type?: string;
|
|
} | null;
|
|
status: string;
|
|
}) => ({
|
|
id: String(sp.id),
|
|
name: sp.process_step?.step_name || '',
|
|
isMaterialInput: (sp.process_step?.step_code || '').includes('MAT') || (sp.process_step?.step_name || '').includes('자재투입'),
|
|
isInspection: sp.process_step?.needs_inspection || false,
|
|
isCompleted: sp.status === 'completed',
|
|
stepProgressId: sp.id,
|
|
needsInspection: sp.process_step?.needs_inspection || false,
|
|
connectionType: sp.process_step?.connection_type || undefined,
|
|
connectionTarget: undefined, // step_progress API에 미포함, processListCache에서 보완
|
|
completionType: sp.process_step?.completion_type || undefined,
|
|
}));
|
|
} else {
|
|
steps = processSteps.map((ps: {
|
|
id: number; step_name: string; step_code: string;
|
|
needs_inspection?: boolean; connection_type?: string; completion_type?: string;
|
|
}, si: number) => ({
|
|
id: `${item.id}-step-${si}`,
|
|
name: ps.step_name,
|
|
isMaterialInput: ps.step_code.includes('MAT') || ps.step_name.includes('자재투입'),
|
|
isInspection: ps.needs_inspection || false,
|
|
isCompleted: false,
|
|
needsInspection: ps.needs_inspection || false,
|
|
connectionType: ps.connection_type || undefined,
|
|
completionType: ps.completion_type || undefined,
|
|
}));
|
|
}
|
|
|
|
const workItem: WorkItemData = {
|
|
id: String(item.id), itemNo: index + 1,
|
|
itemCode: wo.work_order_no || '-', itemName: item.item_name || '-',
|
|
floor: (opts.floor as string) || '-', code: (opts.code as string) || '-',
|
|
width: (opts.width as number) || 0, height: (opts.height as number) || 0,
|
|
quantity: Number(item.quantity) || 0, processType, steps, materialInputs: [],
|
|
};
|
|
|
|
if (opts.cutting_info) {
|
|
const ci = opts.cutting_info as { width: number; sheets: number };
|
|
workItem.cuttingInfo = { width: ci.width, sheets: ci.sheets };
|
|
}
|
|
if (opts.slat_info) {
|
|
const si = opts.slat_info as { length: number; slat_count: number; joint_bar: number; glass_qty: number };
|
|
workItem.slatInfo = { length: si.length, slatCount: si.slat_count, jointBar: si.joint_bar, glassQty: si.glass_qty || 0 };
|
|
}
|
|
if (opts.bending_info) {
|
|
const bi = opts.bending_info as {
|
|
common: { kind: string; type: string; length_quantities: { length: number; quantity: number }[] };
|
|
detail_parts: { part_name: string; material: string; barcy_info: string }[];
|
|
};
|
|
workItem.bendingInfo = {
|
|
common: { kind: bi.common.kind, type: bi.common.type, lengthQuantities: bi.common.length_quantities || [] },
|
|
detailParts: (bi.detail_parts || []).map(dp => ({ partName: dp.part_name, material: dp.material, barcyInfo: dp.barcy_info })),
|
|
};
|
|
}
|
|
if (opts.is_wip) {
|
|
workItem.isWip = true;
|
|
const wi = opts.wip_info as { specification: string; length_quantity: string } | undefined;
|
|
if (wi) {
|
|
workItem.wipInfo = { specification: wi.specification, lengthQuantity: wi.length_quantity };
|
|
}
|
|
}
|
|
if (opts.is_joint_bar) {
|
|
workItem.isJointBar = true;
|
|
const jb = opts.slat_joint_bar_info as { specification: string; length: number; quantity: number } | undefined;
|
|
if (jb) workItem.slatJointBarInfo = jb;
|
|
}
|
|
|
|
return workItem;
|
|
});
|
|
|
|
return { success: true, data: items };
|
|
}
|
|
|
|
// ===== 개소별 중간검사 데이터 저장 =====
|
|
export async function saveItemInspection(
|
|
workOrderId: string,
|
|
itemId: number,
|
|
processType: string,
|
|
inspectionData: Record<string, unknown>
|
|
): Promise<{ success: boolean; data?: Record<string, unknown>; error?: string }> {
|
|
const result = await executeServerAction<Record<string, unknown>>({
|
|
url: `${API_URL}/api/v1/work-orders/${workOrderId}/items/${itemId}/inspection`,
|
|
method: 'POST',
|
|
body: { process_type: processType, inspection_data: inspectionData },
|
|
errorMessage: '검사 데이터 저장에 실패했습니다.',
|
|
});
|
|
return { success: result.success, data: result.data, error: result.error };
|
|
}
|
|
|
|
// ===== 작업지시 전체 검사 데이터 조회 =====
|
|
export interface InspectionDataItem {
|
|
item_id: number;
|
|
item_name: string;
|
|
specification: string | null;
|
|
quantity: number;
|
|
sort_order: number;
|
|
options: Record<string, unknown> | null;
|
|
inspection_data: Record<string, unknown>;
|
|
}
|
|
|
|
export async function getWorkOrderInspectionData(
|
|
workOrderId: string
|
|
): Promise<{
|
|
success: boolean;
|
|
data?: { work_order_id: number; items: InspectionDataItem[]; total: number };
|
|
error?: string;
|
|
}> {
|
|
const result = await executeServerAction<{ work_order_id: number; items: InspectionDataItem[]; total: number }>({
|
|
url: `${API_URL}/api/v1/work-orders/${workOrderId}/inspection-data`,
|
|
errorMessage: '검사 데이터 조회에 실패했습니다.',
|
|
});
|
|
return { success: result.success, data: result.data, error: result.error };
|
|
}
|
|
|
|
// ===== 작업일지 저장 =====
|
|
export async function saveWorkLog(
|
|
workOrderId: string,
|
|
data: {
|
|
basic_data?: Record<string, string>;
|
|
table_data?: Array<Record<string, unknown>>;
|
|
remarks?: string;
|
|
title?: string;
|
|
rendered_html?: string;
|
|
}
|
|
): Promise<{
|
|
success: boolean;
|
|
data?: { document_id: number; document_no: string; status: string };
|
|
error?: string;
|
|
}> {
|
|
const result = await executeServerAction<{ document_id: number; document_no: string; status: string }>({
|
|
url: `${API_URL}/api/v1/work-orders/${workOrderId}/work-log`,
|
|
method: 'POST',
|
|
body: data,
|
|
errorMessage: '작업일지 저장에 실패했습니다.',
|
|
});
|
|
return { success: result.success, data: result.data, error: result.error };
|
|
}
|
|
|
|
// ===== 작업일지 조회 =====
|
|
export async function getWorkLog(
|
|
workOrderId: string
|
|
): Promise<{
|
|
success: boolean;
|
|
data?: {
|
|
template: Record<string, unknown>;
|
|
document: Record<string, unknown> | null;
|
|
auto_values: Record<string, string>;
|
|
work_stats: Record<string, unknown>;
|
|
bending_images: Record<string, string>;
|
|
};
|
|
error?: string;
|
|
}> {
|
|
const result = await executeServerAction<{
|
|
template: Record<string, unknown>;
|
|
document: Record<string, unknown> | null;
|
|
auto_values: Record<string, string>;
|
|
work_stats: Record<string, unknown>;
|
|
bending_images: Record<string, string>;
|
|
}>({
|
|
url: `${API_URL}/api/v1/work-orders/${workOrderId}/work-log`,
|
|
errorMessage: '작업일지 조회에 실패했습니다.',
|
|
});
|
|
return { success: result.success, data: result.data, error: result.error };
|
|
}
|
|
|
|
// ===== 검사 문서 템플릿 타입 (types.ts에서 import) =====
|
|
import type { InspectionTemplateData } from './types';
|
|
|
|
export async function getInspectionTemplate(
|
|
workOrderId: string
|
|
): Promise<{
|
|
success: boolean;
|
|
data?: InspectionTemplateData;
|
|
error?: string;
|
|
}> {
|
|
const result = await executeServerAction<InspectionTemplateData>({
|
|
url: `${API_URL}/api/v1/work-orders/${workOrderId}/inspection-template`,
|
|
errorMessage: '검사 템플릿 조회에 실패했습니다.',
|
|
});
|
|
return { success: result.success, data: result.data, error: result.error };
|
|
}
|
|
|
|
// ===== 검사 문서 동기화 (원본: work_order_items → document_data) =====
|
|
export async function saveInspectionDocument(
|
|
workOrderId: string,
|
|
data: {
|
|
title?: string;
|
|
approvers?: { role_name: string; user_id?: number }[];
|
|
} = {}
|
|
): Promise<{
|
|
success: boolean;
|
|
data?: { document_id: number; document_no: string; status: string };
|
|
error?: string;
|
|
}> {
|
|
const result = await executeServerAction<{ document_id: number; document_no: string; status: string }>({
|
|
url: `${API_URL}/api/v1/work-orders/${workOrderId}/inspection-document`,
|
|
method: 'POST',
|
|
body: data,
|
|
errorMessage: '검사 문서 동기화에 실패했습니다.',
|
|
});
|
|
return { success: result.success, data: result.data, error: result.error };
|
|
}
|
|
|
|
// ===== 부서 목록 조회 (작업 정보용) =====
|
|
export interface DepartmentOption {
|
|
id: number;
|
|
name: string;
|
|
}
|
|
|
|
export async function getDepartments(): Promise<{
|
|
success: boolean;
|
|
data: DepartmentOption[];
|
|
error?: string;
|
|
}> {
|
|
interface DeptApiItem { id: number; name: string; parent_id?: number | null; [key: string]: unknown }
|
|
const result = await executeServerAction<{ data: DeptApiItem[] } | DeptApiItem[]>({
|
|
url: buildApiUrl('/api/v1/departments', { per_page: 100 }),
|
|
errorMessage: '부서 목록 조회에 실패했습니다.',
|
|
});
|
|
if (!result.success || !result.data) return { success: false, data: [], error: result.error };
|
|
const list = Array.isArray(result.data) ? result.data : (result.data.data || []);
|
|
return {
|
|
success: true,
|
|
data: list.map((d) => ({ id: d.id, name: d.name })),
|
|
};
|
|
}
|
|
|
|
// ===== 부서별 사용자 목록 조회 =====
|
|
export interface DepartmentUser {
|
|
id: number;
|
|
name: string;
|
|
}
|
|
|
|
export async function getDepartmentUsers(departmentId: number): Promise<{
|
|
success: boolean;
|
|
data: DepartmentUser[];
|
|
error?: string;
|
|
}> {
|
|
interface UserApiItem { id: number; name: string; [key: string]: unknown }
|
|
const result = await executeServerAction<{ data: UserApiItem[] } | UserApiItem[]>({
|
|
url: buildApiUrl(`/api/v1/departments/${departmentId}/users`),
|
|
errorMessage: '부서 사용자 목록 조회에 실패했습니다.',
|
|
});
|
|
if (!result.success || !result.data) return { success: false, data: [], error: result.error };
|
|
const list = Array.isArray(result.data) ? result.data : (result.data.data || []);
|
|
return {
|
|
success: true,
|
|
data: list.map((u) => ({ id: u.id, name: u.name })),
|
|
};
|
|
}
|
|
|
|
// ===== 자재 투입용 재고 검색 =====
|
|
export interface StockSearchResult {
|
|
itemId: number;
|
|
itemCode: string;
|
|
itemName: string;
|
|
stockQty: number;
|
|
availableQty: number;
|
|
lotCount: number;
|
|
lots: Array<{ lotNo: string; availableQty: number; fifoOrder: number }>;
|
|
}
|
|
|
|
export async function searchStockByCode(
|
|
search: string
|
|
): Promise<{ success: boolean; data: StockSearchResult[]; error?: string }> {
|
|
const result = await executeServerAction<{
|
|
data: Array<{
|
|
id: number;
|
|
item_id: number;
|
|
item_code: string;
|
|
item_name: string;
|
|
stock_qty: number;
|
|
available_qty: number;
|
|
lot_count: number;
|
|
lots?: Array<{ lot_no: string; available_qty: number; fifo_order: number }>;
|
|
}>;
|
|
}>({
|
|
url: buildApiUrl('/api/v1/stocks', { search, per_page: 10, with_lots: 'true' }),
|
|
errorMessage: '재고 검색에 실패했습니다.',
|
|
});
|
|
if (!result.success || !result.data) return { success: false, data: [], error: result.error };
|
|
const items = Array.isArray(result.data) ? result.data : (result.data.data || []);
|
|
return {
|
|
success: true,
|
|
data: items.map((s) => ({
|
|
itemId: s.item_id,
|
|
itemCode: s.item_code,
|
|
itemName: s.item_name,
|
|
stockQty: s.stock_qty || 0,
|
|
availableQty: s.available_qty || 0,
|
|
lotCount: s.lot_count || 0,
|
|
lots: (s.lots || []).map((l) => ({
|
|
lotNo: l.lot_no,
|
|
availableQty: l.available_qty,
|
|
fifoOrder: l.fifo_order,
|
|
})),
|
|
})),
|
|
};
|
|
} |