private async Task <DialogTurnResult> NameStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
        {
            var details = (ChatbotDetails)stepContext.Values["details"];

            if ((bool)stepContext.Result)
            {
                var message = "Wie soll die Landschaft heißen?" + Environment.NewLine;
                var vmName  = details.VmName;
                message = message + "Folgende Landschaften existieren in deinem Azure:" + Environment.NewLine;

                var handler = new AzureHandler(details.User.Tenant, details.User.TokenResponse.Token);
                foreach (var tag in handler.GetAllAvailableLandscapes())
                {
                    message = message + tag + Environment.NewLine;
                }
                message = message + "Bitte tippe als Antwort den Namen der Landschaft zu der die VM " + vmName + " hinzugehört" + Environment.NewLine;
                var promptMessage = MessageFactory.Text(message, message, InputHints.ExpectingInput);
                return(await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions { Prompt = promptMessage }, cancellationToken));
            }
            else
            {
                details.RunWithCompleteLandscape = false;
                return(await stepContext.EndDialogAsync(details, cancellationToken));
            }
        }
예제 #2
0
        private async Task <DialogTurnResult> GetVmStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
        {
            var details = (ChatbotDetails)stepContext.Options;

            stepContext.Values["details"] = details;

            if (details.VmName == null)
            {
                var message = "Welche VM soll gestartet werden? Bitte wähle aus." + Environment.NewLine;

                IList <Choice> choices = new List <Choice>();
                var            handler = new AzureHandler(details.User.Tenant, details.User.TokenResponse.Token);
                foreach (var vm in handler.GetListOfVms())
                {
                    choices.Add(new Choice(vm.Name));
                }
                //TODO hier bereits laufende VMS nicht anzeigen

                message = message + "Hier ist die Liste der Vms, welche von dir gestartet werden können:";
                var promptMessage = MessageFactory.Text(message, message, InputHints.ExpectingInput);
                return(await stepContext.PromptAsync(nameof(ChoicePrompt), new PromptOptions()
                {
                    Choices = choices, Prompt = promptMessage
                }, cancellationToken));
            }

            return(await stepContext.NextAsync(new FoundChoice()
            {
                Value = details.VmName
            }, cancellationToken));
        }
예제 #3
0
        private async Task <DialogTurnResult> LandscapeStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
        {
            var details = (ChatbotDetails)stepContext.Options;
            var handler = new AzureHandler(details.User.Tenant, details.User.TokenResponse.Token);
            var tags    = handler.GetListOfVms().FirstOrDefault(x => x.Name == details.VmName)?.Tags;

            if (tags == null)
            {
                return(await stepContext.BeginDialogAsync(nameof(AddVmToLandscapeActDialog), details, cancellationToken));
            }

            var landscapeTag = tags.FirstOrDefault(x => x.Key == "Landschaft").Value;

            details.LandscapeTag = landscapeTag;

            if (string.IsNullOrWhiteSpace(landscapeTag))
            {
                details.RunWithCompleteLandscape = true;
                return(await stepContext.BeginDialogAsync(nameof(AddVmToLandscapeActDialog), details, cancellationToken));
            }
            else
            {
                var message = "Die ausgewählte VM hat folgende Tags:" + Environment.NewLine;
                foreach (var tag in tags)
                {
                    message = message + tag + Environment.NewLine;
                }

                stepContext.Values["details"] = details;
                message = message + " Soll der Vorgang für mehrere VMs der Landschaft: " + landscapeTag + " ausgeführt werden?";
                var promptMessage = MessageFactory.Text(message, message, InputHints.ExpectingInput);
                return(await stepContext.PromptAsync(nameof(ConfirmPrompt), new PromptOptions { Prompt = promptMessage }, cancellationToken));
            }
        }
예제 #4
0
        private async Task <DialogTurnResult> AskForObligationVmsStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
        {
            var details = (ChatbotDetails)stepContext.Values["details"];

            if (stepContext.Result is FoundChoice choice)
            {
                details.LandscapeTag = choice.Value;

                var message = "Die Landschaft " + details.LandscapeTag + " hat folgende VMs." + Environment.NewLine +
                              " Bitte tippe die IDs der VMs mit Leerzeichen getrennt ein, welche als notwendig gekennzeichnet werden sollen.";

                var handler = new AzureHandler(details.User.Tenant, details.User.TokenResponse.Token);
                int id      = 0;
                var dic     = new Dictionary <int, string>();
                foreach (var vm in handler.GetListOfVmsFromSpecificLandscapeTag(details.LandscapeTag))
                {
                    dic.Add(id, vm);
                    message = message + Environment.NewLine + id + ".) " + vm;
                    id++;
                }

                stepContext.Values["dic"] = dic;
                var promptMessage = MessageFactory.Text(message, message, InputHints.ExpectingInput);
                return(await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions { Prompt = promptMessage }, cancellationToken));
            }
            else
            {
                return(await stepContext.EndDialogAsync(null, cancellationToken));
            }
        }
예제 #5
0
        private async Task <DialogTurnResult> ObligationVmsStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
        {
            var details = (ChatbotDetails)stepContext.Values["details"];
            var handler = new AzureHandler(details.User.Tenant, details.User.TokenResponse.Token);
            var choice  = (FoundChoice)stepContext.Result;

            if (choice.Value == "Alle VMs")
            {
                return(await stepContext.NextAsync(details, cancellationToken));
            }
            else
            {
                details.OnlyObligationVms     = true;
                stepContext.Values["details"] = details;
                var landscapeObligationToStartList = handler.GetObligationVmsForLandscapeTagAsList(details.LandscapeTag);
                if (landscapeObligationToStartList.Count > 0)
                {
                    var message = "Folgende VMs sind von dir als notwendig hinterlegt worden:";
                    foreach (var vm in landscapeObligationToStartList)
                    {
                        message = message + Environment.NewLine + vm;
                    }
                    message = message + Environment.NewLine + "Soll diese Auswahl erweitert oder eingegrenzt werden?";
                    var promptMessage = MessageFactory.Text(message, message, InputHints.ExpectingInput);
                    return(await stepContext.PromptAsync(nameof(ConfirmPrompt), new PromptOptions()
                    {
                        Prompt = promptMessage
                    }, cancellationToken));
                }
                else
                {
                    return(await stepContext.BeginDialogAsync(nameof(SetObligationVmsForLandscapeDialog), details, cancellationToken));
                }
            }
        }
        private async Task <DialogTurnResult> AskForVmStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
        {
            var details = (ChatbotDetails)stepContext.Values["details"];

            if ((bool)stepContext.Result)
            {
                var list = new AzureHandler(details.User.Tenant, details.User.TokenResponse.Token).GetListOfVms().Select(x => x.Name).ToList();

                IList <Choice> choices = new List <Choice>();

                foreach (var vm in list)
                {
                    choices.Add(new Choice(vm));
                }

                choices.Add(new Choice("Keine"));

                var message = "Die folgenden Vms können zu einer Landschaft hinzugefügt werden" + Environment.NewLine;
                message = message + "Welche soll zu einer Landschaft hinzugefügt werden?";

                var promptMessage = MessageFactory.Text(message, message, InputHints.ExpectingInput);
                return(await stepContext.PromptAsync(nameof(ChoicePrompt), new PromptOptions()
                {
                    Choices = choices, Prompt = promptMessage
                }, cancellationToken));
            }
            await stepContext.Context.SendActivityAsync(MessageFactory.Text("Es wird keine VM zur Landschaft hinzugefügt."), cancellationToken);

            return(await stepContext.EndDialogAsync(details, cancellationToken));
        }
예제 #7
0
        private async Task <DialogTurnResult> ConfirmStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
        {
            var details = (ChatbotDetails)stepContext.Result;
            var handler = new AzureHandler(details.User.Tenant, details.User.TokenResponse.Token);

            var messageText = $"Bitte bestätige: Die Landschaft: {details.LandscapeTag} wird gestartet." + Environment.NewLine;

            messageText = messageText + "Folgende Vms werden gestartet: " + Environment.NewLine;
            if (details.OnlyObligationVms)
            {
                foreach (var vm in handler.GetObligationVmsForLandscapeTag(details.LandscapeTag))
                {
                    messageText = messageText + vm + Environment.NewLine;
                }
            }
            else
            {
                foreach (var vm in handler.GetListOfVmsFromSpecificLandscapeTag(details.LandscapeTag))
                {
                    messageText = messageText + vm + Environment.NewLine;
                }
            }

            messageText = messageText + "Ist das korrekt?";
            stepContext.Values["details"] = details;
            var promptMessage = MessageFactory.Text(messageText, messageText, InputHints.ExpectingInput);

            return(await stepContext.PromptAsync(nameof(ConfirmPrompt), new PromptOptions { Prompt = promptMessage }, cancellationToken));
        }
예제 #8
0
        // default to local filesystem
        public static IBlobHandler GetHandler(UrlType urlType, string url)
        {
            if (DebugMode)
            {
                Console.WriteLine("GetHandler start");
            }

            IBlobHandler blobHandler;

            switch (urlType)
            {
            case UrlType.Azure:
                blobHandler = new AzureHandler(url);
                break;

            case UrlType.AzureFile:
                blobHandler = new AzureFileHandler(url);
                break;

            case UrlType.S3:
                blobHandler = new S3Handler(url);
                break;

            case UrlType.SkyDrive:
                blobHandler = new SkyDriveHandler(url);
                break;

            case UrlType.Local:
                blobHandler = new FileSystemHandler(url);
                break;

            //case UrlType.Sharepoint:
            //    blobHandler = new SharepointHandler(url);
            //    break;

            case UrlType.Dropbox:
                blobHandler = new DropboxHandler(url);
                break;

            default:
                blobHandler = new FileSystemHandler(url);
                break;
            }

            if (DebugMode)
            {
                Console.WriteLine("GetHandler retrieved " + blobHandler.GetType().ToString());
            }



            return(blobHandler);
        }
예제 #9
0
        private async Task <DialogTurnResult> FinalStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
        {
            if ((bool)stepContext.Result)
            {
                var details = (ChatbotDetails)stepContext.Values["details"];
                var handler = new AzureHandler(details.User.Tenant, details.User.TokenResponse.Token);
                handler.StartVmsAsync(details);

                return(await stepContext.EndDialogAsync(details, cancellationToken));
            }

            return(await stepContext.EndDialogAsync(null, cancellationToken));
        }
        private async Task <DialogTurnResult> FinalStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
        {
            var details = (ChatbotDetails)stepContext.Values["details"];

            if ((bool)stepContext.Result)
            {
                var handler = new AzureHandler(details.User.Tenant, details.User.TokenResponse.Token);
                var message = "Tag wird hinzugefügt. Dies wird im Hintergrund eine kurze Zeit benötigen. Bitte beende den Bot nicht.";
                await stepContext.Context.SendActivityAsync(MessageFactory.Text(message), cancellationToken);

                handler.AddLandscapeTagToVmAsync(details.LandscapeTag, details.VmName);

                return(await stepContext.EndDialogAsync(details, cancellationToken));
            }
            return(await stepContext.EndDialogAsync(details, cancellationToken));
        }
예제 #11
0
        public MainWindow()
        {
            InitializeComponent();

            InitializeSpeechRecognizer();

            InitializeDeltaAngles();

            try
            {
                AzureHandler.InitializeAzureStorage();
                _medicineList = AzureHandler.ReadFromTable();
            }
            catch (Exception)
            {
                JsonHandler();
            }
        }
        private async Task <DialogTurnResult> ListVmsStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
        {
            var details = (ChatbotDetails)stepContext.Values["details"];

            if (stepContext.Result is FoundChoice choice)
            {
                details.LandscapeTag          = choice.Value;
                stepContext.Values["details"] = details;
            }
            var handler            = new AzureHandler(details.User.Tenant, details.User.TokenResponse.Token);
            var vmsInThisLandscape = handler.GetListOfVmsFromSpecificLandscapeTag(details.LandscapeTag);
            var message            = "Folgende VMs befinden sich in dieser Landschaft und werden herunter gefahren:" + Environment.NewLine;

            foreach (var vm in vmsInThisLandscape)
            {
                message = message + vm + Environment.NewLine;
            }

            return(await stepContext.NextAsync(details, cancellationToken));
        }
        private async Task <DialogTurnResult> ListTagsStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
        {
            var details = (ChatbotDetails)stepContext.Options;

            stepContext.Values["details"] = details;
            var handler = new AzureHandler(details.User.Tenant, details.User.TokenResponse.Token);
            var tags    = handler.GetListOfVms().FirstOrDefault(x => x.Name == details.VmName)?.Tags;

            if (tags != null)
            {
                var message = "Folgende Tags besitzt diese VM bereits:";
                foreach (var vmTag in tags)
                {
                    message = message + Environment.NewLine + vmTag;
                }

                await stepContext.Context.SendActivityAsync(MessageFactory.Text(message, message, InputHints.IgnoringInput), cancellationToken);
            }
            return(await stepContext.NextAsync(true, cancellationToken));
        }
        private async Task <DialogTurnResult> GetLandscapeStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
        {
            var details = (ChatbotDetails)stepContext.Options;

            details.RunWithCompleteLandscape = true;
            stepContext.Values["details"]    = details;

            if (details.LandscapeTag == null)
            {
                var message = "Welche Landschaft soll herunter gefahren werden? Bitte wähle aus." + Environment.NewLine;

                IList <Choice> choices    = new List <Choice>();
                var            handler    = new AzureHandler(details.User.Tenant, details.User.TokenResponse.Token);
                var            landscapes = handler.GetAllAvailableLandscapes();
                if (!landscapes.Any())
                {
                    await stepContext.Context.SendActivityAsync(MessageFactory.Text("Es existieren keine Landschaften in ihrem Azure Account. Diese müssen zuerst konfiguriert werden. Dies kann über das Azure Portal oder über diesen Bot geschehen."), cancellationToken);

                    return(await stepContext.EndDialogAsync(null, cancellationToken));
                }
                foreach (var tag in landscapes)
                {
                    choices.Add(new Choice(tag));
                }

                message = message + "Folgende Landschaften können von dir herunter gefahren werden:";

                var promptMessage = MessageFactory.Text(message, message, InputHints.ExpectingInput);
                return(await stepContext.PromptAsync(nameof(ChoicePrompt), new PromptOptions()
                {
                    Choices = choices, Prompt = promptMessage
                }, cancellationToken));
            }

            return(await stepContext.NextAsync(new FoundChoice()
            {
                Value = details.LandscapeTag
            }, cancellationToken));
        }
예제 #15
0
        private async Task <DialogTurnResult> CheckForObligationVmsStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
        {
            var details = (ChatbotDetails)stepContext.Values["details"];
            var handler = new AzureHandler(details.User.Tenant, details.User.TokenResponse.Token);
            var choice  = (FoundChoice)stepContext.Result;

            if (choice.Value == "Alle VMs")
            {
                return(await stepContext.NextAsync(details, cancellationToken));
            }
            else
            {
                details.OnlyObligationVms     = true;
                stepContext.Values["details"] = details;

                var landscapeObligationToStartList = handler.GetObligationVmsForLandscapeTagAsList(details.LandscapeTag);
                if (landscapeObligationToStartList.Count > 0)
                {
                    var message = "Folgende VMs sind als notwendig hinterlegt worden:";
                    foreach (var vm in landscapeObligationToStartList)
                    {
                        message = message + Environment.NewLine + vm;
                    }
                    message = message + Environment.NewLine + "Falls diese Auswahl nicht stimmen sollte, muss dies umkonfiguriert werden";
                    var promptMessage = MessageFactory.Text(message, message, InputHints.ExpectingInput);
                    return(await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions()
                    {
                        Prompt = promptMessage
                    }, cancellationToken));
                }
                else
                {
                    var message = "Für diese Landschaft existiert keine Konfiguration für notwenige VMs. Solange die Konfiguration nicht existiert, werden alle VMs der Landschaft gestartet.";
                    await stepContext.Context.SendActivityAsync(MessageFactory.Text(message, message, InputHints.IgnoringInput), cancellationToken);

                    return(await stepContext.NextAsync(details, cancellationToken));
                }
            }
        }
예제 #16
0
        private async Task <DialogTurnResult> AskForLandscapeStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
        {
            var details = (ChatbotDetails)stepContext.Options;

            stepContext.Values["details"] = details;
            var handler    = new AzureHandler(details.User.Tenant, details.User.TokenResponse.Token);
            var landscapes = handler.GetAllAvailableLandscapes();

            IList <Choice> choices = new List <Choice>();

            foreach (var tag in landscapes)
            {
                choices.Add(new Choice(tag));
            }

            var message = "Für welche dieser Landschaften sollen die verpflichtenden VMs konfiguriert werden?";

            var promptMessage = MessageFactory.Text(message, message, InputHints.ExpectingInput);

            return(await stepContext.PromptAsync(nameof(ChoicePrompt), new PromptOptions()
            {
                Choices = choices, Prompt = promptMessage
            }, cancellationToken));
        }
예제 #17
0
        private async Task <DialogTurnResult> SetObligationVmsStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
        {
            var details = (ChatbotDetails)stepContext.Values["details"];
            var handler = new AzureHandler(details.User.Tenant, details.User.TokenResponse.Token);
            var result  = stepContext.Result.ToString().Split(" ");
            var dic     = (Dictionary <int, string>)stepContext.Values["dic"];
            var message = "Jeder VM, welche als notwendig markiert wurde wird jetzt ein Tag in Azure hinzugefügt. Dies wird etwas Zeit benötigen, bis die Daten in Azure gespeichert wurden.";
            await stepContext.Context.SendActivityAsync(MessageFactory.Text(message, message, InputHints.IgnoringInput), cancellationToken);

            foreach (var number in result)
            {
                try
                {
                    if (Int16.TryParse(number, out var numberAsInt))
                    {
                        handler.AddObligationForLandscapeTagToVmAsync(dic[numberAsInt], details.LandscapeTag);
                    }
                    else
                    {
                        throw new Exception("Tryparse hat nicht funktioniert.");
                    }
                }
                catch
                {
                    var message2 = "Die Antwort darf nur aus gültigen IDs mit Leerzeichen getrennt bestehen!";
                    await stepContext.Context.SendActivityAsync(MessageFactory.Text(message2, message2, InputHints.IgnoringInput), cancellationToken);

                    return(await stepContext.ReplaceDialogAsync(nameof(SetObligationVmsForLandscapeDialog), details, cancellationToken));
                }
            }

            var text = "Die angegebenen VMs sind für das nächste Starten der Landschaft als notwendig hinterlegt.";
            await stepContext.Context.SendActivityAsync(MessageFactory.Text(text, text, InputHints.IgnoringInput), cancellationToken);

            return(await stepContext.EndDialogAsync(details, cancellationToken));
        }
예제 #18
0
        //endRegion Steps

        #region Methods

        private static async Task <ChatbotDetails> ShowWarningForUnsupportedVms(ITurnContext context, AzureBotLuis luisResult, ChatbotDetails details, CancellationToken cancellationToken)
        {
            var unsupportedVms          = new List <string>();
            var unsupportedVmLandscapes = new List <string>();
            var azureHandler            = new AzureHandler(details.User.Tenant, details.User.TokenResponse.Token);

            if (luisResult.Entities.VmLandscapeName != null)
            {
                if (!string.IsNullOrWhiteSpace(luisResult.Entities.VmLandscapeName[0]))
                {
                    var vmsWithLuisLandscapeTag = azureHandler.GetListOfVms().Where(x => x.Tags.Any(y => y.Key == "Landschaft" && y.Value == luisResult.Entities.VmLandscapeName[0]));

                    if (vmsWithLuisLandscapeTag.Any())
                    {
                        details.LandscapeTag             = luisResult.Entities.VmLandscapeName[0];
                        details.RunWithCompleteLandscape = true;
                    }
                    else
                    {
                        unsupportedVmLandscapes.Add(luisResult.Entities.VmLandscapeName[0]);
                    }
                }
            }

            if (luisResult.Entities.VmName != null)
            {
                if (!string.IsNullOrWhiteSpace(luisResult.Entities.VmName[0]))
                {
                    var listOfVms = azureHandler.GetListOfVms().Select(x => x.Name).ToList();
                    if (listOfVms.Any(x => x == luisResult.Entities.VmName[0]))
                    {
                        details.VmName = luisResult.Entities.VmName[0];
                    }
                    else
                    {
                        unsupportedVms.Add(luisResult.Entities.VmName[0]);
                    }
                }
            }


            if (details.Intent == AzureBotLuis.Intent.StartSingleVm || details.Intent == AzureBotLuis.Intent.StartVmLandscape)
            {
                if (unsupportedVms.Any() || unsupportedVmLandscapes.Any())
                {
                    var messageText = "Du hast eine Vm oder Landschaft angegeben die nicht in deinem Azure Account zu finden war.";
                    var message     = MessageFactory.Text(messageText, messageText, InputHints.IgnoringInput);
                    await context.SendActivityAsync(message, cancellationToken);

                    foreach (var unsupportedLandscape in unsupportedVmLandscapes)
                    {
                        if (azureHandler.GetListOfVms().FirstOrDefault(x => x.Name == unsupportedLandscape) != null)
                        {
                            details.Intent = AzureBotLuis.Intent.StartSingleVm;
                            details.VmName = unsupportedLandscape;

                            var messageText2 = "Stattdessen wurde eine VM mit dem selben Namen gefunden. Ich gehen davon aus, das du diese gemeint hast.";
                            var message2     = MessageFactory.Text(messageText2, messageText2, InputHints.IgnoringInput);
                            await context.SendActivityAsync(message2, cancellationToken);
                        }
                    }

                    foreach (var unsupportedVm in unsupportedVms)
                    {
                        if (azureHandler.GetAllAvailableLandscapes().FirstOrDefault(x => x == unsupportedVm) != null)
                        {
                            details.Intent       = AzureBotLuis.Intent.StartVmLandscape;
                            details.LandscapeTag = unsupportedVm;

                            var messageText2 = "Stattdessen wurde eine Landschaft mit dem selben Namen gefunden. Ich gehen davon aus, das du diese gemeint hast.";
                            var message2     = MessageFactory.Text(messageText2, messageText2, InputHints.IgnoringInput);
                            await context.SendActivityAsync(message2, cancellationToken);
                        }
                    }
                }
            }

            if (details.Intent == AzureBotLuis.Intent.ShutDownSingleVm || details.Intent == AzureBotLuis.Intent.ShutDownVmLandscape)
            {
                if (unsupportedVms.Any() || unsupportedVmLandscapes.Any())
                {
                    var messageText = "Du hast eine Vm oder Landschaft angegeben die nicht in deinem Azure Account zu finden sind.";
                    var message     = MessageFactory.Text(messageText, messageText, InputHints.IgnoringInput);
                    await context.SendActivityAsync(message, cancellationToken);

                    foreach (var unsupportedLandscape in unsupportedVmLandscapes)
                    {
                        if (azureHandler.GetListOfVms().FirstOrDefault(x => x.Name == unsupportedLandscape) != null)
                        {
                            details.Intent = AzureBotLuis.Intent.ShutDownSingleVm;
                            details.VmName = unsupportedLandscape;

                            var messageText2 = "Stattdessen wurde eine VM mit dem selben Namen gefunden. Ich gehen davon aus, das du diese gemeint hast.";
                            var message2     = MessageFactory.Text(messageText2, messageText2, InputHints.IgnoringInput);
                            await context.SendActivityAsync(message2, cancellationToken);
                        }
                    }

                    foreach (var unsupportedVm in unsupportedVms)
                    {
                        if (azureHandler.GetAllAvailableLandscapes().FirstOrDefault(x => x == unsupportedVm) != null)
                        {
                            details.Intent       = AzureBotLuis.Intent.ShutDownVmLandscape;
                            details.LandscapeTag = unsupportedVm;

                            var messageText2 = "Stattdessen wurde eine Landschaft mit dem selben Namen gefunden. Ich gehen davon aus, das du diese gemeint hast.";
                            var message2     = MessageFactory.Text(messageText2, messageText2, InputHints.IgnoringInput);
                            await context.SendActivityAsync(message2, cancellationToken);
                        }
                    }
                }
            }

            return(details);
        }