Skip to content

The open alternative to Salesforce, designed for AI.

7.7 KB
Raw Blame
import { AppChip } from '@/applications/components/AppChip';
import { useLogicFunctionThirdPartyApplicationInformation } from '@/logic-functions/hooks/useLogicFunctionThirdPartyApplicationInformation';
import { useUpdateSidePanelPageInfo } from '@/side-panel/hooks/useUpdateSidePanelPageInfo';
import { useSidePanelWorkflowIdOrThrow } from '@/side-panel/pages/workflow/hooks/useSidePanelWorkflowIdOrThrow';
import { sidePanelWorkflowStepIdComponentState } from '@/side-panel/pages/workflow/states/sidePanelWorkflowStepIdComponentState';
import { sidePanelPageInfoSelector } from '@/side-panel/states/sidePanelPageInfoSelector';
import { TitleInput } from '@/ui/input/components/TitleInput';
import { useAtomComponentStateValue } from '@/ui/utilities/state/jotai/hooks/useAtomComponentStateValue';
import { useAtomStateValue } from '@/ui/utilities/state/jotai/hooks/useAtomStateValue';
import { flowComponentState } from '@/workflow/states/flowComponentState';
import { useWorkflowWithCurrentVersion } from '@/workflow/hooks/useWorkflowWithCurrentVersion';
import { getStepDefinitionOrThrow } from '@/workflow/utils/getStepDefinitionOrThrow';
import { getWorkflowStepDisplayName } from '@/workflow/utils/getWorkflowStepDisplayName';
import { getWorkflowVisualizerComponentInstanceId } from '@/workflow/utils/getWorkflowVisualizerComponentInstanceId';
import { useUpdateStep } from '@/workflow/workflow-steps/hooks/useUpdateStep';
import { useUpdateTrigger } from '@/workflow/workflow-trigger/hooks/useUpdateTrigger';
import { useWorkflowVersionContent } from '@/workflow/workflow-version/hooks/useWorkflowVersionContent';
import { getActionHeaderTypeOrThrow } from '@/workflow/workflow-steps/workflow-actions/utils/getActionHeaderTypeOrThrow';
import { getActionIcon } from '@/workflow/workflow-steps/workflow-actions/utils/getActionIcon';
import { getActionIconColorOrThrow } from '@/workflow/workflow-steps/workflow-actions/utils/getActionIconColorOrThrow';
import { getTriggerIcon } from '@/workflow/workflow-trigger/utils/getTriggerIcon';
import { getTriggerIconColor } from '@/workflow/workflow-trigger/utils/getTriggerIconColor';
import { useState } from 'react';
import { SidePanelPages } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
import { TRIGGER_STEP_ID } from 'twenty-shared/workflow';
import { useIcons } from 'twenty-ui/icon/provider';
import { HeaderIdentifier } from '@/ui/layout/page/components/HeaderIdentifier';
import { useTheme } from 'twenty-ui/theme';
import { useLingui } from '@lingui/react/macro';

export const SidePanelWorkflowStepInfo = ({
  sidePanelPageInstanceId,
}: {
  sidePanelPageInstanceId: string;
}) => {
  const { t } = useLingui();
  const theme = useTheme();
  const { getIcon } = useIcons();

  const sidePanelPage = useAtomStateValue(sidePanelPageInfoSelector).page;

  const workflowId = useSidePanelWorkflowIdOrThrow();

  const sidePanelWorkflowStepId = useAtomComponentStateValue(
    sidePanelWorkflowStepIdComponentState,
    sidePanelPageInstanceId,
  );

  const workflowWithCurrentVersion = useWorkflowWithCurrentVersion(workflowId);

  const isReadonly =
    sidePanelPage === SidePanelPages.WorkflowStepView ||
    sidePanelPage === SidePanelPages.WorkflowRunStepView;

  const { updateSidePanelPageInfo } = useUpdateSidePanelPageInfo();

  const instanceId = getWorkflowVisualizerComponentInstanceId({
    recordId: workflowId,
  });
  const { updateStep } = useUpdateStep(instanceId);
  const { updateTrigger } = useUpdateTrigger(instanceId);

  const workflowVersionId = workflowWithCurrentVersion?.currentVersion?.id;

  const flow = useAtomComponentStateValue(flowComponentState, instanceId);
  const { content } = useWorkflowVersionContent(workflowVersionId);

  const trigger = flow?.trigger ?? content?.trigger ?? null;
  const steps = flow?.steps ?? content?.steps ?? null;

  const isTriggerStep = sidePanelWorkflowStepId === TRIGGER_STEP_ID;

  const stepDefinition =
    isDefined(sidePanelWorkflowStepId) && isDefined(trigger)
      ? isTriggerStep || isDefined(steps)
        ? getStepDefinitionOrThrow({
            stepId: sidePanelWorkflowStepId,
            trigger,
            steps,
          })
        : undefined
      : undefined;

  const isTrigger = stepDefinition?.type === 'trigger';

  const logicFunctionId =
    stepDefinition?.type === 'action' &&
    stepDefinition.definition.type === 'LOGIC_FUNCTION'
      ? stepDefinition.definition.settings.input.logicFunctionId
      : undefined;

  const thirdPartyApplicationInformation =
    useLogicFunctionThirdPartyApplicationInformation(logicFunctionId);

  const stepName =
    isDefined(stepDefinition) && isDefined(stepDefinition.definition)
      ? isTrigger
        ? (stepDefinition.definition.name ??
          (stepDefinition.definition.type === 'MANUAL'
            ? t`Launch manually`
            : t`Trigger`))
        : (stepDefinition.definition.name ?? t`Action`)
      : '';

  const displayedStepName =
    isReadonly &&
    isDefined(stepDefinition) &&
    isDefined(stepDefinition.definition) &&
    isDefined(stepDefinition.definition.name)
      ? getWorkflowStepDisplayName({
          name: stepDefinition.definition.name,
          type: stepDefinition.definition.type,
        })
      : stepName;

  const [editedTitle, setEditedTitle] = useState<string | null>(null);

  const title =
    editedTitle ??
    (isDefined(displayedStepName) && displayedStepName !== ''
      ? displayedStepName
      : '');

  const handleTitleChange = (newTitle: string) => {
    setEditedTitle(newTitle);
  };

  if (
    !isDefined(workflowId) ||
    !isDefined(sidePanelWorkflowStepId) ||
    !isDefined(workflowWithCurrentVersion?.currentVersion) ||
    !isDefined(stepDefinition) ||
    !isDefined(stepDefinition.definition)
  ) {
    return null;
  }

  const headerIcon = isTrigger
    ? getTriggerIcon(stepDefinition.definition)
    : getActionIcon(stepDefinition.definition.type);

  const headerIconColor = isTrigger
    ? getTriggerIconColor(stepDefinition.definition.type)
    : getActionIconColorOrThrow(stepDefinition.definition.type);

  const headerType = isTrigger
    ? t`Trigger`
    : t(getActionHeaderTypeOrThrow(stepDefinition.definition.type));

  const label = isDefined(thirdPartyApplicationInformation)
    ? thirdPartyApplicationInformation.name
    : headerType;

  const Icon = getIcon(headerIcon ?? 'IconDefault');

  const saveTitle = () => {
    if (!isDefined(workflowVersionId) || !isDefined(workflowId)) {
      return;
    }

    updateSidePanelPageInfo({
      pageTitle: title,
      pageIcon: Icon,
    });

    if (isTrigger) {
      updateTrigger({
        ...stepDefinition.definition,
        name: title,
      } as typeof stepDefinition.definition);
    } else {
      updateStep({
        ...stepDefinition.definition,
        name: title,
      });
    }
  };

  return (
    <HeaderIdentifier
      icon={
        isDefined(thirdPartyApplicationInformation) ? (
          <AppChip
            applicationId={thirdPartyApplicationInformation.applicationId}
            size="md"
            chipOnly
          />
        ) : headerIcon ? (
          <Icon size={theme.icon.size.md} stroke={theme.icon.stroke.sm} />
        ) : undefined
      }
      iconColor={
        isDefined(thirdPartyApplicationInformation)
          ? undefined
          : headerIconColor
      }
      title={
        <TitleInput
          instanceId={`workflow-step-title-${sidePanelPageInstanceId}`}
          disabled={isReadonly}
          sizeVariant="sm"
          value={title}
          onChange={handleTitleChange}
          placeholder={headerType}
          onEnter={saveTitle}
          onEscape={() => setEditedTitle(null)}
          onClickOutside={saveTitle}
          onTab={saveTitle}
          onShiftTab={saveTitle}
        />
      }
      label={label}
    />
  );
};