@seedtactics/insight-client 16.4.0

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

@@ -0,0 +1,166 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/* Copyright (c) 2020, John Lenz
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of John Lenz, Black Maple Software, SeedTactics,
+      nor the names of other contributors may be used to endorse or
+      promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+import { useRef, useCallback, useEffect, useMemo, Fragment } from "react";
+import JsBarcode from "jsbarcode";
+import { LazySeq } from "@seedtactics/immutable-collections";
+import { currentStatus } from "../../cell-status/current-status.js";
+import { useAtomValue } from "jotai";
+import { useReactToPrint } from "react-to-print";
+import { Button } from "@mui/material";
+import { fmsInformation } from "../../network/server-settings.js";
+import { inProcessMaterialInDialog, materialInDialogInfo, usePrintLabel, } from "../../cell-status/material-details.js";
+function Barcode(props) {
+    const ref = useRef(null);
+    const setRef = useCallback((node) => {
+        if (node) {
+            JsBarcode(node, props.text, {
+                format: "CODE128",
+            });
+        }
+        ref.current = node;
+    }, [props.text]);
+    useEffect(() => {
+        if (ref.current) {
+            JsBarcode(ref.current, props.text, {
+                format: "CODE128",
+                fontSize: 30,
+            });
+        }
+    }, [props.text]);
+    return _jsx("svg", { ref: setRef });
+}
+function SinglePage(props) {
+    return (_jsxs("div", { children: [_jsx("div", { style: { marginTop: "4em", display: "flex", justifyContent: "center" }, children: _jsx("h2", { children: "SeedTactic: FMS Insight" }) }), _jsx("div", { style: { display: "flex", justifyContent: "center" }, children: _jsx("p", { style: { fontSize: "x-large" }, children: new Date().toLocaleString(undefined, {
+                        weekday: "long",
+                        month: "long",
+                        day: "numeric",
+                        year: "numeric",
+                        hour: "numeric",
+                        minute: "2-digit",
+                        second: "2-digit",
+                    }) }) }), _jsxs("div", { style: { marginTop: "2em", display: "flex", justifyContent: "space-around" }, children: [_jsx(Barcode, { text: props.materialName ?? props.partName }), props.count >= 2 ? _jsx(Barcode, { text: props.count.toString() }) : undefined] }), props.serial1 && props.serial1 !== "" ? (_jsxs("div", { style: { marginTop: "2em", display: "flex", justifyContent: "space-around" }, children: [_jsx(Barcode, { text: props.serial1 }), props.serial2 && props.serial2 !== "" ? _jsx(Barcode, { text: props.serial2 || "" }) : undefined] })) : undefined, _jsx("div", { style: { marginTop: "2em", marginLeft: "4em", marginRight: "4em", marginBottom: "9em" }, children: props.uniq === null || props.uniq === "" ? (_jsx("p", { style: { fontSize: "x-large" }, children: "Not currently assigned to any jobs" })) : (_jsxs(_Fragment, { children: [_jsx("p", { style: { fontSize: "x-large" }, children: "Assigned To" }), _jsxs("div", { style: { marginTop: "1em", marginLeft: "2em", display: "flex", alignItems: "center" }, children: [_jsx(Barcode, { text: props.partName }), _jsxs("h3", { style: { marginLeft: "4em" }, children: ["assigned to ", props.uniq, props.jobCycles && props.jobCycles > 0
+                                            ? " (" + props.jobCycles.toString() + " scheduled)"
+                                            : ""] })] })] })) }), props.note ? (_jsx("div", { style: { marginBottom: "2em" }, children: _jsx("p", { style: { fontSize: "xxx-large", textAlign: "center" }, children: props.note }) })) : undefined, _jsx("div", { style: { display: "flex", justifyContent: "center" }, children: props.operator ? _jsx("p", { style: { fontSize: "x-large" }, children: props.operator }) : undefined })] }));
+}
+function OneJobPerPage(props) {
+    const allJobs = useAtomValue(currentStatus).jobs;
+    const assignments = useMemo(() => LazySeq.of(props.material || [])
+        .filter((m) => m.jobUnique !== null && m.jobUnique !== undefined && m.jobUnique !== "")
+        .groupBy((m) => m.jobUnique)
+        .map(([uniq, mats]) => [
+        uniq,
+        {
+            cycles: allJobs[uniq]?.cycles ?? 0,
+            length: mats.length,
+            part: mats[0]?.partName ?? "",
+            comment: allJobs[uniq]?.comment,
+            serial1: mats[0]?.serial,
+            serial2: mats[mats.length - 1]?.serial,
+        },
+    ])
+        .toSortedArray(([_, p]) => p.part), [props.material, allJobs]);
+    if (!props.material || props.material.length === 0) {
+        return _jsx("div", {});
+    }
+    else if (assignments.length === 0) {
+        return (_jsx(SinglePage, { partName: props.material[0].partName, materialName: props.materialName, count: props.material.length, uniq: null, note: null, operator: props.operator, serial1: props.material[0].serial, serial2: props.material[props.material.length - 1]?.serial }));
+    }
+    else {
+        return (_jsx("div", { children: assignments.map(([uniq, a], idx) => (_jsxs(Fragment, { children: [_jsx(SinglePage, { partName: a.part, materialName: props.materialName, count: a.length, uniq: uniq, jobCycles: a.cycles, note: a.comment, operator: props.operator, serial1: a.serial1, serial2: a.serial2 }), idx < assignments.length - 1 ? _jsx("div", { style: { pageBreakAfter: "always" } }) : undefined] }, idx))) }));
+    }
+}
+function CombinedToOnePage(props) {
+    const assignments = useMemo(() => LazySeq.of(props.material || [])
+        .filter((m) => m.jobUnique !== null && m.jobUnique !== undefined && m.jobUnique !== "")
+        .groupBy((m) => m.jobUnique)
+        .map(([k, mats]) => [k, { length: mats.length, part: mats[0]?.partName ?? "" }])
+        .toSortedArray(([_, p]) => p.part), [props.material]);
+    const allJobs = useAtomValue(currentStatus).jobs;
+    const notes = useMemo(() => LazySeq.of(props.material || [])
+        .collect((m) => (m.jobUnique ? allJobs[m.jobUnique]?.comment : undefined))
+        .distinct()
+        .toSortedArray((n) => n), [props.material, allJobs]);
+    if (!props.material || props.material.length === 0) {
+        return _jsx("div", {});
+    }
+    return (_jsxs("div", { children: [_jsx("div", { style: { marginTop: "4em", display: "flex", justifyContent: "center" }, children: _jsx("h2", { children: "SeedTactic: FMS Insight" }) }), _jsx("div", { style: { display: "flex", justifyContent: "center" }, children: _jsx("p", { style: { fontSize: "x-large" }, children: new Date().toLocaleString(undefined, {
+                        weekday: "long",
+                        month: "long",
+                        day: "numeric",
+                        year: "numeric",
+                        hour: "numeric",
+                        minute: "2-digit",
+                        second: "2-digit",
+                    }) }) }), _jsxs("div", { style: { marginTop: "2em", display: "flex", justifyContent: "space-around" }, children: [_jsx(Barcode, { text: props.materialName ?? props.material[0].partName }), props.material.length >= 2 ? _jsx(Barcode, { text: props.material.length.toString() }) : undefined] }), props.material[0].serial && props.material[0].serial !== "" ? (_jsxs("div", { style: { marginTop: "2em", display: "flex", justifyContent: "space-around" }, children: [_jsx(Barcode, { text: props.material[0].serial }), props.material.length >= 2 &&
+                        props.material[props.material.length - 1].serial &&
+                        props.material[props.material.length - 1].serial !== "" ? (_jsx(Barcode, { text: props.material[props.material.length - 1].serial || "" })) : undefined] })) : undefined, _jsx("div", { style: { marginTop: "2em", marginLeft: "4em", marginRight: "4em", marginBottom: "9em" }, children: assignments.length === 0 ? (_jsx("p", { style: { fontSize: "x-large" }, children: "Not currently assigned to any jobs" })) : props.materialName ? (_jsxs(_Fragment, { children: [_jsx("p", { style: { fontSize: "x-large" }, children: "Assigned To" }), assignments.map(([uniq, part], idx) => (_jsxs("div", { style: { marginTop: "1em", marginLeft: "2em", display: "flex", alignItems: "center" }, children: [_jsx(Barcode, { text: part.part }), _jsxs("h3", { style: { marginLeft: "4em" }, children: ["x", part.length] }), _jsxs("h3", { style: { marginLeft: "4em" }, children: ["assigned to ", uniq] })] }, idx)))] })) : assignments.length === 1 ? (_jsx("div", { style: { marginTop: "1em", display: "flex", justifyContent: "space-around" }, children: _jsxs("p", { style: { fontSize: "x-large" }, children: [_jsxs("span", { children: ["Assigned to ", assignments[0][0]] }), assignments[0][1].length > 1 ? (_jsxs("span", { style: { marginLeft: "1em" }, children: ["x", assignments[0][1].length] })) : undefined] }) })) : (_jsxs(_Fragment, { children: [_jsx("p", { style: { fontSize: "x-large" }, children: "Assigned To" }), assignments.map(([uniq, part], idx) => (_jsxs("h3", { style: { marginTop: "1em", marginLeft: "2em" }, children: [_jsx("span", { children: uniq }), part.length > 1 ? _jsxs("span", { style: { marginLeft: "1em" }, children: ["x", part.length] }) : undefined] }, idx)))] })) }), notes.length > 0 ? (_jsx("div", { style: { marginBottom: "2em" }, children: notes.map((n, idx) => (_jsx("p", { style: { fontSize: "xxx-large", textAlign: "center" }, children: n }, idx))) })) : undefined, _jsx("div", { style: { display: "flex", justifyContent: "center" }, children: props.operator ? _jsx("p", { style: { fontSize: "x-large" }, children: props.operator }) : undefined })] }));
+}
+export function PrintedLabel(props) {
+    if (props.oneJobPerPage) {
+        return _jsx(OneJobPerPage, { ...props });
+    }
+    else {
+        return _jsx(CombinedToOnePage, { ...props });
+    }
+}
+export function PrintOnClientButton({ mat, materialName, operator, }) {
+    const printRef = useRef(null);
+    const print = useReactToPrint({
+        contentRef: printRef,
+        ignoreGlobalStyles: true,
+    });
+    return (_jsxs(_Fragment, { children: [_jsx(Button, { color: "primary", onClick: () => print(), children: "Print Label" }), _jsx("div", { style: { display: "none" }, children: _jsx("div", { ref: printRef, children: _jsx(PrintedLabel, { materialName: materialName, material: Array.isArray(mat) ? mat : [mat], oneJobPerPage: false, operator: operator }) }) })] }));
+}
+export function PrintLabelButton() {
+    const fmsInfo = useAtomValue(fmsInformation);
+    const matInfo = useAtomValue(materialInDialogInfo);
+    const curMat = useAtomValue(inProcessMaterialInDialog);
+    const [printLabel, printingLabel, printed] = usePrintLabel();
+    if (!fmsInfo.usingLabelPrinterForSerials || matInfo === null || matInfo.materialID < 0)
+        return null;
+    if (fmsInfo.useClientPrinterForLabels) {
+        if (curMat === null) {
+            return null;
+        }
+        else {
+            return _jsx(PrintOnClientButton, { mat: curMat });
+        }
+    }
+    else {
+        return (_jsx(Button, { color: "primary", disabled: printingLabel || printed, onClick: () => printLabel({
+                materialId: matInfo.materialID,
+                proc: curMat?.process ?? 0,
+            }), children: printed ? "Printed" : "Print Label" }));
+    }
+}

package/dist/components/station-monitor/QuarantineButton.d.ts

@@ -0,0 +1,4 @@
+export declare function QuarantineMatButton({ onClose, ignoreOperator, }: {
+    onClose?: () => void;
+    ignoreOperator?: boolean;
+}): import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,184 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/* Copyright (c) 2024, John Lenz
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of John Lenz, Black Maple Software, SeedTactics,
+      nor the names of other contributors may be used to endorse or
+      promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+import { useState } from "react";
+import { Button, Dialog, DialogActions, DialogContent, DialogTitle, TextField, Tooltip } from "@mui/material";
+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 { fmsInformation } from "../../network/server-settings.js";
+import { useAtomValue, useSetAtom } from "jotai";
+function useQuarantineMaterial(ignoreOperator) {
+    const fmsInfo = useAtomValue(fmsInformation);
+    const [removeFromQueue, removingFromQueue] = useRemoveFromQueue();
+    const [signalQuarantine, signalingQuarantine] = useSignalForQuarantine();
+    const inProcMat = useAtomValue(inProcessMaterialInDialog);
+    const curSt = useAtomValue(currentStatus);
+    let operator = useAtomValue(currentOperator);
+    if (ignoreOperator)
+        operator = null;
+    if (inProcMat === null || inProcMat.materialID < 0)
+        return null;
+    const quarantineQueue = fmsInfo.quarantineQueue?.length ? fmsInfo.quarantineQueue : null;
+    const activeQueues = LazySeq.ofObject(curSt.jobs)
+        .flatMap(([_, job]) => job.procsAndPaths)
+        .flatMap((proc) => proc.paths)
+        .flatMap((path) => {
+        const q = [];
+        if (path.inputQueue !== undefined)
+            q.push(path.inputQueue);
+        if (path.outputQueue !== undefined)
+            q.push(path.outputQueue);
+        return q;
+    })
+        .concat(LazySeq.ofObject(curSt.queues)
+        .filter(([, info]) => info.role === QueueRole.RawMaterial || info.role === QueueRole.InProcessTransfer)
+        .map(([qname, _]) => qname))
+        .toRSet((x) => x);
+    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",
+            quarantine: () => removeFromQueue(inProcMat.materialID, operator),
+            removing: removingFromQueue,
+            quarantineQueueDestination: null,
+        };
+    }
+    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";
+                }
+            }
+            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";
+            }
+            break;
+        case LocType.InQueue:
+            if (inProcMat.action.type === ActionType.Loading && !fmsInfo.allowQuarantineToCancelLoad) {
+                return null;
+            }
+            else if (inProcMat.action.type === ActionType.Loading) {
+                type = "CancelLoad";
+            }
+            else {
+                type = "Scrap";
+            }
+            break;
+        case LocType.Free:
+            type = "Scrap";
+            break;
+    }
+    if (type) {
+        return {
+            type,
+            quarantine: (reason) => signalQuarantine(inProcMat.materialID, operator, reason),
+            removing: signalingQuarantine,
+            quarantineQueueDestination: quarantineQueue,
+        };
+    }
+    else {
+        return null;
+    }
+}
+export function QuarantineMatButton({ onClose, ignoreOperator, }) {
+    const [open, setOpen] = useState(false);
+    const [reason, setReason] = useState("");
+    const q = useQuarantineMaterial(!!ignoreOperator);
+    const setMatToShow = useSetAtom(materialDialogOpen);
+    if (q === null)
+        return null;
+    let title;
+    let btnTxt;
+    switch (q.type) {
+        case "Remove":
+            title = "Remove from system";
+            btnTxt = "Remove";
+            break;
+        case "Scrap":
+            title = q.quarantineQueueDestination ? `Move to ${q.quarantineQueueDestination}` : "Remove from queue";
+            btnTxt = q.quarantineQueueDestination ? "Quarantine" : "Remove";
+            break;
+        case "SignalForScrap":
+            title = q.quarantineQueueDestination
+                ? `After unload, move to ${q.quarantineQueueDestination}`
+                : "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?.();
+    }
+    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" })] })] })] }));
+}

package/dist/components/station-monitor/Queues.d.ts

@@ -0,0 +1,23 @@
+import { ReactNode } from "react";
+import * as api from "../../network/api.js";
+import { JobRawMaterialData } from "../../data/queue-material.js";
+export interface RawMaterialJobRowProps {
+    readonly job: JobRawMaterialData;
+    readonly editNote: (job: Readonly<api.IActiveJob>) => void;
+    readonly editQty: (job: JobRawMaterialData) => void;
+}
+interface EditNoteDialogProps {
+    readonly job: {
+        readonly unique: string;
+        readonly partName: string;
+        readonly comment?: string | null;
+    } | null;
+    readonly closeDialog: () => void;
+}
+export declare const EditNoteDialog: import("react").NamedExoticComponent<EditNoteDialogProps>;
+interface QueueProps {
+    readonly queues: ReadonlyArray<string>;
+}
+export declare const Queues: (props: QueueProps) => import("react/jsx-runtime").JSX.Element;
+export default function QueuesPage(props: QueueProps): ReactNode;
+export {};