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.

21.1 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 {
  Badge,
  Button,
  Checkbox,
  DropdownMenuContent,
  DropdownMenuGroup,
  DropdownMenuIcon,
  DropdownMenuItem,
  DropdownMenuLabel,
  DropdownMenuPortal,
  DropdownMenuSeparator,
  DropdownMenuSub,
  DropdownMenuSubContent,
  DropdownMenuSubTrigger,
  HStack,
  MENU_ITEM_SHORTCUTS,
  MenuIcon,
  MenuItem,
  MenuSub,
  MenuSubContent,
  MenuSubTrigger,
  useDisclosure,
  VStack
} from "@carbon/react";
import { distinctItemText } from "@carbon/utils";

import { Trans, useLingui } from "@lingui/react/macro";
import type { ColumnDef } from "@tanstack/react-table";
import { memo, useCallback, useMemo, useState } from "react";
import {
  LuAlignJustify,
  LuBookMarked,
  LuCalendar,
  LuCheck,
  LuFactory,
  LuGitPullRequestArrow,
  LuGroup,
  LuLoaderCircle,
  LuPencil,
  LuTag,
  LuTrash,
  LuTruck,
  LuUser
} from "react-icons/lu";
import { RxCodesandboxLogo } from "react-icons/rx";
import { TbTargetArrow } from "react-icons/tb";
import { Link, useNavigate } from "react-router";
import {
  DateTime,
  EmployeeAvatar,
  exportOnlyColumn,
  Hyperlink,
  ItemLifecycleBadge,
  ItemThumbnail,
  MethodIcon,
  New,
  SupplierAvatarGroup,
  Table,
  TrackingTypeIcon
} from "~/components";
import { Enumerable } from "~/components/Enumerable";
import { useItemPostingGroups } from "~/components/Form/ItemPostingGroup";
import { ReplenishmentSystemIcon } from "~/components/Icons";
import { ConfirmDelete } from "~/components/Modals";
import type { BulkActionScope, InfiniteOptions } from "~/components/Table";
import { usePermissions } from "~/hooks";
import { useBulkFormAction } from "~/hooks/useBulkAction";
import { useCustomColumns } from "~/hooks/useCustomColumns";
import { methodType } from "~/modules/shared/shared.models";
import { usePeople, useSuppliers } from "~/stores";
import { path } from "~/utils/path";
import {
  itemReplenishmentSystems,
  itemTrackingTypes
} from "../../items.models";
import type { ToolListItem } from "../../types";

type ToolsTableProps = {
  data: ToolListItem[];
  tags: { name: string }[];
  count: number;
  infinite: InfiniteOptions;
};

const ToolsTable = memo((props: ToolsTableProps) => {
  const { data, tags, count, infinite } = props;
  const { t } = useLingui();
  const navigate = useNavigate();
  const permissions = usePermissions();

  const translateReplenishment = useCallback(
    (v: string) =>
      v === "Buy" ? t`Buy` : v === "Make" ? t`Make` : t`Buy and Make`,
    [t]
  );
  const translateMethodType = useCallback(
    (v: string) =>
      v === "Purchase to Order"
        ? t`Purchase to Order`
        : v === "Pull from Inventory"
          ? t`Pull from Inventory`
          : t`Make to Order`,
    [t]
  );
  const translateTrackingType = useCallback(
    (v: string) =>
      v === "Inventory"
        ? t`Inventory`
        : v === "Non-Inventory"
          ? t`Non-Inventory`
          : v === "Serial"
            ? t`Serial`
            : t`Batch`,
    [t]
  );

  const deleteItemModal = useDisclosure();
  const [selectedItem, setSelectedItem] = useState<ToolListItem | null>(null);

  const [people] = usePeople();
  const [suppliers] = useSuppliers();
  const supplierMap = useMemo(
    () => new Map(suppliers.map((supplier) => [supplier.id, supplier.name])),
    [suppliers]
  );
  const itemPostingGroups = useItemPostingGroups();
  const customColumns = useCustomColumns<ToolListItem>("tool");

  const columns = useMemo<ColumnDef<ToolListItem>[]>(() => {
    const defaultColumns: ColumnDef<ToolListItem>[] = [
      {
        accessorKey: "id",
        header: t`Tool ID`,
        cell: ({ row }) => (
          <HStack className="py-1 min-w-[200px] truncate">
            <ItemThumbnail
              size="md"
              thumbnailPath={row.original.thumbnailPath}
              type="Tool"
            />
            <Hyperlink to={path.to.toolDetails(row.original.id!)}>
              <VStack spacing={0}>
                {row.original.readableIdWithRevision}
                {distinctItemText(
                  row.original.readableIdWithRevision,
                  row.original.name
                ) && (
                  <div className="w-full truncate text-muted-foreground text-xs">
                    {row.original.name}
                  </div>
                )}
              </VStack>
            </Hyperlink>
          </HStack>
        ),
        meta: {
          mobile: "P1",
          icon: <LuBookMarked />,
          // The accessor is the raw item id — export the readable id
          // the cell shows instead of a UUID.
          exportValue: (row) => row.readableIdWithRevision ?? null
        }
      },
      exportOnlyColumn<ToolListItem>({
        id: "itemName",
        header: t`Item Name`,
        value: (row) => row.name ?? null
      }),
      {
        accessorKey: "description",
        header: t`Description`,
        cell: (item) => (
          <div className="max-w-[320px] truncate">
            {item.getValue<string>()}
          </div>
        ),
        meta: {
          mobile: "P3",
          icon: <LuAlignJustify />
        }
      },
      {
        accessorKey: "itemPostingGroupId",
        header: t`Item Group`,
        cell: (item) => {
          const itemPostingGroupId = item.getValue<string>();
          const itemPostingGroup = itemPostingGroups.find(
            (group) => group.value === itemPostingGroupId
          );
          return <Enumerable value={itemPostingGroup?.label ?? null} />;
        },
        meta: {
          filter: {
            type: "static",
            options: itemPostingGroups.map((group) => ({
              value: group.value,
              label: <Enumerable value={group.label} />
            }))
          },
          icon: <LuGroup />
        }
      },

      {
        accessorKey: "replenishmentSystem",
        header: t`Replenishment`,
        cell: (item) => (
          <Badge variant="secondary">
            <ReplenishmentSystemIcon
              type={item.getValue<string>()}
              className="mr-2"
            />
            <span>{translateReplenishment(item.getValue<string>())}</span>
          </Badge>
        ),
        meta: {
          mobile: "P2",
          filter: {
            type: "static",
            options: itemReplenishmentSystems.map((type) => ({
              value: type,
              label: (
                <Badge variant="secondary">
                  <ReplenishmentSystemIcon type={type} className="mr-2" />
                  <span>{translateReplenishment(type)}</span>
                </Badge>
              )
            }))
          },
          icon: <LuLoaderCircle />
        }
      },
      {
        accessorKey: "defaultMethodType",
        header: t`Default Method`,
        cell: (item) => (
          <VStack spacing={1}>
            <Badge variant="secondary">
              <MethodIcon type={item.getValue<string>()} className="mr-2" />
              <span>{translateMethodType(item.getValue<string>())}</span>
            </Badge>
            <ItemLifecycleBadge
              mode={
                (
                  item.row.original as {
                    supersessionMode?:
                      | "Consume First"
                      | "Prefer New"
                      | "Stock Only"
                      | "No Stock"
                      | null;
                  }
                ).supersessionMode
              }
            />
          </VStack>
        ),
        meta: {
          filter: {
            type: "static",
            options: methodType.map((value) => ({
              value,
              label: (
                <Badge variant="secondary">
                  <MethodIcon type={value} className="mr-2" />
                  <span>{translateMethodType(value)}</span>
                </Badge>
              )
            }))
          },
          icon: <RxCodesandboxLogo />
        }
      },
      {
        accessorKey: "itemTrackingType",
        header: t`Tracking`,
        cell: (item) => (
          <Badge variant="secondary">
            <TrackingTypeIcon type={item.getValue<string>()} className="mr-2" />
            <span>{translateTrackingType(item.getValue<string>())}</span>
          </Badge>
        ),
        meta: {
          filter: {
            type: "static",
            options: itemTrackingTypes.map((type) => ({
              value: type,
              label: (
                <Badge variant="secondary">
                  <TrackingTypeIcon type={type} className="mr-2" />
                  <span>{translateTrackingType(type)}</span>
                </Badge>
              )
            }))
          },
          icon: <TbTargetArrow />
        }
      },
      {
        accessorKey: "tags",
        header: t`Tags`,
        cell: ({ row }) => (
          <HStack spacing={0} className="gap-1">
            {row.original.tags?.map((tag) => (
              <Badge key={tag} variant="secondary">
                {tag}
              </Badge>
            ))}
          </HStack>
        ),
        meta: {
          filter: {
            type: "static",
            options: tags?.map((tag) => ({
              value: tag.name,
              label: <Badge variant="secondary">{tag.name}</Badge>
            })),
            isArray: true
          },
          icon: <LuTag />
        }
      },
      {
        accessorKey: "mpn",
        header: t`Manufacturer Part Number`,
        cell: (item) => (
          <div className="max-w-[200px] truncate">
            {item.getValue<string>()}
          </div>
        ),
        meta: {
          filter: {
            type: "fetcher",
            endpoint: path.to.api.itemMpns,
            transform: (data: string[] | null) =>
              data?.map((mpn) => ({ value: mpn, label: mpn })) ?? []
          },
          icon: <LuFactory />
        }
      },
      {
        accessorKey: "supplierIds",
        header: t`Supplier Part Numbers`,
        cell: ({ row }) => (
          <HStack spacing={0} className="gap-1">
            {row.original.supplierIds
              ?.split(",")
              .filter(Boolean)
              .map((supplierPartId) => (
                <Badge key={supplierPartId} variant="secondary">
                  {supplierPartId}
                </Badge>
              ))}
          </HStack>
        ),
        meta: {
          icon: <LuTruck />
        }
      },
      {
        accessorKey: "suppliers",
        header: t`Supplier`,
        cell: ({ row }) => (
          <SupplierAvatarGroup supplierIds={row.original.suppliers ?? []} />
        ),
        meta: {
          filter: {
            type: "static",
            options: suppliers.map((supplier) => ({
              value: supplier.id,
              label: supplier.name
            })),
            isArray: true
          },
          icon: <LuTruck />,
          exportValue: (row) =>
            row.suppliers
              ?.map((supplierId) => supplierMap.get(supplierId))
              .filter(Boolean)
              .join(", ") ?? null
        }
      },
      {
        accessorKey: "active",
        header: t`Active`,
        cell: (item) => <Checkbox isChecked={item.getValue<boolean>()} />,
        meta: {
          filter: {
            type: "static",
            options: [
              { value: "true", label: t`Active` },
              { value: "false", label: t`Inactive` }
            ]
          },
          pluralHeader: t`Active Statuses`,
          icon: <LuCheck />
        }
      },
      // {
      //   id: "assignee",
      //   header: "Assignee",
      //   cell: ({ row }) => (
      //     <EmployeeAvatar employeeId={row.original.assignee} />
      //   ),
      //   meta: {
      //     filter: {
      //       type: "static",
      //       options: people.map((employee) => ({
      //         value: employee.id,
      //         label: employee.name,
      //       })),
      //     },
      //   },
      // },
      {
        id: "createdBy",
        header: t`Created By`,
        cell: ({ row }) => (
          <EmployeeAvatar employeeId={row.original.createdBy} />
        ),
        meta: {
          filter: {
            type: "static",
            options: people.map((employee) => ({
              value: employee.id,
              label: employee.name
            }))
          },
          icon: <LuUser />
        }
      },
      {
        accessorKey: "createdAt",
        header: t`Created At`,
        cell: (item) => (
          <DateTime value={item.getValue<string>()} variant="date" />
        ),
        meta: {
          icon: <LuCalendar />
        }
      },
      {
        id: "updatedBy",
        header: t`Updated By`,
        cell: ({ row }) => (
          <EmployeeAvatar employeeId={row.original.updatedBy} />
        ),
        meta: {
          filter: {
            type: "static",
            options: people.map((employee) => ({
              value: employee.id,
              label: employee.name
            }))
          },
          icon: <LuUser />
        }
      },
      {
        accessorKey: "updatedAt",
        header: t`Updated At`,
        cell: (item) => (
          <DateTime value={item.getValue<string>()} variant="date" />
        ),
        meta: {
          icon: <LuCalendar />
        }
      }
    ];
    return [...defaultColumns, ...customColumns];
  }, [
    customColumns,
    people,
    supplierMap,
    suppliers,
    tags,
    itemPostingGroups,
    t,
    translateMethodType,
    translateReplenishment,
    translateTrackingType
  ]);

  const { submit: submitBulk } = useBulkFormAction();
  const onBulkUpdate = useCallback(
    (
      selectedRows: typeof data,
      field:
        | "replenishmentSystem"
        | "defaultMethodType"
        | "itemTrackingType"
        | "itemPostingGroupId",
      value: string,
      scope?: BulkActionScope
    ) => {
      submitBulk(
        path.to.bulkUpdateItems,
        { scope, idsField: "items", ids: selectedRows.map((row) => row.id) },
        { field, value }
      );
    },
    [submitBulk]
  );

  const renderActions = useCallback(
    (selectedRows: typeof data, scope?: BulkActionScope) => {
      return (
        <DropdownMenuContent align="end" className="min-w-[200px]">
          <DropdownMenuLabel>
            <Trans>Update</Trans>
          </DropdownMenuLabel>
          <DropdownMenuSeparator />
          <DropdownMenuGroup>
            <DropdownMenuSub>
              <DropdownMenuSubTrigger>
                <Trans>Item Group</Trans>
              </DropdownMenuSubTrigger>
              <DropdownMenuPortal>
                <DropdownMenuSubContent>
                  {itemPostingGroups.map((group) => (
                    <DropdownMenuItem
                      key={group.value}
                      onClick={() =>
                        onBulkUpdate(
                          selectedRows,
                          "itemPostingGroupId",
                          group.value,
                          scope
                        )
                      }
                    >
                      <Enumerable value={group.label} />
                    </DropdownMenuItem>
                  ))}
                </DropdownMenuSubContent>
              </DropdownMenuPortal>
            </DropdownMenuSub>
            <DropdownMenuSub>
              <DropdownMenuSubTrigger>
                <Trans>Default Method Type</Trans>
              </DropdownMenuSubTrigger>
              <DropdownMenuPortal>
                <DropdownMenuSubContent>
                  {methodType.map((type) => (
                    <DropdownMenuItem
                      key={type}
                      onClick={() =>
                        onBulkUpdate(
                          selectedRows,
                          "defaultMethodType",
                          type,
                          scope
                        )
                      }
                    >
                      <DropdownMenuIcon icon={<MethodIcon type={type} />} />
                      <span>{translateMethodType(type)}</span>
                    </DropdownMenuItem>
                  ))}
                </DropdownMenuSubContent>
              </DropdownMenuPortal>
            </DropdownMenuSub>
            <DropdownMenuSub>
              <DropdownMenuSubTrigger>
                <Trans>Tracking Type</Trans>
              </DropdownMenuSubTrigger>
              <DropdownMenuPortal>
                <DropdownMenuSubContent>
                  {itemTrackingTypes.map((type) => (
                    <DropdownMenuItem
                      key={type}
                      onClick={() =>
                        onBulkUpdate(
                          selectedRows,
                          "itemTrackingType",
                          type,
                          scope
                        )
                      }
                    >
                      <DropdownMenuIcon
                        icon={<TrackingTypeIcon type={type} />}
                      />
                      <span>{translateTrackingType(type)}</span>
                    </DropdownMenuItem>
                  ))}
                </DropdownMenuSubContent>
              </DropdownMenuPortal>
            </DropdownMenuSub>
          </DropdownMenuGroup>
        </DropdownMenuContent>
      );
    },
    [
      onBulkUpdate,
      itemPostingGroups,
      translateMethodType,
      translateTrackingType
    ]
  );

  const renderContextMenu = useMemo(() => {
    return (row: ToolListItem) => {
      const revisions =
        (row.revisions as {
          id: string;
          revision: number;
        }[]) ?? [];
      return (
        <>
          <MenuItem
            shortcut={MENU_ITEM_SHORTCUTS.edit}
            onClick={() => navigate(path.to.tool(row.id!))}
          >
            <MenuIcon icon={<LuPencil />} />
            <Trans>Edit Tool</Trans>
          </MenuItem>
          {revisions && revisions.length > 1 && (
            <MenuSub>
              <MenuSubTrigger>
                <MenuIcon icon={<LuGitPullRequestArrow />} />
                <Trans>Revisions</Trans>
              </MenuSubTrigger>
              <MenuSubContent>
                {revisions.map((revision) => (
                  <MenuItem
                    key={revision.id}
                    onClick={() => navigate(path.to.tool(revision.id))}
                  >
                    <MenuIcon icon={<LuTag />} />
                    {t`Revision ${revision.revision}`}
                  </MenuItem>
                ))}
              </MenuSubContent>
            </MenuSub>
          )}
          <MenuItem
            shortcut={MENU_ITEM_SHORTCUTS.delete}
            destructive
            disabled={!permissions.can("delete", "parts")}
            onClick={() => {
              setSelectedItem(row);
              deleteItemModal.onOpen();
            }}
          >
            <MenuIcon icon={<LuTrash />} />
            <Trans>Delete Tool</Trans>
          </MenuItem>
        </>
      );
    };
  }, [deleteItemModal, navigate, permissions, t]);

  return (
    <>
      <Table<ToolListItem>
        count={count}
        columns={columns}
        data={data}
        infinite={infinite}
        defaultColumnPinning={{
          left: ["id"]
        }}
        defaultColumnVisibility={{
          description: false,
          active: false,
          createdBy: false,
          createdAt: false,
          updatedBy: false,
          updatedAt: false
        }}
        importCSV={[
          {
            table: "tool",
            label: t`Tools`
          },
          {
            table: "bom" as const,
            label: "BOM"
          },
          {
            table: "operations" as const,
            label: "Operations"
          },
          {
            table: "partWithMethod" as const,
            label: "Parts with Methods"
          }
        ]}
        primaryAction={
          permissions.can("create", "parts") && (
            <div className="flex items-center gap-2">
              <Button
                variant="secondary"
                leftIcon={<LuGroup />}
                className="max-md:hidden"
                asChild
              >
                <Link to={path.to.itemPostingGroups}>
                  <Trans>Item Groups</Trans>
                </Link>
              </Button>
              <New label={t`Tool`} to={path.to.newTool} />
            </div>
          )
        }
        renderActions={renderActions}
        renderContextMenu={renderContextMenu}
        title={t`Tools`}
        table="tool"
        withSavedView
        withSelectableRows
      />
      {selectedItem && selectedItem.id && (
        <ConfirmDelete
          action={path.to.deleteItem(selectedItem.id!)}
          isOpen={deleteItemModal.isOpen}
          name={selectedItem.readableIdWithRevision!}
          text={t`Are you sure you want to delete ${selectedItem.readableIdWithRevision!}? This cannot be undone.`}
          onCancel={() => {
            deleteItemModal.onClose();
            setSelectedItem(null);
          }}
          onSubmit={() => {
            deleteItemModal.onClose();
            setSelectedItem(null);
          }}
        />
      )}
    </>
  );
});

ToolsTable.displayName = "ToolTable";

export default ToolsTable;