@seedtactics/insight-client 16.8.4-beta.10 → 16.8.4-beta.11

package/dist/components/station-monitor/QuarantineButton.js

@@ -37,7 +37,7 @@ import { LazySeq } from "@seedtactics/immutable-collections";
 import { currentStatus } from "../../cell-status/current-status.js";
 import { inProcessMaterialInDialog, materialDialogOpen, useRemoveFromQueue, useSignalForQuarantine, } from "../../cell-status/material-details.js";
 import { currentOperator } from "../../data/operators.js";
-import { ActionType, LocType, PalletLocationEnum, QueueRole } from "../../network/api.js";
+import { ActionType, ApiException, LocType, QueueRole, } from "../../network/api.js";
 import { fmsInformation } from "../../network/server-settings.js";
 import { useAtomValue, useSetAtom } from "jotai";
 function useQuarantineMaterial(ignoreOperator) {
@@ -70,75 +70,48 @@ function useQuarantineMaterial(ignoreOperator) {
     const quarantineQueues = LazySeq.ofObject(curSt.queues)
         .filter(([qname, _]) => !activeQueues.has(qname))
         .toRSet(([qname, _]) => qname);
-    const palLoc = LazySeq.ofObject(curSt.pallets).toOrderedMap(([_, pal]) => [
-        pal.palletNum,
-        pal.currentPalletLocation,
-    ]);
     // If in a quarantine queue, allow removal from system
     if (inProcMat.location.type === LocType.InQueue &&
         inProcMat.location.currentQueue &&
         quarantineQueues.has(inProcMat.location.currentQueue)) {
         return {
             type: "Remove",
+            material: inProcMat,
             quarantine: () => removeFromQueue(inProcMat.materialID, operator),
             removing: removingFromQueue,
             quarantineQueueDestination: null,
+            removeFromQueues: null,
+            removingFromQueues: removingFromQueue,
         };
     }
     let type = null;
     switch (inProcMat.location.type) {
         case LocType.OnPallet:
-            if (fmsInfo.allowQuarantineToCancelLoad) {
-                // either cancel load or signal based on material action and pallet location
-                const palAtLoad = inProcMat.location.palletNum &&
-                    palLoc.get(inProcMat.location.palletNum)?.loc === PalletLocationEnum.LoadUnload;
-                if (inProcMat.action.type === ActionType.Loading || palAtLoad) {
-                    type = "CancelLoad";
-                }
-                else {
-                    type = "SignalForScrap";
-                }
+            if (inProcMat.action.type === ActionType.Loading) {
+                return null;
             }
-            else {
-                // must signal since it is currently on a pallet, but only if the material is not loading
-                if (inProcMat.action.type === ActionType.Loading) {
-                    return null;
-                }
-                // Check that the job outputs to a queue, only then can signaling for quarantine work
-                const job = curSt.jobs[inProcMat.jobUnique];
-                if (!job)
-                    return null;
-                const path = job.procsAndPaths?.[inProcMat.process - 1]?.paths?.[inProcMat.path - 1];
-                if (inProcMat.process != job.procsAndPaths.length && (!path || !path.outputQueue)) {
-                    return null;
-                }
-                type = "SignalForScrap";
+            // Check that the job outputs to a queue, only then can signaling for quarantine work
+            const job = curSt.jobs[inProcMat.jobUnique];
+            if (!job)
+                return null;
+            const path = job.procsAndPaths?.[inProcMat.process - 1]?.paths?.[inProcMat.path - 1];
+            if (inProcMat.process != job.procsAndPaths.length && (!path || !path.outputQueue)) {
+                return null;
             }
+            type = "SignalForScrap";
             break;
         case LocType.InQueue:
-            if ((inProcMat.action.type === ActionType.Loading ||
-                inProcMat.action.type === ActionType.LoadingToBasket) &&
-                !fmsInfo.allowQuarantineToCancelLoad) {
-                return null;
-            }
-            else if (inProcMat.action.type === ActionType.Loading ||
+            if (inProcMat.action.type === ActionType.Loading ||
                 inProcMat.action.type === ActionType.LoadingToBasket) {
-                type = "CancelLoad";
-            }
-            else {
-                type = "Scrap";
+                return null;
             }
+            type = "Scrap";
             break;
         case LocType.InBasket:
-            if (inProcMat.action.type === ActionType.Loading && !fmsInfo.allowQuarantineToCancelLoad) {
+            if (inProcMat.action.type === ActionType.Loading) {
                 return null;
             }
-            else if (inProcMat.action.type === ActionType.Loading) {
-                type = "CancelLoad";
-            }
-            else {
-                type = "Scrap";
-            }
+            type = "Scrap";
             break;
         case LocType.Free:
             type = "Scrap";
@@ -147,18 +120,51 @@ function useQuarantineMaterial(ignoreOperator) {
     if (type) {
         return {
             type,
-            quarantine: (reason) => signalQuarantine(inProcMat.materialID, operator, reason),
+            material: inProcMat,
+            quarantine: async (reason) => signalQuarantine(inProcMat.materialID, operator, reason),
             removing: signalingQuarantine,
             quarantineQueueDestination: quarantineQueue,
+            removeFromQueues: inProcMat.location.type === LocType.InQueue &&
+                inProcMat.location.currentQueue !== undefined &&
+                activeQueues.has(inProcMat.location.currentQueue) &&
+                inProcMat.action.type === ActionType.Waiting
+                ? () => removeFromQueue(inProcMat.materialID, operator)
+                : null,
+            removingFromQueues: removingFromQueue,
         };
     }
     else {
         return null;
     }
 }
+function RemoveFromQueuesButton({ material, removeFromQueues, removing, }) {
+    const [open, setOpen] = useState(false);
+    const [error, setError] = useState(null);
+    const setMatToShow = useSetAtom(materialDialogOpen);
+    async function remove() {
+        setError(null);
+        try {
+            await removeFromQueues();
+            setOpen(false);
+            setMatToShow({
+                type: "MatSummary",
+                summary: {
+                    materialID: material.materialID,
+                    partName: material.partName,
+                    serial: material.serial,
+                },
+            });
+        }
+        catch (e) {
+            setError(ApiException.isApiException(e) ? e.response : e instanceof Error ? e.message : String(e));
+        }
+    }
+    return (_jsxs(_Fragment, { children: [_jsx(Tooltip, { title: "Remove from all queues", children: _jsx(Button, { color: "primary", disabled: removing, onClick: () => setOpen(true), children: "Remove from Queues" }) }), _jsxs(Dialog, { open: open, onClose: () => setOpen(false), children: [_jsx(DialogTitle, { children: "Remove Material from Queues" }), _jsxs(DialogContent, { children: [_jsx("p", { children: "The material will be removed from all queues." }), error ? _jsx("p", { role: "alert", children: error }) : null] }), _jsxs(DialogActions, { children: [_jsx(Button, { color: "primary", disabled: removing, onClick: remove, children: "Remove from Queues" }), _jsx(Button, { color: "secondary", disabled: removing, onClick: () => setOpen(false), children: "Cancel" })] })] })] }));
+}
 export function QuarantineMatButton({ onClose, ignoreOperator, }) {
     const [open, setOpen] = useState(false);
     const [reason, setReason] = useState("");
+    const [error, setError] = useState(null);
     const q = useQuarantineMaterial(!!ignoreOperator);
     const setMatToShow = useSetAtom(materialDialogOpen);
     if (q === null)
@@ -182,19 +188,33 @@ export function QuarantineMatButton({ onClose, ignoreOperator, }) {
                 : "After unload, remove the part as scrap";
             btnTxt = q.quarantineQueueDestination ? "Quarantine" : "Scrap";
             break;
-        case "CancelLoad":
-            title = q.quarantineQueueDestination
-                ? `Cancel load and move to ${q.quarantineQueueDestination}`
-                : "Cancel load";
-            btnTxt = "Cancel Load";
-            break;
     }
-    function quarantine() {
-        q?.quarantine(reason);
-        setMatToShow(null);
-        setOpen(false);
-        setReason("");
-        onClose?.();
+    async function quarantine() {
+        if (!q)
+            return;
+        setError(null);
+        try {
+            await q.quarantine(reason);
+            setOpen(false);
+            setReason("");
+            if (q.type === "Remove") {
+                setMatToShow({
+                    type: "MatSummary",
+                    summary: {
+                        materialID: q.material.materialID,
+                        partName: q.material.partName,
+                        serial: q.material.serial,
+                    },
+                });
+            }
+            else {
+                setMatToShow(null);
+                onClose?.();
+            }
+        }
+        catch (e) {
+            setError(ApiException.isApiException(e) ? e.response : e instanceof Error ? e.message : String(e));
+        }
     }
-    return (_jsxs(_Fragment, { children: [_jsx(Tooltip, { title: title, children: _jsx(Button, { color: "primary", disabled: q.removing, onClick: () => setOpen(true), children: btnTxt }) }), _jsxs(Dialog, { open: open, onClose: () => setOpen(false), children: [_jsx(DialogTitle, { children: "Quarantine Material" }), _jsxs(DialogContent, { children: [_jsx("p", { children: title }), _jsx(TextField, { label: "Reason", value: reason, onChange: (e) => setReason(e.target.value), fullWidth: true, autoFocus: true, multiline: true })] }), _jsxs(DialogActions, { children: [_jsx(Button, { color: "primary", onClick: quarantine, children: btnTxt }), _jsx(Button, { color: "secondary", onClick: () => setOpen(false), children: "Cancel" })] })] })] }));
+    return (_jsxs(_Fragment, { children: [_jsx(Tooltip, { title: title, children: _jsx(Button, { color: "primary", disabled: q.removing, onClick: () => setOpen(true), children: btnTxt }) }), q.removeFromQueues ? (_jsx(RemoveFromQueuesButton, { material: q.material, removeFromQueues: q.removeFromQueues, removing: q.removingFromQueues })) : null, _jsxs(Dialog, { open: open, onClose: () => setOpen(false), children: [_jsx(DialogTitle, { children: "Quarantine Material" }), _jsxs(DialogContent, { children: [_jsx("p", { children: title }), _jsx(TextField, { label: "Reason", value: reason, onChange: (e) => setReason(e.target.value), fullWidth: true, autoFocus: true, multiline: true }), error ? _jsx("p", { role: "alert", children: error }) : null] }), _jsxs(DialogActions, { children: [_jsx(Button, { color: "primary", disabled: q.removing, onClick: quarantine, children: btnTxt }), _jsx(Button, { color: "secondary", onClick: () => setOpen(false), children: "Cancel" })] })] })] }));
 }

package/dist/components/station-monitor/Queues.js

@@ -69,6 +69,7 @@ import { materialDialogOpen } from "../../cell-status/material-details.js";
 import { PrintLabelButton } from "./PrintedLabel.js";
 import { AddToQueueButton, AddToQueueMaterialDialogCt, } from "./QueuesAddMaterial.js";
 import { QuarantineMatButton } from "./QuarantineButton.js";
+import { CancelLoadButton } from "./CancelLoadButton.js";
 import { AddByBarcodeDialog, scanBarcodeToAddToQueueDialog } from "../BarcodeScanning.js";
 import { InvalidateCycleDialogButton, InvalidateCycleDialogContent, } from "./InvalidateCycle.js";
 const JobTableRow = styled(TableRow, { shouldForwardProp: (prop) => prop.toString()[0] !== "$" })(({ $noBorderBottom, $highlightedRow, $noncompletedRow }) => ({
@@ -287,7 +288,7 @@ const QueuedMaterialDialog = memo(function QueuedMaterialDialog({ queueNames, })
         setInvalidateSt(null);
     }, []);
     queueNames = usePossibleQueuesForAdd(queueNames);
-    return (_jsx(MaterialDialog, { allowNote: true, onClose: onClose, highlightProcsGreaterOrEqualTo: invalidateSt?.process ?? undefined, extraDialogElements: _jsxs(_Fragment, { children: [_jsx(InvalidateCycleDialogContent, { st: invalidateSt, setState: setInvalidateSt }), _jsx(AddToQueueMaterialDialogCt, { queueNames: queueNames, st: addMatSt, setState: setAddMatSt })] }), buttons: _jsxs(_Fragment, { children: [_jsx(PrintLabelButton, {}), _jsx(QuarantineMatButton, { onClose: onClose }), _jsx(InvalidateCycleDialogButton, { onClose: onClose, st: invalidateSt, setState: setInvalidateSt }), _jsx(AddToQueueButton, { st: addMatSt, queueNames: queueNames, onClose: onClose })] }) }));
+    return (_jsx(MaterialDialog, { allowNote: true, onClose: onClose, highlightProcsGreaterOrEqualTo: invalidateSt?.process ?? undefined, extraDialogElements: _jsxs(_Fragment, { children: [_jsx(InvalidateCycleDialogContent, { st: invalidateSt, setState: setInvalidateSt }), _jsx(AddToQueueMaterialDialogCt, { queueNames: queueNames, st: addMatSt, setState: setAddMatSt })] }), buttons: _jsxs(_Fragment, { children: [_jsx(PrintLabelButton, {}), _jsx(QuarantineMatButton, { onClose: onClose }), _jsx(CancelLoadButton, { onClose: onClose }), _jsx(InvalidateCycleDialogButton, { onClose: onClose, st: invalidateSt, setState: setInvalidateSt }), _jsx(AddToQueueButton, { st: addMatSt, queueNames: queueNames, onClose: onClose })] }) }));
 });
 export const Queues = (props) => {
     const operator = useAtomValue(currentOperator);

package/dist/components/station-monitor/QueuesAddMaterial.js

@@ -183,6 +183,7 @@ export function AddToQueueButton({ st: { enteredOperator, newMaterialTy, toQueue
     const [addExistingMat, addingExistingMat] = matDetails.useAddExistingMaterialToQueue();
     const [addNewMat, addingNewMat] = matDetails.useAddNewMaterialToQueue();
     const [addNewCasting, addingNewCasting] = useAddNewCastingToQueue();
+    const [addError, setAddError] = useState(null);
     const allowAdd = useAllowAddToQueue(queueNames);
     if (!allowAdd) {
         return null;
@@ -213,52 +214,62 @@ export function AddToQueueButton({ st: { enteredOperator, newMaterialTy, toQueue
         withSerialMsg = " With Serial " + newSerial;
     }
     const curQueue = inProcMat?.location.currentQueue ?? null;
-    return (_jsx(_Fragment, { children: _jsx(Tooltip, { title: toQueue === null
-                ? "Select a queue to add the material to"
-                : fmsInfo.requireOperatorNamePromptWhenAddingMaterial &&
-                    (enteredOperator === null || enteredOperator === "")
-                    ? "Please enter an operator name"
-                    : "", children: _jsx("span", { children: _jsx(Button, { color: "primary", disabled: toQueue === null ||
-                        addingExistingMat ||
-                        addingNewMat ||
-                        addingNewCasting ||
-                        (existingMat === null && newMaterialTy === null) ||
-                        (fmsInfo.requireOperatorNamePromptWhenAddingMaterial &&
-                            (enteredOperator === null || enteredOperator === "")), onClick: () => {
-                        if (existingMat) {
-                            addExistingMat({
-                                materialId: existingMat.materialID,
-                                queue: toQueue ?? "",
-                                queuePosition: -1,
-                                operator: enteredOperator ?? operator,
-                            });
-                        }
-                        else if (newMaterialTy &&
-                            newMaterialTy.kind === "JobAndProc" &&
-                            newMaterialTy.jobUnique) {
-                            addNewMat({
-                                jobUnique: newMaterialTy.jobUnique,
-                                lastCompletedProcess: newMaterialTy.last_proc,
-                                serial: newSerial ?? undefined,
-                                workorder: newWorkorder ?? newMaterialTy?.workorder,
-                                queue: toQueue ?? "",
-                                queuePosition: -1,
-                                operator: enteredOperator ?? operator,
-                            });
-                        }
-                        else if (newMaterialTy &&
-                            newMaterialTy.kind === "RawMat" &&
-                            newMaterialTy.rawMatName) {
-                            addNewCasting({
-                                casting: newMaterialTy.rawMatName,
-                                quantity: 1,
-                                queue: toQueue ?? "",
-                                serials: newSerial ? [newSerial] : undefined,
-                                workorder: newWorkorder,
-                                operator: enteredOperator ?? operator,
-                            });
-                        }
-                        setMatToShow(null);
-                        onClose();
-                    }, children: toQueue === null ? ("Add to Queue") : (_jsxs("span", { children: [curQueue !== null ? `Move From ${curQueue} To` : "Add To", " ", toQueue, withSerialMsg, addProcMsg] })) }) }) }) }));
+    return (_jsxs(_Fragment, { children: [_jsx(Tooltip, { title: toQueue === null
+                    ? "Select a queue to add the material to"
+                    : fmsInfo.requireOperatorNamePromptWhenAddingMaterial &&
+                        (enteredOperator === null || enteredOperator === "")
+                        ? "Please enter an operator name"
+                        : "", children: _jsx("span", { children: _jsx(Button, { color: "primary", disabled: toQueue === null ||
+                            addingExistingMat ||
+                            addingNewMat ||
+                            addingNewCasting ||
+                            (existingMat === null && newMaterialTy === null) ||
+                            (fmsInfo.requireOperatorNamePromptWhenAddingMaterial &&
+                                (enteredOperator === null || enteredOperator === "")), onClick: async () => {
+                            setAddError(null);
+                            try {
+                                if (existingMat) {
+                                    await addExistingMat({
+                                        materialId: existingMat.materialID,
+                                        queue: toQueue ?? "",
+                                        queuePosition: -1,
+                                        operator: enteredOperator ?? operator,
+                                    });
+                                }
+                                else if (newMaterialTy &&
+                                    newMaterialTy.kind === "JobAndProc" &&
+                                    newMaterialTy.jobUnique) {
+                                    await addNewMat({
+                                        jobUnique: newMaterialTy.jobUnique,
+                                        lastCompletedProcess: newMaterialTy.last_proc,
+                                        serial: newSerial ?? undefined,
+                                        workorder: newWorkorder ?? newMaterialTy?.workorder,
+                                        queue: toQueue ?? "",
+                                        queuePosition: -1,
+                                        operator: enteredOperator ?? operator,
+                                    });
+                                }
+                                else if (newMaterialTy &&
+                                    newMaterialTy.kind === "RawMat" &&
+                                    newMaterialTy.rawMatName) {
+                                    await addNewCasting({
+                                        casting: newMaterialTy.rawMatName,
+                                        quantity: 1,
+                                        queue: toQueue ?? "",
+                                        serials: newSerial ? [newSerial] : undefined,
+                                        workorder: newWorkorder,
+                                        operator: enteredOperator ?? operator,
+                                    });
+                                }
+                                setMatToShow(null);
+                                onClose();
+                            }
+                            catch (e) {
+                                setAddError(api.ApiException.isApiException(e)
+                                    ? e.response
+                                    : e instanceof Error
+                                        ? e.message
+                                        : String(e));
+                            }
+                        }, children: toQueue === null ? ("Add to Queue") : (_jsxs("span", { children: [curQueue !== null ? `Move From ${curQueue} To` : "Add To", " ", toQueue, withSerialMsg, addProcMsg] })) }) }) }), addError ? _jsx("p", { role: "alert", children: addError }) : null] }));
 }

package/dist/components/station-monitor/SystemOverview.js

@@ -43,6 +43,7 @@ import { last30Jobs } from "../../cell-status/scheduled-jobs.js";
 import { addDays } from "date-fns";
 import { durationToSeconds } from "../../util/parseISODuration.js";
 import { InvalidateCycleDialogButton, InvalidateCycleDialogContent, SwapMaterialButtons, SwapMaterialDialogContent, } from "./InvalidateCycle.js";
+import { CancelLoadButton } from "./CancelLoadButton.js";
 import { QuarantineMatButton } from "./QuarantineButton.js";
 import { SelectInspTypeDialog, SignalInspectionButton } from "./SelectInspType.js";
 import { useSetTitle } from "../routes.js";
@@ -825,7 +826,7 @@ const SystemOverviewMaterialDialog = memo(function SystemOverviewMaterialDialog(
         setSwapSt(null);
         setInvalidateSt(null);
     }
-    return (_jsx(MaterialDialog, { onClose: onClose, allowNote: true, highlightProcsGreaterOrEqualTo: invalidateSt?.process ?? undefined, extraDialogElements: _jsxs(_Fragment, { children: [_jsx(SwapMaterialDialogContent, { st: swapSt, setState: setSwapSt }), invalidateSt !== null ? (_jsx(InvalidateCycleDialogContent, { st: invalidateSt, setState: setInvalidateSt })) : null] }), buttons: _jsxs(_Fragment, { children: [_jsx(QuarantineMatButton, { ignoreOperator: ignoreOperator }), _jsx(SignalInspectionButton, {}), _jsx(SwapMaterialButtons, { st: swapSt, setState: setSwapSt, onClose: onClose, ignoreOperator: ignoreOperator }), _jsx(InvalidateCycleDialogButton, { st: invalidateSt, setState: setInvalidateSt, onClose: onClose, ignoreOperator: ignoreOperator })] }) }));
+    return (_jsx(MaterialDialog, { onClose: onClose, allowNote: true, highlightProcsGreaterOrEqualTo: invalidateSt?.process ?? undefined, extraDialogElements: _jsxs(_Fragment, { children: [_jsx(SwapMaterialDialogContent, { st: swapSt, setState: setSwapSt }), invalidateSt !== null ? (_jsx(InvalidateCycleDialogContent, { st: invalidateSt, setState: setInvalidateSt })) : null] }), buttons: _jsxs(_Fragment, { children: [_jsx(QuarantineMatButton, { ignoreOperator: ignoreOperator }), _jsx(CancelLoadButton, { onClose: onClose, ignoreOperator: ignoreOperator }), _jsx(SignalInspectionButton, {}), _jsx(SwapMaterialButtons, { st: swapSt, setState: setSwapSt, onClose: onClose, ignoreOperator: ignoreOperator }), _jsx(InvalidateCycleDialogButton, { st: invalidateSt, setState: setInvalidateSt, onClose: onClose, ignoreOperator: ignoreOperator })] }) }));
 });
 export function SystemOverviewPage({ ignoreOperator, whiteBackground, }) {
     useSetTitle("System Overview");

package/dist/components/station-monitor/Whiteboard.js

@@ -58,12 +58,12 @@ export const SortableRegion = memo(function SortableRegion(props) {
             const overMatId = over ? numericId(over.id) : null;
             if (over && active.id !== over.id && activeMatId !== null && overMatId !== null) {
                 const overIdx = props.matIds.indexOf(overMatId);
-                addExistingMatToQueue({
+                void addExistingMatToQueue({
                     materialId: activeMatId,
                     queue: props.queueName,
                     queuePosition: overIdx,
                     operator: operator,
-                });
+                }).catch(console.error);
                 reorderQueuedMat({
                     queue: props.queueName,
                     matId: activeMatId,

package/dist/index.html

@@ -43,7 +43,7 @@
         }
       }
     </style>
-    <script type="module" crossorigin src="/assets/index-BB3Eqktr.js"></script>
+    <script type="module" crossorigin src="/assets/index-CQhVwNX7.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-DXfAwuj-.css">
   </head>
   <body>

package/dist/network/api.d.ts

@@ -53,6 +53,8 @@ export declare class JobsClient {
     protected processRemoveMaterialFromAllQueues(response: Response): Promise<void>;
     signalMaterialForQuarantine(materialId: number, operName: string | null | undefined, reason: string | undefined, signal?: AbortSignal): Promise<void>;
     protected processSignalMaterialForQuarantine(response: Response): Promise<void>;
+    cancelLoad(materialId: number, operName: string | null | undefined, request: CancelLoadRequest, signal?: AbortSignal): Promise<void>;
+    protected processCancelLoad(response: Response): Promise<void>;
     invalidatePalletCycle(materialId: number, operName: string | null | undefined, changeCastingTo: string | null | undefined, changeJobUniqueTo: string | null | undefined, process: number, signal?: AbortSignal): Promise<MaterialDetails>;
     protected processInvalidatePalletCycle(response: Response): Promise<MaterialDetails>;
     swapMaterialOnPallet(materialId: number, operName: string | null | undefined, mat: MatToPutOnPallet, signal?: AbortSignal): Promise<void>;
@@ -140,7 +142,6 @@ export declare class FMSInfo implements IFMSInfo {
     openIDConnectClientId?: string | undefined;
     usingLabelPrinterForSerials?: boolean | undefined;
     useClientPrinterForLabels?: boolean | undefined;
-    allowQuarantineToCancelLoad?: boolean | undefined;
     quarantineQueue?: string | undefined;
     customStationMonitorDialogUrl?: string | undefined;
     supportsRebookings?: string | undefined;
@@ -172,7 +173,6 @@ export interface IFMSInfo {
     openIDConnectClientId?: string | undefined;
     usingLabelPrinterForSerials?: boolean | undefined;
     useClientPrinterForLabels?: boolean | undefined;
-    allowQuarantineToCancelLoad?: boolean | undefined;
     quarantineQueue?: string | undefined;
     customStationMonitorDialogUrl?: string | undefined;
     supportsRebookings?: string | undefined;
@@ -722,7 +722,7 @@ export declare class CurrentStatus implements ICurrentStatus {
         [key: string]: BasketStatus;
     } | undefined;
     basketMoveInstructions?: BasketMoveInstruction[] | undefined;
-    customState?: unknown | undefined;
+    customState?: any | undefined;
     constructor(data?: ICurrentStatus);
     init(_data?: any): void;
     static fromJS(data: any): CurrentStatus;
@@ -747,7 +747,7 @@ export interface ICurrentStatus {
         [key: string]: BasketStatus;
     } | undefined;
     basketMoveInstructions?: BasketMoveInstruction[] | undefined;
-    customState?: unknown | undefined;
+    customState?: any | undefined;
 }
 export declare class HistoricJob extends Job implements IHistoricJob {
     scheduleId?: string | undefined;
@@ -905,6 +905,7 @@ export declare enum LocType {
 export declare class InProcessMaterialAction implements IInProcessMaterialAction {
     type: ActionType;
     workId?: string | undefined;
+    loadCancellationId?: string | undefined;
     loadOntoPalletNum?: number | undefined;
     loadOntoFace?: number | undefined;
     processAfterLoad?: number | undefined;
@@ -927,6 +928,7 @@ export declare class InProcessMaterialAction implements IInProcessMaterialAction
 export interface IInProcessMaterialAction {
     type: ActionType;
     workId?: string | undefined;
+    loadCancellationId?: string | undefined;
     loadOntoPalletNum?: number | undefined;
     loadOntoFace?: number | undefined;
     processAfterLoad?: number | undefined;
@@ -1369,6 +1371,18 @@ export interface IQueuePosition {
     queue: string;
     position: number;
 }
+export declare class CancelLoadRequest implements ICancelLoadRequest {
+    expectedLoadCancellationId: string;
+    reason?: string | undefined;
+    constructor(data?: ICancelLoadRequest);
+    init(_data?: any): void;
+    static fromJS(data: any): CancelLoadRequest;
+    toJSON(data?: any): any;
+}
+export interface ICancelLoadRequest {
+    expectedLoadCancellationId: string;
+    reason?: string | undefined;
+}
 export declare class MatToPutOnPallet implements IMatToPutOnPallet {
     pallet: number;
     materialIDToSetOnPallet: number;

package/dist/network/api.js

@@ -853,6 +853,45 @@ export class JobsClient {
         }
         return Promise.resolve(null);
     }
+    cancelLoad(materialId, operName, request, signal) {
+        let url_ = this.baseUrl + "/api/v1/jobs/material/{materialId}/cancel-load?";
+        if (materialId === undefined || materialId === null)
+            throw new globalThis.Error("The parameter 'materialId' must be defined.");
+        url_ = url_.replace("{materialId}", encodeURIComponent("" + materialId));
+        if (operName !== undefined && operName !== null)
+            url_ += "operName=" + encodeURIComponent("" + operName) + "&";
+        url_ = url_.replace(/[?&]$/, "");
+        const content_ = JSON.stringify(request);
+        let options_ = {
+            body: content_,
+            method: "PUT",
+            signal,
+            headers: {
+                "Content-Type": "application/json",
+            },
+        };
+        return this.http.fetch(url_, options_).then((_response) => {
+            return this.processCancelLoad(_response);
+        });
+    }
+    processCancelLoad(response) {
+        const status = response.status;
+        let _headers = {};
+        if (response.headers && response.headers.forEach) {
+            response.headers.forEach((v, k) => (_headers[k] = v));
+        }
+        if (status === 200) {
+            return response.text().then((_responseText) => {
+                return;
+            });
+        }
+        else if (status !== 200 && status !== 204) {
+            return response.text().then((_responseText) => {
+                return throwException("An unexpected server error occurred.", status, _responseText, _headers);
+            });
+        }
+        return Promise.resolve(null);
+    }
     invalidatePalletCycle(materialId, operName, changeCastingTo, changeJobUniqueTo, process, signal) {
         let url_ = this.baseUrl + "/api/v1/jobs/material/{materialId}/invalidate-process?";
         if (materialId === undefined || materialId === null)
@@ -2239,7 +2278,6 @@ export class FMSInfo {
             this.openIDConnectClientId = _data["OpenIDConnectClientId"];
             this.usingLabelPrinterForSerials = _data["UsingLabelPrinterForSerials"];
             this.useClientPrinterForLabels = _data["UseClientPrinterForLabels"];
-            this.allowQuarantineToCancelLoad = _data["AllowQuarantineToCancelLoad"];
             this.quarantineQueue = _data["QuarantineQueue"];
             this.customStationMonitorDialogUrl = _data["CustomStationMonitorDialogUrl"];
             this.supportsRebookings = _data["SupportsRebookings"];
@@ -2287,7 +2325,6 @@ export class FMSInfo {
         data["OpenIDConnectClientId"] = this.openIDConnectClientId;
         data["UsingLabelPrinterForSerials"] = this.usingLabelPrinterForSerials;
         data["UseClientPrinterForLabels"] = this.useClientPrinterForLabels;
-        data["AllowQuarantineToCancelLoad"] = this.allowQuarantineToCancelLoad;
         data["QuarantineQueue"] = this.quarantineQueue;
         data["CustomStationMonitorDialogUrl"] = this.customStationMonitorDialogUrl;
         data["SupportsRebookings"] = this.supportsRebookings;
@@ -3982,6 +4019,7 @@ export class InProcessMaterialAction {
         if (_data) {
             this.type = _data["Type"];
             this.workId = _data["WorkId"];
+            this.loadCancellationId = _data["LoadCancellationId"];
             this.loadOntoPalletNum = _data["LoadOntoPalletNum"];
             this.loadOntoFace = _data["LoadOntoFace"];
             this.processAfterLoad = _data["ProcessAfterLoad"];
@@ -4008,6 +4046,7 @@ export class InProcessMaterialAction {
         data = typeof data === "object" ? data : {};
         data["Type"] = this.type;
         data["WorkId"] = this.workId;
+        data["LoadCancellationId"] = this.loadCancellationId;
         data["LoadOntoPalletNum"] = this.loadOntoPalletNum;
         data["LoadOntoFace"] = this.loadOntoFace;
         data["ProcessAfterLoad"] = this.processAfterLoad;
@@ -5058,6 +5097,34 @@ export class QueuePosition {
         return data;
     }
 }
+export class CancelLoadRequest {
+    constructor(data) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    this[property] = data[property];
+            }
+        }
+    }
+    init(_data) {
+        if (_data) {
+            this.expectedLoadCancellationId = _data["ExpectedLoadCancellationId"];
+            this.reason = _data["Reason"];
+        }
+    }
+    static fromJS(data) {
+        data = typeof data === "object" ? data : {};
+        let result = new CancelLoadRequest();
+        result.init(data);
+        return result;
+    }
+    toJSON(data) {
+        data = typeof data === "object" ? data : {};
+        data["ExpectedLoadCancellationId"] = this.expectedLoadCancellationId;
+        data["Reason"] = this.reason;
+        return data;
+    }
+}
 export class MatToPutOnPallet {
     constructor(data) {
         if (data) {

package/dist/network/backend-mock.js

@@ -226,6 +226,9 @@ export function registerMockBackend(offsetSeconds, mockD, mockEvts) {
         signalMaterialForQuarantine() {
             return Promise.resolve();
         },
+        cancelLoad() {
+            return Promise.resolve();
+        },
         swapMaterialOnPallet() {
             return Promise.resolve();
         },

package/dist/network/backend.d.ts

@@ -11,6 +11,7 @@ export interface JobAPI {
     addUnprocessedMaterialToQueue(jobUnique: string, lastCompletedProcess: number, queue: string, pos: number, operatorName: string | null, workorder: string | null, serial: string): Promise<Readonly<api.IInProcessMaterial> | undefined>;
     addUnallocatedCastingToQueue(castingName: string, queue: string, qty: number, operatrorName: string | null, workorder: string | null, serials: string[]): Promise<ReadonlyArray<Readonly<api.IInProcessMaterial>>>;
     signalMaterialForQuarantine(materialId: number, operName: string | null, reason: string | undefined): Promise<void>;
+    cancelLoad(materialId: number, operName: string | null, request: Readonly<api.ICancelLoadRequest>): Promise<void>;
     swapMaterialOnPallet(materialId: number, operName: string | null, mat: Readonly<api.IMatToPutOnPallet>): Promise<void>;
     invalidatePalletCycle(materialId: number, operName: string | null | undefined, changeCastingTo: string | null | undefined, changeJobUniqueTo: string | null | undefined, process: number): Promise<Readonly<api.IMaterialDetails> | null | undefined>;
     unscheduledRebookings(signal?: AbortSignal): Promise<ReadonlyArray<Readonly<api.IRebooking>>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seedtactics/insight-client",
-  "version": "16.8.4-beta.10",
+  "version": "16.8.4-beta.11",
   "license": "BSD-3-Clause",
   "repository": {
     "url": "https://github.com/SeedTactics/fms-insight"