Added support to timeout for the DTMF dialogs

luislera · luislera · commit 2d315f01b485 · 2023-03-08T15:58:08.000-03:00
diff --git a/packages/Telephony/Actions/BatchFixedLengthInput.cs b/packages/Telephony/Actions/BatchFixedLengthInput.cs
@@ -22,7 +22,6 @@ public class BatchFixedLengthInput : BatchRegexInput
         [JsonProperty("$kind")]
         public new const string Kind = "Microsoft.Telephony.BatchFixedLengthInput";
 
-        private const string _dtmfCharacterRegex = @"^[\d#\*]+$";
         private const string _interruptionMaskRegex = @"^[\d]+$";
         private int _batchLength;
 
@@ -68,15 +67,7 @@ public int BatchLength
         /// <inheritdoc/>
         public override Task<DialogTurnResult> ContinueDialogAsync(DialogContext dc, CancellationToken cancellationToken = default)
         {
-            if ((dc.Context.Activity.Type == ActivityTypes.Message) &&
-                (Regex.Match(dc.Context.Activity.Text, _dtmfCharacterRegex).Success || dc.State.GetValue(TurnPath.Interrupted, () => false)))
-            {
-                return base.ContinueDialogAsync(dc, cancellationToken);
-            }
-            else
-            {
-                return Task.FromResult(new DialogTurnResult(DialogTurnStatus.Waiting));
-            }
+            return base.ContinueDialogAsync(dc, cancellationToken);
         }
     }
 }
diff --git a/packages/Telephony/Actions/BatchRegexInput.cs b/packages/Telephony/Actions/BatchRegexInput.cs
@@ -4,12 +4,15 @@
 using System;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
+using System.Security.Claims;
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 using AdaptiveExpressions.Properties;
+using Microsoft.Bot.Builder;
 using Microsoft.Bot.Builder.Dialogs;
 using Microsoft.Bot.Builder.Dialogs.Adaptive;
+using Microsoft.Bot.Components.Telephony.Common;
 using Microsoft.Bot.Schema;
 using Newtonsoft.Json;
 
@@ -23,6 +26,7 @@ public class BatchRegexInput : Dialog
         [JsonProperty("$kind")]
         public const string Kind = "Microsoft.Telephony.BatchRegexInput";
         protected const string AggregationDialogMemory = "this.aggregation";
+        private static IStateMatrix stateMatrix = new LatchingStateMatrix();
 
         /// <summary>
         /// Initializes a new instance of the <see cref="BatchRegexInput"/> class.
@@ -85,9 +89,24 @@ public BatchRegexInput([CallerFilePath] string sourceFilePath = "", [CallerLineN
         [JsonProperty("interruptionMask")]
         public StringExpression InterruptionMask { get; set; }
 
+        /// <summary>
+        /// Gets or sets a value indicating how long to wait for before timing out and using the default value.
+        /// </summary>
+        [JsonProperty("timeOutInMilliseconds")]
+        public IntExpression TimeOutInMilliseconds { get; set; }
+
+        /// <summary>
+        /// Gets or sets a default value when failing after a time out.
+        /// </summary>
+        [JsonProperty("defaultValue")]
+        public StringExpression DefaultValue { get; set; }
+
         /// <inheritdoc/>
         public override async Task<DialogTurnResult> BeginDialogAsync(DialogContext dc, object options = null, CancellationToken cancellationToken = default(CancellationToken))
         {
+            //start a timer that will continue this conversation
+            await InitTimeoutTimerAsync(dc, cancellationToken).ConfigureAwait(false);
+
             return await PromptUserAsync(dc, cancellationToken).ConfigureAwait(false);
         }
 
@@ -101,6 +120,14 @@ public override async Task<DialogTurnResult> ContinueDialogAsync(DialogContext d
                 return await PromptUserAsync(dc, cancellationToken).ConfigureAwait(false);
             }
 
+            //Handle case where we timed out
+            var activity = dc.Context.Activity;
+            if (!wasInterrupted && activity.Type != ActivityTypes.Message && activity.Name == ActivityEventNames.ContinueConversation)
+            {
+                await SendActivityAsync(dc, cancellationToken).ConfigureAwait(false);
+                return await dc.EndDialogAsync(cancellationToken: cancellationToken).ConfigureAwait(false);
+            }
+
             //Get value of termination string from expression
             string regexPattern = this.TerminationConditionRegexPattern?.GetValue(dc.State);
 
@@ -120,6 +147,19 @@ public override async Task<DialogTurnResult> ContinueDialogAsync(DialogContext d
             }
             else
             {
+                //If we didn't timeout then we have to manage our timer somehow.
+                //For starters, complete our existing timer.
+                var timerId = dc.State.GetValue<string>("this.TimerId");
+
+                //Should never happen but if it does, it shouldn't be fatal.
+                if (timerId != null)
+                {
+                    await stateMatrix.CompleteAsync(timerId).ConfigureAwait(false);
+                }
+
+                // Restart the timeout timer
+                await InitTimeoutTimerAsync(dc, cancellationToken).ConfigureAwait(false);
+
                 //else, save the updated aggregation and end the turn
                 dc.State.SetValue(AggregationDialogMemory, existingAggregation);
                 return new DialogTurnResult(DialogTurnStatus.Waiting);
@@ -198,5 +238,59 @@ protected override async Task<bool> OnPreBubbleEventAsync(DialogContext dc, Dial
 
             return new DialogTurnResult(DialogTurnStatus.Waiting);
         }
+
+        private async Task<DialogTurnResult> SendActivityAsync(DialogContext dc, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            var defaultValue = this.DefaultValue ?? throw new InvalidOperationException($"Value for DefaultValue property is not defined.");
+            var msg = new Activity()
+            {
+                From = new ChannelAccount()
+                {
+                    Role = "bot"
+                },
+                Type = "message",
+                Text = defaultValue.GetValue(dc.State)
+            };
+            await dc.Context.SendActivityAsync(msg, cancellationToken).ConfigureAwait(false);
+
+            return new DialogTurnResult(DialogTurnStatus.Complete);
+        }
+
+        private void CreateTimerForConversation(DialogContext dc, string timerId, CancellationToken cancellationToken)
+        {
+            BotAdapter adapter = dc.Context.Adapter;
+            var identity = dc.Context.TurnState.Get<ClaimsIdentity>("BotIdentity");
+
+            ConversationReference conversationReference = dc.Context.Activity.GetConversationReference();
+            var timeoutExpression = this.TimeOutInMilliseconds ?? throw new InvalidOperationException($"Value for TimeOutInMilliseconds property is not defined.");
+            int timeout = timeoutExpression.GetValue(dc.State);
+
+            var audience = dc.Context.TurnState.Get<string>(BotAdapter.OAuthScopeKey);
+
+            //Question remaining to be answered: Will this task get garbage collected? If so, we need to maintain a handle for it.
+            Task.Run(async () =>
+            {
+                await Task.Delay(timeout).ConfigureAwait(false);
+
+                //if we aren't already complete, go ahead and timeout
+                await stateMatrix.RunForStatusAsync(timerId, StateStatus.Running, async () =>
+                {
+                    await adapter.ContinueConversationAsync(
+                        identity,
+                        conversationReference,
+                        audience,
+                        BotWithLookup.OnTurn, //Leverage dirty hack to achieve Bot lookup from component
+                        cancellationToken).ConfigureAwait(false);
+                }).ConfigureAwait(false);
+            });
+        }
+
+        private async Task InitTimeoutTimerAsync(DialogContext dc, CancellationToken cancellationToken)
+        {
+            var timerId = Guid.NewGuid().ToString();
+            CreateTimerForConversation(dc, timerId, cancellationToken);
+            await stateMatrix.StartAsync(timerId).ConfigureAwait(false);
+            dc.State.SetValue("this.TimerId", timerId);
+        }
     }
 }
diff --git a/packages/Telephony/Actions/BatchTerminationCharacterInput.cs b/packages/Telephony/Actions/BatchTerminationCharacterInput.cs
@@ -22,7 +22,6 @@ public class BatchTerminationCharacterInput : BatchRegexInput
         [JsonProperty("$kind")]
         public new const string Kind = "Microsoft.Telephony.BatchTerminationCharacterInput";
 
-        private const string _dtmfCharacterRegex = @"^[\d#\*]+$";
         private const string _interruptionMaskRegex = @"^[\d]+$";
         private string _terminationCharacter;
 
@@ -62,15 +61,7 @@ public string TerminationCharacter
         /// <inheritdoc/>
         public override Task<DialogTurnResult> ContinueDialogAsync(DialogContext dc, CancellationToken cancellationToken = default)
         {
-            if ((dc.Context.Activity.Type == ActivityTypes.Message) && 
-                (Regex.Match(dc.Context.Activity.Text, _dtmfCharacterRegex).Success || dc.State.GetValue(TurnPath.Interrupted, () => false)))
-            {
-                return base.ContinueDialogAsync(dc, cancellationToken);
-            }
-            else
-            {
-                return Task.FromResult(new DialogTurnResult(DialogTurnStatus.Waiting));
-            }
+            return base.ContinueDialogAsync(dc, cancellationToken);
         }
     }
 }
diff --git a/packages/Telephony/Schemas/Microsoft.Telephony.BatchFixedLengthInput.schema b/packages/Telephony/Schemas/Microsoft.Telephony.BatchFixedLengthInput.schema
@@ -49,6 +49,23 @@
       "$ref": "schema:#/definitions/booleanExpression",
       "title": "Always Prompt",
       "description": "When true, if batch is interrupted, it will attempt to restart the batch rather than abandon it."
+    },
+    "timeOutInMilliseconds": {
+      "$ref": "schema:#/definitions/integerExpression",
+      "title": "Timeout in milliseconds",
+      "description": "After the specified amount of milliseconds the dialog will complete with its default value if the user doesn't respond.",
+      "examples": [
+        "10",
+        "=conversation.xyz"
+      ]
+    },
+    "defaultValue": {
+      "$ref": "schema:#/definitions/stringExpression",
+      "title": "Default value",
+      "description": "Value to be shown to the user when the timeout is reached.",
+      "examples": [
+        "Timeout error"
+      ]
     }
   },
   "$policies": {
diff --git a/packages/Telephony/Schemas/Microsoft.Telephony.BatchFixedLengthInput.uischema b/packages/Telephony/Schemas/Microsoft.Telephony.BatchFixedLengthInput.uischema
@@ -9,6 +9,8 @@
       "property",
       "allowInterruptions",
       "alwaysPrompt",
+      "timeOutInMilliseconds",
+      "defaultValue",
       "*"
     ],
     "properties": {
@@ -31,6 +33,16 @@
         "intellisenseScopes": [
           "variable-scopes"
         ]
+      },
+      "timeOutInMilliseconds": {
+        "intellisenseScopes": [
+          "variable-scopes"
+        ]
+      },
+      "defaultValue": {
+        "intellisenseScopes": [
+          "variable-scopes"
+        ]
       }
     }
   },
diff --git a/packages/Telephony/Schemas/Microsoft.Telephony.BatchRegexInput.schema b/packages/Telephony/Schemas/Microsoft.Telephony.BatchRegexInput.schema
@@ -57,6 +57,23 @@
       "$ref": "schema:#/definitions/booleanExpression",
       "title": "Always Prompt",
       "description": "When true, if batch is interrupted, it will attempt to restart the batch rather than abandon it."
+    },
+    "timeOutInMilliseconds": {
+      "$ref": "schema:#/definitions/integerExpression",
+      "title": "Timeout in milliseconds",
+      "description": "After the specified amount of milliseconds the dialog will complete with its default value if the user doesn't respond.",
+      "examples": [
+        "10",
+        "=conversation.xyz"
+      ]
+    },
+    "defaultValue": {
+      "$ref": "schema:#/definitions/stringExpression",
+      "title": "Default value",
+      "description": "Value to be shown to the user when the timeout is reached.",
+      "examples": [
+        "Timeout error"
+      ]
     }
   },
   "$policies": {
diff --git a/packages/Telephony/Schemas/Microsoft.Telephony.BatchRegexInput.uischema b/packages/Telephony/Schemas/Microsoft.Telephony.BatchRegexInput.uischema
@@ -9,6 +9,8 @@
       "property",
       "allowInterruptions",
       "alwaysPrompt",
+      "timeOutInMilliseconds",
+      "defaultValue",
       "*"
     ],
     "properties": {
@@ -36,6 +38,16 @@
         "intellisenseScopes": [
           "variable-scopes"
         ]
+      },
+      "timeOutInMilliseconds": {
+        "intellisenseScopes": [
+          "variable-scopes"
+        ]
+      },
+      "defaultValue": {
+        "intellisenseScopes": [
+          "variable-scopes"
+        ]
       }
     }
   },
diff --git a/packages/Telephony/Schemas/Microsoft.Telephony.BatchTerminationCharacterInput.schema b/packages/Telephony/Schemas/Microsoft.Telephony.BatchTerminationCharacterInput.schema
@@ -49,6 +49,23 @@
       "$ref": "schema:#/definitions/booleanExpression",
       "title": "Always Prompt",
       "description": "When true, if batch is interrupted, it will attempt to restart the batch rather than abandon it."
+    },
+    "timeOutInMilliseconds": {
+      "$ref": "schema:#/definitions/integerExpression",
+      "title": "Timeout in milliseconds",
+      "description": "After the specified amount of milliseconds the dialog will complete with its default value if the user doesn't respond.",
+      "examples": [
+        "10",
+        "=conversation.xyz"
+      ]
+    },
+    "defaultValue": {
+      "$ref": "schema:#/definitions/stringExpression",
+      "title": "Default value",
+      "description": "Value to be shown to the user when the timeout is reached.",
+      "examples": [
+        "Timeout error"
+      ]
     }
   },"$policies": {
         "interactive": true
diff --git a/packages/Telephony/Schemas/Microsoft.Telephony.BatchTerminationCharacterInput.uischema b/packages/Telephony/Schemas/Microsoft.Telephony.BatchTerminationCharacterInput.uischema
@@ -9,6 +9,8 @@
       "property",
       "allowInterruptions",
       "alwaysPrompt",
+      "timeOutInMilliseconds",
+      "defaultValue",
       "*"
     ],
     "properties": {
@@ -31,6 +33,16 @@
         "intellisenseScopes": [
           "variable-scopes"
         ]
+      },
+      "timeOutInMilliseconds": {
+        "intellisenseScopes": [
+          "variable-scopes"
+        ]
+      },
+      "defaultValue": {
+        "intellisenseScopes": [
+          "variable-scopes"
+        ]
       }
     }
   },

Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,6 @@ public class BatchFixedLengthInput : BatchRegexInput`
`22`	`22`	`[JsonProperty("$kind")]`
`23`	`23`	`public new const string Kind = "Microsoft.Telephony.BatchFixedLengthInput";`
`24`	`24`
`25`		`- private const string _dtmfCharacterRegex = @"^[\d#\*]+$";`
`26`	`25`	`private const string _interruptionMaskRegex = @"^[\d]+$";`
`27`	`26`	`private int _batchLength;`
`28`	`27`
`@@ -68,15 +67,7 @@ public int BatchLength`
`68`	`67`	`/// <inheritdoc/>`
`69`	`68`	`public override Task<DialogTurnResult> ContinueDialogAsync(DialogContext dc, CancellationToken cancellationToken = default)`
`70`	`69`	`{`
`71`		`- if ((dc.Context.Activity.Type == ActivityTypes.Message) &&`
`72`		`- (Regex.Match(dc.Context.Activity.Text, _dtmfCharacterRegex).Success \|\| dc.State.GetValue(TurnPath.Interrupted, () => false)))`
`73`		`- {`
`74`		`- return base.ContinueDialogAsync(dc, cancellationToken);`
`75`		`- }`
`76`		`- else`
`77`		`- {`
`78`		`- return Task.FromResult(new DialogTurnResult(DialogTurnStatus.Waiting));`
`79`		`- }`
	`70`	`+ return base.ContinueDialogAsync(dc, cancellationToken);`
`80`	`71`	`}`
`81`	`72`	`}`
`82`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,6 @@ public class BatchTerminationCharacterInput : BatchRegexInput`
`22`	`22`	`[JsonProperty("$kind")]`
`23`	`23`	`public new const string Kind = "Microsoft.Telephony.BatchTerminationCharacterInput";`
`24`	`24`
`25`		`- private const string _dtmfCharacterRegex = @"^[\d#\*]+$";`
`26`	`25`	`private const string _interruptionMaskRegex = @"^[\d]+$";`
`27`	`26`	`private string _terminationCharacter;`
`28`	`27`
`@@ -62,15 +61,7 @@ public string TerminationCharacter`
`62`	`61`	`/// <inheritdoc/>`
`63`	`62`	`public override Task<DialogTurnResult> ContinueDialogAsync(DialogContext dc, CancellationToken cancellationToken = default)`
`64`	`63`	`{`
`65`		`- if ((dc.Context.Activity.Type == ActivityTypes.Message) &&`
`66`		`- (Regex.Match(dc.Context.Activity.Text, _dtmfCharacterRegex).Success \|\| dc.State.GetValue(TurnPath.Interrupted, () => false)))`
`67`		`- {`
`68`		`- return base.ContinueDialogAsync(dc, cancellationToken);`
`69`		`- }`
`70`		`- else`
`71`		`- {`
`72`		`- return Task.FromResult(new DialogTurnResult(DialogTurnStatus.Waiting));`
`73`		`- }`
	`64`	`+ return base.ContinueDialogAsync(dc, cancellationToken);`
`74`	`65`	`}`
`75`	`66`	`}`
`76`	`67`	`}`