Exemple #1
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));
            }
        }
Exemple #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));
        }
        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));
        }
Exemple #4
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);
        }