@gadmin2n/schematics 0.0.139 → 0.0.141

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

@@ -0,0 +1,86 @@
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { customRequest } from 'helpers/http';
+import i18n from '../../../../i18n';
+import { HumanApprovalConfigEditor } from './HumanApprovalConfigEditor';
+
+vi.mock('helpers/http', () => ({ customRequest: vi.fn() }));
+vi.mock('./SubjectPicker', () => ({
+  SubjectPicker: () => <div data-testid="subject-picker" />,
+}));
+vi.mock('./ApproverSourceEditor', () => ({
+  ApproverSourceEditor: () => <div data-testid="approver-source-editor" />,
+}));
+
+Object.defineProperty(window, 'matchMedia', {
+  writable: true,
+  value: () => ({
+    matches: false,
+    addListener: () => undefined,
+    removeListener: () => undefined,
+    addEventListener: () => undefined,
+    removeEventListener: () => undefined,
+    dispatchEvent: () => false,
+  }),
+});
+
+describe('HumanApprovalConfigEditor', () => {
+  beforeEach(async () => {
+    await i18n.changeLanguage('zh_CN');
+    vi.mocked(customRequest).mockResolvedValue([
+      {
+        code: 'myoa',
+        name: 'MyOA',
+        isEnabled: true,
+        inputParameters: [
+          { key: 'title', label: '单据标题', required: true },
+          { key: 'content', label: '审批内容', required: true },
+        ],
+      },
+    ] as never);
+  });
+
+  it('shows the selected channel contract and stores AP argument bindings', async () => {
+    const onChange = vi.fn();
+
+    render(
+      <HumanApprovalConfigEditor
+        value={{
+          channelRef: 'myoa',
+          channelInputBindings: {
+            title: { source: 'WORKFLOW', path: 'requestTitle' },
+            content: { source: 'INPUT', path: 'description' },
+          },
+          approverSources: [],
+          subjects: [],
+          approvalRule: { mode: 'ANY' },
+          rejectionRule: { mode: 'ANY' },
+          timeout: { durationSeconds: 0, action: 'REJECTED' },
+        }}
+        onChange={onChange}
+        schema={{ type: 'object' }}
+      />,
+    );
+
+    await waitFor(() =>
+      expect(screen.getByText('单据信息')).toBeInTheDocument(),
+    );
+    expect(screen.getByText('单据标题')).toBeInTheDocument();
+    expect(screen.getByText('审批内容')).toBeInTheDocument();
+    expect(screen.getByLabelText('单据标题的字段路径')).toHaveValue(
+      'requestTitle',
+    );
+
+    fireEvent.change(screen.getByLabelText('单据标题的字段路径'), {
+      target: { value: 'approval.title' },
+    });
+
+    expect(onChange).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        channelInputBindings: expect.objectContaining({
+          title: { source: 'WORKFLOW', path: 'approval.title' },
+        }),
+      }),
+    );
+  });
+});

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

@@ -0,0 +1,458 @@
+import React, { useEffect, useMemo, useState } from 'react';
+import {
+  Alert,
+  Button,
+  Card,
+  Divider,
+  InputNumber,
+  Radio,
+  Select,
+  Space,
+  Tag,
+  Typography,
+} from 'antd';
+import { ApiOutlined, DeleteOutlined, TeamOutlined } from '@ant-design/icons';
+import type { WidgetProps } from '../schema-form/widget-registry';
+import { useTranslation } from 'react-i18next';
+import { customRequest } from 'helpers/http';
+import { ApprovalRuleEditor } from './ApprovalRuleEditor';
+import { SubjectPicker, type SubjectSelection } from './SubjectPicker';
+import { ApproverSourceEditor } from './ApproverSourceEditor';
+import type { ApproverSourceConfig } from './approver-source';
+import { ParameterBindingEditor } from '../../components/ParameterBindingEditor';
+import type { ParameterBinding } from '../../types/parameter-binding';
+
+type Provider = 'USER' | 'USER_GROUP';
+type SubjectSource =
+  | { source: 'STATIC'; provider: Provider; refs: string[] }
+  | { source: 'DYNAMIC'; provider: Provider; inputKey: string };
+type Rule = {
+  mode: 'ANY' | 'ALL' | 'COUNT' | 'PERCENTAGE';
+  count?: number;
+  percentage?: number;
+};
+type ApprovalConfig = {
+  channelRef?: string;
+  channelInputBindings?: Record<string, ParameterBinding>;
+  approverSources?: ApproverSourceConfig[];
+  subjects: SubjectSource[];
+  approvalRule: Rule;
+  rejectionRule: Rule;
+  timeout: { durationSeconds: number; action: 'APPROVED' | 'REJECTED' };
+};
+
+type ApprovalChannelOption = {
+  code: string;
+  name: string;
+  isEnabled: boolean;
+  inputParameters: Array<{
+    key: string;
+    label?: string;
+    required?: boolean;
+  }>;
+};
+
+const RULE_SCHEMA = {
+  type: 'object' as const,
+  default: { mode: 'ANY' },
+};
+
+export function HumanApprovalConfigEditor({
+  value,
+  onChange,
+  disabled,
+  schema,
+}: WidgetProps<ApprovalConfig | undefined>) {
+  const { t } = useTranslation('workflow');
+  const [channels, setChannels] = useState<ApprovalChannelOption[]>([]);
+  const config: ApprovalConfig = {
+    channelRef: value?.channelRef,
+    channelInputBindings: value?.channelInputBindings ?? {},
+    approverSources: value?.approverSources ?? [],
+    subjects: value?.subjects ?? [],
+    approvalRule: value?.approvalRule ?? { mode: 'ANY' },
+    rejectionRule: value?.rejectionRule ?? { mode: 'ANY' },
+    timeout: value?.timeout ?? { durationSeconds: 0, action: 'REJECTED' },
+  };
+  useEffect(() => {
+    customRequest<ApprovalChannelOption[]>('approval-channels', 'GET')
+      .then((items) => setChannels(items.filter((item) => item.isEnabled)))
+      .catch(() => setChannels([]));
+  }, []);
+  const staticSelections = useMemo<SubjectSelection[]>(() => {
+    const grouped = new Map<string, string[]>();
+    for (const subject of config.subjects) {
+      if (subject.source !== 'STATIC') continue;
+      grouped.set(subject.provider, [
+        ...new Set([...(grouped.get(subject.provider) ?? []), ...subject.refs]),
+      ]);
+    }
+    return [...grouped].map(([provider, refs]) => ({ provider, refs }));
+  }, [config.subjects]);
+  const dynamicSources = config.subjects.filter(
+    (subject): subject is Extract<SubjectSource, { source: 'DYNAMIC' }> =>
+      subject.source === 'DYNAMIC',
+  );
+  const selectedChannel = channels.find(
+    (channel) => channel.code === config.channelRef,
+  );
+
+  function update(patch: Partial<ApprovalConfig>) {
+    onChange({ ...config, ...patch });
+  }
+
+  function updateStatic(next: SubjectSelection[]) {
+    update({
+      subjects: [
+        ...next.map((subject) => ({
+          source: 'STATIC' as const,
+          provider: subject.provider as Provider,
+          refs: subject.refs,
+        })),
+        ...dynamicSources,
+      ],
+    });
+  }
+
+  function removeDynamic(inputKey: string) {
+    update({
+      subjects: config.subjects.filter(
+        (subject) =>
+          subject.source !== 'DYNAMIC' || subject.inputKey !== inputKey,
+      ),
+    });
+  }
+
+  return (
+    <Space direction="vertical" size={16} style={{ width: '100%' }}>
+      <Card
+        size="small"
+        title={
+          <Space>
+            <TeamOutlined />
+            <span>{t('approval.whoCanApprove')}</span>
+          </Space>
+        }
+      >
+        <Typography.Paragraph type="secondary">
+          {t('approval.description')}
+        </Typography.Paragraph>
+        <Typography.Text strong>{t('approval.fixedApprovers')}</Typography.Text>
+        <div style={{ marginTop: 8 }}>
+          <SubjectPicker
+            value={staticSelections}
+            onChange={updateStatic}
+            disabled={disabled}
+            schema={schema}
+          />
+        </div>
+
+        {dynamicSources.length > 0 && (
+          <Space direction="vertical" size={8} style={{ width: '100%' }}>
+            <Divider />
+            <Alert
+              type="info"
+              showIcon
+              message={t('approval.directLookup')}
+              description={t('approval.directLookupHint')}
+            />
+            {dynamicSources.map((source) => {
+              const isUser = source.provider === 'USER';
+              return (
+                <div
+                  key={source.inputKey}
+                  style={{
+                    display: 'flex',
+                    alignItems: 'center',
+                    justifyContent: 'space-between',
+                    gap: 12,
+                    padding: '10px 12px',
+                    border: '1px solid #91caff',
+                    borderRadius: 8,
+                    background: '#f5faff',
+                  }}
+                >
+                  <Space>
+                    <ApiOutlined style={{ color: '#1677ff' }} />
+                    <div>
+                      <Typography.Text strong>
+                        {isUser
+                          ? t('approval.userIds')
+                          : t('approval.groupIds')}
+                      </Typography.Text>
+                      <Typography.Text
+                        type="secondary"
+                        style={{ display: 'block', fontSize: 12 }}
+                      >
+                        {t('approval.lookupDescription')}
+                      </Typography.Text>
+                    </div>
+                  </Space>
+                  <Space>
+                    <Tag color="blue">
+                      {t('approval.lookup')}: {source.inputKey}
+                    </Tag>
+                    <Button
+                      type="text"
+                      danger
+                      aria-label={t('approval.remove', {
+                        name: source.inputKey,
+                      })}
+                      icon={<DeleteOutlined />}
+                      disabled={disabled}
+                      onClick={() => removeDynamic(source.inputKey)}
+                    />
+                  </Space>
+                </div>
+              );
+            })}
+          </Space>
+        )}
+
+        <Divider />
+
+        <ApproverSourceEditor
+          value={config.approverSources ?? []}
+          disabled={disabled}
+          onChange={(approverSources) => update({ approverSources })}
+        />
+      </Card>
+
+      <Card size="small" title={t('approval.decisionRules')}>
+        <Space direction="vertical" size={14} style={{ width: '100%' }}>
+          <div>
+            <Typography.Text strong>
+              {t('approval.approveWhen')}
+            </Typography.Text>
+            <div style={{ marginTop: 6 }}>
+              <ApprovalRuleEditor
+                value={config.approvalRule}
+                onChange={(approvalRule) => update({ approvalRule })}
+                disabled={disabled}
+                schema={RULE_SCHEMA}
+              />
+            </div>
+          </div>
+          <div>
+            <Typography.Text strong>{t('approval.rejectWhen')}</Typography.Text>
+            <div style={{ marginTop: 6 }}>
+              <ApprovalRuleEditor
+                value={config.rejectionRule}
+                onChange={(rejectionRule) => update({ rejectionRule })}
+                disabled={disabled}
+                schema={RULE_SCHEMA}
+              />
+            </div>
+          </div>
+        </Space>
+      </Card>
+
+      <Card
+        size="small"
+        title={
+          <Space>
+            <ApiOutlined />
+            <span>{t('approval.channel')}</span>
+          </Space>
+        }
+      >
+        <Typography.Paragraph type="secondary">
+          {t('approval.channelDescription')}
+        </Typography.Paragraph>
+        <Select
+          allowClear
+          showSearch
+          optionFilterProp="label"
+          disabled={disabled}
+          value={config.channelRef}
+          placeholder={t('approval.builtInInbox')}
+          options={channels.map((channel) => ({
+            value: channel.code,
+            label: channel.name,
+          }))}
+          onChange={(channelRef) => {
+            const channel = channels.find((item) => item.code === channelRef);
+            update({
+              channelRef,
+              channelInputBindings: channel
+                ? Object.fromEntries(
+                    channel.inputParameters.map((parameter) => [
+                      parameter.key,
+                      config.channelInputBindings?.[parameter.key] ?? {
+                        source: 'WORKFLOW',
+                        path: parameter.key,
+                      },
+                    ]),
+                  )
+                : {},
+            });
+          }}
+          style={{ width: '100%' }}
+        />
+        <Typography.Text
+          type="secondary"
+          style={{ display: 'block', fontSize: 12, marginTop: 8 }}
+        >
+          {config.channelRef
+            ? t('approval.externalChannelHint')
+            : t('approval.builtInInboxHint')}
+        </Typography.Text>
+        {selectedChannel && selectedChannel.inputParameters.length > 0 && (
+          <>
+            <Divider />
+            <Typography.Text strong>
+              {t('approval.channelInputs')}
+            </Typography.Text>
+            <Typography.Paragraph
+              type="secondary"
+              style={{ marginTop: 4, marginBottom: 12 }}
+            >
+              {t('approval.channelInputsDescription')}
+            </Typography.Paragraph>
+            <Space direction="vertical" size={14} style={{ width: '100%' }}>
+              {selectedChannel.inputParameters.map((parameter) => {
+                const name = parameter.label?.trim() || parameter.key;
+                return (
+                  <div key={parameter.key}>
+                    <Space size={6} style={{ marginBottom: 6 }}>
+                      <Typography.Text strong>{name}</Typography.Text>
+                      {parameter.required && (
+                        <Tag color="blue">{t('approval.required')}</Tag>
+                      )}
+                    </Space>
+                    <ParameterBindingEditor
+                      name={name}
+                      defaultPath={parameter.key}
+                      value={config.channelInputBindings?.[parameter.key]}
+                      disabled={disabled}
+                      onChange={(binding) =>
+                        update({
+                          channelInputBindings: {
+                            ...config.channelInputBindings,
+                            [parameter.key]: binding,
+                          },
+                        })
+                      }
+                    />
+                  </div>
+                );
+              })}
+            </Space>
+          </>
+        )}
+      </Card>
+
+      <TimeoutSection
+        value={config.timeout}
+        disabled={disabled}
+        onChange={(timeout) => update({ timeout })}
+      />
+    </Space>
+  );
+}
+
+type TimeoutUnit = 'MINUTES' | 'HOURS' | 'DAYS';
+
+function TimeoutSection({
+  value,
+  disabled,
+  onChange,
+}: {
+  value: ApprovalConfig['timeout'];
+  disabled?: boolean;
+  onChange(value: ApprovalConfig['timeout']): void;
+}) {
+  const { t } = useTranslation('workflow');
+  const [unit, setUnit] = useState<TimeoutUnit>(() => preferredUnit(value));
+  const never = value.durationSeconds === 0;
+  const factor = unit === 'DAYS' ? 86400 : unit === 'HOURS' ? 3600 : 60;
+  const amount = never ? 1 : Math.max(1, value.durationSeconds / factor);
+
+  return (
+    <Card size="small" title={t('approval.timeout')}>
+      <Radio.Group
+        value={never ? 'NEVER' : 'AFTER'}
+        disabled={disabled}
+        onChange={(event) =>
+          onChange({
+            ...value,
+            durationSeconds: event.target.value === 'NEVER' ? 0 : factor,
+          })
+        }
+      >
+        <Radio value="NEVER">{t('approval.neverTimeout')}</Radio>
+        <Radio value="AFTER">{t('approval.timeoutAfter')}</Radio>
+      </Radio.Group>
+
+      {!never && (
+        <Space
+          direction="vertical"
+          size={12}
+          style={{ width: '100%', marginTop: 16 }}
+        >
+          <Space.Compact style={{ width: '100%' }}>
+            <InputNumber
+              aria-label={t('approval.timeoutAmount')}
+              min={1}
+              precision={0}
+              value={amount}
+              disabled={disabled}
+              onChange={(next) =>
+                onChange({
+                  ...value,
+                  durationSeconds: Math.max(1, next ?? 1) * factor,
+                })
+              }
+              style={{ width: '100%' }}
+            />
+            <Select
+              aria-label={t('approval.timeoutUnit')}
+              value={unit}
+              disabled={disabled}
+              options={[
+                { label: t('approval.minutes'), value: 'MINUTES' },
+                { label: t('approval.hours'), value: 'HOURS' },
+                { label: t('approval.days'), value: 'DAYS' },
+              ]}
+              onChange={(next: TimeoutUnit) => {
+                setUnit(next);
+              }}
+              style={{ width: 130 }}
+            />
+          </Space.Compact>
+          <div>
+            <Typography.Text strong>
+              {t('approval.whenTimeRunsOut')}
+            </Typography.Text>
+            <Select
+              aria-label={t('approval.timeoutAction')}
+              value={value.action}
+              disabled={disabled}
+              options={[
+                { label: t('approval.autoReject'), value: 'REJECTED' },
+                { label: t('approval.autoApprove'), value: 'APPROVED' },
+              ]}
+              onChange={(action) => onChange({ ...value, action })}
+              style={{ width: '100%', marginTop: 6 }}
+            />
+          </div>
+        </Space>
+      )}
+      {never && (
+        <Typography.Paragraph
+          type="secondary"
+          style={{ marginTop: 12, marginBottom: 0 }}
+        >
+          {t('approval.waitHint')}
+        </Typography.Paragraph>
+      )}
+    </Card>
+  );
+}
+
+function preferredUnit(timeout: ApprovalConfig['timeout']): TimeoutUnit {
+  const seconds = timeout.durationSeconds;
+  if (seconds > 0 && seconds % 86400 === 0) return 'DAYS';
+  if (seconds > 0 && seconds % 3600 === 0) return 'HOURS';
+  return 'MINUTES';
+}

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

@@ -0,0 +1,81 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import i18n from '../../../../i18n';
+import { ReturnResultConfigEditor } from './ReturnResultConfigEditor';
+
+const schema = { type: 'object' as const };
+
+describe('ReturnResultConfigEditor', () => {
+  beforeEach(async () => {
+    await i18n.changeLanguage('en');
+  });
+
+  it('uses the connected previous node by default without asking for a path', () => {
+    const onChange = vi.fn();
+    render(
+      <ReturnResultConfigEditor
+        value={undefined}
+        onChange={onChange}
+        schema={schema}
+      />,
+    );
+
+    expect(
+      screen.getByText('Return the previous node result'),
+    ).toBeInTheDocument();
+    expect(screen.queryByLabelText('Workflow data field')).toBeNull();
+    expect(onChange).toHaveBeenCalledWith({
+      resultType: 'JSON',
+      sourceMode: 'INPUT',
+      httpStatusCode: 200,
+      httpHeaders: {},
+    });
+  });
+
+  it('can return a field from the original Workflow data', () => {
+    const onChange = vi.fn();
+    render(
+      <ReturnResultConfigEditor
+        value={{
+          resultType: 'APPROVAL_SUBJECTS',
+          sourceMode: 'WORKFLOW',
+          path: 'approvers',
+        }}
+        onChange={onChange}
+        schema={schema}
+      />,
+    );
+
+    expect(screen.getByLabelText('Workflow data field')).toHaveValue(
+      'approvers',
+    );
+    fireEvent.click(
+      screen.getByRole('radio', { name: 'Return the previous node result' }),
+    );
+    expect(onChange).toHaveBeenLastCalledWith({
+      resultType: 'APPROVAL_SUBJECTS',
+      sourceMode: 'INPUT',
+    });
+  });
+
+  it('configures ordinary data with an HTTP status for external callers', () => {
+    const onChange = vi.fn();
+    render(
+      <ReturnResultConfigEditor
+        value={{
+          resultType: 'JSON',
+          sourceMode: 'INPUT',
+          httpStatusCode: 201,
+          httpHeaders: {},
+        }}
+        onChange={onChange}
+        schema={schema}
+      />,
+    );
+
+    expect(screen.getByRole('radio', { name: 'Ordinary data' })).toBeChecked();
+    expect(
+      screen.getByRole('spinbutton', { name: 'HTTP status code' }),
+    ).toHaveValue('201');
+  });
+});