Skip to content

Open-source manufacturing ERP, MES and QMS. Quoting, MRP, inventory, shop floor, quality and lot/serial traceability on one Postgres schema, with a REST API and MCP server. Self-host or use Carbon Cloud.

25.0 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-only
// Carbon (github.com/crbnos/carbon). Modified or adapted versions of this file,
// including ports, remain AGPLv3; serving them over a network requires releasing their source.

import { useCarbon } from "@carbon/auth";
import {
  Button,
  Combobox as ComboboxBase,
  cn,
  Input,
  InputGroup,
  InputRightElement,
  Modal,
  ModalBody,
  ModalContent,
  ModalDescription,
  ModalFooter,
  ModalHeader,
  ModalTitle,
  NumberDecrementStepper,
  NumberField,
  NumberIncrementStepper,
  NumberInput,
  NumberInputGroup,
  NumberInputStepper,
  Tabs,
  TabsContent,
  TabsList,
  TabsTrigger,
  toast
} from "@carbon/react";
import { Trans, useLingui } from "@lingui/react/macro";
import { useCallback, useEffect, useState } from "react";
import {
  LuCheck,
  LuChevronDown,
  LuChevronUp,
  LuList,
  LuQrCode
} from "react-icons/lu";
import { useFetcher } from "react-router";
import { path } from "~/utils/path";

interface ItemOption {
  value: string;
  label: string;
  helper?: string;
}

interface ItemDetails {
  id: string;
  name: string;
  unitOfMeasureCode: string;
  itemTrackingType: "Serial" | "Batch" | "Inventory" | null;
}

export function MaintenanceAddPartModal({
  dispatchId,
  itemOptions,
  onClose
}: {
  dispatchId: string;
  itemOptions: ItemOption[];
  onClose: () => void;
}) {
  const { t } = useLingui();
  const fetcher = useFetcher<{ success: boolean; message: string }>();
  const { carbon } = useCarbon();

  const [selectedItemId, setSelectedItemId] = useState<string>("");
  const [itemDetails, setItemDetails] = useState<ItemDetails | null>(null);
  const [quantity, setQuantity] = useState(1);
  const [isLoadingItem, setIsLoadingItem] = useState(false);

  // For serial tracking
  const [selectedSerialNumbers, setSelectedSerialNumbers] = useState<
    Array<{ index: number; id: string }>
  >([{ index: 0, id: "" }]);
  const [serialErrors, setSerialErrors] = useState<Record<number, string>>({});
  const [serialOptions, setSerialOptions] = useState<
    Array<{ label: string; value: string; helper?: string }>
  >([]);

  // For batch tracking
  const [selectedBatches, setSelectedBatches] = useState<
    Array<{ index: number; id: string; quantity: number }>
  >([{ index: 0, id: "", quantity: 1 }]);
  const [batchErrors, setBatchErrors] = useState<Record<number, string>>({});
  const [batchOptions, setBatchOptions] = useState<
    Array<{ label: string; value: string; helper?: string; quantity: number }>
  >([]);

  const [activeTab, setActiveTab] = useState("scan");

  const handleItemChange = useCallback(
    async (itemId: string) => {
      setSelectedItemId(itemId);
      setItemDetails(null);
      setQuantity(1);
      setSelectedSerialNumbers([{ index: 0, id: "" }]);
      setSelectedBatches([{ index: 0, id: "", quantity: 1 }]);
      setSerialErrors({});
      setBatchErrors({});
      setSerialOptions([]);
      setBatchOptions([]);

      if (itemId && carbon) {
        setIsLoadingItem(true);

        // Fetch item details
        const { data } = await carbon
          .from("item")
          .select("id, name, unitOfMeasureCode, itemTrackingType")
          .eq("id", itemId)
          .single();

        if (data) {
          setItemDetails(data as ItemDetails);

          // Fetch serial numbers if serial tracked
          if (data.itemTrackingType === "Serial") {
            const { data: serials } = await carbon
              .from("trackedEntity")
              .select("id, readableId, status")
              .eq("sourceDocumentId", itemId)
              .eq("status", "Available");

            setSerialOptions(
              serials?.map((sn) => ({
                label: sn.readableId
                  ? `${sn.readableId} — ${sn.id}`
                  : (sn.id ?? ""),
                value: sn.id
              })) ?? []
            );
          }

          // Fetch batch numbers if batch tracked
          if (data.itemTrackingType === "Batch") {
            const { data: batches } = await carbon
              .from("trackedEntity")
              .select("id, readableId, status, quantity")
              .eq("sourceDocumentId", itemId)
              .eq("status", "Available");

            setBatchOptions(
              batches?.map((batch) => ({
                label: batch.readableId
                  ? `${batch.readableId} — ${batch.id.slice(0, 10)} — ${batch.quantity} available`
                  : `${batch.id.slice(0, 10)} — ${batch.quantity} available`,
                value: batch.id,
                quantity: batch.quantity ?? 0
              })) ?? []
            );
          }
        }
        setIsLoadingItem(false);
      }
    },
    [carbon]
  );

  const validateSerialNumber = useCallback(
    (value: string, index: number) => {
      if (!value) return t`Serial number is required`;
      const isDuplicate = selectedSerialNumbers.some(
        (sn, i) => sn.id === value && i !== index
      );
      if (isDuplicate) return t`Duplicate serial number`;
      const isValid = serialOptions.some((opt) => opt.value === value);
      if (!isValid) return t`Serial number is not available`;
      return null;
    },
    [selectedSerialNumbers, serialOptions, t]
  );

  const validateBatch = useCallback(
    (value: string, qty: number, index: number) => {
      if (!value) return t`Batch number is required`;
      if (qty <= 0) return t`Quantity must be greater than 0`;
      const isDuplicate = selectedBatches.some(
        (b, i) => b.id === value && i !== index
      );
      if (isDuplicate) return t`Duplicate batch number`;
      const batch = batchOptions.find((b) => b.value === value);
      if (!batch) return t`Batch is not available`;
      if (qty > batch.quantity) return t`Only ${batch.quantity} available`;
      return null;
    },
    [selectedBatches, batchOptions, t]
  );

  const handleSubmit = useCallback(() => {
    if (!selectedItemId || !itemDetails) {
      toast.error(t`Please select an item`);
      return;
    }

    const trackingType = itemDetails.itemTrackingType;

    if (trackingType === "Serial") {
      // Validate all serial numbers
      let hasErrors = false;
      const newErrors: Record<number, string> = {};
      selectedSerialNumbers.forEach((sn) => {
        const error = validateSerialNumber(sn.id, sn.index);
        if (error) {
          newErrors[sn.index] = error;
          hasErrors = true;
        }
      });
      setSerialErrors(newErrors);
      if (hasErrors) return;

      // Submit serial tracked items
      const payload = {
        itemId: selectedItemId,
        unitOfMeasureCode: itemDetails.unitOfMeasureCode,
        children: selectedSerialNumbers.map((sn) => ({
          trackedEntityId: sn.id,
          quantity: 1
        }))
      };

      fetcher.submit(JSON.stringify(payload), {
        method: "post",
        action: path.to.addAndIssueMaintenanceDispatchItem(dispatchId),
        encType: "application/json"
      });
    } else if (trackingType === "Batch") {
      // Validate all batches
      let hasErrors = false;
      const newErrors: Record<number, string> = {};
      selectedBatches.forEach((batch) => {
        const error = validateBatch(batch.id, batch.quantity, batch.index);
        if (error) {
          newErrors[batch.index] = error;
          hasErrors = true;
        }
      });
      setBatchErrors(newErrors);
      if (hasErrors) return;

      // Submit batch tracked items
      const payload = {
        itemId: selectedItemId,
        unitOfMeasureCode: itemDetails.unitOfMeasureCode,
        children: selectedBatches.map((batch) => ({
          trackedEntityId: batch.id,
          quantity: batch.quantity
        }))
      };

      fetcher.submit(JSON.stringify(payload), {
        method: "post",
        action: path.to.addAndIssueMaintenanceDispatchItem(dispatchId),
        encType: "application/json"
      });
    } else {
      // Inventory item
      if (quantity <= 0) {
        toast.error(t`Quantity must be greater than 0`);
        return;
      }

      const payload = {
        itemId: selectedItemId,
        unitOfMeasureCode: itemDetails.unitOfMeasureCode,
        quantity
      };

      fetcher.submit(JSON.stringify(payload), {
        method: "post",
        action: path.to.addAndIssueMaintenanceDispatchItem(dispatchId),
        encType: "application/json"
      });
    }
  }, [
    selectedItemId,
    itemDetails,
    quantity,
    selectedSerialNumbers,
    selectedBatches,
    validateSerialNumber,
    validateBatch,
    dispatchId,
    fetcher,
    t
  ]);

  useEffect(() => {
    if (fetcher.data?.success) {
      onClose();
      if (fetcher.data.message) {
        toast.success(fetcher.data.message);
      }
    } else if (fetcher.data?.message) {
      toast.error(fetcher.data.message);
    }
  }, [fetcher.data, onClose]);

  return (
    <Modal open onOpenChange={onClose}>
      <ModalContent>
        <ModalHeader>
          <ModalTitle>
            <Trans>Add Spare Part</Trans>
          </ModalTitle>
          <ModalDescription>
            <Trans>Select an item and specify the quantity to issue</Trans>
          </ModalDescription>
        </ModalHeader>
        <ModalBody>
          <div className="flex flex-col gap-4">
            {/* Item Selection */}
            <div>
              <label className="block text-sm font-medium mb-1">
                <Trans>Item</Trans>
              </label>
              <ComboboxBase
                placeholder={t`Select an item...`}
                value={selectedItemId}
                onChange={handleItemChange}
                options={itemOptions}
              />
            </div>

            {isLoadingItem && (
              <div className="text-sm text-muted-foreground">
                <Trans>Loading item details...</Trans>
              </div>
            )}

            {/* Inventory Item - Simple Quantity */}
            {itemDetails &&
              (itemDetails.itemTrackingType === "Inventory" ||
                !itemDetails.itemTrackingType) && (
                <div>
                  <label className="block text-sm font-medium mb-1">
                    <Trans>Quantity</Trans>
                  </label>
                  <NumberField
                    value={quantity}
                    onChange={(value) => setQuantity(value)}
                    minValue={1}
                  >
                    <NumberInputGroup>
                      <NumberInput name="quantity" />
                      <NumberInputStepper>
                        <NumberIncrementStepper>
                          <LuChevronUp />
                        </NumberIncrementStepper>
                        <NumberDecrementStepper>
                          <LuChevronDown />
                        </NumberDecrementStepper>
                      </NumberInputStepper>
                    </NumberInputGroup>
                  </NumberField>
                </div>
              )}

            {/* Serial Tracked Item */}
            {itemDetails && itemDetails.itemTrackingType === "Serial" && (
              <Tabs value={activeTab} onValueChange={setActiveTab}>
                <TabsList className="grid w-full grid-cols-2 mb-4">
                  <TabsTrigger value="scan">
                    <LuQrCode className="mr-2" />
                    <Trans>Scan</Trans>
                  </TabsTrigger>
                  <TabsTrigger value="select">
                    <LuList className="mr-2" />
                    <Trans>Select</Trans>
                  </TabsTrigger>
                </TabsList>
                <TabsContent value="scan">
                  <div className="flex flex-col gap-4">
                    {selectedSerialNumbers.map((sn, index) => (
                      <div
                        key={`${index}-scan`}
                        className="flex flex-col gap-1"
                      >
                        <div className="flex items-center gap-2">
                          <div className="flex-1">
                            <InputGroup>
                              <Input
                                placeholder={t`Serial Number ${index + 1}`}
                                value={sn.id}
                                onChange={(e) => {
                                  const newValue = e.target.value;
                                  setSelectedSerialNumbers((prev) => {
                                    const updated = [...prev];
                                    updated[index] = { index, id: newValue };
                                    return updated;
                                  });
                                }}
                                onBlur={(e) => {
                                  const error = validateSerialNumber(
                                    e.target.value,
                                    index
                                  );
                                  setSerialErrors((prev) => {
                                    const newErrors = { ...prev };
                                    if (error) {
                                      newErrors[index] = error;
                                    } else {
                                      delete newErrors[index];
                                    }
                                    return newErrors;
                                  });
                                }}
                                className={cn(
                                  serialErrors[index] && "border-destructive"
                                )}
                              />
                              <InputRightElement className="pl-2">
                                {!serialErrors[index] && sn.id ? (
                                  <LuCheck className="text-emerald-500" />
                                ) : (
                                  <LuQrCode />
                                )}
                              </InputRightElement>
                            </InputGroup>
                          </div>
                        </div>
                        {serialErrors[index] && (
                          <span className="text-xs text-destructive">
                            {serialErrors[index]}
                          </span>
                        )}
                      </div>
                    ))}
                  </div>
                </TabsContent>
                <TabsContent value="select">
                  <div className="flex flex-col gap-4">
                    {selectedSerialNumbers.map((sn, index) => (
                      <div
                        key={`${index}-select`}
                        className="flex flex-col gap-1"
                      >
                        <div className="flex items-center gap-2">
                          <div className="flex-1">
                            <ComboboxBase
                              placeholder={t`Select Serial ${index + 1}`}
                              value={sn.id}
                              onChange={(value) => {
                                setSelectedSerialNumbers((prev) => {
                                  const updated = [...prev];
                                  updated[index] = { index, id: value };
                                  return updated;
                                });
                                const error = validateSerialNumber(
                                  value,
                                  index
                                );
                                setSerialErrors((prev) => {
                                  const newErrors = { ...prev };
                                  if (error) {
                                    newErrors[index] = error;
                                  } else {
                                    delete newErrors[index];
                                  }
                                  return newErrors;
                                });
                              }}
                              options={serialOptions}
                            />
                          </div>
                        </div>
                        {serialErrors[index] && (
                          <span className="text-xs text-destructive">
                            {serialErrors[index]}
                          </span>
                        )}
                      </div>
                    ))}
                  </div>
                </TabsContent>
              </Tabs>
            )}

            {/* Batch Tracked Item */}
            {itemDetails && itemDetails.itemTrackingType === "Batch" && (
              <Tabs value={activeTab} onValueChange={setActiveTab}>
                <TabsList className="grid w-full grid-cols-2 mb-4">
                  <TabsTrigger value="scan">
                    <LuQrCode className="mr-2" />
                    <Trans>Scan</Trans>
                  </TabsTrigger>
                  <TabsTrigger value="select">
                    <LuList className="mr-2" />
                    <Trans>Select</Trans>
                  </TabsTrigger>
                </TabsList>
                <TabsContent value="scan">
                  <div className="flex flex-col gap-4">
                    {selectedBatches.map((batch, index) => (
                      <div
                        key={`${index}-scan`}
                        className="flex flex-col gap-1"
                      >
                        <div className="flex items-center gap-2">
                          <div className="flex-1">
                            <InputGroup>
                              <Input
                                placeholder={t`Batch Number ${index + 1}`}
                                value={batch.id}
                                onChange={(e) => {
                                  const newValue = e.target.value;
                                  setSelectedBatches((prev) => {
                                    const updated = [...prev];
                                    updated[index] = {
                                      ...batch,
                                      id: newValue
                                    };
                                    return updated;
                                  });
                                }}
                                onBlur={(e) => {
                                  const error = validateBatch(
                                    e.target.value,
                                    batch.quantity,
                                    index
                                  );
                                  setBatchErrors((prev) => {
                                    const newErrors = { ...prev };
                                    if (error) {
                                      newErrors[index] = error;
                                    } else {
                                      delete newErrors[index];
                                    }
                                    return newErrors;
                                  });
                                }}
                                className={cn(
                                  batchErrors[index] && "border-destructive"
                                )}
                              />
                              <InputRightElement className="pl-2">
                                {!batchErrors[index] && batch.id ? (
                                  <LuCheck className="text-emerald-500" />
                                ) : (
                                  <LuQrCode />
                                )}
                              </InputRightElement>
                            </InputGroup>
                          </div>
                          <div className="w-20">
                            <NumberField
                              value={batch.quantity}
                              onChange={(value) => {
                                setSelectedBatches((prev) => {
                                  const updated = [...prev];
                                  updated[index] = {
                                    ...batch,
                                    quantity: value
                                  };
                                  return updated;
                                });
                              }}
                              minValue={1}
                            >
                              <NumberInputGroup className="relative">
                                <NumberInput name="quantity" />
                                <NumberInputStepper>
                                  <NumberIncrementStepper>
                                    <LuChevronUp />
                                  </NumberIncrementStepper>
                                  <NumberDecrementStepper>
                                    <LuChevronDown />
                                  </NumberDecrementStepper>
                                </NumberInputStepper>
                              </NumberInputGroup>
                            </NumberField>
                          </div>
                        </div>
                        {batchErrors[index] && (
                          <span className="text-xs text-destructive">
                            {batchErrors[index]}
                          </span>
                        )}
                      </div>
                    ))}
                  </div>
                </TabsContent>
                <TabsContent value="select">
                  <div className="flex flex-col gap-4">
                    {selectedBatches.map((batch, index) => (
                      <div
                        key={`${index}-select`}
                        className="flex flex-col gap-1"
                      >
                        <div className="flex items-center gap-2">
                          <div className="flex-1">
                            <ComboboxBase
                              placeholder={t`Select Batch ${index + 1}`}
                              value={batch.id}
                              onChange={(value) => {
                                setSelectedBatches((prev) => {
                                  const updated = [...prev];
                                  updated[index] = { ...batch, id: value };
                                  return updated;
                                });
                                const error = validateBatch(
                                  value,
                                  batch.quantity,
                                  index
                                );
                                setBatchErrors((prev) => {
                                  const newErrors = { ...prev };
                                  if (error) {
                                    newErrors[index] = error;
                                  } else {
                                    delete newErrors[index];
                                  }
                                  return newErrors;
                                });
                              }}
                              options={batchOptions}
                            />
                          </div>
                          <div className="w-20">
                            <NumberField
                              value={batch.quantity}
                              onChange={(value) => {
                                setSelectedBatches((prev) => {
                                  const updated = [...prev];
                                  updated[index] = {
                                    ...batch,
                                    quantity: value
                                  };
                                  return updated;
                                });
                              }}
                              minValue={1}
                            >
                              <NumberInputGroup>
                                <NumberInput name="quantity" />
                                <NumberInputStepper>
                                  <NumberIncrementStepper />
                                  <NumberDecrementStepper />
                                </NumberInputStepper>
                              </NumberInputGroup>
                            </NumberField>
                          </div>
                        </div>
                        {batchErrors[index] && (
                          <span className="text-xs text-destructive">
                            {batchErrors[index]}
                          </span>
                        )}
                      </div>
                    ))}
                  </div>
                </TabsContent>
              </Tabs>
            )}
          </div>
        </ModalBody>
        <ModalFooter>
          <Button variant="secondary" onClick={onClose}>
            <Trans>Cancel</Trans>
          </Button>
          <Button
            variant="primary"
            onClick={handleSubmit}
            isLoading={fetcher.state !== "idle"}
            isDisabled={
              fetcher.state !== "idle" || !selectedItemId || isLoadingItem
            }
          >
            <Trans>Add & Issue</Trans>
          </Button>
        </ModalFooter>
      </ModalContent>
    </Modal>
  );
}