@gadmin2n/schematics 0.0.147 → 0.0.149

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/node-instances/widgets/EventTriggerConfigEditor.test.tsx

@@ -0,0 +1,140 @@
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { useState } from 'react';
+import { describe, expect, it, vi } from 'vitest';
+import i18n from '../../../../i18n';
+import { EventTriggerConfigEditor } from './EventTriggerConfigEditor';
+
+vi.mock('./event-catalog.api', () => ({
+  eventCatalogApi: {
+    list: vi.fn().mockResolvedValue([
+      {
+        registrationCode: 'request',
+        label: '申请变化',
+        schemaName: 'public',
+        tableName: 'request',
+        operations: ['INSERT', 'UPDATE'],
+        watchedFields: ['status'],
+        primaryKeyFields: ['id'],
+        fields: [
+          {
+            path: 'primaryKey.id',
+            type: 'number',
+            primaryKey: true,
+            nullable: false,
+          },
+          {
+            path: 'before.status',
+            type: 'string',
+            primaryKey: false,
+            nullable: true,
+          },
+          {
+            path: 'after.status',
+            type: 'string',
+            primaryKey: false,
+            nullable: false,
+          },
+        ],
+      },
+    ]),
+  },
+}));
+
+Object.defineProperty(window, 'matchMedia', {
+  writable: true,
+  value: () => ({
+    matches: false,
+    addListener() {},
+    removeListener() {},
+    addEventListener() {},
+    removeEventListener() {},
+    dispatchEvent: () => false,
+  }),
+});
+
+function Editor() {
+  const [value, setValue] = useState<
+    NonNullable<Parameters<typeof EventTriggerConfigEditor>[0]['value']>
+  >({
+    registrationCode: 'request',
+    processingMode: 'PARALLEL',
+    operationRules: [{ operation: 'INSERT' }, { operation: 'UPDATE' }],
+  });
+  return (
+    <>
+      <EventTriggerConfigEditor
+        value={value}
+        onChange={(next) => setValue(next!)}
+        schema={{ type: 'object' }}
+      />
+      <output data-testid="config">{JSON.stringify(value)}</output>
+    </>
+  );
+}
+
+describe('event operation condition editor', () => {
+  it('preserves separate operation conditions, supports value lists and disabling one operation', async () => {
+    await i18n.changeLanguage('zh_CN');
+    render(<Editor />);
+    await screen.findByText('新增时');
+    fireEvent.click(screen.getByText('满足条件时启动'));
+    fireEvent.change(screen.getByRole('textbox', { name: '条件 1 的比较值' }), {
+      target: { value: 'PENDING' },
+    });
+    fireEvent.click(screen.getByText('修改时'));
+    fireEvent.click(screen.getByText('满足条件时启动'));
+    fireEvent.mouseDown(
+      screen.getByRole('combobox', { name: '条件 1 的判断方式' }),
+    );
+    const operators = await screen.findAllByText('属于以下任一值');
+    fireEvent.click(operators[operators.length - 1]);
+    const input = screen.getByRole('combobox', { name: '条件 1 的比较值' });
+    for (const value of ['DRAFT', 'REJECTED']) {
+      fireEvent.change(input, { target: { value } });
+      fireEvent.keyDown(input, { key: 'Enter', code: 'Enter', keyCode: 13 });
+      fireEvent.keyUp(input, { key: 'Enter', code: 'Enter', keyCode: 13 });
+      await waitFor(() =>
+        expect(screen.getByTestId('config').textContent).toContain(value),
+      );
+    }
+    let config = JSON.parse(screen.getByTestId('config').textContent!);
+    expect(config.operationRules).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          operation: 'INSERT',
+          match: expect.objectContaining({
+            conditions: [
+              expect.objectContaining({
+                left: { source: 'WORKFLOW', path: 'after.status' },
+                right: expect.objectContaining({ value: 'PENDING' }),
+              }),
+            ],
+          }),
+        }),
+        expect.objectContaining({
+          operation: 'UPDATE',
+          match: expect.objectContaining({
+            conditions: [
+              expect.objectContaining({
+                operator: 'IN',
+                left: { source: 'WORKFLOW', path: 'before.status' },
+                right: expect.objectContaining({
+                  value: '["DRAFT","REJECTED"]',
+                }),
+              }),
+            ],
+          }),
+        }),
+      ]),
+    );
+    fireEvent.click(screen.getByText('新增时'));
+    expect(screen.getByDisplayValue('PENDING')).toBeInTheDocument();
+    fireEvent.click(screen.getByText('不启动'));
+    config = JSON.parse(screen.getByTestId('config').textContent!);
+    expect(
+      config.operationRules.map(
+        (rule: { operation: string }) => rule.operation,
+      ),
+    ).toEqual(['UPDATE']);
+  });
+});

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/node-instances/widgets/EventTriggerConfigEditor.tsx

@@ -14,17 +14,24 @@ import {
 import { useEffect, useMemo, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import type { WidgetProps } from '../schema-form/widget-registry';
-import { eventCatalogApi, type BusinessEventOption } from './event-catalog.api';
+import {
+  eventCatalogApi,
+  type BusinessEventOption,
+  type BusinessEventOperation,
+} from './event-catalog.api';
 
 type EventTriggerConfig = {
   registrationCode: string;
-  match?: EventMatch;
+  operationRules: Array<{
+    operation: BusinessEventOperation;
+    match?: EventMatch;
+  }>;
   processingMode: 'PARALLEL' | 'SERIAL_BY_KEY';
   concurrencyKeyPath?: string;
   maxConcurrency?: number | null;
 };
 
-type EventMatchOperator = 'EQ' | 'NEQ' | 'EMPTY' | 'NOT_EMPTY';
+type EventMatchOperator = 'EQ' | 'NEQ' | 'IN' | 'EMPTY' | 'NOT_EMPTY';
 type EventMatchCondition = {
   id: string;
   left: { source: 'WORKFLOW'; path: string };
@@ -42,6 +49,7 @@ type EventMatch = {
 
 const DEFAULT_CONFIG: EventTriggerConfig = {
   registrationCode: '',
+  operationRules: [],
   processingMode: 'PARALLEL',
 };
 
@@ -81,6 +89,8 @@ export function EventTriggerConfigEditor({
   const [loading, setLoading] = useState(true);
   const [loadFailed, setLoadFailed] = useState(false);
   const config = { ...DEFAULT_CONFIG, ...value };
+  const [activeOperation, setActiveOperation] =
+    useState<BusinessEventOperation>('INSERT');
   const selectedEvent = useMemo(
     () =>
       events.find(
@@ -88,6 +98,24 @@ export function EventTriggerConfigEditor({
       ),
     [config.registrationCode, events],
   );
+  const operation = selectedEvent?.operations.includes(activeOperation)
+    ? activeOperation
+    : selectedEvent?.operations[0];
+  const rule = config.operationRules.find(
+    (item) => item.operation === operation,
+  );
+  const match = rule?.match;
+
+  function changeMatch(next?: EventMatch, enabled = true) {
+    if (!operation) return;
+    onChange({
+      ...config,
+      operationRules: [
+        ...config.operationRules.filter((item) => item.operation !== operation),
+        ...(enabled ? [{ operation, ...(next ? { match: next } : {}) }] : []),
+      ],
+    });
+  }
   const serialKeyFields = useMemo(
     () =>
       (selectedEvent?.fields ?? []).filter(
@@ -99,10 +127,13 @@ export function EventTriggerConfigEditor({
   );
   const matchFields = useMemo(
     () =>
-      (selectedEvent?.fields ?? []).filter((field) =>
-        ['string', 'number', 'boolean'].includes(field.type),
+      (selectedEvent?.fields ?? []).filter(
+        (field) =>
+          ['string', 'number', 'boolean'].includes(field.type) &&
+          !(operation === 'INSERT' && field.path.startsWith('before.')) &&
+          !(operation === 'DELETE' && field.path.startsWith('after.')),
       ),
-    [selectedEvent],
+    [selectedEvent, operation],
   );
   const defaultMatchField =
     matchFields.find((field) => !field.primaryKey) ?? matchFields[0];
@@ -145,6 +176,9 @@ export function EventTriggerConfigEditor({
 
     onChange({
       registrationCode,
+      operationRules: (event?.operations ?? []).map((operation) => ({
+        operation,
+      })),
       processingMode: config.processingMode,
       ...(config.processingMode === 'SERIAL_BY_KEY'
         ? {
@@ -161,7 +195,7 @@ export function EventTriggerConfigEditor({
     if (processingMode === 'PARALLEL') {
       onChange({
         registrationCode: config.registrationCode,
-        ...(config.match ? { match: config.match } : {}),
+        operationRules: config.operationRules,
         processingMode,
       });
       return;
@@ -180,31 +214,24 @@ export function EventTriggerConfigEditor({
     });
   }
 
-  function changeMatchMode(mode: 'ALWAYS' | 'CONDITIONAL') {
-    if (mode === 'ALWAYS') {
-      const { match: _match, ...next } = config;
-      onChange(next);
+  function changeMatchMode(mode: 'NEVER' | 'ALWAYS' | 'CONDITIONAL') {
+    if (mode !== 'CONDITIONAL') {
+      changeMatch(undefined, mode === 'ALWAYS');
       return;
     }
-    onChange({
-      ...config,
-      match: {
-        combineOperation: 'AND',
-        conditions: [newMatchCondition(defaultMatchField)],
-      },
+    changeMatch({
+      combineOperation: 'AND',
+      conditions: [newMatchCondition(defaultMatchField)],
     });
   }
 
   function updateMatchCondition(index: number, next: EventMatchCondition) {
-    if (!config.match) return;
-    onChange({
-      ...config,
-      match: {
-        ...config.match,
-        conditions: config.match.conditions.map((condition, current) =>
-          current === index ? next : condition,
-        ),
-      },
+    if (!match) return;
+    changeMatch({
+      ...match,
+      conditions: match.conditions.map((condition, current) =>
+        current === index ? next : condition,
+      ),
     });
   }
 
@@ -268,8 +295,7 @@ export function EventTriggerConfigEditor({
             className="workflow-node-config__inline-message"
           >
             <code>
-              {selectedEvent.schemaName}.{selectedEvent.tableName} ·{' '}
-              {selectedEvent.watchedFields.join(', ')}
+              {selectedEvent.schemaName}.{selectedEvent.tableName}
             </code>
           </Typography.Text>
         )}
@@ -277,11 +303,23 @@ export function EventTriggerConfigEditor({
 
       <Card size="small" title={t('nodeEditors.event.startCondition')}>
         <Radio.Group
-          value={config.match ? 'CONDITIONAL' : 'ALWAYS'}
+          value={operation}
+          onChange={(event) => setActiveOperation(event.target.value)}
+          style={{ display: 'block', marginBottom: 16 }}
+        >
+          {(selectedEvent?.operations ?? []).map((item) => (
+            <Radio.Button key={item} value={item}>
+              {t(`nodeEditors.event.operations.${item}`)}
+            </Radio.Button>
+          ))}
+        </Radio.Group>
+        <Radio.Group
+          value={!rule ? 'NEVER' : match ? 'CONDITIONAL' : 'ALWAYS'}
           disabled={disabled || !selectedEvent}
           onChange={(event) => changeMatchMode(event.target.value)}
         >
           <Space direction="vertical" size={8}>
+            <Radio value="NEVER">{t('nodeEditors.event.neverStart')}</Radio>
             <Radio value="ALWAYS">{t('nodeEditors.event.alwaysStart')}</Radio>
             <Radio value="CONDITIONAL">
               {t('nodeEditors.event.conditionalStart')}
@@ -289,23 +327,20 @@ export function EventTriggerConfigEditor({
           </Space>
         </Radio.Group>
 
-        {config.match && (
+        {match && (
           <Space
             direction="vertical"
             size={10}
             style={{ width: '100%', marginTop: 14 }}
           >
-            {config.match.conditions.length > 1 && (
+            {match.conditions.length > 1 && (
               <Radio.Group
-                value={config.match.combineOperation}
+                value={match.combineOperation}
                 disabled={disabled}
                 onChange={(event) =>
-                  onChange({
-                    ...config,
-                    match: {
-                      ...config.match!,
-                      combineOperation: event.target.value,
-                    },
+                  changeMatch({
+                    ...match!,
+                    combineOperation: event.target.value,
                   })
                 }
               >
@@ -318,7 +353,7 @@ export function EventTriggerConfigEditor({
               </Radio.Group>
             )}
 
-            {config.match.conditions.map((condition, index) => {
+            {match.conditions.map((condition, index) => {
               const selectedField = matchFields.find(
                 (field) => field.path === condition.left.path,
               );
@@ -356,7 +391,8 @@ export function EventTriggerConfigEditor({
                               : {
                                   source: 'FIXED',
                                   valueType: fixedValueType(field),
-                                  value: '',
+                                  value:
+                                    condition.operator === 'IN' ? '[]' : '',
                                 },
                           });
                         }}
@@ -369,7 +405,7 @@ export function EventTriggerConfigEditor({
                         value={condition.operator}
                         disabled={disabled}
                         options={(
-                          ['EQ', 'NEQ', 'EMPTY', 'NOT_EMPTY'] as const
+                          ['EQ', 'NEQ', 'IN', 'EMPTY', 'NOT_EMPTY'] as const
                         ).map((operator) => ({
                           value: operator,
                           label: t(
@@ -382,17 +418,38 @@ export function EventTriggerConfigEditor({
                             operator,
                             right: UNARY_MATCH_OPERATORS.has(operator)
                               ? undefined
-                              : (condition.right ?? {
+                              : {
                                   source: 'FIXED',
                                   valueType: fixedValueType(selectedField),
-                                  value: '',
-                                }),
+                                  value: operator === 'IN' ? '[]' : '',
+                                },
                           })
                         }
                         style={{ width: '30%' }}
                       />
                       {!UNARY_MATCH_OPERATORS.has(condition.operator) &&
-                        (selectedField?.type === 'boolean' ? (
+                        (condition.operator === 'IN' ? (
+                          <Select
+                            mode="tags"
+                            aria-label={t('nodeEditors.event.conditionValue', {
+                              number: index + 1,
+                            })}
+                            value={parseValueList(condition.right?.value)}
+                            disabled={disabled}
+                            placeholder={t('nodeEditors.event.valueListHint')}
+                            onChange={(values) =>
+                              updateMatchCondition(index, {
+                                ...condition,
+                                right: {
+                                  source: 'FIXED',
+                                  valueType: fixedValueType(selectedField),
+                                  value: JSON.stringify(values),
+                                },
+                              })
+                            }
+                            style={{ width: '25%' }}
+                          />
+                        ) : selectedField?.type === 'boolean' ? (
                           <Select
                             aria-label={t('nodeEditors.event.conditionValue', {
                               number: index + 1,
@@ -474,14 +531,11 @@ export function EventTriggerConfigEditor({
                       })}
                       disabled={disabled}
                       onClick={() =>
-                        onChange({
-                          ...config,
-                          match: {
-                            ...config.match!,
-                            conditions: config.match!.conditions.filter(
-                              (_, current) => current !== index,
-                            ),
-                          },
+                        changeMatch({
+                          ...match!,
+                          conditions: match!.conditions.filter(
+                            (_, current) => current !== index,
+                          ),
                         })
                       }
                     >
@@ -500,15 +554,12 @@ export function EventTriggerConfigEditor({
               icon={<PlusOutlined />}
               disabled={disabled}
               onClick={() =>
-                onChange({
-                  ...config,
-                  match: {
-                    ...config.match!,
-                    conditions: [
-                      ...config.match!.conditions,
-                      newMatchCondition(defaultMatchField),
-                    ],
-                  },
+                changeMatch({
+                  ...match!,
+                  conditions: [
+                    ...match!.conditions,
+                    newMatchCondition(defaultMatchField),
+                  ],
                 })
               }
             >
@@ -618,3 +669,14 @@ export function EventTriggerConfigEditor({
     </Space>
   );
 }
+
+function parseValueList(value?: string): string[] {
+  try {
+    const parsed: unknown = JSON.parse(value ?? '[]');
+    return Array.isArray(parsed)
+      ? parsed.filter((item): item is string => typeof item === 'string')
+      : [];
+  } catch {
+    return [];
+  }
+}