Rename steps to actions, rename rules to conditions (#1382)

* Adaptive: rename rules to conditions

* Adaptive: rename steps to actions

* revert changes for componentDialog.ts, dialogContext.ts

Author: Qi Kang

…ialogs-adaptive/src/steps/beginDialog.ts …logs-adaptive/src/actions/beginDialog.tslibraries/botbuilder-dialogs-adaptive/src/steps/beginDialog.ts renamed to libraries/botbuilder-dialogs-adaptive/src/actions/beginDialog.ts libraries/botbuilder-dialogs-adaptive/src/steps/beginDialog.ts renamed to libraries/botbuilder-dialogs-adaptive/src/actions/beginDialog.ts

@@ -8,26 +8,26 @@
 import { DialogTurnResult, DialogCommand, DialogContext } from 'botbuilder-dialogs';
 import { SequenceContext } from '../sequenceContext';
 
-export type CodeStepHandler<T extends DialogContext = SequenceContext> = (context: T, options?: object) => Promise<DialogTurnResult>;
+export type CodeActionHandler<T extends DialogContext = SequenceContext> = (context: T, options?: object) => Promise<DialogTurnResult>;
 
-export class CodeStep<T extends DialogContext = SequenceContext> extends DialogCommand {
-    private handler: CodeStepHandler<T>;
+export class CodeAction<T extends DialogContext = SequenceContext> extends DialogCommand {
+    private handler: CodeActionHandler<T>;
 
-    constructor(handler: CodeStepHandler<T>);
-    constructor(id: string, handler: CodeStepHandler<T>);
-    constructor(idOrHandler: string|CodeStepHandler<T>, handler?: CodeStepHandler<T>) {
+    constructor(handler: CodeActionHandler<T>);
+    constructor(id: string, handler: CodeActionHandler<T>);
+    constructor(idOrHandler: string|CodeActionHandler<T>, handler?: CodeActionHandler<T>) {
         if (typeof idOrHandler === 'function') {
             handler = idOrHandler;
             idOrHandler = undefined;
         }
         super(idOrHandler as string);
         this.handler = handler;
     }
-    
+
     protected onComputeID(): string {
-        return `codeStep[${this.hashedLabel(this.handler.toString())}]`;
+        return `codeAction[${this.hashedLabel(this.handler.toString())}]`;
     }
-    
+
     protected async onRunCommand(context: T, options: object): Promise<DialogTurnResult> {
         return await this.handler(context, options);
     }

…s-adaptive/src/steps/cancelAllDialogs.ts …adaptive/src/actions/cancelAllDialogs.tslibraries/botbuilder-dialogs-adaptive/src/steps/cancelAllDialogs.ts renamed to libraries/botbuilder-dialogs-adaptive/src/actions/cancelAllDialogs.ts libraries/botbuilder-dialogs-adaptive/src/steps/cancelAllDialogs.ts renamed to libraries/botbuilder-dialogs-adaptive/src/actions/cancelAllDialogs.ts

@@ -0,0 +1,89 @@
+/**
+ * @module botbuilder-planning
+ */
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { DialogCommand, DialogTurnResult, Dialog, DialogConfiguration } from 'botbuilder-dialogs';
+import { ActionChangeType, SequenceContext, ActionChangeList, ActionState } from '../sequenceContext';
+
+export interface EditActionsConfiguration extends DialogConfiguration {
+    /**
+     * The type of change to make to the dialogs list of actions.
+     */
+    changeType?: ActionChangeType;
+
+    /**
+     * The actions to update the dialog with.
+     */
+    actions?: Dialog[];
+
+    /**
+     * Tags to insert actions before when [changeType](#changetype) is `ActionChangeType.insertActionsBeforeTags`.
+     */
+    tags?: string[];
+}
+
+export class EditActions extends DialogCommand {
+    /**
+     * The type of change to make to the dialogs list of actions.
+     */
+    public changeType: ActionChangeType;
+
+    /**
+     * The actions to update the dialog with.
+     */
+    public actions: Dialog[];
+
+    /**
+     * Tags to insert actions before when [changeType](#changetype) is `PlanChangeType.doActionsBeforeTags`.
+     */
+    public tags: string[];
+
+    /**
+     * Creates a new `EditActions` instance.
+     * @param changeType The type of change to make to the dialogs list of actions.
+     * @param actions The actions to update the dialog with.
+     */
+    constructor();
+    constructor(changeType: ActionChangeType, actions: Dialog[], tags?: string[]);
+    constructor(changeType?: ActionChangeType, actions?: Dialog[], tags?: string[]) {
+        super();
+        if (changeType !== undefined) { this.changeType = changeType }
+        if (Array.isArray(actions)) { this.actions = actions }
+        if (Array.isArray(tags)) { this.tags = tags }
+    }
+
+    protected onComputeID(): string {
+        return `editActions[${this.hashedLabel(this.changeType)}]`;
+    }
+
+    public configure(config: EditActionsConfiguration): this {
+        return super.configure(config);
+    }
+
+    public getDependencies(): Dialog[] {
+        return this.actions;
+    }
+
+    protected async onRunCommand(sequence: SequenceContext, options: object): Promise<DialogTurnResult> {
+        // Ensure planning context and condition
+        if (!(sequence instanceof SequenceContext)) { throw new Error(`${this.id}: should only be used within a planning or sequence dialog.`) }
+        if (this.changeType == undefined) { throw new Error(`${this.id}: no 'changeType' specified.`) }
+
+        // Queue changes
+        const changes: ActionChangeList = {
+            changeType: this.changeType,
+            actions: this.actions.map((action) => {
+                return { dialogId: action.id, dialogStack: [] } as ActionState
+            })
+        };
+        if (this.changeType == ActionChangeType.insertActionsBeforeTags) {
+            changes.tags = this.tags;
+        }
+        sequence.queueChanges(changes);
+
+        return await sequence.endDialog();
+    }
+}

…r-dialogs-adaptive/src/steps/codeStep.ts …alogs-adaptive/src/actions/codeAction.tslibraries/botbuilder-dialogs-adaptive/src/steps/codeStep.ts renamed to libraries/botbuilder-dialogs-adaptive/src/actions/codeAction.ts libraries/botbuilder-dialogs-adaptive/src/steps/codeStep.ts renamed to libraries/botbuilder-dialogs-adaptive/src/actions/codeAction.ts

@@ -6,11 +6,11 @@
  * Licensed under the MIT License.
  */
 import { DialogCommand, DialogTurnResult, Dialog, DialogConfiguration } from 'botbuilder-dialogs';
-import { SequenceContext, StepChangeList, StepChangeType } from '../sequenceContext';
+import { SequenceContext, ActionChangeList, ActionChangeType } from '../sequenceContext';
 import { ExpressionPropertyValue, ExpressionProperty } from '../expressionProperty';
 
 /**
- * Configuration info passed to a `ForEach` step.
+ * Configuration info passed to a `ForEach` action.
  */
 export interface ForEachConfiguration extends DialogConfiguration {
     /**
@@ -29,32 +29,32 @@ export interface ForEachConfiguration extends DialogConfiguration {
     valueProperty?: string;
 
     /**
-     * Steps to be run for each page of items.
+     * Actions to be run for each page of items.
      */
-    steps?: Dialog[];
+    actions?: Dialog[];
 }
 
 /**
- * Executes a set of steps once for each item in an in-memory list or collection.
- * 
+ * Executes a set of actions once for each item in an in-memory list or collection.
+ *
  * @remarks
- * Each iteration of the loop will store an item from the list or collection at [property](#property) 
- * to `dialog.item`. The loop can be exited early by including either a `EndDialog` or `GotoDialog` 
- * step.
+ * Each iteration of the loop will store an item from the list or collection at [property](#property)
+ * to `dialog.item`. The loop can be exited early by including either a `EndDialog` or `GotoDialog`
+ * action.
  */
 export class ForEach extends DialogCommand {
 
     /**
      * Creates a new `ForEach` instance.
      * @param list Expression used to compute the list that should be enumerated.
-     * @param steps Steps to be run for each page of items. 
+     * @param actions Actions to be run for each page of items.
      */
     constructor();
-    constructor(list: ExpressionPropertyValue<any[]|object>, steps: Dialog[]);
-    constructor(list?: ExpressionPropertyValue<any[]|object>, steps?: Dialog[]) {
+    constructor(list: ExpressionPropertyValue<any[]|object>, actions: Dialog[]);
+    constructor(list?: ExpressionPropertyValue<any[]|object>, actions?: Dialog[]) {
         super();
         if (list) { this.list = new ExpressionProperty(list) }
-        if (steps) { this.steps = steps } 
+        if (actions) { this.actions = actions }
     }
 
     protected onComputeID(): string {
@@ -78,9 +78,9 @@ export class ForEach extends DialogCommand {
     public valueProperty: string = 'dialog.value';
 
     /**
-     * Steps to be run for each page of items.
+     * Actions to be run for each page of items.
      */
-    public steps: Dialog[] = [];
+    public actions: Dialog[] = [];
 
     public configure(config: ForEachConfiguration): this {
         for (const key in config) {
@@ -101,7 +101,7 @@ export class ForEach extends DialogCommand {
     }
 
     public getDependencies(): Dialog[] {
-        return this.steps;
+        return this.actions;
     }
 
     protected async onRunCommand(sequence: SequenceContext, options: ForEachOptions): Promise<DialogTurnResult> {
@@ -121,18 +121,18 @@ export class ForEach extends DialogCommand {
         if (item !== undefined) {
             sequence.state.setValue(this.valueProperty, item);
             sequence.state.setValue(this.indexProperty, offset);
-            const changes: StepChangeList = {
-                changeType: StepChangeType.insertSteps,
-                steps: []
+            const changes: ActionChangeList = {
+                changeType: ActionChangeType.insertActions,
+                actions: []
             };
-            this.steps.forEach((step) => changes.steps.push({ dialogStack: [], dialogId: step.id }));
+            this.actions.forEach((action) => changes.actions.push({ dialogStack: [], dialogId: action.id }));
 
-            // Add a call back into forEachPage() at the end of repeated steps.
+            // Add a call back into forEachPage() at the end of repeated actions.
             // - A new offset is passed in which causes the next page of results to be returned.
-            changes.steps.push({ 
-                dialogStack: [], 
-                dialogId: this.id, 
-                options: { 
+            changes.actions.push({
+                dialogStack: [],
+                dialogId: this.id,
+                options: {
                     list: list,
                     offset: offset + 1
                 }