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.
TypeScript ai-agentsbill-of-materialserpinventory-managementleanmanufacturingmanufacturing-execution-systemmcp-servermesmrpopen-source-erppostgresqlproduction-planningqmsquality-management-systemreact-routerself-hostedsupabasetraceabilitytypescript
// 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;