Skip to content

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

4.8 KB
Raw Blame
import {
  getSearchField,
  getSharedRemappedField,
} from "metabase-lib/v1/metadata/utils/remapping";
import { isFuzzyOperator } from "metabase-lib/v1/operators/utils";
import type {
  ParameterField,
  ParameterWithTemplateTagTarget,
} from "metabase-lib/v1/parameters/types";
import type {
  Parameter,
  ValuesQueryType,
  ValuesSourceConfig,
  ValuesSourceType,
} from "metabase-types/api";

import { deriveFieldOperatorFromParameter } from "./operators";
import { getFields } from "./parameter-fields";
import { getParameterType } from "./parameter-type";

export const getQueryType = (
  parameter: ParameterWithTemplateTagTarget,
): ValuesQueryType => {
  return parameter.values_query_type ?? getDefaultQueryType(parameter);
};

const getDefaultQueryType = (
  parameter: ParameterWithTemplateTagTarget,
): ValuesQueryType => {
  if (parameter.hasVariableTemplateTagTarget) {
    return "none";
  } else {
    const operator = deriveFieldOperatorFromParameter(parameter);
    return operator != null && isFuzzyOperator(operator) ? "none" : "list";
  }
};

export const getSourceType = (parameter: Parameter): ValuesSourceType => {
  return parameter.values_source_type ?? null;
};

export const getSourceConfig = (parameter: Parameter): ValuesSourceConfig => {
  return parameter.values_source_config ?? {};
};

/**
 * Whether the parameter's selected values can be remapped to human-readable
 * labels. True when a connected field has a remapping, when a static list
 * includes [value, label] pairs, or when a card/question source configures a
 * label column.
 */
export const hasRemappedParameterValues = (
  parameter: Parameter | null | undefined,
  fields: ParameterField[],
): boolean => {
  if (getSharedRemappedField(fields) != null) {
    return true;
  }

  if (parameter == null) {
    return false;
  }

  const sourceType = getSourceType(parameter);
  const sourceConfig = getSourceConfig(parameter);
  const sourceLabelField = sourceConfig.label_field;
  const sourceValues = sourceConfig.values ?? [];

  return (
    (sourceType === "static-list" &&
      sourceValues.some((value) => Array.isArray(value) && value.length > 1)) ||
    (sourceType === "card" && sourceLabelField != null)
  );
};

export const canUseCustomSource = (parameter: Parameter) => {
  const type = getParameterType(parameter);

  switch (type) {
    case "string":
    case "location":
    case "category":
    case "number":
    case "id":
      return true;
    default:
      return false;
  }
};

export const isValidSourceConfig = (
  sourceType: ValuesSourceType,
  { card_id, value_field, values }: ValuesSourceConfig,
) => {
  switch (sourceType) {
    case "card":
      return card_id != null && value_field != null;
    case "static-list":
      return values != null && values.length > 0;
    default:
      return true;
  }
};

export const getSourceConfigForType = (
  sourceType: ValuesSourceType,
  { card_id, value_field, label_field, values }: ValuesSourceConfig,
): ValuesSourceConfig => {
  switch (sourceType) {
    case "card":
      return { card_id, value_field, label_field };
    case "static-list":
      return { values };
    default:
      return {};
  }
};

export const canListParameterValues = (parameter: Parameter) => {
  const queryType = getQueryType(parameter);
  const sourceType = getSourceType(parameter);
  const fields = getFields(parameter);
  const canListFields = canListFieldValues(fields);

  return sourceType
    ? queryType === "list"
    : queryType !== "none" && canListFields;
};

export const canListFieldValues = (fields: ParameterField[]) => {
  const hasFields = fields.length > 0;
  const hasFieldValues = fields
    .filter((field) => typeof field.id === "number")
    .every((field) => field.has_field_values === "list");

  return hasFields && hasFieldValues;
};

export const canSearchParameterValues = (
  parameter: Parameter,
  disablePKRemapping = false,
) => {
  const operator = deriveFieldOperatorFromParameter(parameter);
  if (operator && isFuzzyOperator(operator) && !canUseCustomSource(parameter)) {
    return false;
  }

  const queryType = getQueryType(parameter);
  const sourceType = getSourceType(parameter);
  const fields = getFields(parameter);
  const canSearchFields = canSearchFieldValues(fields, disablePKRemapping);

  return sourceType
    ? queryType === "search"
    : queryType !== "none" && canSearchFields;
};

export const canSearchFieldValues = (
  fields: ParameterField[],
  disablePKRemapping = false,
) => {
  const hasFields = fields.length > 0;
  const canSearch = fields.every((field) =>
    getSearchField(field, disablePKRemapping),
  );
  const hasFieldValues = fields.some(
    (field) =>
      field.has_field_values === "search" ||
      (field.has_field_values === "list" && field.has_more_values === true),
  );

  return hasFields && canSearch && hasFieldValues;
};