@naisys/erp 3.0.0-beta.10

package/dist/routes/labor-tickets.js

@@ -0,0 +1,268 @@
+import { ClockOutLaborTicketSchema, CreateResponseSchema, ErrorResponseSchema, LaborTicketListResponseSchema, MutateResponseSchema, OperationRunStatus, } from "@naisys/erp-shared";
+import { z } from "zod/v4";
+import { hasPermission, requirePermission } from "../auth-middleware.js";
+import { notFound } from "../error-handler.js";
+import { API_PREFIX, selfLink } from "../hateoas.js";
+import { checkOpRunInProgress, formatAuditFields, formatDate, mutationResult, permGate, resolveOpRun, } from "../route-helpers.js";
+import { clockIn, clockOut, deleteLaborTicket, listLaborTickets, } from "../services/labor-ticket-service.js";
+function laborResource(orderKey, runNo, seqNo) {
+    return `orders/${orderKey}/runs/${runNo}/ops/${seqNo}/labor`;
+}
+function laborTicketListActions(orderKey, runNo, seqNo, opRunStatus, user, tickets) {
+    const actions = [];
+    const base = `${API_PREFIX}/${laborResource(orderKey, runNo, seqNo)}`;
+    const isInProgress = opRunStatus === OperationRunStatus.in_progress;
+    const isExecutor = hasPermission(user, "order_executor");
+    const executorGate = permGate(isExecutor, "order_executor");
+    const userHasOpenTicket = user != null && tickets.some((t) => t.userId === user.id && !t.clockOut);
+    const anyOpenTickets = tickets.some((t) => !t.clockOut);
+    // clock-in: show for non-executors (disabled for permission), or executors with status logic
+    if (!isExecutor) {
+        actions.push({
+            rel: "clock-in",
+            href: `${base}/clock-in`,
+            method: "POST",
+            title: "Clock In",
+            ...executorGate,
+        });
+    }
+    else if (!isInProgress) {
+        actions.push({
+            rel: "clock-in",
+            href: `${base}/clock-in`,
+            method: "POST",
+            title: "Clock In",
+            disabled: true,
+            disabledReason: "Operation must be in progress to clock in",
+        });
+    }
+    else if (!userHasOpenTicket) {
+        actions.push({
+            rel: "clock-in",
+            href: `${base}/clock-in`,
+            method: "POST",
+            title: "Clock In",
+        });
+    }
+    // clock-out for executor
+    if (isExecutor && isInProgress && userHasOpenTicket) {
+        actions.push({
+            rel: "clock-out",
+            href: `${base}/clock-out`,
+            method: "POST",
+            title: "Clock Out",
+            schema: `${API_PREFIX}/schemas/ClockOutLaborTicket`,
+            body: {},
+        });
+    }
+    // manager clock-out: for non-executor managers only
+    if (!isExecutor &&
+        hasPermission(user, "order_manager") &&
+        isInProgress &&
+        anyOpenTickets) {
+        actions.push({
+            rel: "clock-out",
+            href: `${base}/clock-out`,
+            method: "POST",
+            title: "Clock Out",
+            schema: `${API_PREFIX}/schemas/ClockOutLaborTicket`,
+            body: { userId: 0, ticketId: 0 },
+        });
+    }
+    return actions;
+}
+function laborTicketActionTemplates(orderKey, runNo, seqNo, user) {
+    if (!hasPermission(user, "order_manager"))
+        return [];
+    return [
+        {
+            rel: "deleteTicket",
+            hrefTemplate: `${API_PREFIX}/${laborResource(orderKey, runNo, seqNo)}/{ticketId}`,
+            method: "DELETE",
+            title: "Delete Ticket",
+        },
+    ];
+}
+function formatLaborTicket(orderKey, runNo, seqNo, ticket) {
+    return {
+        id: ticket.id,
+        operationRunId: ticket.operationRunId,
+        userId: ticket.userId,
+        username: ticket.user.username,
+        runId: ticket.runId,
+        clockIn: ticket.clockIn.toISOString(),
+        clockOut: formatDate(ticket.clockOut),
+        cost: ticket.cost,
+        ...formatAuditFields(ticket),
+        _links: [
+            selfLink(`/${laborResource(orderKey, runNo, seqNo)}/${ticket.id}`),
+        ],
+    };
+}
+const LaborParamsSchema = z.object({
+    orderKey: z.string(),
+    runNo: z.coerce.number().int(),
+    seqNo: z.coerce.number().int(),
+});
+const LaborTicketParamsSchema = z.object({
+    orderKey: z.string(),
+    runNo: z.coerce.number().int(),
+    seqNo: z.coerce.number().int(),
+    ticketId: z.coerce.number().int(),
+});
+export default function laborTicketRoutes(fastify) {
+    const app = fastify.withTypeProvider();
+    // LIST
+    app.get("/", {
+        schema: {
+            description: "List labor tickets for an operation run",
+            tags: ["Labor Tickets"],
+            params: LaborParamsSchema,
+            response: {
+                200: LaborTicketListResponseSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        handler: async (request, reply) => {
+            const { orderKey, runNo, seqNo } = request.params;
+            const resolved = await resolveOpRun(orderKey, runNo, seqNo);
+            if (!resolved) {
+                return notFound(reply, "Operation run not found");
+            }
+            const items = await listLaborTickets(resolved.opRun.id);
+            return {
+                items: items.map((ticket) => {
+                    const { _links, ...rest } = formatLaborTicket(orderKey, runNo, seqNo, ticket);
+                    return rest;
+                }),
+                total: items.length,
+                _links: [selfLink(`/${laborResource(orderKey, runNo, seqNo)}`)],
+                _linkTemplates: [
+                    {
+                        rel: "item",
+                        hrefTemplate: `${API_PREFIX}/${laborResource(orderKey, runNo, seqNo)}/{id}`,
+                    },
+                ],
+                _actions: laborTicketListActions(orderKey, runNo, seqNo, resolved.opRun.status, request.erpUser, items),
+                _actionTemplates: laborTicketActionTemplates(orderKey, runNo, seqNo, request.erpUser),
+            };
+        },
+    });
+    // CLOCK IN
+    app.post("/clock-in", {
+        schema: {
+            description: "Clock in to an operation run (auto clocks out any open tickets for this user)",
+            tags: ["Labor Tickets"],
+            params: LaborParamsSchema,
+            response: {
+                200: CreateResponseSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_executor"),
+        handler: async (request, reply) => {
+            const { orderKey, runNo, seqNo } = request.params;
+            const userId = request.erpUser.id;
+            const resolved = await resolveOpRun(orderKey, runNo, seqNo);
+            if (!resolved)
+                return notFound(reply, "Operation run not found");
+            const opErr = checkOpRunInProgress(resolved.opRun.status);
+            if (opErr) {
+                reply.status(409);
+                return { statusCode: 409, error: "Conflict", message: opErr };
+            }
+            const ticket = await clockIn(resolved.opRun.id, userId, userId);
+            const full = formatLaborTicket(orderKey, runNo, seqNo, ticket);
+            return mutationResult(request, reply, full, {
+                id: full.id,
+                _links: full._links,
+            });
+        },
+    });
+    // CLOCK OUT
+    app.post("/clock-out", {
+        schema: {
+            description: "Clock out of an operation run",
+            tags: ["Labor Tickets"],
+            params: LaborParamsSchema,
+            body: ClockOutLaborTicketSchema,
+            response: {
+                200: MutateResponseSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_executor"),
+        handler: async (request, reply) => {
+            const { orderKey, runNo, seqNo } = request.params;
+            const userId = request.erpUser.id;
+            const body = request.body;
+            const resolved = await resolveOpRun(orderKey, runNo, seqNo);
+            if (!resolved)
+                return notFound(reply, "Operation run not found");
+            const opErr = checkOpRunInProgress(resolved.opRun.status);
+            if (opErr) {
+                reply.status(409);
+                return { statusCode: 409, error: "Conflict", message: opErr };
+            }
+            // Non-managers can only clock out their own tickets
+            const isManager = hasPermission(request.erpUser, "order_manager");
+            const opts = {
+                userId: body.userId ?? (isManager ? undefined : userId),
+                ticketId: body.ticketId,
+            };
+            // Non-managers cannot specify another user's ID
+            if (!isManager && body.userId && body.userId !== userId) {
+                reply.status(409);
+                return {
+                    statusCode: 409,
+                    error: "Conflict",
+                    message: "Non-managers can only clock out their own tickets",
+                };
+            }
+            await clockOut(resolved.opRun.id, opts, userId);
+            // Return full list after clock-out
+            const items = await listLaborTickets(resolved.opRun.id);
+            const full = {
+                items: items.map((ticket) => {
+                    const { _links, ...rest } = formatLaborTicket(orderKey, runNo, seqNo, ticket);
+                    return rest;
+                }),
+                total: items.length,
+                _links: [selfLink(`/${laborResource(orderKey, runNo, seqNo)}`)],
+                _linkTemplates: [
+                    {
+                        rel: "item",
+                        hrefTemplate: `${API_PREFIX}/${laborResource(orderKey, runNo, seqNo)}/{id}`,
+                    },
+                ],
+                _actions: laborTicketListActions(orderKey, runNo, seqNo, resolved.opRun.status, request.erpUser, items),
+                _actionTemplates: laborTicketActionTemplates(orderKey, runNo, seqNo, request.erpUser),
+            };
+            return mutationResult(request, reply, full, {
+                _actions: full._actions,
+            });
+        },
+    });
+    // DELETE
+    app.delete("/:ticketId", {
+        schema: {
+            description: "Delete a labor ticket",
+            tags: ["Labor Tickets"],
+            params: LaborTicketParamsSchema,
+            response: {
+                204: z.void(),
+                404: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_manager"),
+        handler: async (request, reply) => {
+            const { ticketId } = request.params;
+            const userId = request.erpUser.id;
+            await deleteLaborTicket(ticketId, userId);
+            reply.status(204);
+        },
+    });
+}
+//# sourceMappingURL=labor-tickets.js.map

package/dist/routes/operation-dependencies.js

@@ -0,0 +1,170 @@
+import { CreateOperationDependencySchema, CreateResponseSchema, ErrorResponseSchema, OperationDependencyListResponseSchema, RevisionStatus, } from "@naisys/erp-shared";
+import { z } from "zod/v4";
+import { hasPermission, requirePermission } from "../auth-middleware.js";
+import { conflict, notFound } from "../error-handler.js";
+import { API_PREFIX, selfLink } from "../hateoas.js";
+import { mutationResult, resolveRevision } from "../route-helpers.js";
+import { createDependency, deleteDependency, listDependencies, } from "../services/operation-dependency-service.js";
+import { findExisting } from "../services/operation-service.js";
+const ParamsSchema = z.object({
+    orderKey: z.string(),
+    revNo: z.coerce.number().int(),
+    seqNo: z.coerce.number().int(),
+});
+const DepParamsSchema = z.object({
+    orderKey: z.string(),
+    revNo: z.coerce.number().int(),
+    seqNo: z.coerce.number().int(),
+    predecessorSeqNo: z.coerce.number().int(),
+});
+function depBasePath(orderKey, revNo, seqNo) {
+    return `/orders/${orderKey}/revs/${revNo}/ops/${seqNo}/deps`;
+}
+function formatDependency(dep) {
+    return {
+        id: dep.id,
+        predecessorSeqNo: dep.predecessor.seqNo,
+        predecessorTitle: dep.predecessor.title,
+        createdAt: dep.createdAt.toISOString(),
+        createdBy: dep.createdBy.username,
+    };
+}
+function depActionTemplates(basePath, revStatus, user) {
+    if (!hasPermission(user, "order_planner") ||
+        revStatus !== RevisionStatus.draft)
+        return [];
+    return [
+        {
+            rel: "deleteDependency",
+            hrefTemplate: `${API_PREFIX}${basePath}/{predecessorSeqNo}`,
+            method: "DELETE",
+            title: "Remove Dependency",
+        },
+    ];
+}
+export default function operationDependencyRoutes(fastify) {
+    const app = fastify.withTypeProvider();
+    // LIST dependencies (predecessors) for an operation
+    app.get("/", {
+        schema: {
+            description: "List predecessor dependencies for an operation",
+            tags: ["Operation Dependencies"],
+            params: ParamsSchema,
+            response: {
+                200: OperationDependencyListResponseSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        handler: async (request, reply) => {
+            const { orderKey, revNo, seqNo } = request.params;
+            const resolved = await resolveRevision(orderKey, revNo);
+            if (!resolved) {
+                return notFound(reply, "Revision not found");
+            }
+            const operation = await findExisting(resolved.rev.id, seqNo);
+            if (!operation) {
+                return notFound(reply, `Operation ${seqNo} not found`);
+            }
+            const items = await listDependencies(operation.id);
+            const user = request.erpUser;
+            const base = depBasePath(orderKey, revNo, seqNo);
+            return {
+                items: items.map((dep) => formatDependency(dep)),
+                total: items.length,
+                _links: [selfLink(base)],
+                _actions: hasPermission(user, "order_planner") &&
+                    resolved.rev.status === RevisionStatus.draft
+                    ? [
+                        {
+                            rel: "create",
+                            href: `${API_PREFIX}${base}`,
+                            method: "POST",
+                            title: "Add Dependency",
+                            schema: `${API_PREFIX}/schemas/CreateOperationDependency`,
+                        },
+                    ]
+                    : [],
+                _actionTemplates: depActionTemplates(base, resolved.rev.status, user),
+            };
+        },
+    });
+    // CREATE a dependency
+    app.post("/", {
+        schema: {
+            description: "Add a predecessor dependency to an operation",
+            tags: ["Operation Dependencies"],
+            params: ParamsSchema,
+            body: CreateOperationDependencySchema,
+            response: {
+                201: CreateResponseSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_planner"),
+        handler: async (request, reply) => {
+            const { orderKey, revNo, seqNo } = request.params;
+            const { predecessorSeqNo } = request.body;
+            const userId = request.erpUser.id;
+            const resolved = await resolveRevision(orderKey, revNo);
+            if (!resolved) {
+                return notFound(reply, "Revision not found");
+            }
+            if (resolved.rev.status !== RevisionStatus.draft) {
+                return conflict(reply, `Cannot modify dependencies on a ${resolved.rev.status} revision`);
+            }
+            const successor = await findExisting(resolved.rev.id, seqNo);
+            if (!successor) {
+                return notFound(reply, `Operation ${seqNo} not found`);
+            }
+            const predecessor = await findExisting(resolved.rev.id, predecessorSeqNo);
+            if (!predecessor) {
+                return notFound(reply, `Predecessor operation ${predecessorSeqNo} not found`);
+            }
+            if (successor.id === predecessor.id) {
+                return conflict(reply, "An operation cannot depend on itself");
+            }
+            const dep = await createDependency(successor.id, predecessor.id, userId);
+            const full = formatDependency(dep);
+            reply.status(201);
+            return mutationResult(request, reply, full, {
+                id: full.id,
+            });
+        },
+    });
+    // DELETE a dependency
+    app.delete("/:predecessorSeqNo", {
+        schema: {
+            description: "Remove a predecessor dependency from an operation",
+            tags: ["Operation Dependencies"],
+            params: DepParamsSchema,
+            response: {
+                204: z.void(),
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_planner"),
+        handler: async (request, reply) => {
+            const { orderKey, revNo, seqNo, predecessorSeqNo } = request.params;
+            const resolved = await resolveRevision(orderKey, revNo);
+            if (!resolved) {
+                return notFound(reply, "Revision not found");
+            }
+            if (resolved.rev.status !== RevisionStatus.draft) {
+                return conflict(reply, `Cannot modify dependencies on a ${resolved.rev.status} revision`);
+            }
+            const successor = await findExisting(resolved.rev.id, seqNo);
+            if (!successor) {
+                return notFound(reply, `Operation ${seqNo} not found`);
+            }
+            const predecessor = await findExisting(resolved.rev.id, predecessorSeqNo);
+            if (!predecessor) {
+                return notFound(reply, `Predecessor operation ${predecessorSeqNo} not found`);
+            }
+            await deleteDependency(successor.id, predecessor.id);
+            reply.status(204);
+        },
+    });
+}
+//# sourceMappingURL=operation-dependencies.js.map