1862 lines
64 KiB
TypeScript
1862 lines
64 KiB
TypeScript
import { Response } from "express";
|
|
import { getPool } from "../database/db";
|
|
import logger from "../utils/logger";
|
|
import { AuthenticatedRequest } from "../middleware/authMiddleware";
|
|
|
|
// 불량 상세 항목 타입
|
|
interface DefectDetailItem {
|
|
defect_code: string;
|
|
defect_name: string;
|
|
qty: string;
|
|
disposition: string;
|
|
}
|
|
|
|
/**
|
|
* 체크리스트 복사 공통 함수
|
|
* 분할 행/재작업 카드 생성 시 마스터의 체크리스트를 새 행에 복사한다.
|
|
*
|
|
* 전략: routingDetailId가 있으면 원본 템플릿에서, 없으면 마스터의 기존 결과에서 복사
|
|
*/
|
|
async function copyChecklistToSplit(
|
|
client: { query: (text: string, values?: any[]) => Promise<any> },
|
|
masterProcessId: string,
|
|
newProcessId: string,
|
|
routingDetailId: string | null,
|
|
companyCode: string,
|
|
userId: string
|
|
): Promise<number> {
|
|
// A. routing_detail_id가 있으면 원본 템플릿(process_work_item + detail)에서 복사
|
|
if (routingDetailId) {
|
|
const result = await client.query(
|
|
`INSERT INTO process_work_result (
|
|
company_code, work_order_process_id,
|
|
source_work_item_id, source_detail_id,
|
|
work_phase, item_title, item_sort_order,
|
|
detail_content, detail_type, detail_sort_order, is_required,
|
|
inspection_code, inspection_method, unit, lower_limit, upper_limit,
|
|
input_type, lookup_target, display_fields, duration_minutes,
|
|
status, writer
|
|
)
|
|
SELECT
|
|
pwi.company_code, $1,
|
|
pwi.id, pwd.id,
|
|
pwi.work_phase, pwi.title, pwi.sort_order::text,
|
|
pwd.content, pwd.detail_type, pwd.sort_order::text, pwd.is_required,
|
|
pwd.inspection_code, pwd.inspection_method, pwd.unit, pwd.lower_limit, pwd.upper_limit,
|
|
pwd.input_type, pwd.lookup_target, pwd.display_fields, pwd.duration_minutes::text,
|
|
'pending', $2
|
|
FROM process_work_item pwi
|
|
JOIN process_work_item_detail pwd ON pwd.work_item_id = pwi.id
|
|
AND pwd.company_code = pwi.company_code
|
|
WHERE pwi.routing_detail_id = $3
|
|
AND pwi.company_code = $4
|
|
ORDER BY pwi.sort_order, pwd.sort_order`,
|
|
[newProcessId, userId, routingDetailId, companyCode]
|
|
);
|
|
return result.rowCount ?? 0;
|
|
}
|
|
|
|
// B. routing_detail_id가 없으면 마스터 행의 process_work_result에서 구조만 복사 (타이머/결과값 초기화)
|
|
const result = await client.query(
|
|
`INSERT INTO process_work_result (
|
|
company_code, work_order_process_id,
|
|
source_work_item_id, source_detail_id,
|
|
work_phase, item_title, item_sort_order,
|
|
detail_content, detail_type, detail_sort_order, is_required,
|
|
inspection_code, inspection_method, unit, lower_limit, upper_limit,
|
|
input_type, lookup_target, display_fields, duration_minutes,
|
|
status, writer
|
|
)
|
|
SELECT
|
|
company_code, $1,
|
|
source_work_item_id, source_detail_id,
|
|
work_phase, item_title, item_sort_order,
|
|
detail_content, detail_type, detail_sort_order, is_required,
|
|
inspection_code, inspection_method, unit, lower_limit, upper_limit,
|
|
input_type, lookup_target, display_fields, duration_minutes,
|
|
'pending', $2
|
|
FROM process_work_result
|
|
WHERE work_order_process_id = $3
|
|
AND company_code = $4
|
|
ORDER BY item_sort_order, detail_sort_order`,
|
|
[newProcessId, userId, masterProcessId, companyCode]
|
|
);
|
|
return result.rowCount ?? 0;
|
|
}
|
|
|
|
/**
|
|
* D-BE1: 작업지시 공정 일괄 생성
|
|
* PC에서 작업지시 생성 후 호출. 1 트랜잭션으로 work_order_process + process_work_result 일괄 생성.
|
|
*/
|
|
export const createWorkProcesses = async (
|
|
req: AuthenticatedRequest,
|
|
res: Response
|
|
) => {
|
|
const pool = getPool();
|
|
const client = await pool.connect();
|
|
|
|
try {
|
|
const companyCode = req.user!.companyCode;
|
|
const userId = req.user!.userId;
|
|
|
|
const { work_instruction_id, item_code, routing_version_id, plan_qty } =
|
|
req.body;
|
|
|
|
if (!work_instruction_id || !routing_version_id) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message:
|
|
"work_instruction_id와 routing_version_id는 필수입니다.",
|
|
});
|
|
}
|
|
|
|
logger.info("[pop/production] create-work-processes 요청", {
|
|
companyCode,
|
|
userId,
|
|
work_instruction_id,
|
|
item_code,
|
|
routing_version_id,
|
|
plan_qty,
|
|
});
|
|
|
|
await client.query("BEGIN");
|
|
|
|
// 중복 호출 방지: 이미 생성된 공정이 있는지 확인
|
|
const existCheck = await client.query(
|
|
`SELECT COUNT(*) as cnt FROM work_order_process
|
|
WHERE wo_id = $1 AND company_code = $2`,
|
|
[work_instruction_id, companyCode]
|
|
);
|
|
if (parseInt(existCheck.rows[0].cnt, 10) > 0) {
|
|
await client.query("ROLLBACK");
|
|
return res.status(409).json({
|
|
success: false,
|
|
message: "이미 공정이 생성된 작업지시입니다.",
|
|
});
|
|
}
|
|
|
|
// 1. item_routing_detail + process_mng JOIN (공정 목록 + 공정명)
|
|
const routingDetails = await client.query(
|
|
`SELECT rd.id, rd.seq_no, rd.process_code,
|
|
COALESCE(pm.process_name, rd.process_code) as process_name,
|
|
rd.is_required, rd.is_fixed_order, rd.standard_time
|
|
FROM item_routing_detail rd
|
|
LEFT JOIN process_mng pm ON pm.process_code = rd.process_code
|
|
AND pm.company_code = rd.company_code
|
|
WHERE rd.routing_version_id = $1 AND rd.company_code = $2
|
|
ORDER BY CAST(rd.seq_no AS int) NULLS LAST`,
|
|
[routing_version_id, companyCode]
|
|
);
|
|
|
|
if (routingDetails.rows.length === 0) {
|
|
await client.query("ROLLBACK");
|
|
return res.status(404).json({
|
|
success: false,
|
|
message: "라우팅 버전에 등록된 공정이 없습니다.",
|
|
});
|
|
}
|
|
|
|
const processes: Array<{
|
|
id: string;
|
|
seq_no: string;
|
|
process_name: string;
|
|
checklist_count: number;
|
|
}> = [];
|
|
let totalChecklists = 0;
|
|
|
|
for (const rd of routingDetails.rows) {
|
|
// 2. work_order_process INSERT
|
|
const wopResult = await client.query(
|
|
`INSERT INTO work_order_process (
|
|
company_code, wo_id, seq_no, process_code, process_name,
|
|
is_required, is_fixed_order, standard_time, plan_qty,
|
|
status, routing_detail_id, writer
|
|
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
|
|
RETURNING id`,
|
|
[
|
|
companyCode,
|
|
work_instruction_id,
|
|
rd.seq_no,
|
|
rd.process_code,
|
|
rd.process_name,
|
|
rd.is_required,
|
|
rd.is_fixed_order,
|
|
rd.standard_time,
|
|
plan_qty || null,
|
|
parseInt(rd.seq_no, 10) === 1 ? "acceptable" : "waiting",
|
|
rd.id,
|
|
userId,
|
|
]
|
|
);
|
|
const wopId = wopResult.rows[0].id;
|
|
|
|
// 3. process_work_result INSERT (공통 함수로 체크리스트 복사)
|
|
const checklistCount = await copyChecklistToSplit(
|
|
client, wopId, wopId, rd.id, companyCode, userId
|
|
);
|
|
totalChecklists += checklistCount;
|
|
|
|
processes.push({
|
|
id: wopId,
|
|
seq_no: rd.seq_no,
|
|
process_name: rd.process_name,
|
|
checklist_count: checklistCount,
|
|
});
|
|
|
|
logger.info("[pop/production] 공정 생성 완료", {
|
|
wopId,
|
|
processName: rd.process_name,
|
|
checklistCount,
|
|
});
|
|
}
|
|
|
|
await client.query("COMMIT");
|
|
|
|
logger.info("[pop/production] create-work-processes 완료", {
|
|
companyCode,
|
|
work_instruction_id,
|
|
total_processes: processes.length,
|
|
total_checklists: totalChecklists,
|
|
});
|
|
|
|
return res.json({
|
|
success: true,
|
|
data: {
|
|
processes,
|
|
total_processes: processes.length,
|
|
total_checklists: totalChecklists,
|
|
},
|
|
});
|
|
} catch (error: any) {
|
|
await client.query("ROLLBACK");
|
|
logger.error("[pop/production] create-work-processes 오류:", error);
|
|
return res.status(500).json({
|
|
success: false,
|
|
message: error.message || "공정 생성 중 오류가 발생했습니다.",
|
|
});
|
|
} finally {
|
|
client.release();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* D-BE2: 타이머 API (시작/일시정지/재시작)
|
|
*/
|
|
export const controlTimer = async (
|
|
req: AuthenticatedRequest,
|
|
res: Response
|
|
) => {
|
|
const pool = getPool();
|
|
|
|
try {
|
|
const companyCode = req.user!.companyCode;
|
|
const userId = req.user!.userId;
|
|
|
|
const { work_order_process_id, action } = req.body;
|
|
|
|
if (!work_order_process_id || !action) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: "work_order_process_id와 action은 필수입니다.",
|
|
});
|
|
}
|
|
|
|
if (!["start", "pause", "resume", "complete"].includes(action)) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message:
|
|
"action은 start, pause, resume, complete 중 하나여야 합니다.",
|
|
});
|
|
}
|
|
|
|
logger.info("[pop/production] timer 요청", {
|
|
companyCode,
|
|
userId,
|
|
work_order_process_id,
|
|
action,
|
|
});
|
|
|
|
let result;
|
|
|
|
switch (action) {
|
|
case "start":
|
|
// 최초 1회만 설정, 이미 있으면 무시
|
|
result = await pool.query(
|
|
`UPDATE work_order_process
|
|
SET started_at = CASE WHEN started_at IS NULL THEN NOW()::text ELSE started_at END,
|
|
status = CASE WHEN status = 'waiting' THEN 'in_progress' ELSE status END,
|
|
updated_date = NOW()
|
|
WHERE id = $1 AND company_code = $2
|
|
RETURNING id, started_at, status`,
|
|
[work_order_process_id, companyCode]
|
|
);
|
|
break;
|
|
|
|
case "pause":
|
|
result = await pool.query(
|
|
`UPDATE work_order_process
|
|
SET paused_at = NOW()::text,
|
|
updated_date = NOW()
|
|
WHERE id = $1 AND company_code = $2 AND paused_at IS NULL
|
|
RETURNING id, paused_at`,
|
|
[work_order_process_id, companyCode]
|
|
);
|
|
break;
|
|
|
|
case "resume":
|
|
// 일시정지 시간 누적 후 paused_at 초기화
|
|
result = await pool.query(
|
|
`UPDATE work_order_process
|
|
SET total_paused_time = (
|
|
COALESCE(total_paused_time::int, 0)
|
|
+ EXTRACT(EPOCH FROM NOW() - paused_at::timestamp)::int
|
|
)::text,
|
|
paused_at = NULL,
|
|
updated_date = NOW()
|
|
WHERE id = $1 AND company_code = $2 AND paused_at IS NOT NULL
|
|
RETURNING id, total_paused_time`,
|
|
[work_order_process_id, companyCode]
|
|
);
|
|
break;
|
|
|
|
case "complete": {
|
|
const { good_qty, defect_qty } = req.body;
|
|
|
|
const groupSumResult = await pool.query(
|
|
`SELECT COALESCE(SUM(
|
|
CASE WHEN group_started_at IS NOT NULL AND group_completed_at IS NOT NULL THEN
|
|
EXTRACT(EPOCH FROM group_completed_at::timestamp - group_started_at::timestamp)::int
|
|
- COALESCE(group_total_paused_time::int, 0)
|
|
ELSE 0 END
|
|
), 0)::text AS total_work_seconds
|
|
FROM process_work_result
|
|
WHERE work_order_process_id = $1 AND company_code = $2`,
|
|
[work_order_process_id, companyCode]
|
|
);
|
|
const calculatedWorkTime = groupSumResult.rows[0]?.total_work_seconds || "0";
|
|
|
|
result = await pool.query(
|
|
`UPDATE work_order_process
|
|
SET status = 'completed',
|
|
completed_at = NOW()::text,
|
|
completed_by = $3,
|
|
actual_work_time = $4,
|
|
good_qty = COALESCE($5, good_qty),
|
|
defect_qty = COALESCE($6, defect_qty),
|
|
paused_at = NULL,
|
|
updated_date = NOW()
|
|
WHERE id = $1 AND company_code = $2
|
|
AND status != 'completed'
|
|
RETURNING id, status, completed_at, completed_by, actual_work_time, good_qty, defect_qty`,
|
|
[
|
|
work_order_process_id,
|
|
companyCode,
|
|
userId,
|
|
calculatedWorkTime,
|
|
good_qty || null,
|
|
defect_qty || null,
|
|
]
|
|
);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!result || result.rowCount === 0) {
|
|
return res.status(404).json({
|
|
success: false,
|
|
message: "대상 공정을 찾을 수 없거나 현재 상태에서 수행할 수 없습니다.",
|
|
});
|
|
}
|
|
|
|
logger.info("[pop/production] timer 완료", {
|
|
action,
|
|
work_order_process_id,
|
|
result: result.rows[0],
|
|
});
|
|
|
|
return res.json({
|
|
success: true,
|
|
data: result.rows[0],
|
|
});
|
|
} catch (error: any) {
|
|
logger.error("[pop/production] timer 오류:", error);
|
|
return res.status(500).json({
|
|
success: false,
|
|
message: error.message || "타이머 처리 중 오류가 발생했습니다.",
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 그룹(작업항목)별 타이머 제어
|
|
* 좌측 사이드바의 각 작업 그룹마다 독립적인 시작/정지/재개/완료 타이머
|
|
*/
|
|
export const controlGroupTimer = async (
|
|
req: AuthenticatedRequest,
|
|
res: Response
|
|
) => {
|
|
const pool = getPool();
|
|
|
|
try {
|
|
const companyCode = req.user!.companyCode;
|
|
const { work_order_process_id, source_work_item_id, action } = req.body;
|
|
|
|
if (!work_order_process_id || !source_work_item_id || !action) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message:
|
|
"work_order_process_id, source_work_item_id, action은 필수입니다.",
|
|
});
|
|
}
|
|
|
|
if (!["start", "pause", "resume", "complete"].includes(action)) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message:
|
|
"action은 start, pause, resume, complete 중 하나여야 합니다.",
|
|
});
|
|
}
|
|
|
|
logger.info("[pop/production] group-timer 요청", {
|
|
companyCode,
|
|
work_order_process_id,
|
|
source_work_item_id,
|
|
action,
|
|
});
|
|
|
|
const whereClause = `work_order_process_id = $1 AND source_work_item_id = $2 AND company_code = $3`;
|
|
const baseParams = [work_order_process_id, source_work_item_id, companyCode];
|
|
|
|
let result;
|
|
|
|
switch (action) {
|
|
case "start":
|
|
result = await pool.query(
|
|
`UPDATE process_work_result
|
|
SET group_started_at = CASE WHEN group_started_at IS NULL THEN NOW()::text ELSE group_started_at END,
|
|
updated_date = NOW()
|
|
WHERE ${whereClause}
|
|
RETURNING id, group_started_at`,
|
|
baseParams
|
|
);
|
|
await pool.query(
|
|
`UPDATE work_order_process
|
|
SET started_at = NOW()::text, updated_date = NOW()
|
|
WHERE id = $1 AND company_code = $2 AND started_at IS NULL`,
|
|
[work_order_process_id, companyCode]
|
|
);
|
|
break;
|
|
|
|
case "pause":
|
|
result = await pool.query(
|
|
`UPDATE process_work_result
|
|
SET group_paused_at = NOW()::text,
|
|
updated_date = NOW()
|
|
WHERE ${whereClause} AND group_paused_at IS NULL
|
|
RETURNING id, group_paused_at`,
|
|
baseParams
|
|
);
|
|
break;
|
|
|
|
case "resume":
|
|
result = await pool.query(
|
|
`UPDATE process_work_result
|
|
SET group_total_paused_time = (
|
|
COALESCE(group_total_paused_time::int, 0)
|
|
+ EXTRACT(EPOCH FROM NOW() - group_paused_at::timestamp)::int
|
|
)::text,
|
|
group_paused_at = NULL,
|
|
updated_date = NOW()
|
|
WHERE ${whereClause} AND group_paused_at IS NOT NULL
|
|
RETURNING id, group_total_paused_time`,
|
|
baseParams
|
|
);
|
|
break;
|
|
|
|
case "complete": {
|
|
result = await pool.query(
|
|
`UPDATE process_work_result
|
|
SET group_completed_at = NOW()::text,
|
|
group_total_paused_time = CASE
|
|
WHEN group_paused_at IS NOT NULL THEN (
|
|
COALESCE(group_total_paused_time::int, 0)
|
|
+ EXTRACT(EPOCH FROM NOW() - group_paused_at::timestamp)::int
|
|
)::text
|
|
ELSE group_total_paused_time
|
|
END,
|
|
group_paused_at = NULL,
|
|
updated_date = NOW()
|
|
WHERE ${whereClause}
|
|
RETURNING id, group_started_at, group_completed_at, group_total_paused_time`,
|
|
baseParams
|
|
);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!result || result.rowCount === 0) {
|
|
return res.status(404).json({
|
|
success: false,
|
|
message: "대상 그룹을 찾을 수 없거나 현재 상태에서 수행할 수 없습니다.",
|
|
});
|
|
}
|
|
|
|
logger.info("[pop/production] group-timer 완료", {
|
|
action,
|
|
source_work_item_id,
|
|
affectedRows: result.rowCount,
|
|
});
|
|
|
|
return res.json({
|
|
success: true,
|
|
data: result.rows[0],
|
|
affectedRows: result.rowCount,
|
|
});
|
|
} catch (error: any) {
|
|
logger.error("[pop/production] group-timer 오류:", error);
|
|
return res.status(500).json({
|
|
success: false,
|
|
message: error.message || "그룹 타이머 처리 중 오류가 발생했습니다.",
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 불량 유형 목록 조회 (defect_standard_mng)
|
|
*/
|
|
export const getDefectTypes = async (
|
|
req: AuthenticatedRequest,
|
|
res: Response
|
|
) => {
|
|
const pool = getPool();
|
|
|
|
try {
|
|
const companyCode = req.user!.companyCode;
|
|
|
|
let query: string;
|
|
let params: unknown[];
|
|
|
|
if (companyCode === "*") {
|
|
query = `
|
|
SELECT id, defect_code, defect_name, defect_type, severity, company_code
|
|
FROM defect_standard_mng
|
|
WHERE is_active = 'Y'
|
|
ORDER BY defect_code`;
|
|
params = [];
|
|
} else {
|
|
query = `
|
|
SELECT id, defect_code, defect_name, defect_type, severity, company_code
|
|
FROM defect_standard_mng
|
|
WHERE is_active = 'Y' AND company_code = $1
|
|
ORDER BY defect_code`;
|
|
params = [companyCode];
|
|
}
|
|
|
|
const result = await pool.query(query, params);
|
|
|
|
logger.info("[pop/production] defect-types 조회", {
|
|
companyCode,
|
|
count: result.rowCount,
|
|
});
|
|
|
|
return res.json({
|
|
success: true,
|
|
data: result.rows,
|
|
});
|
|
} catch (error: any) {
|
|
logger.error("[pop/production] defect-types 오류:", error);
|
|
return res.status(500).json({
|
|
success: false,
|
|
message: error.message || "불량 유형 조회 중 오류가 발생했습니다.",
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 실적 저장 (누적 방식)
|
|
* 이번 차수 생산수량을 기존 누적치에 더한다.
|
|
* result_status는 'draft' 유지 (확정 전까지 계속 추가 등록 가능)
|
|
*/
|
|
export const saveResult = async (
|
|
req: AuthenticatedRequest,
|
|
res: Response
|
|
) => {
|
|
const pool = getPool();
|
|
|
|
try {
|
|
const companyCode = req.user!.companyCode;
|
|
const userId = req.user!.userId;
|
|
|
|
const {
|
|
work_order_process_id,
|
|
production_qty,
|
|
good_qty,
|
|
defect_qty,
|
|
defect_detail,
|
|
result_note,
|
|
} = req.body;
|
|
|
|
if (!work_order_process_id) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: "work_order_process_id는 필수입니다.",
|
|
});
|
|
}
|
|
|
|
if (!production_qty || parseInt(production_qty, 10) <= 0) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: "생산수량을 입력해주세요.",
|
|
});
|
|
}
|
|
|
|
const statusCheck = await pool.query(
|
|
`SELECT wop.status, wop.result_status, wop.total_production_qty, wop.good_qty,
|
|
wop.defect_qty, wop.concession_qty, wop.defect_detail,
|
|
wop.input_qty, wop.parent_process_id, wop.wo_id, wop.seq_no
|
|
FROM work_order_process wop
|
|
WHERE wop.id = $1 AND wop.company_code = $2`,
|
|
[work_order_process_id, companyCode]
|
|
);
|
|
|
|
if (statusCheck.rowCount === 0) {
|
|
return res.status(404).json({
|
|
success: false,
|
|
message: "공정을 찾을 수 없습니다.",
|
|
});
|
|
}
|
|
|
|
const prev = statusCheck.rows[0];
|
|
|
|
// 마스터 행에 직접 실적 등록 방지 (분할 행이 존재하는 경우)
|
|
if (!prev.parent_process_id) {
|
|
const splitCheck = await pool.query(
|
|
`SELECT COUNT(*) as cnt FROM work_order_process
|
|
WHERE parent_process_id = $1 AND company_code = $2`,
|
|
[work_order_process_id, companyCode]
|
|
);
|
|
if (parseInt(splitCheck.rows[0].cnt, 10) > 0) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: "원본 공정에는 직접 실적을 등록할 수 없습니다. 분할된 접수 카드에서 등록해주세요.",
|
|
});
|
|
}
|
|
}
|
|
|
|
if (prev.result_status === "confirmed") {
|
|
return res.status(403).json({
|
|
success: false,
|
|
message: "이미 확정된 실적입니다. 추가 등록이 불가능합니다.",
|
|
});
|
|
}
|
|
|
|
// 초과 생산 경고 (차단하지 않음 - 현장 유연성)
|
|
const prevTotal = parseInt(prev.total_production_qty, 10) || 0;
|
|
const acceptedQty = parseInt(prev.input_qty, 10) || 0;
|
|
const requestedQty = parseInt(production_qty, 10) || 0;
|
|
if (acceptedQty > 0 && (prevTotal + requestedQty) > acceptedQty) {
|
|
logger.warn("[pop/production] 초과 생산 감지", {
|
|
work_order_process_id,
|
|
prevTotal, requestedQty, acceptedQty,
|
|
overAmount: (prevTotal + requestedQty) - acceptedQty,
|
|
});
|
|
}
|
|
|
|
// 서버 측 양품/불량/특채 계산 (클라이언트 good_qty는 참고만)
|
|
const addProduction = parseInt(production_qty, 10) || 0;
|
|
let addDefect = 0;
|
|
let addConcession = 0;
|
|
|
|
let defectDetailStr: string | null = null;
|
|
if (defect_detail && Array.isArray(defect_detail)) {
|
|
const validated = defect_detail.map((item: DefectDetailItem) => ({
|
|
defect_code: item.defect_code || "",
|
|
defect_name: item.defect_name || "",
|
|
qty: item.qty || "0",
|
|
disposition: item.disposition || "scrap",
|
|
}));
|
|
defectDetailStr = JSON.stringify(validated);
|
|
|
|
for (const item of validated) {
|
|
const itemQty = parseInt(item.qty, 10) || 0;
|
|
addDefect += itemQty;
|
|
if (item.disposition === "accept") {
|
|
addConcession += itemQty;
|
|
}
|
|
}
|
|
} else {
|
|
addDefect = parseInt(defect_qty, 10) || 0;
|
|
}
|
|
const addGood = addProduction - addDefect;
|
|
|
|
const newTotal = (parseInt(prev.total_production_qty, 10) || 0) + addProduction;
|
|
const newGood = (parseInt(prev.good_qty, 10) || 0) + addGood;
|
|
const newDefect = (parseInt(prev.defect_qty, 10) || 0) + addDefect;
|
|
const newConcession = (parseInt(prev.concession_qty, 10) || 0) + addConcession;
|
|
|
|
// 기존 defect_detail에 이번 차수 상세를 병합
|
|
let mergedDefectDetail: string | null = null;
|
|
if (defectDetailStr) {
|
|
let existingEntries: DefectDetailItem[] = [];
|
|
try {
|
|
existingEntries = prev.defect_detail ? JSON.parse(prev.defect_detail) : [];
|
|
} catch { /* 파싱 실패 시 빈 배열 */ }
|
|
const newEntries: DefectDetailItem[] = JSON.parse(defectDetailStr);
|
|
const merged = [...existingEntries];
|
|
for (const ne of newEntries) {
|
|
const existing = merged.find(
|
|
(e) => e.defect_code === ne.defect_code && e.disposition === ne.disposition
|
|
);
|
|
if (existing) {
|
|
existing.qty = String(
|
|
(parseInt(existing.qty, 10) || 0) + (parseInt(ne.qty, 10) || 0)
|
|
);
|
|
} else {
|
|
merged.push(ne);
|
|
}
|
|
}
|
|
mergedDefectDetail = JSON.stringify(merged);
|
|
}
|
|
|
|
const result = await pool.query(
|
|
`UPDATE work_order_process
|
|
SET total_production_qty = $3,
|
|
good_qty = $4,
|
|
defect_qty = $5,
|
|
concession_qty = $9,
|
|
defect_detail = COALESCE($6, defect_detail),
|
|
result_note = COALESCE($7, result_note),
|
|
result_status = 'draft',
|
|
status = CASE WHEN status IN ('acceptable', 'waiting') THEN 'in_progress' ELSE status END,
|
|
writer = $8,
|
|
updated_date = NOW()
|
|
WHERE id = $1 AND company_code = $2
|
|
RETURNING id, total_production_qty, good_qty, defect_qty, concession_qty, defect_detail, result_note, result_status, status`,
|
|
[
|
|
work_order_process_id,
|
|
companyCode,
|
|
String(newTotal),
|
|
String(newGood),
|
|
String(newDefect),
|
|
mergedDefectDetail,
|
|
result_note || null,
|
|
userId,
|
|
String(newConcession),
|
|
]
|
|
);
|
|
|
|
if (result.rowCount === 0) {
|
|
return res.status(404).json({
|
|
success: false,
|
|
message: "공정을 찾을 수 없거나 권한이 없습니다.",
|
|
});
|
|
}
|
|
|
|
// 현재 분할 행의 공정 정보 조회
|
|
const currentSeq = await pool.query(
|
|
`SELECT wop.seq_no, wop.wo_id, wop.input_qty as current_input_qty,
|
|
wop.parent_process_id, wop.process_code, wop.process_name,
|
|
wop.is_required, wop.is_fixed_order, wop.standard_time,
|
|
wop.equipment_code, wop.routing_detail_id,
|
|
wi.qty as instruction_qty
|
|
FROM work_order_process wop
|
|
JOIN work_instruction wi ON wop.wo_id = wi.id AND wop.company_code = wi.company_code
|
|
WHERE wop.id = $1 AND wop.company_code = $2`,
|
|
[work_order_process_id, companyCode]
|
|
);
|
|
|
|
// 재작업 카드 자동 생성 (disposition = 'rework' 항목이 있을 때)
|
|
if (currentSeq.rowCount > 0 && defect_detail && Array.isArray(defect_detail)) {
|
|
let totalReworkQty = 0;
|
|
for (const item of defect_detail) {
|
|
if (item.disposition === "rework") {
|
|
totalReworkQty += parseInt(item.qty, 10) || 0;
|
|
}
|
|
}
|
|
if (totalReworkQty > 0) {
|
|
const proc = currentSeq.rows[0];
|
|
const masterId = proc.parent_process_id || work_order_process_id;
|
|
const reworkInsert = await pool.query(
|
|
`INSERT INTO work_order_process (
|
|
wo_id, seq_no, process_code, process_name, is_required, is_fixed_order,
|
|
standard_time, equipment_code, routing_detail_id,
|
|
status, input_qty, good_qty, defect_qty, concession_qty, total_production_qty,
|
|
result_status, is_rework, rework_source_id,
|
|
parent_process_id, company_code, writer
|
|
) VALUES (
|
|
$1, $2, $3, $4, $5, $6, $7, $8, $9,
|
|
'acceptable', $10, '0', '0', '0', '0',
|
|
'draft', 'Y', $11,
|
|
$12, $13, $14
|
|
) RETURNING id`,
|
|
[
|
|
proc.wo_id, proc.seq_no, proc.process_code, proc.process_name,
|
|
proc.is_required, proc.is_fixed_order, proc.standard_time,
|
|
proc.equipment_code, proc.routing_detail_id,
|
|
String(totalReworkQty), work_order_process_id,
|
|
masterId, companyCode, userId,
|
|
]
|
|
);
|
|
// 재작업 카드에 체크리스트 복사
|
|
const reworkId = reworkInsert.rows[0]?.id;
|
|
if (reworkId) {
|
|
const reworkChecklistCount = await copyChecklistToSplit(
|
|
pool, masterId, reworkId, proc.routing_detail_id, companyCode, userId
|
|
);
|
|
logger.info("[pop/production] 재작업 카드 자동 생성", {
|
|
reworkId,
|
|
sourceId: work_order_process_id,
|
|
reworkQty: totalReworkQty,
|
|
checklistCount: reworkChecklistCount,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
// 다음 공정 활성화: 양품 발생 시 다음 seq_no의 원본(마스터) 행을 acceptable로
|
|
// waiting -> acceptable (최초 활성화)
|
|
// in_progress -> acceptable (앞공정 추가양품으로 접수가능량 복원)
|
|
if (addGood > 0 && currentSeq.rowCount > 0) {
|
|
const { seq_no, wo_id } = currentSeq.rows[0];
|
|
const nextSeq = String(parseInt(seq_no, 10) + 1);
|
|
const nextUpdate = await pool.query(
|
|
`UPDATE work_order_process
|
|
SET status = CASE WHEN status IN ('waiting', 'in_progress') THEN 'acceptable' ELSE status END,
|
|
updated_date = NOW()
|
|
WHERE wo_id = $1 AND seq_no = $2 AND company_code = $3
|
|
AND parent_process_id IS NULL
|
|
AND status != 'completed'
|
|
RETURNING id, process_name, status`,
|
|
[wo_id, nextSeq, companyCode]
|
|
);
|
|
if (nextUpdate.rowCount > 0) {
|
|
logger.info("[pop/production] 다음 공정 상태 전환", {
|
|
nextProcess: nextUpdate.rows[0],
|
|
});
|
|
}
|
|
}
|
|
|
|
// 개별 분할 행 자동완료: 이 분할 행의 접수분 전량 생산 시 completed
|
|
if (currentSeq.rowCount > 0) {
|
|
const { seq_no, wo_id, current_input_qty, instruction_qty } = currentSeq.rows[0];
|
|
const myInputQty = parseInt(current_input_qty, 10) || 0;
|
|
|
|
if (newTotal >= myInputQty && myInputQty > 0) {
|
|
await pool.query(
|
|
`UPDATE work_order_process
|
|
SET status = 'completed',
|
|
result_status = 'confirmed',
|
|
completed_at = NOW()::text,
|
|
completed_by = $3,
|
|
updated_date = NOW()
|
|
WHERE id = $1 AND company_code = $2
|
|
AND status != 'completed'`,
|
|
[work_order_process_id, companyCode, userId]
|
|
);
|
|
logger.info("[pop/production] 분할 행 자동 완료", {
|
|
work_order_process_id, newTotal, myInputQty,
|
|
});
|
|
|
|
// 같은 공정의 모든 분할 행이 completed인지 체크 -> 원본도 completed로
|
|
const seqNum = parseInt(seq_no, 10);
|
|
const instrQty = parseInt(instruction_qty, 10) || 0;
|
|
|
|
// 앞공정 양품 합산 (접수가능 잔여 계산용)
|
|
let prevGoodQty = instrQty;
|
|
if (seqNum > 1) {
|
|
const prevSeq = String(seqNum - 1);
|
|
const prevProcess = await pool.query(
|
|
`SELECT COALESCE(SUM(good_qty::int), 0) + COALESCE(SUM(concession_qty::int), 0) as total_good
|
|
FROM work_order_process
|
|
WHERE wo_id = $1 AND seq_no = $2 AND company_code = $3`,
|
|
[wo_id, prevSeq, companyCode]
|
|
);
|
|
if (prevProcess.rowCount > 0) {
|
|
prevGoodQty = parseInt(prevProcess.rows[0].total_good, 10) || 0;
|
|
}
|
|
}
|
|
|
|
// 같은 seq_no의 모든 분할 행 접수량 합산 + 미완료 행 카운트
|
|
const siblingCheck = await pool.query(
|
|
`SELECT
|
|
COALESCE(SUM(input_qty::int), 0) as total_input,
|
|
COUNT(*) FILTER (WHERE status != 'completed') as incomplete_count
|
|
FROM work_order_process
|
|
WHERE wo_id = $1 AND seq_no = $2 AND company_code = $3
|
|
AND parent_process_id IS NOT NULL`,
|
|
[wo_id, seq_no, companyCode]
|
|
);
|
|
|
|
const totalInput = parseInt(siblingCheck.rows[0].total_input, 10) || 0;
|
|
const incompleteCount = parseInt(siblingCheck.rows[0].incomplete_count, 10) || 0;
|
|
const remainingAcceptable = prevGoodQty - totalInput;
|
|
|
|
// 모든 분할 행 완료 + 잔여 접수가능 0 -> 원본(마스터)도 completed
|
|
if (incompleteCount === 0 && remainingAcceptable <= 0) {
|
|
const masterId = currentSeq.rows[0].parent_process_id;
|
|
if (masterId) {
|
|
await pool.query(
|
|
`UPDATE work_order_process
|
|
SET status = 'completed',
|
|
result_status = 'confirmed',
|
|
completed_at = NOW()::text,
|
|
completed_by = $3,
|
|
updated_date = NOW()
|
|
WHERE id = $1 AND company_code = $2
|
|
AND status != 'completed'`,
|
|
[masterId, companyCode, userId]
|
|
);
|
|
logger.info("[pop/production] 원본(마스터) 공정 자동 완료", {
|
|
masterId, totalInput, prevGoodQty,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
// 작업지시 전체 완료 판정
|
|
const { wo_id: woIdForWi } = currentSeq.rows[0];
|
|
await checkAndCompleteWorkInstruction(pool, woIdForWi, companyCode, userId);
|
|
}
|
|
|
|
logger.info("[pop/production] save-result 완료 (누적)", {
|
|
companyCode,
|
|
work_order_process_id,
|
|
added: { production_qty: addProduction, good_qty: addGood, defect_qty: addDefect },
|
|
accumulated: { total: newTotal, good: newGood, defect: newDefect },
|
|
});
|
|
|
|
// 자동 완료 후 최신 데이터 반환 (status가 변경되었을 수 있음)
|
|
const latestData = await pool.query(
|
|
`SELECT id, total_production_qty, good_qty, defect_qty, concession_qty, defect_detail, result_note, result_status, status, input_qty
|
|
FROM work_order_process WHERE id = $1 AND company_code = $2`,
|
|
[work_order_process_id, companyCode]
|
|
);
|
|
|
|
return res.json({
|
|
success: true,
|
|
data: latestData.rows[0] || result.rows[0],
|
|
});
|
|
} catch (error: any) {
|
|
logger.error("[pop/production] save-result 오류:", error);
|
|
return res.status(500).json({
|
|
success: false,
|
|
message: error.message || "실적 저장 중 오류가 발생했습니다.",
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 작업지시(work_instruction) 전체 완료 판정
|
|
* 마지막 공정의 모든 행이 completed이면 작업지시도 완료 처리
|
|
*/
|
|
const checkAndCompleteWorkInstruction = async (
|
|
pool: any,
|
|
woId: string,
|
|
companyCode: string,
|
|
userId: string
|
|
) => {
|
|
const maxSeqResult = await pool.query(
|
|
`SELECT MAX(seq_no::int) as max_seq
|
|
FROM work_order_process
|
|
WHERE wo_id = $1 AND company_code = $2`,
|
|
[woId, companyCode]
|
|
);
|
|
|
|
if (maxSeqResult.rowCount === 0 || !maxSeqResult.rows[0].max_seq) return;
|
|
|
|
const maxSeq = String(maxSeqResult.rows[0].max_seq);
|
|
|
|
const incompleteCheck = await pool.query(
|
|
`SELECT COUNT(*) as cnt
|
|
FROM work_order_process
|
|
WHERE wo_id = $1 AND seq_no = $2 AND company_code = $3
|
|
AND status != 'completed'`,
|
|
[woId, maxSeq, companyCode]
|
|
);
|
|
|
|
if (parseInt(incompleteCheck.rows[0].cnt, 10) > 0) return;
|
|
|
|
const totalGoodResult = await pool.query(
|
|
`SELECT COALESCE(SUM(good_qty::int), 0) + COALESCE(SUM(concession_qty::int), 0) as total_good
|
|
FROM work_order_process
|
|
WHERE wo_id = $1 AND seq_no = $2 AND company_code = $3`,
|
|
[woId, maxSeq, companyCode]
|
|
);
|
|
|
|
const completedQty = totalGoodResult.rows[0].total_good;
|
|
|
|
const updateResult = await pool.query(
|
|
`UPDATE work_instruction
|
|
SET status = 'completed',
|
|
progress_status = 'completed',
|
|
completed_qty = $3,
|
|
writer = $4,
|
|
updated_date = NOW()
|
|
WHERE id = $1 AND company_code = $2
|
|
AND status != 'completed'
|
|
RETURNING id, item_id`,
|
|
[woId, companyCode, String(completedQty), userId]
|
|
);
|
|
|
|
logger.info("[pop/production] 작업지시 전체 완료", {
|
|
woId, completedQty, companyCode,
|
|
});
|
|
|
|
// 생산완료→재고 입고: 마지막 공정의 target_warehouse_id가 설정된 경우 inventory_stock UPSERT
|
|
if (updateResult.rowCount > 0 && completedQty > 0) {
|
|
try {
|
|
const itemId = updateResult.rows[0].item_id;
|
|
|
|
// item_info에서 item_number 조회
|
|
const itemResult = await pool.query(
|
|
`SELECT item_number FROM item_info WHERE id = $1 AND company_code = $2`,
|
|
[itemId, companyCode]
|
|
);
|
|
if (itemResult.rowCount === 0) {
|
|
logger.warn("[pop/production] 재고입고 건너뜀: item_info 없음", { itemId, companyCode });
|
|
return;
|
|
}
|
|
const itemCode = itemResult.rows[0].item_number;
|
|
|
|
// 마지막 공정의 창고 설정 조회 (마스터 행에서)
|
|
const warehouseResult = await pool.query(
|
|
`SELECT target_warehouse_id, target_location_code
|
|
FROM work_order_process
|
|
WHERE wo_id = $1 AND seq_no = $2 AND company_code = $3
|
|
AND parent_process_id IS NULL
|
|
LIMIT 1`,
|
|
[woId, maxSeq, companyCode]
|
|
);
|
|
|
|
if (warehouseResult.rowCount === 0 || !warehouseResult.rows[0].target_warehouse_id) {
|
|
logger.info("[pop/production] 재고입고 건너뜀: 목표창고 미설정", { woId });
|
|
return;
|
|
}
|
|
|
|
const warehouseCode = warehouseResult.rows[0].target_warehouse_id;
|
|
const locationCode = warehouseResult.rows[0].target_location_code || warehouseCode;
|
|
|
|
// inventory_stock UPSERT
|
|
await pool.query(
|
|
`INSERT INTO inventory_stock (id, company_code, item_code, warehouse_code, location_code, current_qty, last_in_date, created_date, updated_date, writer)
|
|
VALUES (gen_random_uuid()::text, $1, $2, $3, $4, $5, NOW(), NOW(), NOW(), $6)
|
|
ON CONFLICT (company_code, item_code, warehouse_code, location_code)
|
|
DO UPDATE SET current_qty = (COALESCE(inventory_stock.current_qty::numeric, 0) + $5::numeric)::text,
|
|
last_in_date = NOW(),
|
|
updated_date = NOW(),
|
|
writer = $6`,
|
|
[companyCode, itemCode, warehouseCode, locationCode, String(completedQty), userId]
|
|
);
|
|
|
|
logger.info("[pop/production] 생산완료→재고 입고 완료", {
|
|
woId, itemCode, warehouseCode, locationCode, qty: completedQty, companyCode,
|
|
});
|
|
} catch (inventoryError: any) {
|
|
// 재고 입고 실패해도 공정 완료는 유지 (재고는 보조 기능)
|
|
logger.error("[pop/production] 재고입고 오류 (공정 완료는 유지):", inventoryError);
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 실적 확정은 더 이상 단일 확정이 아님.
|
|
* 마지막 등록 확인 용도로 유지. 실적은 save-result에서 차수별로 쌓임.
|
|
*/
|
|
export const confirmResult = async (
|
|
req: AuthenticatedRequest,
|
|
res: Response
|
|
) => {
|
|
const pool = getPool();
|
|
|
|
try {
|
|
const companyCode = req.user!.companyCode;
|
|
const userId = req.user!.userId;
|
|
|
|
const { work_order_process_id } = req.body;
|
|
|
|
if (!work_order_process_id) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: "work_order_process_id는 필수입니다.",
|
|
});
|
|
}
|
|
|
|
const statusCheck = await pool.query(
|
|
`SELECT status, result_status, total_production_qty FROM work_order_process
|
|
WHERE id = $1 AND company_code = $2`,
|
|
[work_order_process_id, companyCode]
|
|
);
|
|
|
|
if (statusCheck.rowCount === 0) {
|
|
return res.status(404).json({
|
|
success: false,
|
|
message: "공정을 찾을 수 없습니다.",
|
|
});
|
|
}
|
|
|
|
const currentProcess = statusCheck.rows[0];
|
|
|
|
if (!currentProcess.total_production_qty ||
|
|
parseInt(currentProcess.total_production_qty, 10) <= 0) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: "등록된 실적이 없습니다. 실적을 먼저 등록해주세요.",
|
|
});
|
|
}
|
|
|
|
// 수동 확정: 무조건 completed 처리 (수동 완료 용도)
|
|
const result = await pool.query(
|
|
`UPDATE work_order_process
|
|
SET result_status = 'confirmed',
|
|
status = 'completed',
|
|
completed_at = NOW()::text,
|
|
completed_by = $3,
|
|
writer = $3,
|
|
updated_date = NOW()
|
|
WHERE id = $1 AND company_code = $2
|
|
RETURNING id, status, result_status, total_production_qty, good_qty, defect_qty`,
|
|
[work_order_process_id, companyCode, userId]
|
|
);
|
|
|
|
if (result.rowCount === 0) {
|
|
return res.status(404).json({
|
|
success: false,
|
|
message: "공정을 찾을 수 없습니다.",
|
|
});
|
|
}
|
|
|
|
// 공정 정보 조회 (다음 공정 활성화 + 마스터 캐스케이드용)
|
|
const seqCheck = await pool.query(
|
|
`SELECT wop.seq_no, wop.wo_id, wop.parent_process_id,
|
|
wi.qty as instruction_qty
|
|
FROM work_order_process wop
|
|
JOIN work_instruction wi ON wop.wo_id = wi.id AND wop.company_code = wi.company_code
|
|
WHERE wop.id = $1 AND wop.company_code = $2`,
|
|
[work_order_process_id, companyCode]
|
|
);
|
|
|
|
if (seqCheck.rowCount > 0) {
|
|
const { seq_no, wo_id, parent_process_id, instruction_qty } = seqCheck.rows[0];
|
|
const seqNum = parseInt(seq_no, 10);
|
|
const instrQty = parseInt(instruction_qty, 10) || 0;
|
|
|
|
// 다음 공정 활성화 (양품이 있으면)
|
|
const goodQty = parseInt(result.rows[0].good_qty, 10) || 0;
|
|
if (goodQty > 0) {
|
|
const nextSeq = String(seqNum + 1);
|
|
await pool.query(
|
|
`UPDATE work_order_process
|
|
SET status = CASE WHEN status IN ('waiting', 'in_progress') THEN 'acceptable' ELSE status END,
|
|
updated_date = NOW()
|
|
WHERE wo_id = $1 AND seq_no = $2 AND company_code = $3
|
|
AND parent_process_id IS NULL
|
|
AND status != 'completed'`,
|
|
[wo_id, nextSeq, companyCode]
|
|
);
|
|
}
|
|
|
|
// 마스터 자동완료 캐스케이드 (분할 행인 경우)
|
|
if (parent_process_id) {
|
|
let prevGoodQty = instrQty;
|
|
if (seqNum > 1) {
|
|
const prevSeq = String(seqNum - 1);
|
|
const prevProcess = await pool.query(
|
|
`SELECT COALESCE(SUM(good_qty::int), 0) + COALESCE(SUM(concession_qty::int), 0) as total_good
|
|
FROM work_order_process
|
|
WHERE wo_id = $1 AND seq_no = $2 AND company_code = $3`,
|
|
[wo_id, prevSeq, companyCode]
|
|
);
|
|
if (prevProcess.rowCount > 0) {
|
|
prevGoodQty = parseInt(prevProcess.rows[0].total_good, 10) || 0;
|
|
}
|
|
}
|
|
|
|
const siblingCheck = await pool.query(
|
|
`SELECT
|
|
COALESCE(SUM(input_qty::int), 0) as total_input,
|
|
COUNT(*) FILTER (WHERE status != 'completed') as incomplete_count
|
|
FROM work_order_process
|
|
WHERE wo_id = $1 AND seq_no = $2 AND company_code = $3
|
|
AND parent_process_id IS NOT NULL`,
|
|
[wo_id, seq_no, companyCode]
|
|
);
|
|
|
|
const totalInput = parseInt(siblingCheck.rows[0].total_input, 10) || 0;
|
|
const incompleteCount = parseInt(siblingCheck.rows[0].incomplete_count, 10) || 0;
|
|
const remainingAcceptable = prevGoodQty - totalInput;
|
|
|
|
if (incompleteCount === 0 && remainingAcceptable <= 0) {
|
|
await pool.query(
|
|
`UPDATE work_order_process
|
|
SET status = 'completed',
|
|
result_status = 'confirmed',
|
|
completed_at = NOW()::text,
|
|
completed_by = $3,
|
|
updated_date = NOW()
|
|
WHERE id = $1 AND company_code = $2
|
|
AND status != 'completed'`,
|
|
[parent_process_id, companyCode, userId]
|
|
);
|
|
logger.info("[pop/production] confirmResult: 마스터 자동 완료", {
|
|
masterId: parent_process_id, totalInput, prevGoodQty,
|
|
});
|
|
}
|
|
}
|
|
|
|
// 작업지시 전체 완료 판정
|
|
await checkAndCompleteWorkInstruction(pool, wo_id, companyCode, userId);
|
|
}
|
|
|
|
logger.info("[pop/production] confirm-result 완료", {
|
|
companyCode,
|
|
work_order_process_id,
|
|
userId,
|
|
finalStatus: result.rows[0].status,
|
|
});
|
|
|
|
return res.json({
|
|
success: true,
|
|
data: result.rows[0],
|
|
});
|
|
} catch (error: any) {
|
|
logger.error("[pop/production] confirm-result 오류:", error);
|
|
return res.status(500).json({
|
|
success: false,
|
|
message: error.message || "실적 확정 중 오류가 발생했습니다.",
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 실적 이력 조회 (work_order_process_log에서 차수별 추출)
|
|
* total_production_qty 변경 이력 = 각 차수의 등록 기록
|
|
*/
|
|
export const getResultHistory = async (
|
|
req: AuthenticatedRequest,
|
|
res: Response
|
|
) => {
|
|
const pool = getPool();
|
|
|
|
try {
|
|
const companyCode = req.user!.companyCode;
|
|
const rawWopId = req.query.work_order_process_id;
|
|
const work_order_process_id = Array.isArray(rawWopId) ? rawWopId[0] : rawWopId;
|
|
|
|
if (!work_order_process_id) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: "work_order_process_id는 필수입니다.",
|
|
});
|
|
}
|
|
|
|
// 소유권 확인
|
|
const ownerCheck = await pool.query(
|
|
`SELECT id FROM work_order_process WHERE id = $1 AND company_code = $2`,
|
|
[work_order_process_id, companyCode]
|
|
);
|
|
if (ownerCheck.rowCount === 0) {
|
|
return res.status(404).json({ success: false, message: "공정을 찾을 수 없습니다." });
|
|
}
|
|
|
|
// 같은 changed_at 기준으로 그룹핑하여 차수별 이력 추출
|
|
// total_production_qty가 증가한(new_value > old_value) 로그만 = 실적 등록 시점
|
|
const historyResult = await pool.query(
|
|
`WITH grouped AS (
|
|
SELECT
|
|
changed_at,
|
|
MAX(changed_by) as changed_by,
|
|
MAX(CASE WHEN changed_column = 'total_production_qty' THEN old_value END) as total_old,
|
|
MAX(CASE WHEN changed_column = 'total_production_qty' THEN new_value END) as total_new,
|
|
MAX(CASE WHEN changed_column = 'good_qty' THEN old_value END) as good_old,
|
|
MAX(CASE WHEN changed_column = 'good_qty' THEN new_value END) as good_new,
|
|
MAX(CASE WHEN changed_column = 'defect_qty' THEN old_value END) as defect_old,
|
|
MAX(CASE WHEN changed_column = 'defect_qty' THEN new_value END) as defect_new
|
|
FROM work_order_process_log
|
|
WHERE original_id = $1
|
|
AND changed_column IN ('total_production_qty', 'good_qty', 'defect_qty')
|
|
AND new_value IS NOT NULL
|
|
GROUP BY changed_at
|
|
)
|
|
SELECT * FROM grouped
|
|
WHERE total_new IS NOT NULL
|
|
AND (COALESCE(total_new::int, 0) - COALESCE(total_old::int, 0)) > 0
|
|
ORDER BY changed_at ASC`,
|
|
[work_order_process_id]
|
|
);
|
|
|
|
const batches = historyResult.rows.map((row: any, idx: number) => {
|
|
const batchQty = (parseInt(row.total_new, 10) || 0) - (parseInt(row.total_old, 10) || 0);
|
|
const batchGood = (parseInt(row.good_new, 10) || 0) - (parseInt(row.good_old, 10) || 0);
|
|
const batchDefect = (parseInt(row.defect_new, 10) || 0) - (parseInt(row.defect_old, 10) || 0);
|
|
|
|
return {
|
|
seq: idx + 1,
|
|
batch_qty: batchQty,
|
|
batch_good: batchGood,
|
|
batch_defect: batchDefect,
|
|
accumulated_total: parseInt(row.total_new, 10) || 0,
|
|
changed_at: row.changed_at,
|
|
changed_by: row.changed_by,
|
|
};
|
|
});
|
|
|
|
logger.info("[pop/production] result-history 조회", {
|
|
work_order_process_id,
|
|
batchCount: batches.length,
|
|
});
|
|
|
|
return res.json({
|
|
success: true,
|
|
data: batches,
|
|
});
|
|
} catch (error: any) {
|
|
logger.error("[pop/production] result-history 오류:", error);
|
|
return res.status(500).json({
|
|
success: false,
|
|
message: error.message || "이력 조회 중 오류가 발생했습니다.",
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 앞공정 완료량 + 접수가능량 조회
|
|
* GET /api/pop/production/available-qty?work_order_process_id=xxx
|
|
* 반환: { prevGoodQty, myInputQty, availableQty, instructionQty }
|
|
*/
|
|
export const getAvailableQty = async (req: AuthenticatedRequest, res: Response) => {
|
|
const pool = getPool();
|
|
try {
|
|
const companyCode = req.user!.companyCode;
|
|
const rawWopId = req.query.work_order_process_id;
|
|
const work_order_process_id = Array.isArray(rawWopId) ? rawWopId[0] : rawWopId;
|
|
|
|
if (!work_order_process_id) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: "work_order_process_id가 필요합니다.",
|
|
});
|
|
}
|
|
|
|
const current = await pool.query(
|
|
`SELECT wop.seq_no, wop.wo_id, wop.parent_process_id,
|
|
wi.qty as instruction_qty
|
|
FROM work_order_process wop
|
|
JOIN work_instruction wi ON wop.wo_id = wi.id AND wop.company_code = wi.company_code
|
|
WHERE wop.id = $1 AND wop.company_code = $2`,
|
|
[work_order_process_id, companyCode]
|
|
);
|
|
|
|
if (current.rowCount === 0) {
|
|
return res.status(404).json({ success: false, message: "공정을 찾을 수 없습니다." });
|
|
}
|
|
|
|
const { seq_no, wo_id, instruction_qty } = current.rows[0];
|
|
const instrQty = parseInt(instruction_qty, 10) || 0;
|
|
const seqNum = parseInt(seq_no, 10);
|
|
|
|
// 같은 공정(wo_id + seq_no)의 모든 분할 행 접수량 합산
|
|
const totalAccepted = await pool.query(
|
|
`SELECT COALESCE(SUM(input_qty::int), 0) as total_input
|
|
FROM work_order_process
|
|
WHERE wo_id = $1 AND seq_no = $2 AND company_code = $3
|
|
AND parent_process_id IS NOT NULL`,
|
|
[wo_id, seq_no, companyCode]
|
|
);
|
|
const myInputQty = parseInt(totalAccepted.rows[0].total_input, 10) || 0;
|
|
|
|
// 앞공정 양품+특채 합산
|
|
let prevGoodQty = instrQty;
|
|
if (seqNum > 1) {
|
|
const prevSeq = String(seqNum - 1);
|
|
const prevProcess = await pool.query(
|
|
`SELECT COALESCE(SUM(good_qty::int), 0) + COALESCE(SUM(concession_qty::int), 0) as total_good
|
|
FROM work_order_process
|
|
WHERE wo_id = $1 AND seq_no = $2 AND company_code = $3`,
|
|
[wo_id, prevSeq, companyCode]
|
|
);
|
|
if (prevProcess.rowCount > 0) {
|
|
prevGoodQty = parseInt(prevProcess.rows[0].total_good, 10) || 0;
|
|
}
|
|
}
|
|
|
|
const availableQty = Math.max(0, prevGoodQty - myInputQty);
|
|
|
|
logger.info("[pop/production] available-qty 조회", {
|
|
work_order_process_id,
|
|
prevGoodQty,
|
|
myInputQty,
|
|
availableQty,
|
|
instructionQty: instrQty,
|
|
});
|
|
|
|
return res.json({
|
|
success: true,
|
|
data: {
|
|
prevGoodQty,
|
|
myInputQty,
|
|
availableQty,
|
|
instructionQty: instrQty,
|
|
},
|
|
});
|
|
} catch (error: any) {
|
|
logger.error("[pop/production] available-qty 오류:", error);
|
|
return res.status(500).json({
|
|
success: false,
|
|
message: error.message || "접수가능량 조회 중 오류가 발생했습니다.",
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 공정 접수 (수량 지정)
|
|
* POST /api/pop/production/accept-process
|
|
* body: { work_order_process_id, accept_qty }
|
|
* - 접수 상한 = 앞공정.good_qty - 내.input_qty (첫 공정은 지시수량 - input_qty)
|
|
* - 추가 접수 가능 (in_progress 상태에서도)
|
|
* - status: acceptable/waiting -> in_progress (또는 이미 in_progress면 유지)
|
|
*/
|
|
export const acceptProcess = async (req: AuthenticatedRequest, res: Response) => {
|
|
const pool = getPool();
|
|
try {
|
|
const companyCode = req.user!.companyCode;
|
|
const userId = req.user!.userId;
|
|
const { work_order_process_id, accept_qty } = req.body;
|
|
|
|
if (!work_order_process_id || !accept_qty) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: "work_order_process_id와 accept_qty가 필요합니다.",
|
|
});
|
|
}
|
|
|
|
const qty = parseInt(accept_qty, 10);
|
|
if (qty <= 0) {
|
|
return res.status(400).json({ success: false, message: "접수 수량은 1 이상이어야 합니다." });
|
|
}
|
|
|
|
// 원본(마스터) 행 조회 - parent_process_id가 NULL인 행 또는 직접 지정된 행
|
|
const current = await pool.query(
|
|
`SELECT wop.id, wop.seq_no, wop.wo_id, wop.status, wop.parent_process_id,
|
|
wop.process_code, wop.process_name, wop.is_required, wop.is_fixed_order,
|
|
wop.standard_time, wop.equipment_code, wop.routing_detail_id,
|
|
wi.qty as instruction_qty
|
|
FROM work_order_process wop
|
|
JOIN work_instruction wi ON wop.wo_id = wi.id AND wop.company_code = wi.company_code
|
|
WHERE wop.id = $1 AND wop.company_code = $2`,
|
|
[work_order_process_id, companyCode]
|
|
);
|
|
|
|
if (current.rowCount === 0) {
|
|
return res.status(404).json({ success: false, message: "공정을 찾을 수 없습니다." });
|
|
}
|
|
|
|
const row = current.rows[0];
|
|
// 접수 대상은 원본(마스터) 행이어야 함
|
|
const masterId = row.parent_process_id || row.id;
|
|
|
|
if (row.status === "completed") {
|
|
return res.status(400).json({ success: false, message: "이미 완료된 공정입니다." });
|
|
}
|
|
if (row.status !== "acceptable") {
|
|
return res.status(400).json({ success: false, message: `원본 공정 상태(${row.status})에서는 접수할 수 없습니다. 접수가능 상태의 카드에서 접수해주세요.` });
|
|
}
|
|
|
|
const instrQty = parseInt(row.instruction_qty, 10) || 0;
|
|
const seqNum = parseInt(row.seq_no, 10);
|
|
|
|
// 같은 공정(wo_id + seq_no)의 모든 분할 행 접수량 합산
|
|
const totalAccepted = await pool.query(
|
|
`SELECT COALESCE(SUM(input_qty::int), 0) as total_input
|
|
FROM work_order_process
|
|
WHERE wo_id = $1 AND seq_no = $2 AND company_code = $3
|
|
AND parent_process_id IS NOT NULL`,
|
|
[row.wo_id, row.seq_no, companyCode]
|
|
);
|
|
const currentTotalInput = totalAccepted.rows[0].total_input;
|
|
|
|
// 앞공정 양품+특채 합산
|
|
let prevGoodQty = instrQty;
|
|
if (seqNum > 1) {
|
|
const prevSeq = String(seqNum - 1);
|
|
const prevProcess = await pool.query(
|
|
`SELECT COALESCE(SUM(good_qty::int), 0) + COALESCE(SUM(concession_qty::int), 0) as total_good
|
|
FROM work_order_process
|
|
WHERE wo_id = $1 AND seq_no = $2 AND company_code = $3`,
|
|
[row.wo_id, prevSeq, companyCode]
|
|
);
|
|
if (prevProcess.rowCount > 0) {
|
|
prevGoodQty = parseInt(prevProcess.rows[0].total_good, 10) || 0;
|
|
}
|
|
}
|
|
|
|
const availableQty = prevGoodQty - currentTotalInput;
|
|
if (qty > availableQty) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: `접수가능량(${availableQty})을 초과합니다. (앞공정 완료: ${prevGoodQty}, 기접수합계: ${currentTotalInput})`,
|
|
});
|
|
}
|
|
|
|
// 분할 행 INSERT (원본 행에서 공정 정보 복사)
|
|
const result = await pool.query(
|
|
`INSERT INTO work_order_process (
|
|
wo_id, seq_no, process_code, process_name, is_required, is_fixed_order,
|
|
standard_time, equipment_code, routing_detail_id,
|
|
status, input_qty, good_qty, defect_qty, total_production_qty,
|
|
result_status, accepted_by, accepted_at, started_at,
|
|
parent_process_id, company_code, writer
|
|
) VALUES (
|
|
$1, $2, $3, $4, $5, $6, $7, $8, $9,
|
|
'in_progress', $10, '0', '0', '0',
|
|
'draft', $11, NOW()::text, NOW()::text,
|
|
$12, $13, $11
|
|
) RETURNING id, input_qty, status, process_name, result_status, accepted_by`,
|
|
[
|
|
row.wo_id, row.seq_no, row.process_code, row.process_name,
|
|
row.is_required, row.is_fixed_order, row.standard_time,
|
|
row.equipment_code, row.routing_detail_id,
|
|
String(qty), userId, masterId, companyCode,
|
|
]
|
|
);
|
|
|
|
// 분할 행에 체크리스트 복사 (마스터의 routing_detail_id 또는 마스터의 기존 체크리스트에서)
|
|
const splitId = result.rows[0].id;
|
|
const checklistCount = await copyChecklistToSplit(
|
|
pool, masterId, splitId, row.routing_detail_id, companyCode, userId
|
|
);
|
|
|
|
// 마스터는 항상 acceptable 유지 (completed 전환은 saveResult에서 처리)
|
|
const newTotalInput = currentTotalInput + qty;
|
|
|
|
logger.info("[pop/production] accept-process 분할 접수 완료", {
|
|
companyCode, userId, masterId,
|
|
splitId,
|
|
acceptedQty: qty,
|
|
totalAccepted: newTotalInput,
|
|
prevGoodQty,
|
|
checklistCount,
|
|
});
|
|
|
|
return res.json({
|
|
success: true,
|
|
data: result.rows[0],
|
|
message: `${qty}개 접수 완료 (총 접수합계: ${newTotalInput})`,
|
|
});
|
|
} catch (error: any) {
|
|
logger.error("[pop/production] accept-process 오류:", error);
|
|
return res.status(500).json({
|
|
success: false,
|
|
message: error.message || "접수 중 오류가 발생했습니다.",
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 접수 취소: input_qty를 0으로 리셋하고 status를 acceptable로 되돌림
|
|
* 조건: 아직 실적(total_production_qty)이 없어야 함
|
|
*/
|
|
export const cancelAccept = async (
|
|
req: AuthenticatedRequest,
|
|
res: Response
|
|
) => {
|
|
const pool = getPool();
|
|
|
|
try {
|
|
const companyCode = req.user!.companyCode;
|
|
const userId = req.user!.userId;
|
|
const { work_order_process_id } = req.body;
|
|
|
|
if (!work_order_process_id) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: "work_order_process_id는 필수입니다.",
|
|
});
|
|
}
|
|
|
|
const current = await pool.query(
|
|
`SELECT id, status, input_qty, total_production_qty, result_status,
|
|
parent_process_id, wo_id, seq_no, process_name
|
|
FROM work_order_process
|
|
WHERE id = $1 AND company_code = $2`,
|
|
[work_order_process_id, companyCode]
|
|
);
|
|
|
|
if (current.rowCount === 0) {
|
|
return res.status(404).json({ success: false, message: "공정을 찾을 수 없습니다." });
|
|
}
|
|
|
|
const proc = current.rows[0];
|
|
|
|
// 분할 행만 취소 가능 (원본 행은 취소 대상이 아님)
|
|
if (!proc.parent_process_id) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: "원본 공정은 접수 취소할 수 없습니다. 분할된 접수 카드에서 취소해주세요.",
|
|
});
|
|
}
|
|
|
|
if (proc.status !== "in_progress") {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: `현재 상태(${proc.status})에서는 접수 취소할 수 없습니다. 진행중 상태만 가능합니다.`,
|
|
});
|
|
}
|
|
|
|
const totalProduced = parseInt(proc.total_production_qty ?? "0", 10) || 0;
|
|
const currentInputQty = parseInt(proc.input_qty ?? "0", 10) || 0;
|
|
const unproducedQty = currentInputQty - totalProduced;
|
|
|
|
if (unproducedQty <= 0) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: "취소할 미소진 접수분이 없습니다. 모든 접수량에 대해 실적이 등록되었습니다.",
|
|
});
|
|
}
|
|
|
|
let cancelledQty = unproducedQty;
|
|
|
|
if (totalProduced === 0) {
|
|
// 실적이 없으면 분할 행 완전 삭제
|
|
await pool.query(
|
|
`DELETE FROM work_order_process WHERE id = $1 AND company_code = $2`,
|
|
[work_order_process_id, companyCode]
|
|
);
|
|
} else {
|
|
// 실적이 있으면 input_qty를 실적 수량으로 축소 + 접수분 전량 생산이므로 completed
|
|
await pool.query(
|
|
`UPDATE work_order_process
|
|
SET input_qty = $3, status = 'completed', result_status = 'confirmed',
|
|
completed_at = NOW()::text, completed_by = $4,
|
|
updated_date = NOW(), writer = $4
|
|
WHERE id = $1 AND company_code = $2`,
|
|
[work_order_process_id, companyCode, String(totalProduced), userId]
|
|
);
|
|
}
|
|
|
|
// 원본(마스터) 행을 다시 acceptable로 복원 (잔여 접수 가능하도록)
|
|
await pool.query(
|
|
`UPDATE work_order_process
|
|
SET status = 'acceptable', updated_date = NOW()
|
|
WHERE id = $1 AND company_code = $2 AND parent_process_id IS NULL`,
|
|
[proc.parent_process_id, companyCode]
|
|
);
|
|
|
|
logger.info("[pop/production] cancel-accept 완료 (분할 행)", {
|
|
companyCode, userId, work_order_process_id,
|
|
masterId: proc.parent_process_id,
|
|
previousInputQty: currentInputQty,
|
|
totalProduced,
|
|
cancelledQty,
|
|
action: totalProduced === 0 ? "DELETE" : "SHRINK",
|
|
});
|
|
|
|
return res.json({
|
|
success: true,
|
|
data: { id: work_order_process_id, process_name: proc.process_name },
|
|
message: `미소진 ${cancelledQty}개 접수가 취소되었습니다.`,
|
|
});
|
|
} catch (error: any) {
|
|
logger.error("[pop/production] cancel-accept 오류:", error);
|
|
return res.status(500).json({
|
|
success: false,
|
|
message: error.message || "접수 취소 중 오류가 발생했습니다.",
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 창고 목록 조회 (POP 생산용)
|
|
*/
|
|
export const getWarehouses = async (
|
|
req: AuthenticatedRequest,
|
|
res: Response
|
|
) => {
|
|
const pool = getPool();
|
|
try {
|
|
const companyCode = req.user!.companyCode;
|
|
const result = await pool.query(
|
|
`SELECT id, warehouse_code, warehouse_name, warehouse_type
|
|
FROM warehouse_info
|
|
WHERE company_code = $1 AND COALESCE(status, '') != '삭제'
|
|
ORDER BY warehouse_name`,
|
|
[companyCode]
|
|
);
|
|
return res.json({ success: true, data: result.rows });
|
|
} catch (error: any) {
|
|
logger.error("[pop/production] 창고 목록 조회 실패:", error);
|
|
return res.status(500).json({ success: false, message: error.message });
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 특정 창고의 위치(로케이션) 목록 조회
|
|
* warehouseId는 warehouse_info.id → warehouse_code를 조회해서 warehouse_location과 매칭
|
|
*/
|
|
export const getWarehouseLocations = async (
|
|
req: AuthenticatedRequest,
|
|
res: Response
|
|
) => {
|
|
const pool = getPool();
|
|
try {
|
|
const companyCode = req.user!.companyCode;
|
|
const { warehouseId } = req.params;
|
|
if (!warehouseId) {
|
|
return res.status(400).json({ success: false, message: "warehouseId는 필수입니다." });
|
|
}
|
|
|
|
// warehouse_info.id → warehouse_code 변환
|
|
const whInfo = await pool.query(
|
|
`SELECT warehouse_code FROM warehouse_info WHERE id = $1 AND company_code = $2`,
|
|
[warehouseId, companyCode]
|
|
);
|
|
if (whInfo.rowCount === 0) {
|
|
return res.json({ success: true, data: [] });
|
|
}
|
|
const warehouseCode = whInfo.rows[0].warehouse_code;
|
|
|
|
const result = await pool.query(
|
|
`SELECT id, location_code, location_name
|
|
FROM warehouse_location
|
|
WHERE warehouse_code = $1 AND company_code = $2
|
|
ORDER BY location_name`,
|
|
[warehouseCode, companyCode]
|
|
);
|
|
return res.json({ success: true, data: result.rows });
|
|
} catch (error: any) {
|
|
logger.error("[pop/production] 창고 위치 조회 실패:", error);
|
|
return res.status(500).json({ success: false, message: error.message });
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 마지막 공정 여부 확인
|
|
* 같은 wo_id에서 현재 seq_no보다 큰 공정(마스터 행)이 없으면 마지막
|
|
*/
|
|
export const isLastProcess = async (
|
|
req: AuthenticatedRequest,
|
|
res: Response
|
|
) => {
|
|
const pool = getPool();
|
|
try {
|
|
const companyCode = req.user!.companyCode;
|
|
const { processId } = req.params;
|
|
if (!processId) {
|
|
return res.json({ success: true, data: { isLast: false } });
|
|
}
|
|
|
|
// 현재 공정의 wo_id와 seq_no 조회 (분할 행이면 parent의 seq_no 기준)
|
|
const process = await pool.query(
|
|
`SELECT wo_id, seq_no, parent_process_id
|
|
FROM work_order_process
|
|
WHERE id = $1 AND company_code = $2`,
|
|
[processId, companyCode]
|
|
);
|
|
if (process.rowCount === 0) {
|
|
return res.json({ success: true, data: { isLast: false } });
|
|
}
|
|
|
|
const { wo_id, seq_no, parent_process_id } = process.rows[0];
|
|
|
|
// 분할 행이면 마스터의 seq_no 기준으로 판단
|
|
let effectiveSeqNo = seq_no;
|
|
if (parent_process_id) {
|
|
const master = await pool.query(
|
|
`SELECT seq_no FROM work_order_process WHERE id = $1 AND company_code = $2`,
|
|
[parent_process_id, companyCode]
|
|
);
|
|
if (master.rowCount > 0) {
|
|
effectiveSeqNo = master.rows[0].seq_no;
|
|
}
|
|
}
|
|
|
|
const next = await pool.query(
|
|
`SELECT id FROM work_order_process
|
|
WHERE wo_id = $1 AND company_code = $2
|
|
AND CAST(seq_no AS int) > CAST($3 AS int)
|
|
AND parent_process_id IS NULL
|
|
LIMIT 1`,
|
|
[wo_id, companyCode, effectiveSeqNo]
|
|
);
|
|
|
|
// 현재 공정의 기존 창고 설정도 반환 (기본값 세팅용)
|
|
const warehouseInfo = await pool.query(
|
|
`SELECT target_warehouse_id, target_location_code
|
|
FROM work_order_process
|
|
WHERE id = $1 AND company_code = $2`,
|
|
[processId, companyCode]
|
|
);
|
|
|
|
return res.json({
|
|
success: true,
|
|
data: {
|
|
isLast: next.rowCount === 0,
|
|
woId: wo_id,
|
|
seqNo: effectiveSeqNo,
|
|
targetWarehouseId: warehouseInfo.rows[0]?.target_warehouse_id || null,
|
|
targetLocationCode: warehouseInfo.rows[0]?.target_location_code || null,
|
|
},
|
|
});
|
|
} catch (error: any) {
|
|
logger.error("[pop/production] 마지막 공정 확인 오류:", error);
|
|
return res.status(500).json({ success: false, message: error.message });
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 공정의 목표 창고/위치 업데이트
|
|
* 마지막 공정 완료 전 또는 완료 후 창고를 지정한다.
|
|
* 마스터 행에 저장하여 checkAndCompleteWorkInstruction이 참조할 수 있도록 한다.
|
|
*/
|
|
export const updateTargetWarehouse = async (
|
|
req: AuthenticatedRequest,
|
|
res: Response
|
|
) => {
|
|
const pool = getPool();
|
|
try {
|
|
const companyCode = req.user!.companyCode;
|
|
const userId = req.user!.userId;
|
|
const { work_order_process_id, target_warehouse_id, target_location_code } = req.body;
|
|
|
|
if (!work_order_process_id || !target_warehouse_id) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: "work_order_process_id와 target_warehouse_id는 필수입니다.",
|
|
});
|
|
}
|
|
|
|
// 분할 행이면 마스터 행도 함께 업데이트
|
|
const procInfo = await pool.query(
|
|
`SELECT parent_process_id FROM work_order_process WHERE id = $1 AND company_code = $2`,
|
|
[work_order_process_id, companyCode]
|
|
);
|
|
|
|
const idsToUpdate = [work_order_process_id];
|
|
if (procInfo.rowCount > 0 && procInfo.rows[0].parent_process_id) {
|
|
idsToUpdate.push(procInfo.rows[0].parent_process_id);
|
|
}
|
|
|
|
for (const id of idsToUpdate) {
|
|
await pool.query(
|
|
`UPDATE work_order_process
|
|
SET target_warehouse_id = $3,
|
|
target_location_code = $4,
|
|
writer = $5,
|
|
updated_date = NOW()
|
|
WHERE id = $1 AND company_code = $2`,
|
|
[id, companyCode, target_warehouse_id, target_location_code || null, userId]
|
|
);
|
|
}
|
|
|
|
logger.info("[pop/production] 목표 창고 업데이트", {
|
|
companyCode, userId, work_order_process_id,
|
|
target_warehouse_id, target_location_code,
|
|
updatedIds: idsToUpdate,
|
|
});
|
|
|
|
return res.json({ success: true, data: { target_warehouse_id, target_location_code } });
|
|
} catch (error: any) {
|
|
logger.error("[pop/production] 목표 창고 업데이트 오류:", error);
|
|
return res.status(500).json({ success: false, message: error.message });
|
|
}
|
|
};
|