Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

3.5 KB
Raw Blame
import { t } from "ttag";

import type { TreeTableColumnDef } from "metabase/ui";
import { Ellipsified } from "metabase/ui";
import type {
  SourceReplacementColumnErrorType,
  SourceReplacementColumnMapping,
} from "metabase-types/api";

import { getColumnErrorMessage } from "../../../../utils";
import type { EntityItem } from "../../types";

import { NameCell } from "./NameCell";
import type { ColumnMappingItem } from "./types";

function getEntityName(entityInfo: EntityItem | undefined): string {
  if (entityInfo?.type === "table") {
    return entityInfo.data?.display_name ?? "";
  } else if (entityInfo?.type === "card") {
    return entityInfo.data?.name ?? "";
  }
  return "";
}

function getEntityHeader(entityName: string, columnCount: number): string {
  return `${entityName} (${columnCount})`;
}

function getSourceColumnCount(
  columnMappings: SourceReplacementColumnMapping[],
): number {
  return columnMappings.filter(({ source }) => source != null).length;
}

function getTargetColumnCount(
  columnMappings: SourceReplacementColumnMapping[],
): number {
  return columnMappings.filter(({ target }) => target != null).length;
}

function getSourceColumn(
  header: string,
): TreeTableColumnDef<ColumnMappingItem> {
  return {
    id: "source",
    header,
    width: "auto",
    minWidth: 100,
    maxAutoWidth: 520,
    enableSorting: true,
    accessorFn: (item) => item.source?.display_name,
    cell: ({ row }) => {
      const item = row.original;
      if (item.source == null) {
        return null;
      }
      return <NameCell column={item.source} />;
    },
  };
}

function getTargetColumn(
  header: string,
): TreeTableColumnDef<ColumnMappingItem> {
  return {
    id: "target",
    header,
    width: "auto",
    minWidth: 100,
    maxAutoWidth: 520,
    enableSorting: true,
    accessorFn: (item) => item.target?.display_name,
    cell: ({ row }) => {
      const item = row.original;
      if (item.target == null) {
        return null;
      }
      return <NameCell column={item.target} />;
    },
  };
}

function getErrorMessage(errors: SourceReplacementColumnErrorType[]) {
  const messages = errors
    .map(getColumnErrorMessage)
    .filter((message) => message != null);
  return messages.length > 0 ? messages.join(" ") : null;
}

function getDetailsColumn(): TreeTableColumnDef<ColumnMappingItem> {
  return {
    id: "errors",
    header: t`Details`,
    width: "auto",
    minWidth: 100,
    maxAutoWidth: 520,
    enableSorting: true,
    accessorFn: (item) => getErrorMessage(item.errors ?? []),
    cell: ({ row }) => {
      const { errors } = row.original;
      const message = getErrorMessage(errors ?? []);
      if (message == null) {
        return null;
      }
      return <Ellipsified>{message}</Ellipsified>;
    },
  };
}

export function getColumns(
  sourceItem: EntityItem | undefined,
  targetItem: EntityItem | undefined,
  columnMappings: SourceReplacementColumnMapping[],
): TreeTableColumnDef<ColumnMappingItem>[] {
  const sourceHeader = getEntityHeader(
    getEntityName(sourceItem),
    getSourceColumnCount(columnMappings),
  );
  const targetHeader = getEntityHeader(
    getEntityName(targetItem),
    getTargetColumnCount(columnMappings),
  );

  return [
    getSourceColumn(sourceHeader),
    getTargetColumn(targetHeader),
    getDetailsColumn(),
  ];
}

export function getRows(
  columnMappings: SourceReplacementColumnMapping[],
): ColumnMappingItem[] {
  return columnMappings.map((columnMapping, index) => ({
    id: index,
    source: columnMapping.source,
    target: columnMapping.target,
    errors: columnMapping.errors,
  }));
}