@haiiro/docuflow 0.0.12 → 0.0.13

package/src/front-components/launch-process.front-component.tsx

@@ -0,0 +1,270 @@
+import { useState } from 'react';
+import { defineFrontComponent } from 'twenty-sdk/define';
+import {
+  enqueueSnackbar,
+  openSidePanelPage,
+  SidePanelPages,
+  useSelectedObjectMetadata,
+  useSelectedRecordIds,
+} from 'twenty-sdk/front-component';
+import { IconPlayerPlay } from 'twenty-ui/icon';
+import { useTheme } from 'twenty-ui/theme';
+
+import { callAppRoute, getErrorMessage, listRecords } from 'src/front/api';
+import { useAsync } from 'src/front/hooks/use-async';
+import { DocflowRoot, Message, pluralize, SectionTitle } from 'src/front/ui/components';
+import { FormFieldInputs } from 'src/front/ui/form-field-inputs';
+import { Button, MenuRow } from 'src/front/ui/kit';
+import { restAnd, restEq, restIn } from 'src/shared/api/rest-filter.util';
+import { DOCFLOW_SECTION, LAUNCH_RECORDS_LIMIT } from 'src/shared/docflow.constants';
+import { type FormField, type FormValues } from 'src/shared/form/form-field.type';
+import { findMissingRequiredFields } from 'src/shared/form/form-fields.util';
+import { logDocflowError } from 'src/shared/log.util';
+import {
+  buildLaunchParameters,
+  isLaunchTrigger,
+  parseLaunchFields,
+  parseLaunchObject,
+} from 'src/shared/workflow/launch-step.util';
+import { type WorkflowTrigger } from 'src/shared/workflow/workflow-run.type';
+import { LAUNCH_PROCESS_FRONT_COMPONENT_UNIVERSAL_IDENTIFIER } from 'src/universal-identifiers';
+
+const PROCESSES_LIMIT = 200;
+const RECORD_NOUN: [string, string, string] = ['запись', 'записи', 'записей'];
+
+type WorkflowRecord = {
+  id: string;
+  name?: string | null;
+  smbLaunchFields?: unknown;
+  smbLaunchObject?: string | null;
+};
+type WorkflowVersionRecord = { id: string; workflowId: string; trigger?: WorkflowTrigger | null };
+
+type LaunchableProcess = {
+  workflowVersionId: string;
+  name: string;
+  launchFields: FormField[];
+  // Launched on the selected records, or without a record
+  isOnRecords: boolean;
+};
+
+// A plain manual trigger offered everywhere: the process needs no record
+const isGlobalManualTrigger = (trigger: WorkflowTrigger | null | undefined) => {
+  const availability = (trigger?.settings as { availability?: { type?: string } } | undefined)?.availability;
+
+  return trigger?.type === 'MANUAL' && (availability?.type ?? 'GLOBAL') === 'GLOBAL';
+};
+
+// The published docflow processes this place can launch: on the selected
+// records the ones of their object, and everywhere the ones without a record.
+const loadLaunchableProcesses = async (objectName: string | undefined): Promise<LaunchableProcess[]> => {
+  const { records: workflows } = await listRecords<WorkflowRecord>('workflows', {
+    filter: restEq('smbSection', DOCFLOW_SECTION),
+    order_by: 'name[AscNullsLast]',
+    limit: PROCESSES_LIMIT,
+  });
+
+  if (workflows.length === 0) {
+    return [];
+  }
+
+  const { records: versions } = await listRecords<WorkflowVersionRecord>('workflowVersions', {
+    filter: restAnd(restEq('status', 'ACTIVE'), restIn('workflowId', workflows.map(({ id }) => id))),
+    limit: PROCESSES_LIMIT,
+  });
+
+  const processes = workflows.flatMap((workflow): LaunchableProcess[] => {
+    const active = versions.find((version) => version.workflowId === workflow.id);
+    const launchObject = isLaunchTrigger(active?.trigger) ? parseLaunchObject(workflow.smbLaunchObject) : undefined;
+    const isLaunchable =
+      active !== undefined &&
+      (isLaunchTrigger(active.trigger) || isGlobalManualTrigger(active.trigger)) &&
+      (launchObject === undefined || launchObject === objectName);
+
+    return isLaunchable
+      ? [
+          {
+            workflowVersionId: active.id,
+            name: workflow.name?.trim() || 'Без названия',
+            launchFields: isLaunchTrigger(active.trigger) ? parseLaunchFields(workflow.smbLaunchFields) : [],
+            isOnRecords: launchObject !== undefined,
+          },
+        ]
+      : [];
+  });
+
+  // The processes of the record come first
+  return [...processes.filter(({ isOnRecords }) => isOnRecords), ...processes.filter(({ isOnRecords }) => !isOnRecords)];
+};
+
+const LaunchForm = ({
+  process,
+  recordIds,
+  onBack,
+}: {
+  process: LaunchableProcess;
+  recordIds: string[];
+  onBack: (() => void) | undefined;
+}) => {
+  const theme = useTheme();
+  const [values, setValues] = useState<FormValues>({});
+  const [isLaunching, setIsLaunching] = useState(false);
+  const [errorMessage, setErrorMessage] = useState<string | undefined>();
+  const launchRecordIds = process.isOnRecords ? recordIds : [];
+
+  const launch = async () => {
+    const parameters = buildLaunchParameters({ fields: process.launchFields, values });
+    const missingFields = findMissingRequiredFields({ fields: process.launchFields, values: parameters });
+
+    if (missingFields.length > 0) {
+      setErrorMessage(`Заполните: ${missingFields.map(({ label }) => label).join(', ')}`);
+
+      return;
+    }
+
+    setIsLaunching(true);
+    setErrorMessage(undefined);
+
+    try {
+      const { workflowRunIds } = await callAppRoute<{ workflowRunIds: string[] }>('/docflow/processes/launch', {
+        workflowVersionId: process.workflowVersionId,
+        values: parameters,
+        recordIds: launchRecordIds,
+      });
+
+      if (workflowRunIds.length > 1) {
+        await enqueueSnackbar({
+          message: `Запущено процессов: ${workflowRunIds.length}`,
+          variant: 'success',
+        });
+      }
+
+      // Like the standard manual launch: the run opens in the side panel
+      await openSidePanelPage({
+        page: SidePanelPages.ViewRecord,
+        objectNameSingular: 'workflowRun',
+        recordId: workflowRunIds[0],
+        resetNavigationStack: true,
+      });
+    } catch (error) {
+      logDocflowError('launch: failed', error, { workflowVersionId: process.workflowVersionId });
+      setErrorMessage(getErrorMessage(error, 'Не удалось запустить процесс'));
+      setIsLaunching(false);
+    }
+  };
+
+  return (
+    <section style={{ display: 'flex', flexDirection: 'column', gap: theme.spacing[3] }} aria-label="Запуск процесса">
+      <SectionTitle
+        action={
+          onBack !== undefined ? (
+            <Button size="sm" variant="ghost" disabled={isLaunching} onClick={onBack}>
+              Другой процесс
+            </Button>
+          ) : undefined
+        }
+      >
+        {process.name}
+      </SectionTitle>
+      {process.isOnRecords && launchRecordIds.length > 1 && (
+        <Message tone="hint">
+          Выбрано {launchRecordIds.length} {pluralize(launchRecordIds.length, RECORD_NOUN)}: процесс запустится на
+          каждой, с одними параметрами.
+        </Message>
+      )}
+      {process.launchFields.length > 0 ? (
+        <FormFieldInputs fields={process.launchFields} values={values} onChange={setValues} disabled={isLaunching} />
+      ) : (
+        <Message tone="hint">Процесс запускается без параметров.</Message>
+      )}
+      {errorMessage !== undefined && <Message tone="danger">{errorMessage}</Message>}
+      <Button
+        variant="solid"
+        tone="accent"
+        size="md"
+        fullWidth
+        icon={IconPlayerPlay}
+        loading={isLaunching}
+        onClick={() => void launch()}
+      >
+        Запустить
+      </Button>
+    </section>
+  );
+};
+
+// "Запустить процесс" of the command menu: the manual launch of a docflow
+// process with its parameters, in the side panel. From a record it offers the
+// processes launched on records of its object and passes the record in; from
+// anywhere else, the processes that need no record. The standard manual launch
+// asks nothing, so a process with parameters is launched here.
+const LaunchProcess = () => {
+  const theme = useTheme();
+  const selectedRecordIds = useSelectedRecordIds();
+  const selectedObject = useSelectedObjectMetadata();
+  const objectName = selectedRecordIds.length > 0 ? selectedObject?.nameSingular : undefined;
+  const [selectedVersionId, setSelectedVersionId] = useState<string | undefined>();
+  const { data: processes, error, loading } = useAsync(
+    () => loadLaunchableProcesses(objectName),
+    [objectName],
+  );
+  const onlyProcess = processes?.length === 1 ? processes[0] : undefined;
+  const selectedProcess = onlyProcess ?? processes?.find(({ workflowVersionId }) => workflowVersionId === selectedVersionId);
+
+  return (
+    <DocflowRoot>
+      <div style={{ display: 'flex', flexDirection: 'column', gap: theme.spacing[3], padding: theme.spacing[3] }}>
+        {loading && processes === undefined && <Message>Загрузка…</Message>}
+        {error !== undefined && <Message tone="danger">{getErrorMessage(error, 'Не удалось прочитать процессы')}</Message>}
+        {selectedRecordIds.length > LAUNCH_RECORDS_LIMIT && (
+          <Message tone="danger">За один раз — не больше {LAUNCH_RECORDS_LIMIT} записей.</Message>
+        )}
+        {processes !== undefined && processes.length === 0 && (
+          <Message tone="hint">
+            {objectName !== undefined
+              ? 'Для этих записей нет опубликованных процессов. Объект, на записях которого запускается процесс, выбирается в «Параметрах запуска» процесса.'
+              : 'Нет опубликованных процессов, которые запускаются вручную.'}
+          </Message>
+        )}
+        {selectedProcess !== undefined ? (
+          <LaunchForm
+            key={selectedProcess.workflowVersionId}
+            process={selectedProcess}
+            recordIds={selectedRecordIds}
+            onBack={onlyProcess === undefined ? () => setSelectedVersionId(undefined) : undefined}
+          />
+        ) : (
+          processes !== undefined &&
+          processes.length > 0 && (
+            <div style={{ display: 'flex', flexDirection: 'column', gap: theme.spacing[1] }}>
+              {processes.map((process, index) => (
+                <div key={process.workflowVersionId}>
+                  {objectName !== undefined && index === processes.findIndex(({ isOnRecords }) => isOnRecords === process.isOnRecords) && (
+                    <SectionTitle>{process.isOnRecords ? 'На выбранной записи' : 'Без записи'}</SectionTitle>
+                  )}
+                  <MenuRow
+                    icon={IconPlayerPlay}
+                    label={process.name}
+                    trailing={
+                      process.launchFields.length > 0
+                        ? `${process.launchFields.length} ${pluralize(process.launchFields.length, ['параметр', 'параметра', 'параметров'])}`
+                        : undefined
+                    }
+                    onClick={() => setSelectedVersionId(process.workflowVersionId)}
+                  />
+                </div>
+              ))}
+            </div>
+          )
+        )}
+      </div>
+    </DocflowRoot>
+  );
+};
+
+export default defineFrontComponent({
+  universalIdentifier: LAUNCH_PROCESS_FRONT_COMPONENT_UNIVERSAL_IDENTIFIER,
+  name: 'docflow-launch-process',
+  description: 'Запуск процесса документооборота с параметрами из командного меню',
+  component: LaunchProcess,
+});