@gadmin2n/schematics 0.0.136 → 0.0.138

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/canvas/components/ExportModal.tsx

@@ -0,0 +1,84 @@
+import React, { useCallback, useEffect, useState } from 'react';
+import { Button, Input, Modal, Space, message } from 'antd';
+import { CopyOutlined, LoadingOutlined } from '@ant-design/icons';
+import { generateExportToken } from '../canvasApi';
+
+interface ExportModalProps {
+  open: boolean;
+  canvasId: string | null;
+  onClose: () => void;
+}
+
+export function ExportModal({ open, canvasId, onClose }: ExportModalProps) {
+  const [url, setUrl] = useState<string>('');
+  const [loading, setLoading] = useState(false);
+
+  useEffect(() => {
+    if (open && canvasId) {
+      setUrl('');
+      setLoading(true);
+      generateExportToken(canvasId)
+        .then((res) => setUrl(res.url))
+        .catch((e: any) =>
+          message.error(e?.message ?? 'Failed to generate export URL'),
+        )
+        .finally(() => setLoading(false));
+    }
+  }, [open, canvasId]);
+
+  const handleCopy = useCallback(async () => {
+    try {
+      await navigator.clipboard.writeText(url);
+      message.success('URL copied to clipboard');
+    } catch {
+      // Fallback for older browsers
+      const textarea = document.getElementById(
+        'canvas-export-url-input',
+      ) as HTMLTextAreaElement;
+      textarea?.select();
+      document.execCommand('copy');
+      message.success('URL copied to clipboard');
+    }
+  }, [url]);
+
+  return (
+    <Modal
+      title="Export Canvas"
+      open={open}
+      onCancel={onClose}
+      footer={
+        <Space>
+          <Button onClick={onClose}>Close</Button>
+          <Button
+            type="primary"
+            icon={<CopyOutlined />}
+            onClick={handleCopy}
+            disabled={!url}
+          >
+            Copy URL
+          </Button>
+        </Space>
+      }
+    >
+      {loading ? (
+        <div style={{ textAlign: 'center', padding: 24 }}>
+          <LoadingOutlined style={{ fontSize: 24 }} />
+          <p>Generating export URL...</p>
+        </div>
+      ) : (
+        <>
+          <p style={{ marginBottom: 8, color: '#666' }}>
+            Export URL (valid for 30 minutes):
+          </p>
+          <Input.TextArea
+            id="canvas-export-url-input"
+            value={url}
+            readOnly
+            autoSize={{ minRows: 3, maxRows: 5 }}
+            onFocus={(e) => e.target.select()}
+          />
+        </>
+      )}
+    </Modal>
+  );
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/canvas/components/ImportModal.tsx

@@ -0,0 +1,166 @@
+import React, { useCallback, useState } from 'react';
+import { Button, Input, Modal, Space, Spin, message } from 'antd';
+import { CloudDownloadOutlined, CheckOutlined } from '@ant-design/icons';
+import ReactDiffViewer, { DiffMethod } from 'react-diff-viewer-continued';
+import { importConfirm, importPreview } from '../canvasApi';
+
+interface ImportModalProps {
+  open: boolean;
+  onClose: () => void;
+  onSuccess: () => void;
+}
+
+type Phase = 'input' | 'preview' | 'confirming';
+
+export function ImportModal({ open, onClose, onSuccess }: ImportModalProps) {
+  const [sourceUrl, setSourceUrl] = useState('');
+  const [phase, setPhase] = useState<Phase>('input');
+  const [loading, setLoading] = useState(false);
+  const [currentJson, setCurrentJson] = useState('');
+  const [incomingJson, setIncomingJson] = useState('');
+  const [payload, setPayload] = useState<any>(null);
+
+  const reset = useCallback(() => {
+    setSourceUrl('');
+    setPhase('input');
+    setLoading(false);
+    setCurrentJson('');
+    setIncomingJson('');
+    setPayload(null);
+  }, []);
+
+  const handleClose = useCallback(() => {
+    reset();
+    onClose();
+  }, [reset, onClose]);
+
+  const handleFetchPreview = useCallback(async () => {
+    if (!sourceUrl.trim()) {
+      message.warning('Please paste the export URL');
+      return;
+    }
+
+    setLoading(true);
+    try {
+      // Step 1: Fetch from source URL (cross-origin)
+      const response = await fetch(sourceUrl.trim());
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => null);
+        throw new Error(
+          errorData?.message || `Failed to fetch: ${response.status}`,
+        );
+      }
+      const exportData = await response.json();
+
+      // Step 2: Send to our import-preview endpoint
+      const preview = await importPreview(exportData);
+
+      // Step 3: Format for diff viewer
+      setCurrentJson(
+        preview.current ? JSON.stringify(preview.current, null, 2) : '',
+      );
+      setIncomingJson(JSON.stringify(preview.incoming, null, 2));
+      setPayload(exportData);
+      setPhase('preview');
+    } catch (e: any) {
+      if (e.message?.includes('expired') || e.message?.includes('invalid')) {
+        message.error(
+          'Export link has expired or is invalid. Please generate a new one from the source environment.',
+        );
+      } else {
+        message.error(
+          e?.message ||
+            'Cannot reach the source environment. Please check the URL and try again.',
+        );
+      }
+    } finally {
+      setLoading(false);
+    }
+  }, [sourceUrl]);
+
+  const handleConfirm = useCallback(async () => {
+    if (!payload) return;
+    setPhase('confirming');
+    try {
+      const result = await importConfirm(payload);
+
+      message.success(`Canvas "${result.canvasName}" imported successfully!`);
+      reset();
+      onClose();
+      onSuccess();
+    } catch (e: any) {
+      message.error(e?.message ?? 'Import failed');
+      setPhase('preview');
+    }
+  }, [payload, reset, onClose, onSuccess]);
+
+  return (
+    <Modal
+      title="Import Canvas"
+      open={open}
+      onCancel={handleClose}
+      width={phase === 'preview' ? '90vw' : 520}
+      footer={
+        phase === 'input' ? (
+          <Space>
+            <Button onClick={handleClose}>Cancel</Button>
+            <Button
+              type="primary"
+              icon={<CloudDownloadOutlined />}
+              onClick={handleFetchPreview}
+              loading={loading}
+            >
+              Fetch &amp; Preview
+            </Button>
+          </Space>
+        ) : (
+          <Space>
+            <Button onClick={handleClose}>Cancel</Button>
+            <Button
+              type="primary"
+              icon={<CheckOutlined />}
+              onClick={handleConfirm}
+              loading={phase === 'confirming'}
+            >
+              Confirm Import
+            </Button>
+          </Space>
+        )
+      }
+    >
+      {phase === 'input' && (
+        <>
+          <p style={{ marginBottom: 8 }}>
+            Paste the export URL from the source environment:
+          </p>
+          <Input.TextArea
+            value={sourceUrl}
+            onChange={(e) => setSourceUrl(e.target.value)}
+            placeholder="https://dev.example.com/api/canvas/export/abc123?token=..."
+            autoSize={{ minRows: 3, maxRows: 5 }}
+          />
+        </>
+      )}
+
+      {phase === 'preview' && (
+        <div style={{ maxHeight: '70vh', overflow: 'auto' }}>
+          <ReactDiffViewer
+            oldValue={currentJson}
+            newValue={incomingJson}
+            splitView
+            compareMethod={DiffMethod.LINES}
+            leftTitle="Current (this environment)"
+            rightTitle="Incoming (source environment)"
+          />
+        </div>
+      )}
+
+      {phase === 'confirming' && (
+        <div style={{ textAlign: 'center', padding: 40 }}>
+          <Spin size="large" />
+          <p style={{ marginTop: 16 }}>Importing canvas...</p>
+        </div>
+      )}
+    </Modal>
+  );
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/canvas/hooks/useCanvasHistory.ts

@@ -7,7 +7,7 @@ export interface CanvasSnapshot {
   layout: LayoutItem[];
 }
 
-/** Max number of undo steps retained before the oldest is dropped. */
+/** Max number of undo/redo steps retained before the oldest is dropped. */
 const MAX_HISTORY_SIZE = 50;
 
 /**
@@ -19,12 +19,14 @@ const MAX_HISTORY_SIZE = 50;
 const COALESCE_WINDOW_MS = 5000;
 
 export function useCanvasHistory() {
-  const stackRef = useRef<CanvasSnapshot[]>([]);
+  const undoStackRef = useRef<CanvasSnapshot[]>([]);
+  const redoStackRef = useRef<CanvasSnapshot[]>([]);
   // Timestamp of the last coalesce=true push that extended the current
   // batch; null when the last push was discrete (coalesce=false) or no
   // batch is in progress.
   const lastCoalescedAtRef = useRef<number | null>(null);
   const [canUndo, setCanUndo] = useState(false);
+  const [canRedo, setCanRedo] = useState(false);
 
   const push = useCallback((snapshot: CanvasSnapshot, coalesce: boolean) => {
     const now = Date.now();
@@ -40,26 +42,63 @@ export function useCanvasHistory() {
       return;
     }
 
-    stackRef.current.push(snapshot);
-    if (stackRef.current.length > MAX_HISTORY_SIZE) {
-      stackRef.current.shift();
+    undoStackRef.current.push(snapshot);
+    if (undoStackRef.current.length > MAX_HISTORY_SIZE) {
+      undoStackRef.current.shift();
     }
     lastCoalescedAtRef.current = coalesce ? now : null;
     setCanUndo(true);
-  }, []);
 
-  const pop = useCallback((): CanvasSnapshot | undefined => {
-    const snapshot = stackRef.current.pop();
-    lastCoalescedAtRef.current = null;
-    setCanUndo(stackRef.current.length > 0);
-    return snapshot;
+    // A new edit invalidates whatever was undone before it.
+    if (redoStackRef.current.length > 0) {
+      redoStackRef.current = [];
+      setCanRedo(false);
+    }
   }, []);
 
+  const undo = useCallback(
+    (current: CanvasSnapshot): CanvasSnapshot | undefined => {
+      const snapshot = undoStackRef.current.pop();
+      if (!snapshot) return undefined;
+
+      redoStackRef.current.push(current);
+      if (redoStackRef.current.length > MAX_HISTORY_SIZE) {
+        redoStackRef.current.shift();
+      }
+
+      lastCoalescedAtRef.current = null;
+      setCanUndo(undoStackRef.current.length > 0);
+      setCanRedo(true);
+      return snapshot;
+    },
+    [],
+  );
+
+  const redo = useCallback(
+    (current: CanvasSnapshot): CanvasSnapshot | undefined => {
+      const snapshot = redoStackRef.current.pop();
+      if (!snapshot) return undefined;
+
+      undoStackRef.current.push(current);
+      if (undoStackRef.current.length > MAX_HISTORY_SIZE) {
+        undoStackRef.current.shift();
+      }
+
+      lastCoalescedAtRef.current = null;
+      setCanRedo(redoStackRef.current.length > 0);
+      setCanUndo(true);
+      return snapshot;
+    },
+    [],
+  );
+
   const clear = useCallback(() => {
-    stackRef.current = [];
+    undoStackRef.current = [];
+    redoStackRef.current = [];
     lastCoalescedAtRef.current = null;
     setCanUndo(false);
+    setCanRedo(false);
   }, []);
 
-  return { push, pop, clear, canUndo };
+  return { push, undo, redo, clear, canUndo, canRedo };
 }

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/components/DslView.tsx

@@ -24,6 +24,8 @@ export interface DslViewHandle {
   copy: () => Promise<void>;
   /** Whether textarea content differs from last applied DSL. */
   isDirty: () => boolean;
+  /** Reset textarea to empty DSL template. */
+  clear: () => void;
 }
 
 function stringifyDsl(dsl: WorkflowDSL | null): string {
@@ -158,6 +160,10 @@ export const DslView = forwardRef<DslViewHandle, DslViewProps>(function DslView(
       apply: handleApply,
       copy: handleCopy,
       isDirty: () => text !== initial,
+      clear: () => {
+        setText(EMPTY_TEMPLATE);
+        setError(null);
+      },
     }),
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [text, initial, onApply],

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/components/NodePropertyPanel.tsx

@@ -257,7 +257,12 @@ export function NodePropertyPanel({
       for (const [key, prop] of Object.entries<any>(properties)) {
         const existingValue = node.config?.[key];
         if (existingValue !== undefined) {
-          mergedConfig[key] = existingValue;
+          mergedConfig[key] =
+            key === 'approvers' && Array.isArray(existingValue)
+              ? existingValue.map((a: any) =>
+                  typeof a === 'string' ? { type: 'user', id: a } : a,
+                )
+              : existingValue;
         } else if (prop.type === 'string') {
           mergedConfig[key] = '';
         } else if (prop.type === 'number') {

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/editor.tsx

@@ -526,6 +526,7 @@ export default function WorkflowEditorPage() {
           flexShrink: 0,
           display: 'flex',
           alignItems: 'center',
+          justifyContent: 'space-between',
         }}
       >
         <Segmented
@@ -536,6 +537,22 @@ export default function WorkflowEditorPage() {
             { label: 'DSL', value: 'dsl' },
           ]}
         />
+        <Button
+          danger
+          size="small"
+          style={{ marginRight: 8 }}
+          onClick={() => {
+            if (viewMode === 'dsl') {
+              dslViewRef.current?.clear();
+            } else {
+              setDsl({ nodes: [], edges: [] });
+              setHasUnsavedChanges(true);
+              setSelectedNodeId(null);
+            }
+          }}
+        >
+          清空
+        </Button>
       </div>
 
       {/* Main area: Flow + Property Panel */}

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/instance-detail.tsx

@@ -23,6 +23,7 @@ import {
   StopOutlined,
 } from '@ant-design/icons';
 import { useNavigate, useParams } from 'react-router-dom';
+import { useGetIdentity } from '@refinedev/core';
 import { customRequest } from 'helpers/http';
 import { EnhancedFlowRenderer } from './components/EnhancedFlowRenderer';
 import type { WorkflowDSL } from './types';
@@ -103,6 +104,7 @@ function getStepStatus(
 export default function WorkflowInstanceDetailPage() {
   const { instanceId } = useParams<{ instanceId: string }>();
   const navigate = useNavigate();
+  const { data: identity } = useGetIdentity<{ id: string }>();
   const [data, setData] = useState<InstanceDetail | null>(null);
   const [loading, setLoading] = useState(true);
   const [actionLoading, setActionLoading] = useState(false);
@@ -175,14 +177,14 @@ export default function WorkflowInstanceDetailPage() {
   const handleApprove = async (nodeId: string, approved: boolean) => {
     setActionLoading(true);
     try {
-      await customRequest(`workflow/instance/${instanceId}/signal`, 'POST', {
-        signalName: 'approval',
-        payload: { nodeId, approved, approvedBy: 'current_user', comment: '' },
+      await customRequest(`workflow/instance/${instanceId}/approve`, 'POST', {
+        nodeId,
+        approved,
       });
       message.success(approved ? 'Approved' : 'Rejected');
       fetchData();
     } catch (e: any) {
-      message.error(e?.message || 'Failed to send signal');
+      message.error(e?.message || 'Failed to submit approval');
     } finally {
       setActionLoading(false);
     }
@@ -370,8 +372,14 @@ export default function WorkflowInstanceDetailPage() {
                   size="small"
                   current={-1}
                   items={data.nodeExecutions.map((ne) => {
+                    const approverIds: string[] =
+                      (ne.input as any)?.approvers || [];
+                    const canApprove =
+                      !!identity?.id && approverIds.includes(identity.id);
                     const isApprovalPending =
-                      ne.nodeType === 'approval' && ne.status === 'RUNNING';
+                      ne.nodeType === 'approval' &&
+                      ne.status === 'RUNNING' &&
+                      canApprove;
                     const isSelected = selectedNodeId === ne.nodeId;
                     return {
                       title: (
@@ -724,7 +732,11 @@ export default function WorkflowInstanceDetailPage() {
 
                         {/* Approval actions */}
                         {selectedExecution.nodeType === 'approval' &&
-                          selectedExecution.status === 'RUNNING' && (
+                          selectedExecution.status === 'RUNNING' &&
+                          !!identity?.id &&
+                          (
+                            (selectedExecution.input as any)?.approvers || []
+                          ).includes(identity.id) && (
                             <Space style={{ width: '100%' }}>
                               <Button
                                 type="primary"