Macrostop and timeline segmentation

app/api/machines/[machineId]/route.ts

@@ -3,7 +3,10 @@ import type { NextRequest } from "next/server";
 import { prisma } from "@/lib/prisma";
 import { requireSession } from "@/lib/auth/requireSession";
 
-function normalizeEvent(row: any) {
+function normalizeEvent(
+  row: any,
+  thresholds: { microMultiplier: number; macroMultiplier: number }
+) {
   // -----------------------------
   // 1) Parse row.data safely
   // data may be:
@@ -91,9 +94,24 @@ function normalizeEvent(row: any) {
       (typeof inner?.stop_duration_seconds === "number" && inner.stop_duration_seconds) ||
       null;
 
-    // tune these thresholds to match your MES spec
-    const MACROSTOP_SEC = 300; // 5 min
-    eventType = stopSec != null && stopSec >= MACROSTOP_SEC ? "macrostop" : "microstop";
+    const microMultiplier = Number(thresholds?.microMultiplier ?? 1.5);
+    const macroMultiplier = Math.max(
+      microMultiplier,
+      Number(thresholds?.macroMultiplier ?? 5)
+    );
+
+    const theoreticalCycle =
+      Number(inner?.theoretical_cycle_time ?? blob?.theoretical_cycle_time) || 0;
+
+    if (stopSec != null) {
+      if (theoreticalCycle > 0) {
+        const macroThresholdSec = theoreticalCycle * macroMultiplier;
+        eventType = stopSec >= macroThresholdSec ? "macrostop" : "microstop";
+      } else {
+        const fallbackMacroSec = 300;
+        eventType = stopSec >= fallbackMacroSec ? "macrostop" : "microstop";
+      }
+    }
   }
 
   // -----------------------------
@@ -203,6 +221,17 @@ export async function GET(
     return NextResponse.json({ ok: false, error: "Not found" }, { status: 404 });
   }
 
+  const orgSettings = await prisma.orgSettings.findUnique({
+    where: { orgId: session.orgId },
+    select: { stoppageMultiplier: true, macroStoppageMultiplier: true },
+  });
+
+  const microMultiplier = Number(orgSettings?.stoppageMultiplier ?? 1.5);
+  const macroMultiplier = Math.max(
+    microMultiplier,
+    Number(orgSettings?.macroStoppageMultiplier ?? 5)
+  );
+
   const rawEvents = await prisma.machineEvent.findMany({
     where: {
       orgId: session.orgId,
@@ -224,7 +253,9 @@ export async function GET(
     },
   });
 
-  const normalized = rawEvents.map(normalizeEvent);
+  const normalized = rawEvents.map((row) =>
+    normalizeEvent(row, { microMultiplier, macroMultiplier })
+  );
 
 const ALLOWED_TYPES = new Set([
   "slow-cycle",
@@ -308,14 +339,15 @@ const cycles = rawCycles
       location: machine.location,
       latestHeartbeat: machine.heartbeats[0] ?? null,
       latestKpi: machine.kpiSnapshots[0] ?? null,
-      effectiveCycleTime
+      effectiveCycleTime,
       
     },
+    thresholds: {
+      stoppageMultiplier: microMultiplier,
+      macroStoppageMultiplier: macroMultiplier,
+    },
     events,
     cycles
   });
   
 }
-
-
-

app/api/machines/pair/route.ts

@@ -3,10 +3,20 @@ import { randomBytes } from "crypto";
 import { prisma } from "@/lib/prisma";
 import { getBaseUrl } from "@/lib/appUrl";
 import { normalizePairingCode } from "@/lib/pairingCode";
+import { z } from "zod";
+
+const pairSchema = z.object({
+  code: z.string().trim().max(16).optional(),
+  pairingCode: z.string().trim().max(16).optional(),
+});
 
 export async function POST(req: Request) {
   const body = await req.json().catch(() => ({}));
-  const rawCode = String(body.code || body.pairingCode || "").trim();
+  const parsed = pairSchema.safeParse(body);
+  if (!parsed.success) {
+    return NextResponse.json({ ok: false, error: "Invalid pairing payload" }, { status: 400 });
+  }
+  const rawCode = String(parsed.data.code || parsed.data.pairingCode || "").trim();
   const code = normalizePairingCode(rawCode);
 
   if (!code || code.length !== 5) {

app/api/machines/route.ts

@@ -3,9 +3,16 @@ import { randomBytes } from "crypto";
 import { prisma } from "@/lib/prisma";
 import { cookies } from "next/headers";
 import { generatePairingCode } from "@/lib/pairingCode";
+import { z } from "zod";
 
 const COOKIE_NAME = "mis_session";
 
+const createMachineSchema = z.object({
+  name: z.string().trim().min(1).max(80),
+  code: z.string().trim().max(40).optional(),
+  location: z.string().trim().max(80).optional(),
+});
+
 async function requireSession() {
   const sessionId = (await cookies()).get(COOKIE_NAME)?.value;
   if (!sessionId) return null;
@@ -79,14 +86,15 @@ export async function POST(req: Request) {
   if (!session) return NextResponse.json({ ok: false, error: "Unauthorized" }, { status: 401 });
 
   const body = await req.json().catch(() => ({}));
-  const name = String(body.name || "").trim();
-  const codeRaw = String(body.code || "").trim();
-  const locationRaw = String(body.location || "").trim();
-
-  if (!name) {
-    return NextResponse.json({ ok: false, error: "Machine name is required" }, { status: 400 });
+  const parsed = createMachineSchema.safeParse(body);
+  if (!parsed.success) {
+    return NextResponse.json({ ok: false, error: "Invalid machine payload" }, { status: 400 });
   }
 
+  const name = parsed.data.name;
+  const codeRaw = parsed.data.code ?? "";
+  const locationRaw = parsed.data.location ?? "";
+
   const existing = await prisma.machine.findFirst({
     where: { orgId: session.orgId, name },
     select: { id: true },