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.

10.7 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,
  MENU_ITEM_SHORTCUTS,
  MenuIcon,
  MenuItem,
  useDisclosure
} from "@carbon/react";
import { useLingui } from "@lingui/react/macro";
import type { ColumnDef } from "@tanstack/react-table";
import { memo, useCallback, useMemo, useState } from "react";
import { flushSync } from "react-dom";
import {
  LuBlocks,
  LuBookMarked,
  LuCalendar,
  LuChartNoAxesColumnIncreasing,
  LuCircleGauge,
  LuDna,
  LuMap,
  LuOctagonX,
  LuPencil,
  LuShieldCheck,
  LuTrash,
  LuUser
} from "react-icons/lu";
import { useNavigate } from "react-router";
import { DateTime, EmployeeAvatar, Hyperlink, New, Table } from "~/components";
import { Enumerable } from "~/components/Enumerable";
import { EnumerableGroup } from "~/components/EnumerableGroup";
import { useLocations } from "~/components/Form/Location";
import { ConfirmDelete } from "~/components/Modals";
import type { InfiniteOptions } from "~/components/Table";
import { usePermissions } from "~/hooks";
import { useCustomColumns } from "~/hooks/useCustomColumns";
import { useItems } from "~/stores/items";
import { usePeople } from "~/stores/people";
import type { ListItem } from "~/types";
import { path } from "~/utils/path";
import {
  nonConformancePriority,
  nonConformanceSource,
  nonConformanceStatus
} from "../../quality.models";
import type { Issue } from "../../types";
import { getPriorityIcon, getSourceIcon } from "./IssueIcons";
import IssueStatus from "./IssueStatus";

type IssuesTableProps = {
  data: Issue[];
  types: ListItem[];
  count: number;
  infinite: InfiniteOptions;
};

const IssuesTable = memo((props: IssuesTableProps) => {
  const { data, types, count, infinite } = props;
  const navigate = useNavigate();
  const { t } = useLingui();
  const permissions = usePermissions();
  const deleteDisclosure = useDisclosure();
  const [selectedIssue, setSelectedIssue] = useState<Issue | null>(null);

  const customColumns = useCustomColumns<Issue>("nonConformance");
  const locations = useLocations();
  const [people] = usePeople();
  const [items] = useItems();

  const columns = useMemo<ColumnDef<Issue>[]>(() => {
    const defaultColumns: ColumnDef<Issue>[] = [
      {
        accessorKey: "nonConformanceId",
        header: t`Name`,
        cell: ({ row }) => (
          <Hyperlink to={path.to.issue(row.original.id!)}>
            <div className="flex flex-col gap-0">
              <span className="text-sm font-medium">
                {row.original.nonConformanceId}
              </span>
              <span className="text-xs text-muted-foreground">
                {row.original.name}
              </span>
            </div>
          </Hyperlink>
        ),
        meta: {
          mobile: "P1",
          icon: <LuBookMarked />
        }
      },

      {
        accessorKey: "status",
        header: t`Status`,
        cell: ({ row }) => <IssueStatus status={row.original.status} />,
        meta: {
          mobile: "P2",
          icon: <LuCircleGauge />,
          filter: {
            type: "static",
            options: nonConformanceStatus.map((status) => ({
              label: status,
              value: status
            }))
          }
        }
      },
      {
        accessorKey: "nonConformanceTypeId",
        header: t`Type`,
        cell: ({ row }) => (
          <Enumerable
            value={
              types.find(
                (type) => type.id === row.original.nonConformanceTypeId
              )?.name ?? null
            }
          />
        ),
        meta: {
          mobile: "P2",
          icon: <LuOctagonX />,
          filter: {
            type: "static",
            options: types.map((type) => ({
              label: type.name,
              value: type.id
            }))
          }
        }
      },

      {
        accessorKey: "priority",
        header: t`Priority`,
        cell: ({ row }) => (
          <div className="flex gap-2 items-center">
            {getPriorityIcon(row.original.priority ?? "Low", false)}
            {row.original.priority}
          </div>
        ),
        meta: {
          icon: <LuChartNoAxesColumnIncreasing />,
          filter: {
            type: "static",
            options: nonConformancePriority.map((priority) => ({
              label: priority,
              value: priority
            }))
          }
        }
      },
      {
        accessorKey: "source",
        header: t`Source`,
        cell: ({ row }) => (
          <div className="flex gap-2 items-center">
            {getSourceIcon(row.original.source ?? "Internal", false)}
            {row.original.source}
          </div>
        ),
        meta: {
          icon: <LuDna />,
          filter: {
            type: "static",
            options: nonConformanceSource.map((source) => ({
              label: source,
              value: source
            }))
          }
        }
      },
      {
        accessorKey: "containmentStatus",
        header: t`Containment`,
        cell: ({ row }) => {
          const status = row.original.containmentStatus ?? "Uncontained";
          return (
            <Badge variant={status === "Contained" ? "green" : "orange"}>
              {status}
            </Badge>
          );
        },
        meta: {
          icon: <LuShieldCheck />,
          filter: {
            type: "static",
            options: [
              { label: "Contained", value: "Contained" },
              { label: "Uncontained", value: "Uncontained" }
            ]
          }
        }
      },
      {
        accessorKey: "locationId",
        header: t`Location`,
        cell: ({ row }) => (
          <Enumerable
            value={
              locations.find(
                (location) => location.value === row.original.locationId
              )?.label ?? null
            }
          />
        ),
        meta: {
          icon: <LuMap />,
          filter: {
            type: "static",
            options: locations.map((location) => ({
              label: location.label,
              value: location.value
            }))
          }
        }
      },
      {
        accessorKey: "assignee",
        header: t`Assignee`,
        cell: ({ row }) => (
          <EmployeeAvatar employeeId={row.original.assignee} />
        ),
        meta: {
          mobile: "P3",
          filter: {
            type: "static",
            options: people.map((employee) => ({
              value: employee.id,
              label: employee.name
            }))
          },
          icon: <LuUser />
        }
      },

      {
        id: "items",
        header: t`Items`,
        cell: ({ row }) => (
          <EnumerableGroup
            chip="outline"
            items={((row.original.items ?? []) as Array<string>).flatMap(
              (i) => {
                const item = items.find((x) => x.id === i);
                if (!item) return [];
                return { label: item.readableIdWithRevision ?? item.id };
              }
            )}
          />
        ),
        meta: {
          icon: <LuBlocks />,
          filter: {
            type: "static",
            options: items.map((item) => ({
              value: item.id,
              label: (
                <Badge variant="outline">{item.readableIdWithRevision}</Badge>
              )
            })),
            isArray: true
          }
        }
      },
      {
        accessorKey: "openDate",
        header: t`Open Date`,
        cell: ({ row }) => (
          <DateTime value={row.original.openDate} variant="date" />
        ),
        meta: {
          filter: {
            type: "dateRange"
          },
          icon: <LuCalendar />
        }
      },
      {
        accessorKey: "closeDate",
        header: t`Closed Date`,
        cell: ({ row }) => (
          <DateTime value={row.original.closeDate} variant="date" />
        ),
        meta: {
          filter: {
            type: "dateRange"
          },
          icon: <LuCalendar />
        }
      },
      {
        accessorKey: "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 />
        }
      }
    ];
    return [...defaultColumns, ...customColumns];
  }, [customColumns, items, locations, people, types, t]);

  const renderContextMenu = useCallback(
    (row: Issue) => {
      return (
        <>
          <MenuItem
            shortcut={MENU_ITEM_SHORTCUTS.edit}
            disabled={!permissions.can("update", "quality")}
            onClick={() => {
              navigate(`${path.to.issue(row.id!)}`);
            }}
          >
            <MenuIcon icon={<LuPencil />} />
            Edit Issue
          </MenuItem>
          <MenuItem
            shortcut={MENU_ITEM_SHORTCUTS.delete}
            destructive
            disabled={!permissions.can("delete", "quality")}
            onClick={() => {
              flushSync(() => {
                setSelectedIssue(row);
              });
              deleteDisclosure.onOpen();
            }}
          >
            <MenuIcon icon={<LuTrash />} />
            Delete Issue
          </MenuItem>
        </>
      );
    },
    [navigate, permissions, deleteDisclosure]
  );

  return (
    <>
      <Table<Issue>
        data={data}
        infinite={infinite}
        columns={columns}
        count={count}
        primaryAction={
          permissions.can("create", "quality") && (
            <New label={t`Issue`} to={path.to.newIssue} />
          )
        }
        renderContextMenu={renderContextMenu}
        title={t`Issues`}
        table="nonConformance"
        withSavedView
      />
      {deleteDisclosure.isOpen && selectedIssue && (
        <ConfirmDelete
          action={path.to.deleteIssue(selectedIssue.id!)}
          isOpen
          onCancel={() => {
            setSelectedIssue(null);
            deleteDisclosure.onClose();
          }}
          onSubmit={() => {
            setSelectedIssue(null);
            deleteDisclosure.onClose();
          }}
          name={selectedIssue.name ?? "issue"}
          text={t`Are you sure you want to delete this issue?`}
        />
      )}
    </>
  );
});

IssuesTable.displayName = "IssuesTable";
export default IssuesTable;