[WIP] LG activity copy behavior: copies all possible lg templates

Composer/packages/client/__tests__/store/action/lgHandlers.test.ts

@@ -0,0 +1,71 @@
+import { isLgActivity, copyLgTemplate } from '../../../src/store/action/lgHandlers';
+
+describe('lgHandlers', () => {
+  describe('#isLgActivity', () => {
+    it('can handle empty input', () => {
+      expect(isLgActivity('')).toBeFalsy();
+    });
+
+    it('can identify correct templates', () => {
+      expect(isLgActivity('[bfdactivity-1234]')).toBeTruthy();
+      expect(isLgActivity('[bfdprompt-1234]')).toBeTruthy();
+      expect(isLgActivity('[bfdinvalidPrompt-1234]')).toBeTruthy();
+      expect(isLgActivity('[bfdunrecognizedPrompt-1234]')).toBeTruthy();
+    });
+
+    it('can identify invalid templates', () => {
+      expect(isLgActivity('any string')).toBeFalsy();
+
+      expect(isLgActivity('bfdactivity-1234')).toBeFalsy();
+      expect(isLgActivity('[bfdactivity-1234')).toBeFalsy();
+      expect(isLgActivity('bfdactivity-1234')).toBeFalsy();
+      expect(isLgActivity('[bfdactivity-abc]')).toBeFalsy();
+
+      expect(isLgActivity('[abfdactivity-1234]')).toBeFalsy();
+      expect(isLgActivity('[abfdactivity]')).toBeFalsy();
+      expect(isLgActivity('[bfdactivity-]')).toBeFalsy();
+    });
+  });
+
+  describe('#copyLgTemplate', () => {
+    const lgApi = {
+      getLgTemplates: (id, activity) => Promise.resolve([{ Name: 'bfdactivity-1234', Body: 'Hello' }]),
+      updateLgTemplate: (id, newId, newContent) => Promise.resolve(true),
+    };
+
+    it('can skip invalid input params', async () => {
+      expect(await copyLgTemplate('common', '', 'newId', lgApi)).toEqual('');
+      expect(await copyLgTemplate('common', 'wrong', 'newId', lgApi)).toEqual('wrong');
+      expect(await copyLgTemplate('common', 'wrong', 'newId', null as any)).toEqual('wrong');
+    });
+
+    it('can copy existing template to a new template', async () => {
+      expect(await copyLgTemplate('common', '[bfdactivity-1234]', '[bfdactivity-5678]', lgApi)).toEqual(
+        '[bfdactivity-5678]'
+      );
+    });
+
+    it('can handle non-existing template', async () => {
+      expect(await copyLgTemplate('common', '[bfdactivity-4321]', '[bfdactivity-5678]', lgApi)).toEqual(
+        '[bfdactivity-4321]'
+      );
+    });
+
+    it('can recover from API error', async () => {
+      // getLgTemplates error
+      expect(
+        await copyLgTemplate('common', '[bfdactivity-1234]', 'bfdactivity-5678', {
+          ...lgApi,
+          getLgTemplates: () => Promise.reject(),
+        })
+      ).toEqual('[bfdactivity-1234]');
+
+      expect(
+        await copyLgTemplate('common', '[bfdactivity-1234]', 'bfdactivity-5678', {
+          ...lgApi,
+          updateLgTemplate: () => Promise.reject(),
+        })
+      ).toEqual('Hello');
+    });
+  });
+});

Composer/packages/client/src/extension-container/ExtensionContainer.tsx

@@ -2,6 +2,7 @@ import React, { useState, useEffect } from 'react';
 import { initializeIcons } from 'office-ui-fabric-react';
 import { LuFile, ShellData } from 'shared';
 
+import { copyLgTemplate } from '../store/action/lgHandlers';
 import ApiClient from '../messenger/ApiClient';
 
 import getEditor from './EditorMap';
@@ -95,6 +96,13 @@ const shellApi = {
     });
   },
 
+  copyLgTemplate: (id: string, templateName: string, newTemplateName: string) => {
+    return copyLgTemplate(id, templateName, newTemplateName, {
+      getLgTemplates: shellApi.getLgTemplates,
+      updateLgTemplate: shellApi.updateLgTemplate,
+    });
+  },
+
   createDialog: () => {
     return apiClient.apiCall('createDialog');
   },

Composer/packages/client/src/store/action/lgHandlers.ts

@@ -0,0 +1,42 @@
+const TEMPLATE_PATTERN = /^\[(bfd.+-\d+)\]$/;
+export function isLgActivity(activity: string) {
+  return activity && TEMPLATE_PATTERN.test(activity);
+}
+
+export async function copyLgTemplate(
+  lgFileName: string,
+  templateNameToCopy: string,
+  newTemplateName: string,
+  lgApi: {
+    getLgTemplates: (lgFileName: string, templateName: string) => Promise<any>;
+    updateLgTemplate: (lgFileName: string, newTemplateName: string, newContent: string) => Promise<any>;
+  }
+): Promise<string> {
+  if (!templateNameToCopy) return '';
+  if (!isLgActivity(templateNameToCopy) || !lgApi) return templateNameToCopy;
+
+  const { getLgTemplates, updateLgTemplate } = lgApi;
+  if (!getLgTemplates) return templateNameToCopy;
+
+  let rawLg: any[] = [];
+  try {
+    rawLg = await getLgTemplates(lgFileName, templateNameToCopy);
+  } catch (error) {
+    return templateNameToCopy;
+  }
+
+  const currentLg = rawLg.find(lg => `[${lg.Name}]` === templateNameToCopy);
+
+  if (currentLg) {
+    // Create new lg activity.
+    const newLgContent = currentLg.Body;
+    try {
+      const newTemplateId = (TEMPLATE_PATTERN.exec(newTemplateName) || [])[1];
+      await updateLgTemplate(lgFileName, newTemplateId, newLgContent);
+      return newTemplateName;
+    } catch (e) {
+      return newLgContent;
+    }
+  }
+  return templateNameToCopy;
+}

Composer/packages/extensions/visual-designer/src/editors/ObiEditor.tsx

@@ -39,15 +39,12 @@ export const ObiEditor: FC<ObiEditorProps> = ({
 }): JSX.Element | null => {
   let divRef;
 
-  const { focusedId, focusedEvent, updateLgTemplate, getLgTemplates, removeLgTemplate } = useContext(
-    NodeRendererContext
-  );
+  const { focusedId, focusedEvent, removeLgTemplate, copyLgTemplate } = useContext(NodeRendererContext);
   const [clipboardContext, setClipboardContext] = useState({
     clipboardActions: [],
     setClipboardActions: actions => setClipboardContext({ ...clipboardContext, clipboardActions: actions }),
   });
 
-  const lgApi = { getLgTemplates, removeLgTemplate, updateLgTemplate };
   const dispatchEvent = (eventName: NodeEventTypes, eventData: any): any => {
     let handler;
     switch (eventName) {
@@ -108,7 +105,12 @@ export const ObiEditor: FC<ObiEditorProps> = ({
       case NodeEventTypes.Insert:
         if (eventData.$type === 'PASTE') {
           handler = e => {
-            pasteNodes(data, e.id, e.position, clipboardContext.clipboardActions, lgApi).then(dialog => {
+            // Bind 'common' as lg template file name to align with 'removeLgTemplate' usage.
+            const externalCopyApi = {
+              copyLgTemplate: (templateNameToCopy: string, newTemplateName: string) =>
+                copyLgTemplate('common', templateNameToCopy, newTemplateName),
+            };
+            pasteNodes(data, e.id, e.position, clipboardContext.clipboardActions, externalCopyApi).then(dialog => {
               onChange(dialog);
             });
           };

Composer/packages/extensions/visual-designer/src/index.tsx

@@ -48,6 +48,7 @@ const VisualDesigner: React.FC<VisualDesignerProps> = ({
     updateLgTemplate,
     getLgTemplates,
     removeLgTemplate,
+    copyLgTemplate,
     undo,
     redo,
   } = shellApi;
@@ -62,6 +63,7 @@ const VisualDesigner: React.FC<VisualDesignerProps> = ({
     updateLgTemplate: updateLgTemplate,
     getLgTemplates: getLgTemplates,
     removeLgTemplate: removeLgTemplate,
+    copyLgTemplate: copyLgTemplate,
   });
 
   useEffect(() => {

Composer/packages/extensions/visual-designer/src/store/NodeRendererContext.ts

@@ -1,5 +1,4 @@
 import React from 'react';
-import { string } from 'prop-types';
 
 interface LgTemplate {
   Name: string;
@@ -12,5 +11,6 @@ export const NodeRendererContext = React.createContext({
   focusedTab: '',
   getLgTemplates: (_id: string, _templateName: string) => Promise.resolve([] as LgTemplate[]),
   removeLgTemplate: (_id: string, _templateName: string) => Promise.resolve(),
-  updateLgTemplate: (_id: string, _templateName: string, _template: string) => Promise.resolve('' as string),
+  updateLgTemplate: (_id: string, _templateName: string, _template: string) => Promise.resolve(''),
+  copyLgTemplate: (_id: string, _templateName: string, _newTemplateName: string) => Promise.resolve(''),
 });

Composer/packages/extensions/visual-designer/src/utils/jsonTracker.ts

@@ -196,7 +196,15 @@ export function appendNodesAfter(inputDialog, targetId, newNodes) {
   return dialog;
 }
 
-export async function pasteNodes(inputDialog, arrayPath, arrayIndex, newNodes, lgApi) {
+export async function pasteNodes(
+  inputDialog: any,
+  arrayPath: string,
+  arrayIndex: number,
+  newNodes: any[],
+  externalApi: {
+    copyLgTemplate: (srcTemplateName: string, newTemplateName: string) => Promise<string>;
+  }
+) {
   if (!Array.isArray(newNodes) || newNodes.length === 0) {
     return inputDialog;
   }
@@ -211,7 +219,7 @@ export async function pasteNodes(inputDialog, arrayPath, arrayIndex, newNodes, l
   // Deep copy nodes with external resources
   const copiedNodes = await Promise.all(
     newNodes.map(async x => {
-      const node = await deepCopyAction(x, lgApi);
+      const node = await deepCopyAction(x, externalApi);
       return node;
     })
   );

Composer/packages/lib/shared/__tests__/copyUtils.test.ts → Composer/packages/lib/shared/__tests__/utils/copyUtils.test.ts

@@ -1,26 +1,11 @@
-import { copyAdaptiveAction } from '../src/copyUtils';
+import { copyAdaptiveAction } from '../../src/utils/copyUtils';
 
 describe('copyAdaptiveAction', () => {
-  const lgTemplate = [{ Name: 'bfdactivity-1234', Body: '-hello' }];
   const externalApi = {
     updateDesigner: data => {
       data.$designer = { id: '5678' };
     },
-    lgApi: {
-      getLgTemplates: (fileId, activityId) => {
-        return Promise.resolve(lgTemplate);
-      },
-      updateLgTemplate: (filedId, activityId, activityBody) => {
-        return Promise.resolve(true);
-      },
-    },
-  };
-  const externalApiWithFailure = {
-    ...externalApi,
-    lgApi: {
-      ...externalApi.lgApi,
-      updateLgTemplate: () => Promise.reject(),
-    },
+    copyLgTemplate: (templateToCopy: string, newTemplateName: string) => Promise.resolve(newTemplateName),
   };
 
   it('should return {} when input is invalid', async () => {
@@ -53,12 +38,6 @@ describe('copyAdaptiveAction', () => {
       $designer: { id: '5678' },
       activity: '[bfdactivity-5678]',
     });
-
-    expect(await copyAdaptiveAction(sendActivity, externalApiWithFailure)).toEqual({
-      $type: 'Microsoft.SendActivity',
-      $designer: { id: '5678' },
-      activity: '-hello',
-    });
   });
 
   it('can copy TextInput', async () => {
@@ -72,7 +51,8 @@ describe('copyAdaptiveAction', () => {
       alwaysPrompt: false,
       allowInterruptions: 'true',
       outputFormat: 'none',
-      prompt: '[bfdactivity-1234]',
+      prompt: '[bfdprompt-1234]',
+      invalidPrompt: '[bfdinvalidPrompt-1234]',
     };
 
     expect(await copyAdaptiveAction(promptText, externalApi)).toEqual({
@@ -84,19 +64,8 @@ describe('copyAdaptiveAction', () => {
       alwaysPrompt: false,
       allowInterruptions: 'true',
       outputFormat: 'none',
-      prompt: '[bfdactivity-5678]',
-    });
-
-    expect(await copyAdaptiveAction(promptText, externalApiWithFailure)).toEqual({
-      $type: 'Microsoft.TextInput',
-      $designer: {
-        id: '5678',
-      },
-      maxTurnCount: 3,
-      alwaysPrompt: false,
-      allowInterruptions: 'true',
-      outputFormat: 'none',
-      prompt: '-hello',
+      prompt: '[bfdprompt-5678]',
+      invalidPrompt: '[bfdinvalidPrompt-5678]',
     });
   });
 });

Composer/packages/lib/shared/__tests__/utils/walkAdaptiveAction.test.ts

@@ -0,0 +1,38 @@
+import { walkAdaptiveAction } from '../../src/utils/walkAdaptiveAction';
+
+describe('#walkAdaptiveAction', () => {
+  const action = {
+    $type: 'Microsoft.IfCondition',
+    actions: [{ $type: 'Microsoft.SendActivity' }],
+    elseActions: [
+      {
+        $type: 'Microsoft.Foreach',
+        actions: [{ $type: 'Microsoft.SendActivity' }],
+      },
+    ],
+  };
+
+  it('can walk every child Adaptive Action node', async () => {
+    let actionCount = 0;
+    const counter: any = () => {
+      actionCount += 1;
+    };
+    await walkAdaptiveAction(action, counter);
+    expect(actionCount).toEqual(4);
+  });
+
+  it('can walk every child Adaptive Action node async', async () => {
+    let actionCount = 0;
+    const counter = () => {
+      return new Promise(resolve => {
+        setTimeout(() => {
+          actionCount += 1;
+          resolve();
+        }, 10);
+      });
+    };
+
+    await walkAdaptiveAction(action, counter);
+    expect(actionCount).toEqual(4);
+  });
+});