function GeneralSettings()

in libs/designer/src/lib/ui/settings/index.tsx [231:402]

• 157 lines of code
• 8 McCabe index (conditional complexity)

function GeneralSettings({
  nodeId,
  readOnly,
  nodeSettings,
  isExpanded,
  validationErrors,
  dispatch,
  updateSettings,
}: SettingSectionProps): JSX.Element | null {
  const isTrigger = useSelector((state: RootState) => isRootNodeInGraph(nodeId, 'root', state.workflow.nodesMetadata));
  const maximumWaitingRunsMetadata = useHostOptions().maxWaitingRuns;
  const operationInfo = useOperationInfo(nodeId) ?? ({} as any);
  const nodeInputs = useRawInputParameters(nodeId) ?? ({} as any);

  const { timeout, splitOn, splitOnConfiguration, concurrency, conditionExpressions, invokerConnection, count, shouldFailOperation } =
    useSelector((state: RootState) => getRecordEntry(state.operations.settings, nodeId) ?? {});

  const onConcurrencyToggle = (checked: boolean): void => {
    const value = checked ? (concurrency?.value?.runs ?? constants.CONCURRENCY_ACTION_SLIDER_LIMITS.DEFAULT) : undefined;
    updateSettings({
      concurrency: {
        isSupported: !!concurrency?.isSupported,
        value: { runs: value, enabled: checked },
      },
    });
  };

  const onShouldFailOperationToggle = (checked: boolean): void => {
    updateSettings({
      shouldFailOperation: {
        isSupported: !!shouldFailOperation?.isSupported,
        value: checked,
      },
    });
  };

  const onConcurrencyRunValueChange = (value: number): void => {
    updateSettings({
      concurrency: {
        isSupported: !!concurrency?.isSupported,
        value: { enabled: true, runs: value, maximumWaitingRuns: concurrency?.value?.maximumWaitingRuns },
      },
    });
  };

  const onConcurrencyMaxWaitRunChange = (value: number): void => {
    updateSettings({
      concurrency: {
        isSupported: !!concurrency?.isSupported,
        value: { enabled: true, runs: concurrency?.value?.runs, maximumWaitingRuns: value },
      },
    });
  };

  const onSplitOnToggle = (checked: boolean): void => {
    const splitOnSetting = {
      isSupported: !!splitOn?.isSupported,
      value: {
        enabled: checked,
        value: splitOn?.value?.value ?? undefined,
      },
    };

    updateSettings({ splitOn: splitOnSetting });
    updateOutputsAndTokens(nodeId, operationInfo, dispatch, isTrigger, nodeInputs, { ...nodeSettings, splitOn: splitOnSetting });
  };

  const onTimeoutValueChange = (newVal: string): void => {
    updateSettings({
      timeout: {
        isSupported: !!timeout?.isSupported,
        value: newVal,
      },
    });
  };

  const onCountValueChange = (value: number): void => {
    updateSettings({
      count: {
        isSupported: !!count?.isSupported,
        value: value,
      },
    });
  };

  const onTriggerConditionsChange = (newExpressions: string[]): void => {
    updateSettings(
      {
        conditionExpressions: {
          isSupported: !!conditionExpressions?.isSupported,
          value: newExpressions,
        },
      },
      true
    );
  };

  const onClientTrackingIdChange = (newVal: string): void => {
    updateSettings({
      splitOnConfiguration: {
        correlation: { clientTrackingId: newVal },
      },
    });
  };

  const onSplitOnSelectionChanged = (selectedOption: IDropdownOption): void => {
    const splitOnSetting = {
      isSupported: !!splitOn?.isSupported,
      value: {
        enabled: splitOn?.value?.enabled ?? true,
        value: selectedOption.key.toString(),
      },
    };

    updateSettings({ splitOn: splitOnSetting });
    updateOutputsAndTokens(nodeId, operationInfo, dispatch, isTrigger, nodeInputs, { ...nodeSettings, splitOn: splitOnSetting });
  };

  const onInvokerConnectionToggle = (checked: boolean): void => {
    dispatch(
      updateNodeSettings({
        id: nodeId,
        settings: {
          invokerConnection: {
            isSupported: !!invokerConnection?.isSupported,
            value: { value: invokerConnection?.value?.value, enabled: checked },
          },
        },
      })
    );
  };

  if (
    splitOn?.isSupported ||
    timeout?.isSupported ||
    concurrency?.isSupported ||
    conditionExpressions?.isSupported ||
    invokerConnection?.isSupported ||
    count?.isSupported
  ) {
    return (
      <General
        nodeId={nodeId}
        readOnly={readOnly}
        expanded={isExpanded}
        validationErrors={validationErrors}
        splitOn={splitOn}
        count={count}
        timeout={timeout}
        concurrency={concurrency}
        shouldFailOperation={shouldFailOperation}
        invokerConnection={invokerConnection}
        conditionExpressions={conditionExpressions}
        splitOnConfiguration={splitOnConfiguration}
        onHeaderClick={(sectionName) => dispatch(setExpandedSections(sectionName))}
        onConcurrencyToggle={onConcurrencyToggle}
        onShouldFailOperationToggle={onShouldFailOperationToggle}
        onConcurrencyRunValueChange={onConcurrencyRunValueChange}
        onConcurrencyMaxWaitRunChange={onConcurrencyMaxWaitRunChange}
        onInvokerConnectionToggle={onInvokerConnectionToggle}
        onSplitOnToggle={onSplitOnToggle}
        onSplitOnSelectionChanged={onSplitOnSelectionChanged}
        onTimeoutValueChange={onTimeoutValueChange}
        onCountValueChange={onCountValueChange}
        onTriggerConditionsChange={onTriggerConditionsChange}
        onClientTrackingIdChange={onClientTrackingIdChange}
        maximumWaitingRunsMetadata={maximumWaitingRunsMetadata ?? constants.MAXIMUM_WAITING_RUNS.DEFAULT}
      />
    );
  }
  return null;
}