@open-mercato/core 0.10.1-develop.7709.1.046124599c → 0.10.1-develop.7714.1.9dbb8200d8

package/dist/modules/wms/components/backend/WmsPutawayQueuePage.js

@@ -0,0 +1,598 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import Link from "next/link";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { ArrowLeftRight, Package } from "lucide-react";
+import { Page, PageBody, PageHeader } from "@open-mercato/ui/backend/Page";
+import { DataTable } from "@open-mercato/ui/backend/DataTable";
+import { EmptyState } from "@open-mercato/ui/backend/EmptyState";
+import { RowActions } from "@open-mercato/ui/backend/RowActions";
+import { LoadingMessage, ErrorMessage } from "@open-mercato/ui/backend/detail";
+import { flash } from "@open-mercato/ui/backend/FlashMessages";
+import { useConfirmDialog } from "@open-mercato/ui/backend/confirm-dialog";
+import { useGuardedMutation } from "@open-mercato/ui/backend/injection/useGuardedMutation";
+import { apiCall } from "@open-mercato/ui/backend/utils/apiCall";
+import { buildOptimisticLockHeader } from "@open-mercato/ui/backend/utils/optimisticLock";
+import { raiseCrudError } from "@open-mercato/ui/backend/utils/serverErrors";
+import { surfaceRecordConflict } from "@open-mercato/ui/backend/conflicts";
+import { useT } from "@open-mercato/shared/lib/i18n/context";
+import { Button } from "@open-mercato/ui/primitives/button";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue
+} from "@open-mercato/ui/primitives/select";
+import { StatusBadge } from "@open-mercato/ui/primitives/status-badge";
+import { E } from "../../../../generated/entities.ids.generated.js";
+import { extensionPoints } from "@open-mercato/core/modules/wms/extension-points";
+import { flashMutationError } from "../../lib/flashMutationError.js";
+import {
+  AssignPutawayTaskDialog
+} from "./AssignPutawayTaskDialog.js";
+import {
+  CompletePutawayTaskDialog
+} from "./CompletePutawayTaskDialog.js";
+import {
+  canShowPutawayCompleteAction,
+  formatAgingLabel,
+  mapPutawayQueueSortDir,
+  mapPutawayQueueSortField,
+  putawayStatusVariant
+} from "./inboundStatusUi.js";
+import { applyPutawayLockTokenFromConflict } from "./putawayQueueOptimisticLock.js";
+import { MoveInventoryDialog } from "./MoveInventoryDialog.js";
+import { useWmsInventoryMutationAccess } from "./useWmsInventoryMutationAccess.js";
+import {
+  resolveCatalogVariantLabel,
+  resolveLocationLabel
+} from "./inventoryMutationLoaders.js";
+function toNumber(value) {
+  const parsed = Number(value ?? 0);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function WmsPutawayQueuePage() {
+  const t = useT();
+  const access = useWmsInventoryMutationAccess();
+  const queryClient = useQueryClient();
+  const { confirm, ConfirmDialogElement } = useConfirmDialog();
+  const { runMutation, retryLastMutation } = useGuardedMutation({
+    contextId: "wms-putaway-queue"
+  });
+  const mutationContext = React.useMemo(
+    () => ({ retryLastMutation }),
+    [retryLastMutation]
+  );
+  const [page, setPage] = React.useState(1);
+  const [statusFilter, setStatusFilter] = React.useState(
+    "active"
+  );
+  const [sorting, setSorting] = React.useState([{ id: "createdAt", desc: false }]);
+  const [completeOpen, setCompleteOpen] = React.useState(false);
+  const [activeTask, setActiveTask] = React.useState(null);
+  const [assignOpen, setAssignOpen] = React.useState(false);
+  const [assignTask, setAssignTask] = React.useState(null);
+  const [manualPutawayOpen, setManualPutawayOpen] = React.useState(false);
+  const [labelCache, setLabelCache] = React.useState({});
+  const [nowMs, setNowMs] = React.useState(() => Date.now());
+  const lockTokensRef = React.useRef({});
+  const [lockOverrides, setLockOverrides] = React.useState({});
+  React.useEffect(() => {
+    const timer = window.setInterval(() => setNowMs(Date.now()), 6e4);
+    return () => window.clearInterval(timer);
+  }, []);
+  const queryKey = React.useMemo(
+    () => ["wms-putaway-queue", page, statusFilter, sorting],
+    [page, sorting, statusFilter]
+  );
+  const tasksQuery = useQuery({
+    queryKey,
+    queryFn: async () => {
+      const sortCol = sorting[0];
+      const base = {
+        page: String(page),
+        pageSize: "50",
+        sortField: sortCol ? mapPutawayQueueSortField(sortCol.id) : "createdAt",
+        sortDir: sortCol ? mapPutawayQueueSortDir(sortCol.id, Boolean(sortCol.desc)) : "asc"
+      };
+      const load = async (status) => {
+        const params = new URLSearchParams(base);
+        if (status) params.set("status", status);
+        const call = await apiCall(
+          `/api/wms/putaway-tasks?${params.toString()}`
+        );
+        if (!call.ok) {
+          await raiseCrudError(
+            call.response,
+            t("wms.backend.putaway.errors.load", "Failed to load putaway tasks.")
+          );
+        }
+        return call.result ?? { items: [], total: 0, totalPages: 1 };
+      };
+      if (statusFilter === "active") return load("open,in_progress");
+      if (statusFilter === "all") return load();
+      return load(statusFilter);
+    }
+  });
+  React.useEffect(() => {
+    const ids = /* @__PURE__ */ new Set();
+    for (const row of tasksQuery.data?.items ?? []) {
+      if (row.catalog_variant_id) ids.add(row.catalog_variant_id);
+      if (row.source_location_id) ids.add(row.source_location_id);
+      if (row.target_location_id) ids.add(row.target_location_id);
+    }
+    const missing = [...ids].filter((id) => !labelCache[id]);
+    if (missing.length === 0) return;
+    let cancelled = false;
+    void Promise.all(
+      missing.map(async (id) => {
+        const [variant, location] = await Promise.all([
+          resolveCatalogVariantLabel(id),
+          resolveLocationLabel(id)
+        ]);
+        return [id, variant || location];
+      })
+    ).then((entries) => {
+      if (cancelled) return;
+      setLabelCache((prev) => {
+        const next = { ...prev };
+        for (const [id, label] of entries) {
+          if (label) next[id] = label;
+        }
+        return next;
+      });
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [labelCache, tasksQuery.data?.items]);
+  const applyLockTokenFromConflict = React.useCallback(
+    (taskId, status, body) => {
+      const refreshed = applyPutawayLockTokenFromConflict(lockTokensRef.current, taskId, {
+        status,
+        body
+      });
+      if (!refreshed) return;
+      setLockOverrides((prev) => ({ ...prev, [taskId]: refreshed }));
+      queryClient.setQueriesData(
+        { queryKey: ["wms-putaway-queue"] },
+        (previous) => {
+          if (!previous?.items) return previous;
+          return {
+            ...previous,
+            items: previous.items.map(
+              (row) => row.id === taskId ? { ...row, updated_at: refreshed } : row
+            )
+          };
+        }
+      );
+    },
+    [queryClient]
+  );
+  const postTaskAction = React.useCallback(
+    async (taskId, action, body, updatedAt) => {
+      if (typeof updatedAt === "string" && updatedAt.trim()) {
+        lockTokensRef.current[taskId] = updatedAt.trim();
+      }
+      let conflictHandled = false;
+      await runMutation({
+        operation: async () => {
+          const call = await apiCall(
+            `/api/wms/putaway-tasks/${encodeURIComponent(taskId)}/${action}`,
+            {
+              method: "POST",
+              headers: {
+                "content-type": "application/json",
+                ...buildOptimisticLockHeader(lockTokensRef.current[taskId])
+              },
+              body: JSON.stringify(body)
+            }
+          );
+          if (!call.ok) {
+            const refreshLockFromConflict = () => {
+              applyLockTokenFromConflict(taskId, call.status, call.result);
+              void queryClient.invalidateQueries({ queryKey: ["wms-putaway-queue"] });
+            };
+            if (surfaceRecordConflict({ status: call.status, body: call.result }, t, {
+              onRefresh: refreshLockFromConflict
+            })) {
+              refreshLockFromConflict();
+              conflictHandled = true;
+              return {};
+            }
+            await raiseCrudError(
+              call.response,
+              t("wms.backend.putaway.errors.action", "Failed to update putaway task.")
+            );
+          }
+          return call.result ?? {};
+        },
+        context: mutationContext,
+        mutationPayload: body
+      });
+      if (conflictHandled) return "conflict";
+      await queryClient.invalidateQueries({ queryKey: ["wms-putaway-queue"] });
+      return "ok";
+    },
+    [applyLockTokenFromConflict, mutationContext, queryClient, runMutation, t]
+  );
+  const resolveRowUpdatedAt = React.useCallback(
+    (row) => lockOverrides[row.id] ?? row.updated_at ?? null,
+    [lockOverrides]
+  );
+  const handleAssignSelf = React.useCallback(
+    async (row) => {
+      if (!access.userId || !access.organizationId || !access.tenantId) return;
+      try {
+        const result = await postTaskAction(
+          row.id,
+          "assign",
+          {
+            organizationId: access.organizationId,
+            tenantId: access.tenantId,
+            assignedTo: access.userId
+          },
+          resolveRowUpdatedAt(row)
+        );
+        if (result === "conflict") return;
+        flash(t("wms.backend.putaway.flash.assigned", "Putaway task assigned"), "success");
+      } catch (error) {
+        flashMutationError(error, t("wms.backend.putaway.errors.action", "Failed to update putaway task."), t);
+      }
+    },
+    [access, postTaskAction, resolveRowUpdatedAt, t]
+  );
+  const handleStart = React.useCallback(
+    async (row) => {
+      if (!access.organizationId || !access.tenantId) return;
+      try {
+        const result = await postTaskAction(
+          row.id,
+          "start",
+          {
+            organizationId: access.organizationId,
+            tenantId: access.tenantId
+          },
+          resolveRowUpdatedAt(row)
+        );
+        if (result === "conflict") return;
+        flash(t("wms.backend.putaway.flash.started", "Putaway task started"), "success");
+      } catch (error) {
+        flashMutationError(error, t("wms.backend.putaway.errors.action", "Failed to update putaway task."), t);
+      }
+    },
+    [access, postTaskAction, resolveRowUpdatedAt, t]
+  );
+  const handleCancel = React.useCallback(
+    async (row) => {
+      if (!access.organizationId || !access.tenantId) return;
+      const confirmed = await confirm({
+        title: t("wms.backend.putaway.cancel.confirm.title", "Cancel putaway task?"),
+        description: t(
+          "wms.backend.putaway.cancel.confirm.description",
+          "The task will be cancelled and will no longer appear in the active queue."
+        ),
+        confirmText: t("wms.backend.putaway.cancel.confirm.submit", "Cancel task"),
+        cancelText: t("wms.backend.putaway.cancel.confirm.keep", "Keep task"),
+        variant: "destructive"
+      });
+      if (!confirmed) return;
+      try {
+        const result = await postTaskAction(
+          row.id,
+          "cancel",
+          {
+            organizationId: access.organizationId,
+            tenantId: access.tenantId
+          },
+          resolveRowUpdatedAt(row)
+        );
+        if (result === "conflict") return;
+        flash(t("wms.backend.putaway.flash.cancelled", "Putaway task cancelled"), "success");
+      } catch (error) {
+        flashMutationError(error, t("wms.backend.putaway.errors.action", "Failed to update putaway task."), t);
+      }
+    },
+    [access, confirm, postTaskAction, resolveRowUpdatedAt, t]
+  );
+  const openComplete = React.useCallback(
+    (row) => {
+      setActiveTask({
+        id: row.id,
+        warehouseId: row.warehouse_id ?? "",
+        quantity: toNumber(row.quantity),
+        targetLocationId: row.target_location_id,
+        catalogVariantId: row.catalog_variant_id,
+        sourceLocationId: row.source_location_id,
+        serialNumber: row.serial_number,
+        updatedAt: resolveRowUpdatedAt(row)
+      });
+      setCompleteOpen(true);
+    },
+    [resolveRowUpdatedAt]
+  );
+  const openAssign = React.useCallback(
+    (row) => {
+      setAssignTask({
+        id: row.id,
+        assignedTo: row.assigned_to,
+        updatedAt: resolveRowUpdatedAt(row)
+      });
+      setAssignOpen(true);
+    },
+    [resolveRowUpdatedAt]
+  );
+  const columns = React.useMemo(
+    () => [
+      {
+        id: "status",
+        accessorKey: "status",
+        header: t("wms.backend.putaway.columns.status", "Status"),
+        enableSorting: true,
+        cell: ({ row }) => {
+          const status = row.original.status?.trim();
+          if (!status) return "\u2014";
+          return /* @__PURE__ */ jsx(StatusBadge, { variant: putawayStatusVariant(status), dot: true, children: t(`wms.backend.putaway.status.${status}`, status) });
+        }
+      },
+      {
+        id: "variant",
+        header: t("wms.backend.putaway.columns.variant", "Variant"),
+        cell: ({ row }) => {
+          const id = row.original.catalog_variant_id;
+          if (!id) return "\u2014";
+          return labelCache[id] || id.slice(0, 8);
+        }
+      },
+      {
+        id: "quantity",
+        accessorKey: "quantity",
+        header: t("wms.backend.putaway.columns.quantity", "Qty"),
+        enableSorting: true,
+        cell: ({ row }) => toNumber(row.original.quantity)
+      },
+      {
+        id: "serial",
+        accessorKey: "serial_number",
+        header: t("wms.backend.putaway.columns.serial", "Serial"),
+        cell: ({ row }) => {
+          const serial = row.original.serial_number?.trim();
+          if (!serial) return "\u2014";
+          return serial;
+        }
+      },
+      {
+        id: "source",
+        header: t("wms.backend.putaway.columns.source", "Source"),
+        cell: ({ row }) => {
+          const id = row.original.source_location_id;
+          if (!id) return "\u2014";
+          return labelCache[id] || id.slice(0, 8);
+        }
+      },
+      {
+        id: "target",
+        header: t("wms.backend.putaway.columns.target", "Target"),
+        cell: ({ row }) => {
+          const id = row.original.target_location_id;
+          if (!id) return "\u2014";
+          return labelCache[id] || id.slice(0, 8);
+        }
+      },
+      {
+        id: "assignee",
+        header: t("wms.backend.putaway.columns.assignee", "Assignee"),
+        cell: ({ row }) => {
+          const id = row.original.assigned_to;
+          if (!id) return t("wms.backend.putaway.assignee.unassigned", "Unassigned");
+          if (id === access.userId) return t("wms.backend.putaway.assignee.me", "Me");
+          return id.slice(0, 8);
+        }
+      },
+      {
+        id: "aging",
+        accessorKey: "created_at",
+        header: t("wms.backend.putaway.columns.aging", "Aging"),
+        enableSorting: true,
+        cell: ({ row }) => formatAgingLabel(row.original.created_at, nowMs) ?? "\u2014"
+      }
+    ],
+    [access.userId, labelCache, nowMs, t]
+  );
+  const rowActions = React.useCallback(
+    (row) => {
+      const status = row.status;
+      if (status !== "open" && status !== "in_progress") return null;
+      const isAssignee = Boolean(access.userId && row.assigned_to === access.userId);
+      const canComplete = canShowPutawayCompleteAction({
+        canManagePutaway: access.canManagePutaway,
+        canAdjustInventory: access.canAdjust,
+        isAssignee
+      });
+      if (!access.canManagePutaway && !canComplete) return null;
+      const items = [];
+      if (access.canManagePutaway) {
+        items.push({
+          id: "assign",
+          label: t("wms.backend.putaway.actions.assign", "Assign\u2026"),
+          onSelect: () => openAssign(row)
+        });
+        if (!row.assigned_to || row.assigned_to !== access.userId) {
+          items.push({
+            id: "assign-me",
+            label: t("wms.backend.putaway.actions.assignMe", "Assign to me"),
+            onSelect: () => void handleAssignSelf(row)
+          });
+        }
+        if (status === "open") {
+          items.push({
+            id: "start",
+            label: t("wms.backend.putaway.actions.start", "Start"),
+            onSelect: () => void handleStart(row)
+          });
+        }
+      }
+      if (canComplete) {
+        items.push({
+          id: "complete",
+          label: t("wms.backend.putaway.actions.complete", "Complete"),
+          onSelect: () => openComplete(row)
+        });
+      }
+      if (access.canManagePutaway) {
+        items.push({
+          id: "cancel",
+          label: t("wms.backend.putaway.actions.cancel", "Cancel"),
+          onSelect: () => void handleCancel(row)
+        });
+      }
+      if (items.length === 0) return null;
+      return /* @__PURE__ */ jsx(RowActions, { items });
+    },
+    [
+      access.canAdjust,
+      access.canManagePutaway,
+      access.userId,
+      handleAssignSelf,
+      handleCancel,
+      handleStart,
+      openAssign,
+      openComplete,
+      t
+    ]
+  );
+  return /* @__PURE__ */ jsxs(Page, { children: [
+    /* @__PURE__ */ jsxs(PageBody, { className: "space-y-6", children: [
+      /* @__PURE__ */ jsx(
+        PageHeader,
+        {
+          title: t("wms.backend.putaway.title", "Putaway queue"),
+          description: t(
+            "wms.backend.putaway.description",
+            "Open and in-progress putaway tasks from accepted receipts."
+          ),
+          actions: /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap gap-2", children: [
+            /* @__PURE__ */ jsx(Button, { type: "button", variant: "outline", asChild: true, children: /* @__PURE__ */ jsx(Link, { href: "/backend/wms/asns", children: t("wms.backend.putaway.actions.asns", "ASNs") }) }),
+            access.canMove ? /* @__PURE__ */ jsxs(Button, { type: "button", variant: "outline", onClick: () => setManualPutawayOpen(true), children: [
+              /* @__PURE__ */ jsx(ArrowLeftRight, { className: "size-4" }),
+              t("wms.backend.putaway.actions.manualPutaway", "Manual put away")
+            ] }) : null
+          ] })
+        }
+      ),
+      tasksQuery.isLoading ? /* @__PURE__ */ jsx(LoadingMessage, { label: t("wms.backend.putaway.loading", "Loading putaway tasks\u2026") }) : null,
+      tasksQuery.isError ? /* @__PURE__ */ jsx(ErrorMessage, { label: t("wms.backend.putaway.errors.load", "Failed to load putaway tasks.") }) : null,
+      tasksQuery.data ? /* @__PURE__ */ jsxs("section", { className: "rounded-lg border bg-card p-5 text-card-foreground shadow-sm", children: [
+        /* @__PURE__ */ jsxs("div", { className: "mb-4 flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between", children: [
+          /* @__PURE__ */ jsxs("div", { className: "flex items-start gap-3", children: [
+            /* @__PURE__ */ jsx("div", { className: "rounded-md border bg-muted/40 p-2 text-muted-foreground", children: /* @__PURE__ */ jsx(Package, { className: "size-5" }) }),
+            /* @__PURE__ */ jsxs("div", { className: "space-y-1", children: [
+              /* @__PURE__ */ jsx("h2", { className: "text-xl font-semibold", children: t("wms.backend.putaway.section.title", "Tasks") }),
+              /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground", children: t(
+                "wms.backend.putaway.section.description",
+                "Filter and complete open or in-progress putaway work."
+              ) })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs(
+            Select,
+            {
+              value: statusFilter,
+              onValueChange: (value) => {
+                setPage(1);
+                setStatusFilter(value);
+              },
+              children: [
+                /* @__PURE__ */ jsx(SelectTrigger, { className: "w-[200px]", "data-testid": "putaway-status-filter", children: /* @__PURE__ */ jsx(SelectValue, {}) }),
+                /* @__PURE__ */ jsxs(SelectContent, { children: [
+                  /* @__PURE__ */ jsx(SelectItem, { value: "active", children: t("wms.backend.putaway.filters.active", "Open + in progress") }),
+                  /* @__PURE__ */ jsx(SelectItem, { value: "open", children: t("wms.backend.putaway.status.open", "Open") }),
+                  /* @__PURE__ */ jsx(SelectItem, { value: "in_progress", children: t("wms.backend.putaway.status.in_progress", "In progress") }),
+                  /* @__PURE__ */ jsx(SelectItem, { value: "done", children: t("wms.backend.putaway.status.done", "Done") }),
+                  /* @__PURE__ */ jsx(SelectItem, { value: "cancelled", children: t("wms.backend.putaway.status.cancelled", "Cancelled") }),
+                  /* @__PURE__ */ jsx(SelectItem, { value: "all", children: t("wms.backend.putaway.filters.all", "All statuses") })
+                ] })
+              ]
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx(
+          DataTable,
+          {
+            embedded: true,
+            columns,
+            data: tasksQuery.data.items,
+            isLoading: tasksQuery.isFetching,
+            entityId: E.wms.putaway_task,
+            sortable: true,
+            manualSorting: true,
+            sorting,
+            onSortingChange: (next) => {
+              setSorting(next);
+              setPage(1);
+            },
+            rowActions,
+            pagination: {
+              page,
+              pageSize: 50,
+              total: tasksQuery.data.total,
+              totalPages: tasksQuery.data.totalPages,
+              totalIsCapped: tasksQuery.data?.totalIsCapped === true,
+              onPageChange: setPage
+            },
+            perspective: { tableId: extensionPoints.hosts.putawayTasksTable.tableId },
+            emptyState: /* @__PURE__ */ jsx(
+              EmptyState,
+              {
+                title: t("wms.backend.putaway.empty.title", "No putaway tasks"),
+                description: t(
+                  "wms.backend.putaway.empty.description",
+                  "Tasks appear after ASN lines are received with QC pass."
+                )
+              }
+            )
+          }
+        )
+      ] }) : null
+    ] }),
+    access.canManagePutaway ? /* @__PURE__ */ jsx(
+      AssignPutawayTaskDialog,
+      {
+        open: assignOpen,
+        onOpenChange: setAssignOpen,
+        access,
+        task: assignTask,
+        onConflict: (taskId, status, body) => {
+          applyLockTokenFromConflict(taskId, status, body);
+        },
+        onSuccess: () => void tasksQuery.refetch()
+      }
+    ) : null,
+    access.canAdjust ? /* @__PURE__ */ jsx(
+      CompletePutawayTaskDialog,
+      {
+        open: completeOpen,
+        onOpenChange: setCompleteOpen,
+        access,
+        task: activeTask,
+        onSuccess: () => void tasksQuery.refetch()
+      }
+    ) : null,
+    access.canMove ? /* @__PURE__ */ jsx(
+      MoveInventoryDialog,
+      {
+        open: manualPutawayOpen,
+        onOpenChange: setManualPutawayOpen,
+        access,
+        movementType: "putaway"
+      }
+    ) : null,
+    ConfirmDialogElement
+  ] });
+}
+export {
+  WmsPutawayQueuePage as default
+};
+//# sourceMappingURL=WmsPutawayQueuePage.js.map