jason
404 lines
13 KiB
TypeScript
404 lines
13 KiB
TypeScript
// Admin-dashboard data-access helpers. Built as plain async functions so admin
|
|
// server components can await them directly (no HTTP round-trip) and we can
|
|
// still expose them under /api/v1 later if a client UI needs live refresh.
|
|
//
|
|
// All of these are read-only. Write paths stay in the existing route handlers.
|
|
|
|
import { prisma } from "./prisma";
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Work-in-progress
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Operations currently being worked on the shop floor: status is either
|
|
* `in_progress` (an operator holds the claim) or `partial` (unclaimed but has
|
|
* unitsCompleted logged — resumable). Ordered newest-claim first so the most
|
|
* recent activity surfaces at the top of the dashboard.
|
|
*/
|
|
export async function getWipOperations(limit = 50) {
|
|
const rows = await prisma.operation.findMany({
|
|
where: { status: { in: ["in_progress", "partial"] } },
|
|
orderBy: [{ status: "asc" }, { claimedAt: "desc" }, { updatedAt: "desc" }],
|
|
take: limit,
|
|
select: {
|
|
id: true,
|
|
sequence: true,
|
|
name: true,
|
|
status: true,
|
|
claimedAt: true,
|
|
unitsCompleted: true,
|
|
plannedMinutes: true,
|
|
plannedUnits: true,
|
|
machine: { select: { name: true, kind: true } },
|
|
claimedBy: { select: { id: true, name: true } },
|
|
part: {
|
|
select: {
|
|
id: true,
|
|
code: true,
|
|
name: true,
|
|
qty: true,
|
|
assembly: {
|
|
select: {
|
|
id: true,
|
|
code: true,
|
|
name: true,
|
|
qty: true,
|
|
project: { select: { id: true, code: true, name: true } },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
});
|
|
return rows;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// QC failures (blocked steps)
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Operations currently in `qc_failed` — an operator stamped a failing QC
|
|
* record on close and the step is blocked until an admin hits qc-reset.
|
|
* We surface the most recent failing QCRecord alongside so the dashboard
|
|
* can show the failing note / who did the inspection without needing a
|
|
* second round-trip.
|
|
*/
|
|
export async function getQcFailures(limit = 25) {
|
|
const rows = await prisma.operation.findMany({
|
|
where: { status: "qc_failed" },
|
|
orderBy: { updatedAt: "desc" },
|
|
take: limit,
|
|
select: {
|
|
id: true,
|
|
sequence: true,
|
|
name: true,
|
|
kind: true,
|
|
updatedAt: true,
|
|
part: {
|
|
select: {
|
|
id: true,
|
|
code: true,
|
|
name: true,
|
|
assembly: {
|
|
select: {
|
|
id: true,
|
|
code: true,
|
|
project: { select: { id: true, code: true, name: true } },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
qcRecords: {
|
|
where: { passed: false },
|
|
orderBy: { createdAt: "desc" },
|
|
take: 1,
|
|
select: {
|
|
id: true,
|
|
createdAt: true,
|
|
notes: true,
|
|
operator: { select: { id: true, name: true } },
|
|
},
|
|
},
|
|
},
|
|
});
|
|
return rows;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Overdue projects
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Projects whose `dueDate` has passed and which are not yet `completed` /
|
|
* `cancelled`. We also compute a completion percentage (completed ops /
|
|
* total ops) so the dashboard can show "40% through, 3 days late" at a
|
|
* glance. Project is the only entity in the schema with a due-date field;
|
|
* there's no per-operation deadline.
|
|
*/
|
|
export async function getOverdueProjects(now: Date = new Date(), limit = 50) {
|
|
const projects = await prisma.project.findMany({
|
|
where: {
|
|
dueDate: { lt: now },
|
|
status: { notIn: ["completed", "cancelled"] },
|
|
},
|
|
orderBy: { dueDate: "asc" },
|
|
take: limit,
|
|
select: {
|
|
id: true,
|
|
code: true,
|
|
name: true,
|
|
status: true,
|
|
dueDate: true,
|
|
assemblies: {
|
|
select: {
|
|
parts: {
|
|
select: {
|
|
_count: { select: { operations: true } },
|
|
operations: { select: { status: true } },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
return projects.map((p) => {
|
|
let total = 0;
|
|
let completed = 0;
|
|
for (const a of p.assemblies) {
|
|
for (const part of a.parts) {
|
|
for (const op of part.operations) {
|
|
total += 1;
|
|
if (op.status === "completed") completed += 1;
|
|
}
|
|
}
|
|
}
|
|
return {
|
|
id: p.id,
|
|
code: p.code,
|
|
name: p.name,
|
|
status: p.status,
|
|
dueDate: p.dueDate!, // guaranteed non-null by the where clause
|
|
totalOps: total,
|
|
completedOps: completed,
|
|
progressPct: total === 0 ? 0 : Math.round((completed / total) * 100),
|
|
daysLate: Math.max(0, Math.floor((now.getTime() - p.dueDate!.getTime()) / 86_400_000)),
|
|
};
|
|
});
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Hours: plan vs actual
|
|
// ---------------------------------------------------------------------------
|
|
//
|
|
// We fetch every closed TimeLog in the window (endedAt IS NOT NULL, inside
|
|
// since..until) and sum durations ourselves rather than using SQL GROUP BY —
|
|
// Prisma's groupBy doesn't support computed duration columns, and a shop
|
|
// floor's TimeLog volume (tens/day) makes in-memory aggregation trivial.
|
|
//
|
|
// "Plan" is the sum of Operation.plannedMinutes scoped the same way: ops
|
|
// that have ANY TimeLog overlapping the window. That keeps plan and actual
|
|
// comparable — we don't count ops the team never touched.
|
|
|
|
export interface HoursRow {
|
|
id: string; // machine or operator id
|
|
name: string;
|
|
kind: "machine" | "operator";
|
|
actualMinutes: number;
|
|
plannedMinutes: number | null; // null when no ops in the window had plans
|
|
operations: number; // distinct ops touched
|
|
}
|
|
|
|
export interface HoursReport {
|
|
sinceIso: string;
|
|
untilIso: string;
|
|
byMachine: HoursRow[];
|
|
byOperator: HoursRow[];
|
|
unassignedMachineMinutes: number; // ops with machineId null
|
|
totalActualMinutes: number;
|
|
totalPlannedMinutes: number;
|
|
}
|
|
|
|
export async function getHoursReport(since: Date, until: Date = new Date()): Promise<HoursReport> {
|
|
const logs = await prisma.timeLog.findMany({
|
|
where: {
|
|
endedAt: { not: null, gte: since, lte: until },
|
|
},
|
|
select: {
|
|
startedAt: true,
|
|
endedAt: true,
|
|
operatorId: true,
|
|
operator: { select: { name: true } },
|
|
operation: {
|
|
select: {
|
|
id: true,
|
|
plannedMinutes: true,
|
|
machineId: true,
|
|
machine: { select: { name: true } },
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
const byMachine = new Map<string, HoursRow>();
|
|
const byOperator = new Map<string, HoursRow>();
|
|
// Ops we've already counted a plan for (plannedMinutes is per-op, not per-log)
|
|
const planCountedOps = new Set<string>();
|
|
// Distinct ops seen per bucket, so `operations` isn't double-counted across logs
|
|
const opsPerMachine = new Map<string, Set<string>>();
|
|
const opsPerOperator = new Map<string, Set<string>>();
|
|
|
|
let unassignedMachineMinutes = 0;
|
|
let totalActual = 0;
|
|
let totalPlanned = 0;
|
|
|
|
for (const log of logs) {
|
|
const minutes = Math.max(
|
|
0,
|
|
Math.round((log.endedAt!.getTime() - log.startedAt.getTime()) / 60_000),
|
|
);
|
|
if (minutes === 0) continue;
|
|
totalActual += minutes;
|
|
|
|
// --- by machine ---
|
|
const mId = log.operation.machineId;
|
|
if (mId) {
|
|
const row = byMachine.get(mId) ?? {
|
|
id: mId,
|
|
name: log.operation.machine?.name ?? "(unknown)",
|
|
kind: "machine" as const,
|
|
actualMinutes: 0,
|
|
plannedMinutes: 0,
|
|
operations: 0,
|
|
};
|
|
row.actualMinutes += minutes;
|
|
byMachine.set(mId, row);
|
|
const ops = opsPerMachine.get(mId) ?? new Set<string>();
|
|
ops.add(log.operation.id);
|
|
opsPerMachine.set(mId, ops);
|
|
} else {
|
|
unassignedMachineMinutes += minutes;
|
|
}
|
|
|
|
// --- by operator ---
|
|
const opRow = byOperator.get(log.operatorId) ?? {
|
|
id: log.operatorId,
|
|
name: log.operator.name,
|
|
kind: "operator" as const,
|
|
actualMinutes: 0,
|
|
plannedMinutes: 0,
|
|
operations: 0,
|
|
};
|
|
opRow.actualMinutes += minutes;
|
|
byOperator.set(log.operatorId, opRow);
|
|
const ops = opsPerOperator.get(log.operatorId) ?? new Set<string>();
|
|
ops.add(log.operation.id);
|
|
opsPerOperator.set(log.operatorId, ops);
|
|
|
|
// --- planned total (per-op, once) ---
|
|
if (log.operation.plannedMinutes != null && !planCountedOps.has(log.operation.id)) {
|
|
planCountedOps.add(log.operation.id);
|
|
totalPlanned += log.operation.plannedMinutes;
|
|
if (mId) {
|
|
const row = byMachine.get(mId)!;
|
|
row.plannedMinutes = (row.plannedMinutes ?? 0) + log.operation.plannedMinutes;
|
|
}
|
|
// Operator plans don't really make sense (one op, many operators) —
|
|
// leave byOperator.plannedMinutes at 0 and only show actual in that table.
|
|
}
|
|
}
|
|
|
|
// Resolve distinct op counts
|
|
for (const [id, ops] of opsPerMachine) byMachine.get(id)!.operations = ops.size;
|
|
for (const [id, ops] of opsPerOperator) byOperator.get(id)!.operations = ops.size;
|
|
|
|
// Machines without plans → display null so UI shows "—"
|
|
for (const row of byMachine.values()) {
|
|
if (row.plannedMinutes === 0) row.plannedMinutes = null;
|
|
}
|
|
for (const row of byOperator.values()) row.plannedMinutes = null;
|
|
|
|
return {
|
|
sinceIso: since.toISOString(),
|
|
untilIso: until.toISOString(),
|
|
byMachine: [...byMachine.values()].sort((a, b) => b.actualMinutes - a.actualMinutes),
|
|
byOperator: [...byOperator.values()].sort((a, b) => b.actualMinutes - a.actualMinutes),
|
|
unassignedMachineMinutes,
|
|
totalActualMinutes: totalActual,
|
|
totalPlannedMinutes: totalPlanned,
|
|
};
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Audit log
|
|
// ---------------------------------------------------------------------------
|
|
|
|
export interface AuditQuery {
|
|
limit?: number;
|
|
cursor?: string | null; // AuditLog.id — we order by at desc, so cursor = last id on the page
|
|
action?: string | null;
|
|
entity?: string | null;
|
|
actorId?: string | null;
|
|
since?: Date | null;
|
|
until?: Date | null;
|
|
}
|
|
|
|
export async function getAuditLog(q: AuditQuery = {}) {
|
|
const limit = Math.min(200, Math.max(1, q.limit ?? 50));
|
|
const rows = await prisma.auditLog.findMany({
|
|
where: {
|
|
...(q.action ? { action: q.action } : {}),
|
|
...(q.entity ? { entity: q.entity } : {}),
|
|
...(q.actorId ? { actorId: q.actorId } : {}),
|
|
...(q.since || q.until
|
|
? { at: { ...(q.since ? { gte: q.since } : {}), ...(q.until ? { lte: q.until } : {}) } }
|
|
: {}),
|
|
},
|
|
orderBy: { at: "desc" },
|
|
take: limit + 1, // over-fetch by one so we can tell if there's a next page
|
|
...(q.cursor ? { cursor: { id: q.cursor }, skip: 1 } : {}),
|
|
select: {
|
|
id: true,
|
|
actorId: true,
|
|
action: true,
|
|
entity: true,
|
|
entityId: true,
|
|
before: true,
|
|
after: true,
|
|
ipAddress: true,
|
|
at: true,
|
|
actor: { select: { id: true, name: true, role: true } },
|
|
},
|
|
});
|
|
const hasMore = rows.length > limit;
|
|
const page = hasMore ? rows.slice(0, limit) : rows;
|
|
return { rows: page, nextCursor: hasMore ? page[page.length - 1]?.id ?? null : null };
|
|
}
|
|
|
|
/**
|
|
* Distinct facet values so the admin filter dropdowns know what to offer
|
|
* (instead of making the user guess action/entity names).
|
|
*/
|
|
export async function getAuditFacets() {
|
|
const [actions, entities, actors] = await Promise.all([
|
|
prisma.auditLog.findMany({ select: { action: true }, distinct: ["action"], orderBy: { action: "asc" } }),
|
|
prisma.auditLog.findMany({ select: { entity: true }, distinct: ["entity"], orderBy: { entity: "asc" } }),
|
|
prisma.user.findMany({
|
|
where: { auditLogs: { some: {} } },
|
|
select: { id: true, name: true, role: true },
|
|
orderBy: { name: "asc" },
|
|
}),
|
|
]);
|
|
return {
|
|
actions: actions.map((a) => a.action),
|
|
entities: entities.map((e) => e.entity),
|
|
actors,
|
|
};
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Formatters (shared across admin pages)
|
|
// ---------------------------------------------------------------------------
|
|
|
|
export function formatMinutes(m: number): string {
|
|
if (m < 60) return `${m}m`;
|
|
const hours = Math.floor(m / 60);
|
|
const mins = m % 60;
|
|
return mins === 0 ? `${hours}h` : `${hours}h ${mins}m`;
|
|
}
|
|
|
|
export function formatRelative(d: Date, now: Date = new Date()): string {
|
|
const sec = Math.round((now.getTime() - d.getTime()) / 1000);
|
|
if (sec < 45) return "just now";
|
|
if (sec < 90) return "a minute ago";
|
|
const min = Math.round(sec / 60);
|
|
if (min < 60) return `${min}m ago`;
|
|
const hr = Math.round(min / 60);
|
|
if (hr < 24) return `${hr}h ago`;
|
|
const day = Math.round(hr / 24);
|
|
if (day < 30) return `${day}d ago`;
|
|
return d.toLocaleDateString();
|
|
}
|