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));
}
}
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> 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));
}
}
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));
}
}
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));
}
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));
}
// 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);
}
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));
}
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));
}
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));
}
}
}
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));
}
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));
}
//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);
}