Skip to content

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

10.7 KB
Raw Blame
import { useDisclosure } from "@mantine/hooks";
import cx from "classnames";
import type { ReactElement } from "react";
import { useEffect, useMemo } from "react";
import { t } from "ttag";

import {
  QuestionNotFoundError,
  SdkError,
  SdkLoader,
} from "embedding-sdk-bundle/components/private/PublicComponentWrapper";
import { QuestionVisualization } from "embedding-sdk-bundle/components/private/SdkQuestion/components/Visualization";
import { SdkQuestion } from "embedding-sdk-bundle/components/public/SdkQuestion";
import { QuestionAlertsButton } from "embedding-sdk-bundle/components/public/notifications/QuestionAlertsButton";
import { useCollectionData } from "embedding-sdk-bundle/hooks/private/use-collection-data";
import { useMobileLayout } from "embedding-sdk-bundle/hooks/private/use-mobile-layout";
import { useQuestionEditorSync } from "embedding-sdk-bundle/hooks/private/use-question-editor-sync";
import { useSdkBreadcrumbs } from "embedding-sdk-bundle/hooks/private/use-sdk-breadcrumb";
import { shouldRunCardQuery } from "embedding-sdk-bundle/lib/sdk-question";
import { useSdkSelector } from "embedding-sdk-bundle/store";
import { getIsGuestEmbed } from "embedding-sdk-bundle/store/selectors";
import type { SdkQuestionTitleProps } from "embedding-sdk-bundle/types/question";
import { SaveQuestionModal } from "metabase/common/components/SaveQuestionModal";
import { useLocale } from "metabase/common/hooks/use-locale";
import {
  Box,
  Button,
  Divider,
  Group,
  PopoverBackButton,
  Stack,
} from "metabase/ui";
import * as Lib from "metabase-lib";

import {
  FlexibleSizeComponent,
  type FlexibleSizeProps,
} from "../FlexibleSizeComponent";
import { RenderIfHasContent } from "../RenderIfHasContent/RenderIfHasContent";
import { SdkInternalNavigationBackButton } from "../SdkInternalNavigation/SdkInternalNavigationBackButton";
import { BreakoutDropdown } from "../SdkQuestion/components/Breakout/BreakoutDropdown";
import { ChartTypeDropdown } from "../SdkQuestion/components/ChartTypeDropdown";
import { DownloadWidgetDropdown } from "../SdkQuestion/components/DownloadWidget";
import { Editor } from "../SdkQuestion/components/Editor";
import { EditorButton } from "../SdkQuestion/components/EditorButton/EditorButton";
import { FilterDropdown } from "../SdkQuestion/components/Filter/FilterDropdown";
import { QuestionSettingsDropdown } from "../SdkQuestion/components/QuestionSettings";
import { RefreshButton } from "../SdkQuestion/components/RefreshButton";
import { ResultToolbar } from "../SdkQuestion/components/ResultToolbar/ResultToolbar";
import {
  SaveButton,
  shouldShowSaveButton,
} from "../SdkQuestion/components/SaveButton";
import { SummarizeDropdown } from "../SdkQuestion/components/Summarize/SummarizeDropdown";
import { useSdkQuestionContext } from "../SdkQuestion/context";

import { DefaultViewTitle } from "./DefaultViewTitle";
import InteractiveQuestionS from "./SdkQuestionDefaultView.module.css";

export interface SdkQuestionDefaultViewProps extends FlexibleSizeProps {
  /**
   * Determines whether the question title is displayed, and allows a custom title to be displayed instead of the default question title. Shown by default.
   */
  title?: SdkQuestionTitleProps;

  /**
   * Determines whether the chart type selector and corresponding settings button are shown. Only relevant when using the default layout.
   */
  withChartTypeSelector?: boolean;

  /**
   * Determines whether the editor button is shown. Only relevant when using the default layout.
   */
  withEditorButton?: boolean;
}

export const SdkQuestionDefaultView = ({
  height,
  width,
  className,
  style,
  title,
  withChartTypeSelector,
  withEditorButton = true,
}: SdkQuestionDefaultViewProps): ReactElement => {
  const { isLocaleLoading } = useLocale();
  const {
    originalId,
    question,
    queryResults,
    isQuestionLoading,
    originalQuestion,
    isSaveEnabled,
    targetCollection,
    onReset,
    onNavigateBack,
    queryQuestion,
  } = useSdkQuestionContext();

  const { reportLocation } = useSdkBreadcrumbs();
  const isGuestEmbed = useSdkSelector(getIsGuestEmbed);

  const isQuestionSaved = question?.isSaved();

  const { isEditorOpen, closeEditor, toggleEditor } = useQuestionEditorSync({
    originalId,
    isQuestionSaved,
    queryResults,
    queryQuestion,
  });

  const [isSaveModalOpen, { open: openSaveModal, close: closeSaveModal }] =
    useDisclosure(false);

  const isNativeQuestion = useMemo(() => {
    if (!question) {
      return false;
    }

    const { isNative } = Lib.queryDisplayInfo(question.query());

    return isNative;
  }, [question]);

  // When visualizing a question for the first time, there is no query result yet.
  const isQueryResultLoading =
    question && shouldRunCardQuery({ question, isGuestEmbed }) && !queryResults;

  useEffect(() => {
    if (
      !isQuestionLoading &&
      question?.isSaved() &&
      originalId !== "new" &&
      originalId !== "new-native" &&
      queryResults
    ) {
      reportLocation({
        type: "question",
        id: question.id(),
        name: question.displayName() || "Question",
        onNavigate: onNavigateBack ?? onReset ?? undefined,
      });
    }
  }, [
    isQuestionLoading,
    question,
    originalId,
    queryResults,
    reportLocation,
    onNavigateBack,
    onReset,
  ]);

  const { canWrite: canWriteToTargetCollection } = useCollectionData(
    targetCollection,
    { skipCollectionFetching: !isSaveEnabled },
  );

  const { ref: containerRef, isMobile } = useMobileLayout();

  // EMB-2177: the loader and the error states have to sit in the same box as
  // the rendered state, otherwise the component collapses and then jumps to
  // the caller's height once the question resolves.
  const sizeProps = { height, width, className, style };

  if (
    !isEditorOpen &&
    (isLocaleLoading || isQuestionLoading || isQueryResultLoading)
  ) {
    return (
      <FlexibleSizeComponent {...sizeProps}>
        <SdkLoader />
      </FlexibleSizeComponent>
    );
  }

  if (!isEditorOpen && !question) {
    return (
      <FlexibleSizeComponent {...sizeProps}>
        {originalId ? (
          <QuestionNotFoundError id={originalId} />
        ) : (
          <SdkError message={t`Question not found`} />
        )}
      </FlexibleSizeComponent>
    );
  }

  const showSaveButton =
    shouldShowSaveButton({
      question,
      originalQuestion,
      canWriteToTargetCollection,
    }) && isSaveEnabled;

  return (
    <FlexibleSizeComponent
      ref={containerRef}
      height={height}
      width={width}
      className={cx(InteractiveQuestionS.Container, className)}
      style={style}
    >
      <RenderIfHasContent
        component={Stack}
        className={InteractiveQuestionS.TopBar}
        gap="sm"
        p="lg"
      >
        <RenderIfHasContent
          component={Group}
          justify="space-between"
          align="flex-end"
          data-testid="interactive-question-top-toolbar"
        >
          <RenderIfHasContent component={Group} gap="xxs">
            <Stack align="flex-start">
              <SdkInternalNavigationBackButton />
              <DefaultViewTitle title={title} />
            </Stack>
          </RenderIfHasContent>
          {showSaveButton && <SaveButton onClick={openSaveModal} ml="auto" />}
        </RenderIfHasContent>
        {queryResults && (
          <RenderIfHasContent
            component={ResultToolbar}
            data-testid="interactive-question-result-toolbar"
          >
            <RenderIfHasContent component={Group} gap="xxs">
              {isEditorOpen ? (
                <PopoverBackButton
                  onClick={toggleEditor}
                  c="core-brand"
                  fz="md"
                  ml="sm"
                >
                  {t`Back to visualization`}
                </PopoverBackButton>
              ) : (
                <>
                  {withChartTypeSelector && (
                    <>
                      <Button.Group>
                        <ChartTypeDropdown />
                        <QuestionSettingsDropdown />
                      </Button.Group>

                      {!isNativeQuestion && !isMobile && (
                        <Divider
                          mx="xxs"
                          orientation="vertical"
                          style={{
                            color: "var(--mb-color-border-neutral) !important",
                          }}
                        />
                      )}
                    </>
                  )}

                  {!isNativeQuestion && !isMobile && (
                    <>
                      <FilterDropdown />
                      <SummarizeDropdown />
                      <BreakoutDropdown />
                    </>
                  )}
                </>
              )}
            </RenderIfHasContent>
            <RenderIfHasContent component={Group} gap="sm" ml="auto">
              {!isEditorOpen && !isMobile && (
                <>
                  <DownloadWidgetDropdown />
                  <QuestionAlertsButton />
                </>
              )}
              {!isEditorOpen && <RefreshButton />}
              {withEditorButton && (
                <EditorButton isOpen={isEditorOpen} onClick={toggleEditor} />
              )}
            </RenderIfHasContent>
          </RenderIfHasContent>
        )}

        {isGuestEmbed && (
          <Box w="100%">
            <SdkQuestion.SqlParametersList />
          </Box>
        )}
      </RenderIfHasContent>

      <Box
        className={cx(InteractiveQuestionS.Main, "sdk-question-main")}
        p="sm"
        w="100%"
        h="100%"
      >
        <Box className={InteractiveQuestionS.Content}>
          {isEditorOpen ? (
            <Editor onApply={closeEditor} />
          ) : (
            <QuestionVisualization height="100%" />
          )}
        </Box>
      </Box>
      {/* Refer to the SaveQuestionProvider for context on why we have to do it like this */}
      <DefaultViewSaveModal isOpen={isSaveModalOpen} close={closeSaveModal} />
    </FlexibleSizeComponent>
  );
};

const DefaultViewSaveModal = ({
  isOpen,
  close,
}: {
  isOpen: boolean;
  close: () => void;
}) => {
  const {
    question,
    originalQuestion,
    onCreate,
    onSave,
    isSaveEnabled,
    targetCollection,
    initialCollection,
  } = useSdkQuestionContext();

  if (!isSaveEnabled || !isOpen || !question) {
    return null;
  }

  return (
    <SaveQuestionModal
      question={question}
      originalQuestion={originalQuestion ?? null}
      opened
      closeOnSuccess
      onClose={close}
      onCreate={onCreate}
      onSave={async (question) => {
        await onSave(question);
        close();
      }}
      targetCollection={targetCollection}
      initialCollectionId={initialCollection}
    />
  );
};