462 lines
15 KiB
TypeScript
462 lines
15 KiB
TypeScript
import { NextResponse } from "next/server";
|
|
import type { NextRequest } from "next/server";
|
|
import { requireSession } from "@/lib/auth/requireSession";
|
|
import { prisma } from "@/lib/prisma";
|
|
import type { RecapTimelineResponse, RecapTimelineSegment } from "@/lib/recap/types";
|
|
|
|
type RawSegment =
|
|
| {
|
|
type: "production";
|
|
startMs: number;
|
|
endMs: number;
|
|
priority: number;
|
|
workOrderId: string | null;
|
|
sku: string | null;
|
|
label: string;
|
|
}
|
|
| {
|
|
type: "mold-change";
|
|
startMs: number;
|
|
endMs: number;
|
|
priority: number;
|
|
fromMoldId: string | null;
|
|
toMoldId: string | null;
|
|
durationSec: number;
|
|
label: string;
|
|
}
|
|
| {
|
|
type: "macrostop" | "microstop" | "slow-cycle";
|
|
startMs: number;
|
|
endMs: number;
|
|
priority: number;
|
|
reason: string | null;
|
|
durationSec: number;
|
|
label: string;
|
|
};
|
|
|
|
const EVENT_TYPES = ["mold-change", "macrostop", "microstop", "slow-cycle"] as const;
|
|
type TimelineEventType = (typeof EVENT_TYPES)[number];
|
|
const ACTIVE_STALE_MS = 2 * 60 * 1000;
|
|
const PRIORITY: Record<string, number> = {
|
|
idle: 0,
|
|
production: 1,
|
|
microstop: 2,
|
|
"slow-cycle": 2,
|
|
macrostop: 3,
|
|
"mold-change": 4,
|
|
};
|
|
|
|
function bad(status: number, error: string) {
|
|
return NextResponse.json({ ok: false, error }, { status });
|
|
}
|
|
|
|
function safeNum(value: unknown) {
|
|
if (typeof value === "number" && Number.isFinite(value)) return value;
|
|
if (typeof value === "string" && value.trim()) {
|
|
const parsed = Number(value);
|
|
if (Number.isFinite(parsed)) return parsed;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function normalizeToken(value: unknown) {
|
|
return String(value ?? "").trim();
|
|
}
|
|
|
|
function dedupeByKey<T>(rows: T[], keyFn: (row: T) => string) {
|
|
const seen = new Set<string>();
|
|
const out: T[] = [];
|
|
for (const row of rows) {
|
|
const key = keyFn(row);
|
|
if (seen.has(key)) continue;
|
|
seen.add(key);
|
|
out.push(row);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
function parseHours(raw: string | null) {
|
|
const value = Math.trunc(Number(raw || "24"));
|
|
if (!Number.isFinite(value)) return 24;
|
|
return Math.max(1, Math.min(72, value));
|
|
}
|
|
|
|
function parseDateInput(raw: string | null) {
|
|
if (!raw) return null;
|
|
const asNum = Number(raw);
|
|
if (Number.isFinite(asNum)) {
|
|
const d = new Date(asNum);
|
|
return Number.isFinite(d.getTime()) ? d : null;
|
|
}
|
|
const d = new Date(raw);
|
|
return Number.isFinite(d.getTime()) ? d : null;
|
|
}
|
|
|
|
function extractData(value: unknown) {
|
|
let parsed: unknown = value;
|
|
if (typeof value === "string") {
|
|
try {
|
|
parsed = JSON.parse(value);
|
|
} catch {
|
|
parsed = null;
|
|
}
|
|
}
|
|
const record = typeof parsed === "object" && parsed && !Array.isArray(parsed) ? (parsed as Record<string, unknown>) : {};
|
|
const nested = record.data;
|
|
if (typeof nested === "object" && nested && !Array.isArray(nested)) return nested as Record<string, unknown>;
|
|
return record;
|
|
}
|
|
|
|
function clampToRange(startMs: number, endMs: number, rangeStartMs: number, rangeEndMs: number) {
|
|
const clampedStart = Math.max(rangeStartMs, Math.min(rangeEndMs, startMs));
|
|
const clampedEnd = Math.max(rangeStartMs, Math.min(rangeEndMs, endMs));
|
|
if (clampedEnd <= clampedStart) return null;
|
|
return { startMs: clampedStart, endMs: clampedEnd };
|
|
}
|
|
|
|
function eventIncidentKey(eventType: string, data: Record<string, unknown>, fallbackTsMs: number) {
|
|
const key = String(data.incidentKey ?? data.incident_key ?? "").trim();
|
|
if (key) return key;
|
|
const alertId = String(data.alert_id ?? data.alertId ?? "").trim();
|
|
if (alertId) return `${eventType}:${alertId}`;
|
|
const startMs = safeNum(data.start_ms) ?? safeNum(data.startMs);
|
|
if (startMs != null) return `${eventType}:${Math.trunc(startMs)}`;
|
|
return `${eventType}:${fallbackTsMs}`;
|
|
}
|
|
|
|
function reasonLabelFromData(data: Record<string, unknown>) {
|
|
const direct =
|
|
String(data.reasonText ?? data.reason_label ?? data.reasonLabel ?? "").trim() || null;
|
|
if (direct) return direct;
|
|
|
|
const reason = data.reason;
|
|
if (typeof reason === "string") {
|
|
const text = reason.trim();
|
|
return text || null;
|
|
}
|
|
if (reason && typeof reason === "object" && !Array.isArray(reason)) {
|
|
const rec = reason as Record<string, unknown>;
|
|
const reasonText =
|
|
String(rec.reasonText ?? rec.reason_label ?? rec.reasonLabel ?? "").trim() || null;
|
|
if (reasonText) return reasonText;
|
|
const detail =
|
|
String(rec.detailLabel ?? rec.detail_label ?? rec.detailId ?? rec.detail_id ?? "").trim() || null;
|
|
const category =
|
|
String(rec.categoryLabel ?? rec.category_label ?? rec.categoryId ?? rec.category_id ?? "").trim() || null;
|
|
if (category && detail) return `${category} > ${detail}`;
|
|
if (detail) return detail;
|
|
if (category) return category;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function labelForStop(type: "macrostop" | "microstop" | "slow-cycle", reason: string | null) {
|
|
if (type === "macrostop") return reason ? `Paro: ${reason}` : "Paro";
|
|
if (type === "microstop") return reason ? `Microparo: ${reason}` : "Microparo";
|
|
return "Ciclo lento";
|
|
}
|
|
|
|
function isEquivalent(a: RecapTimelineSegment, b: RecapTimelineSegment) {
|
|
if (a.type !== b.type) return false;
|
|
if (a.type === "idle" && b.type === "idle") return true;
|
|
if (a.type === "production" && b.type === "production") {
|
|
return a.workOrderId === b.workOrderId && a.sku === b.sku && a.label === b.label;
|
|
}
|
|
if (a.type === "mold-change" && b.type === "mold-change") {
|
|
return a.fromMoldId === b.fromMoldId && a.toMoldId === b.toMoldId;
|
|
}
|
|
if (
|
|
(a.type === "macrostop" || a.type === "microstop" || a.type === "slow-cycle") &&
|
|
(b.type === "macrostop" || b.type === "microstop" || b.type === "slow-cycle")
|
|
) {
|
|
return a.type === b.type && a.reason === b.reason;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
export async function GET(req: NextRequest) {
|
|
const session = await requireSession();
|
|
if (!session) return bad(401, "Unauthorized");
|
|
|
|
const url = new URL(req.url);
|
|
const machineId = url.searchParams.get("machineId");
|
|
if (!machineId) return bad(400, "machineId is required");
|
|
const hours = parseHours(url.searchParams.get("hours"));
|
|
const startParam = parseDateInput(url.searchParams.get("start"));
|
|
const endParam = parseDateInput(url.searchParams.get("end"));
|
|
|
|
const machine = await prisma.machine.findFirst({
|
|
where: { id: machineId, orgId: session.orgId },
|
|
select: { id: true },
|
|
});
|
|
if (!machine) return bad(404, "Machine not found");
|
|
|
|
const end = endParam ?? new Date();
|
|
const start = startParam && startParam < end ? startParam : new Date(end.getTime() - hours * 60 * 60 * 1000);
|
|
const rangeStartMs = start.getTime();
|
|
const rangeEndMs = end.getTime();
|
|
|
|
const [cycles, events] = await Promise.all([
|
|
prisma.machineCycle.findMany({
|
|
where: {
|
|
orgId: session.orgId,
|
|
machineId,
|
|
ts: { gte: start, lte: end },
|
|
},
|
|
orderBy: { ts: "asc" },
|
|
select: {
|
|
ts: true,
|
|
cycleCount: true,
|
|
actualCycleTime: true,
|
|
workOrderId: true,
|
|
sku: true,
|
|
},
|
|
}),
|
|
prisma.machineEvent.findMany({
|
|
where: {
|
|
orgId: session.orgId,
|
|
machineId,
|
|
eventType: { in: EVENT_TYPES as unknown as string[] },
|
|
ts: { gte: new Date(start.getTime() - 24 * 60 * 60 * 1000), lte: end },
|
|
},
|
|
orderBy: { ts: "asc" },
|
|
select: {
|
|
ts: true,
|
|
eventType: true,
|
|
data: true,
|
|
},
|
|
}),
|
|
]);
|
|
|
|
const dedupedCycles = dedupeByKey(
|
|
cycles,
|
|
(cycle) =>
|
|
`${cycle.ts.getTime()}:${safeNum(cycle.cycleCount) ?? "na"}:${normalizeToken(cycle.workOrderId).toUpperCase()}:${normalizeToken(cycle.sku).toUpperCase()}:${safeNum(cycle.actualCycleTime) ?? "na"}`
|
|
);
|
|
|
|
const rawSegments: RawSegment[] = [];
|
|
|
|
let currentProduction: RawSegment | null = null;
|
|
for (const cycle of dedupedCycles) {
|
|
if (!cycle.workOrderId) continue;
|
|
const cycleStartMs = cycle.ts.getTime();
|
|
const cycleDurationMs = Math.max(1000, Math.min(600000, Math.trunc((safeNum(cycle.actualCycleTime) ?? 1) * 1000)));
|
|
const cycleEndMs = cycleStartMs + cycleDurationMs;
|
|
|
|
if (
|
|
currentProduction &&
|
|
currentProduction.type === "production" &&
|
|
currentProduction.workOrderId === cycle.workOrderId &&
|
|
currentProduction.sku === cycle.sku &&
|
|
cycleStartMs <= currentProduction.endMs + 5 * 60 * 1000
|
|
) {
|
|
currentProduction.endMs = Math.max(currentProduction.endMs, cycleEndMs);
|
|
continue;
|
|
}
|
|
|
|
if (currentProduction) rawSegments.push(currentProduction);
|
|
currentProduction = {
|
|
type: "production",
|
|
startMs: cycleStartMs,
|
|
endMs: cycleEndMs,
|
|
priority: PRIORITY.production,
|
|
workOrderId: cycle.workOrderId,
|
|
sku: cycle.sku,
|
|
label: cycle.workOrderId,
|
|
};
|
|
}
|
|
if (currentProduction) rawSegments.push(currentProduction);
|
|
|
|
const eventEpisodes = new Map<
|
|
string,
|
|
{
|
|
type: "mold-change" | "macrostop" | "microstop" | "slow-cycle";
|
|
firstTsMs: number;
|
|
lastTsMs: number;
|
|
startMs: number | null;
|
|
endMs: number | null;
|
|
durationSec: number | null;
|
|
statusActive: boolean;
|
|
statusResolved: boolean;
|
|
reason: string | null;
|
|
fromMoldId: string | null;
|
|
toMoldId: string | null;
|
|
}
|
|
>();
|
|
|
|
for (const event of events) {
|
|
const eventType = String(event.eventType || "").toLowerCase() as TimelineEventType;
|
|
if (!EVENT_TYPES.includes(eventType)) continue;
|
|
|
|
const data = extractData(event.data);
|
|
const tsMs = event.ts.getTime();
|
|
const key = eventIncidentKey(eventType, data, tsMs);
|
|
const status = String(data.status ?? "").trim().toLowerCase();
|
|
|
|
const episode = eventEpisodes.get(key) ?? {
|
|
type: eventType,
|
|
firstTsMs: tsMs,
|
|
lastTsMs: tsMs,
|
|
startMs: null,
|
|
endMs: null,
|
|
durationSec: null,
|
|
statusActive: false,
|
|
statusResolved: false,
|
|
reason: null,
|
|
fromMoldId: null,
|
|
toMoldId: null,
|
|
};
|
|
episode.firstTsMs = Math.min(episode.firstTsMs, tsMs);
|
|
episode.lastTsMs = Math.max(episode.lastTsMs, tsMs);
|
|
|
|
const startMs = safeNum(data.start_ms) ?? safeNum(data.startMs);
|
|
const endMs = safeNum(data.end_ms) ?? safeNum(data.endMs);
|
|
const durationSec =
|
|
safeNum(data.duration_sec) ??
|
|
safeNum(data.stoppage_duration_seconds) ??
|
|
safeNum(data.stop_duration_seconds) ??
|
|
safeNum(data.duration_seconds);
|
|
|
|
if (startMs != null) episode.startMs = episode.startMs == null ? startMs : Math.min(episode.startMs, startMs);
|
|
if (endMs != null) episode.endMs = episode.endMs == null ? endMs : Math.max(episode.endMs, endMs);
|
|
if (durationSec != null) episode.durationSec = Math.max(0, Math.trunc(durationSec));
|
|
|
|
if (status === "active") episode.statusActive = true;
|
|
if (status === "resolved") episode.statusResolved = true;
|
|
|
|
const reason = reasonLabelFromData(data);
|
|
if (reason) episode.reason = reason;
|
|
const fromMoldId = String(data.from_mold_id ?? data.fromMoldId ?? "").trim() || null;
|
|
const toMoldId = String(data.to_mold_id ?? data.toMoldId ?? "").trim() || null;
|
|
if (fromMoldId) episode.fromMoldId = fromMoldId;
|
|
if (toMoldId) episode.toMoldId = toMoldId;
|
|
|
|
eventEpisodes.set(key, episode);
|
|
}
|
|
|
|
for (const episode of eventEpisodes.values()) {
|
|
const startMs = Math.trunc(episode.startMs ?? episode.firstTsMs);
|
|
let endMs = Math.trunc(episode.endMs ?? episode.lastTsMs);
|
|
if (episode.statusActive && !episode.statusResolved) {
|
|
const isFreshActive = rangeEndMs - episode.lastTsMs <= ACTIVE_STALE_MS;
|
|
endMs = isFreshActive ? rangeEndMs : episode.lastTsMs;
|
|
} else if (endMs <= startMs && episode.durationSec != null && episode.durationSec > 0) {
|
|
endMs = startMs + episode.durationSec * 1000;
|
|
}
|
|
if (endMs <= startMs) continue;
|
|
|
|
if (episode.type === "mold-change") {
|
|
rawSegments.push({
|
|
type: "mold-change",
|
|
startMs,
|
|
endMs,
|
|
priority: PRIORITY["mold-change"],
|
|
fromMoldId: episode.fromMoldId,
|
|
toMoldId: episode.toMoldId,
|
|
durationSec: Math.max(0, Math.trunc((endMs - startMs) / 1000)),
|
|
label: episode.toMoldId ? `Cambio molde ${episode.toMoldId}` : "Cambio molde",
|
|
});
|
|
continue;
|
|
}
|
|
|
|
const stopType = episode.type;
|
|
rawSegments.push({
|
|
type: stopType,
|
|
startMs,
|
|
endMs,
|
|
priority: PRIORITY[stopType],
|
|
reason: episode.reason,
|
|
durationSec: Math.max(0, Math.trunc((endMs - startMs) / 1000)),
|
|
label: labelForStop(stopType, episode.reason),
|
|
});
|
|
}
|
|
|
|
const clipped = rawSegments
|
|
.map((segment) => {
|
|
const range = clampToRange(segment.startMs, segment.endMs, rangeStartMs, rangeEndMs);
|
|
return range ? { ...segment, ...range } : null;
|
|
})
|
|
.filter((segment): segment is RawSegment => !!segment);
|
|
|
|
const boundaries = new Set<number>([rangeStartMs, rangeEndMs]);
|
|
for (const segment of clipped) {
|
|
boundaries.add(segment.startMs);
|
|
boundaries.add(segment.endMs);
|
|
}
|
|
const orderedBoundaries = Array.from(boundaries).sort((a, b) => a - b);
|
|
|
|
const timeline: RecapTimelineSegment[] = [];
|
|
for (let i = 0; i < orderedBoundaries.length - 1; i += 1) {
|
|
const intervalStart = orderedBoundaries[i];
|
|
const intervalEnd = orderedBoundaries[i + 1];
|
|
if (intervalEnd <= intervalStart) continue;
|
|
|
|
const covering = clipped
|
|
.filter((segment) => segment.startMs < intervalEnd && segment.endMs > intervalStart)
|
|
.sort((a, b) => b.priority - a.priority || b.startMs - a.startMs);
|
|
|
|
const winner = covering[0];
|
|
if (!winner) {
|
|
timeline.push({ type: "idle", startMs: intervalStart, endMs: intervalEnd, label: "Idle" });
|
|
continue;
|
|
}
|
|
|
|
if (winner.type === "production") {
|
|
timeline.push({
|
|
type: "production",
|
|
startMs: intervalStart,
|
|
endMs: intervalEnd,
|
|
workOrderId: winner.workOrderId,
|
|
sku: winner.sku,
|
|
label: winner.label,
|
|
});
|
|
continue;
|
|
}
|
|
if (winner.type === "mold-change") {
|
|
timeline.push({
|
|
type: "mold-change",
|
|
startMs: intervalStart,
|
|
endMs: intervalEnd,
|
|
fromMoldId: winner.fromMoldId,
|
|
toMoldId: winner.toMoldId,
|
|
durationSec: Math.max(0, Math.trunc((intervalEnd - intervalStart) / 1000)),
|
|
label: winner.label,
|
|
});
|
|
continue;
|
|
}
|
|
|
|
timeline.push({
|
|
type: winner.type,
|
|
startMs: intervalStart,
|
|
endMs: intervalEnd,
|
|
reason: winner.reason,
|
|
durationSec: Math.max(0, Math.trunc((intervalEnd - intervalStart) / 1000)),
|
|
label: winner.label,
|
|
});
|
|
}
|
|
|
|
const merged: RecapTimelineSegment[] = [];
|
|
for (const segment of timeline) {
|
|
const prev = merged[merged.length - 1];
|
|
if (!prev || !isEquivalent(prev, segment) || prev.endMs !== segment.startMs) {
|
|
merged.push(segment);
|
|
continue;
|
|
}
|
|
prev.endMs = segment.endMs;
|
|
if (prev.type === "mold-change") prev.durationSec = Math.max(0, Math.trunc((prev.endMs - prev.startMs) / 1000));
|
|
if (prev.type === "macrostop" || prev.type === "microstop" || prev.type === "slow-cycle") {
|
|
prev.durationSec = Math.max(0, Math.trunc((prev.endMs - prev.startMs) / 1000));
|
|
}
|
|
}
|
|
|
|
const response: RecapTimelineResponse = {
|
|
range: {
|
|
start: start.toISOString(),
|
|
end: end.toISOString(),
|
|
},
|
|
segments: merged,
|
|
};
|
|
|
|
return NextResponse.json(response);
|
|
}
|