private async Task <DialogTurnResult> GetAnswerAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
string[] stringPos;
stringPos = new string[21] {
"yes", "ye", "yep", "ya", "yas", "totally", "sure", "ok", "k", "okey", "okay", "alright", "sounds good", "sure thing", "of course", "gladly", "definitely", "indeed", "absolutely", "yes please", "please"
};
string[] stringNeg;
stringNeg = new string[9] {
"no", "nope", "no thanks", "unfortunately not", "apologies", "nah", "not now", "no can do", "no thank you"
};
if (!_luisRecognizer.IsConfigured)
{
await stepContext.Context.SendActivityAsync(
MessageFactory.Text("NOTE: LUIS is not configured. To enable all capabilities, add 'LuisAppId', 'LuisAPIKey' and 'LuisAPIHostName' to the web.config file.", inputHint: InputHints.IgnoringInput), cancellationToken);
return(await stepContext.NextAsync(null, cancellationToken));
}
var luisResult = await _luisRecognizer.RecognizeAsync <Luis.Conversation>(stepContext.Context, cancellationToken);
var moduleDetails = new ModuleDetails()
{
Lecturer = luisResult.Entities.Lecturer,
Opinion = luisResult.Entities.Opinion,
};
if (luisResult.TopIntent().Equals(Luis.Conversation.Intent.None))
{
var didntUnderstandMessageText2 = $"Sorry, I didn't understand that. Could you please rephrase)";
var elsePromptMessage2 = new PromptOptions {
Prompt = MessageFactory.Text(didntUnderstandMessageText2, didntUnderstandMessageText2, InputHints.ExpectingInput)
};
stepContext.ActiveDialog.State[key : "stepIndex"] = (int)stepContext.ActiveDialog.State["stepIndex"] - 1;
return(await stepContext.PromptAsync(nameof(TextPrompt), elsePromptMessage2, cancellationToken));
}
if (stringNeg.Any(luisResult.Text.ToLower().Contains))
{
return(await stepContext.BeginDialogAsync(nameof(EndConversationDialog)));;
}
if (stringPos.Any(luisResult.Text.ToLower().Contains))
{
// Transition to Main Dialog - to choose what to discuss
return(await stepContext.BeginDialogAsync(nameof(MainDialog)));
}
var didntUnderstandMessageText3 = $"Sorry, I didn't understand that. Could you please rephrase)";
var elsePromptMessage3 = new PromptOptions {
Prompt = MessageFactory.Text(didntUnderstandMessageText3, didntUnderstandMessageText3, InputHints.ExpectingInput)
};
stepContext.ActiveDialog.State[key : "stepIndex"] = (int)stepContext.ActiveDialog.State["stepIndex"] - 1;
return(await stepContext.PromptAsync(nameof(TextPrompt), elsePromptMessage3, cancellationToken));
}
public ActionResult Index()
{
if (Session["modules"] != null)
{
List <ModuleDetails> md = Session["modules"] as List <ModuleDetails>;
ModuleDetails md1 = md.Find(x => x.Module.Equals("Membership"));
ViewBag.Create = md1.Create;
}
return(View());
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
//To DO ::
//Get the Value from the Modules and Action Type :
//Check for current users.
//Check Action to validate frm the modules List
//If is Exist Execute Action and
//If is not Exist Redirect Unauthroise Access.
// var modules = (string)filterContext.Controller;
if (Modules != null)
{
if (HttpContext.Current.Session["modules"] != null && HttpContext.Current.Session["user"].ToString() != "Admin")
{
List <ModuleDetails> md = HttpContext.Current.Session["modules"] as List <ModuleDetails>;
ModuleDetails md1 = md.Find(x => x.Module.Equals(Modules));
switch (Action)
{
case "View":
if (md1.View != true)
{
filterContext.Result = new RedirectToRouteResult(
new RouteValueDictionary(new { controller = "Home", action = "NoAccess" }));
}
break;
case "Edit":
if (md1.Edit != true)
{
filterContext.Result = new RedirectToRouteResult(
new RouteValueDictionary(new { controller = "Home", action = "NoAccess" }));
}
break;
case "Create":
if (md1.Create != true)
{
filterContext.Result = new RedirectToRouteResult(
new RouteValueDictionary(new { controller = "Home", action = "NoAccess" }));
}
break;
case "Delete":
if (md1.Delete != true)
{
filterContext.Result = new RedirectToRouteResult(
new RouteValueDictionary(new { controller = "Home", action = "NoAccess" }));
}
break;
}
}
}
base.OnActionExecuting(filterContext);
}
public ActionResult Index()
{
if (Session["modules"] != null)
{
List <ModuleDetails> md = Session["modules"] as List <ModuleDetails>;
ModuleDetails md1 = md.Find(x => x.Module.Equals("Staff"));
ViewBag.Module = md1.Module;
ViewBag.Create = md1.Create;
ViewBag.Edit = md1.Edit;
ViewBag.Delete = md1.Delete;
}
return(View());
}
public async Task HelpSearchGroup([Remainder] string moduleName)
{
moduleName = string.Join(" ", moduleName.Trim().Split(' '));
ModuleDetails module = Commands.CommandSet.FindModule(moduleName, Context);
if (module == null)
{
await ReplyAsync($"No module with the name `{moduleName}` exists").ConfigureAwait(false);
}
else
{
await ReplyAsync(embed : await help.BuildModuleHelpAsync(Context, module, false).ConfigureAwait(false)).ConfigureAwait(false);
}
}
public ActionResult AddToModule(ModuleDetails addmodule)
{
try
{
db.ModuleDetailsProp.Add(addmodule);
ViewBag.message = "Added Module Successfully!";
db.SaveChanges();
}
catch (Exception e)
{
ViewBag.message = e.Message;
}
return(View());
}
private async Task <DialogTurnResult> ExamorCaFavAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
if (!_luisRecognizer.IsConfigured)
{
await stepContext.Context.SendActivityAsync(
MessageFactory.Text("NOTE: LUIS is not configured. To enable all capabilities, add 'LuisAppId', 'LuisAPIKey' and 'LuisAPIHostName' to the web.config file.", inputHint: InputHints.IgnoringInput), cancellationToken);
return(await stepContext.NextAsync(null, cancellationToken));
}
var luisResult = await _luisRecognizer.RecognizeAsync <Luis.Conversation>(stepContext.Context, cancellationToken);
var moduleDetails = new ModuleDetails()
{
ModuleName = luisResult.Entities.Module,
};
switch (luisResult.TopIntent().intent)
{
case Luis.Conversation.Intent.endConversation:
// Transition to EndConversation Dialog
return(await stepContext.BeginDialogAsync(nameof(EndConversationDialog)));
case Luis.Conversation.Intent.discussModule:
var messageText = $"Ok! Why do you like the module?";
var elsePromptMessage = new PromptOptions {
Prompt = MessageFactory.Text(messageText, messageText, InputHints.ExpectingInput)
};
return(await stepContext.PromptAsync(nameof(TextPrompt), elsePromptMessage, cancellationToken));
case Luis.Conversation.Intent.None:
// Catch all for unhandled intents
var didntUnderstandMessageText2 = $"Sorry, I didn't understand that. Could you please rephrase";
var elsePromptMessage2 = new PromptOptions {
Prompt = MessageFactory.Text(didntUnderstandMessageText2, didntUnderstandMessageText2, InputHints.ExpectingInput)
};
stepContext.ActiveDialog.State[key : "stepIndex"] = (int)stepContext.ActiveDialog.State["stepIndex"] - 1;
return(await stepContext.PromptAsync(nameof(TextPrompt), elsePromptMessage2, cancellationToken));
default:
var messageText2 = $"Ok! Why do you like the module?";
var elsePromptMessage3 = new PromptOptions {
Prompt = MessageFactory.Text(messageText2, messageText2, InputHints.ExpectingInput)
};
return(await stepContext.PromptAsync(nameof(TextPrompt), elsePromptMessage3, cancellationToken));
}
}
public ActionResult ViewMemberships()
{
if (Session["modules"] != null)
{
List <ModuleDetails> md = Session["modules"] as List <ModuleDetails>;
ModuleDetails md1 = md.Find(x => x.Module.Equals("Membership"));
ViewBag.Create = md1.Create;
ViewBag.Edit = md1.Edit;
ViewBag.Delete = md1.Delete;
}
List <Membership> data = memOpt.getAllMembership();
model.membership = data;
return(View(model));
}
public ActionResult Index()
{
if (Session["modules"] != null)
{
List <ModuleDetails> md = Session["modules"] as List <ModuleDetails>;
ModuleDetails md1 = md.Find(x => x.Module.Equals("Point of Sale"));
ViewBag.Create = md1.Create;
ViewBag.Edit = md1.Edit;
ViewBag.Delete = md1.Delete;
}
List <Stocks> stocks = po.getAllStocks();
List <Product> product = po.getAllProducts();
model.products = product;
model.stocks = stocks;
return(View(model));
}
public string getDefaultPermission()
{
RoleOperation ro = new RoleOperation();
List <Role> data = ro.getRoles();
ModuleDetails md = new ModuleDetails();
List <ModuleDetails> det = new List <ModuleDetails>();
foreach (var d in data)
{
det.Add(new ModuleDetails {
Module = d.Roles, status = "off"
});
}
string js = JsonConvert.SerializeObject(det);
return(js);
}
static ModuleDetails GetModuleDetails(ModuleSpec moduleSpec)
{
var moduleDetails = new ModuleDetails
{
Id = Guid.NewGuid().ToString(),
Name = moduleSpec.Name,
Type = moduleSpec.Type,
Status = new Status {
ExitStatus = null, RuntimeStatus = new RuntimeStatus {
Status = "Created", Description = "Created"
}, StartTime = null
},
Config = moduleSpec.Config
};
return(moduleDetails);
}
public ActionResult Index()
{
if (Session["modules"] != null)
{
List <ModuleDetails> md = Session["modules"] as List <ModuleDetails>;
ModuleDetails md1 = md.Find(x => x.Module.Equals("Point of Sale"));
ViewBag.Create = md1.Create;
ViewBag.Edit = md1.Edit;
ViewBag.Delete = md1.Delete;
}
List <ProductType> productTypes = po.getAllProductType();
model.prodTypeList = productTypes;
model.ProductType = new ProductType();
return(View(model));
}
internal static void LoadISSWithModuleDetails(ModuleDetails moduleDetails, InitialSessionState iss)
{
PSSnapInException pSSnapInException = new PSSnapInException();
if (moduleDetails.Functions.Count > 0)
{
iss.Commands.Add(moduleDetails.Functions.FirstOrDefault());
}
if (moduleDetails.PSModule.Length > 0)
{
iss.ImportPSModule(new string[] { moduleDetails.PSModule });
}
if (moduleDetails.PSSnapIn.Length > 0)
{
iss.ImportPSSnapIn(moduleDetails.PSSnapIn, out pSSnapInException);
}
}
private async Task <DialogTurnResult> GetInfoAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
if (!_luisRecognizer.IsConfigured)
{
await stepContext.Context.SendActivityAsync(
MessageFactory.Text("NOTE: LUIS is not configured. To enable all capabilities, add 'LuisAppId', 'LuisAPIKey' and 'LuisAPIHostName' to the web.config file.", inputHint: InputHints.IgnoringInput), cancellationToken);
return(await stepContext.NextAsync(null, cancellationToken));
}
var luisResult = await _luisRecognizer.RecognizeAsync <Luis.Conversation>(stepContext.Context, cancellationToken);
var moduleDetails = new ModuleDetails()
{
Lecturer = luisResult.Entities.Lecturer,
Opinion = luisResult.Entities.Opinion,
};
if (luisResult.TopIntent().Equals(Luis.Conversation.Intent.endConversation))
{
return(await stepContext.BeginDialogAsync(nameof(EndConversationDialog)));;
}
if (luisResult.TopIntent().Equals(Luis.Conversation.Intent.None))
{
var didntUnderstandMessageText2 = $"Sorry, I didn't understand that. Could you please rephrase)";
var elsePromptMessage2 = new PromptOptions {
Prompt = MessageFactory.Text(didntUnderstandMessageText2, didntUnderstandMessageText2, InputHints.ExpectingInput)
};
stepContext.ActiveDialog.State[key : "stepIndex"] = (int)stepContext.ActiveDialog.State["stepIndex"] - 1;
return(await stepContext.PromptAsync(nameof(TextPrompt), elsePromptMessage2, cancellationToken));
}
var messageText = $"That's interesting to know!";
var elsePromptMessage = MessageFactory.Text(messageText, messageText, InputHints.ExpectingInput);
await stepContext.Context.SendActivityAsync(elsePromptMessage, cancellationToken);
var message = $"Would you like to talk about another aspect of university?.";
var messageFac = new PromptOptions {
Prompt = MessageFactory.Text(message, message, InputHints.ExpectingInput)
};
return(await stepContext.PromptAsync(nameof(TextPrompt), messageFac, cancellationToken));
}
private async Task <DialogTurnResult> NextDialogAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
if (!_luisRecognizer.IsConfigured)
{
await stepContext.Context.SendActivityAsync(
MessageFactory.Text("NOTE: LUIS is not configured. To enable all capabilities, add 'LuisAppId', 'LuisAPIKey' and 'LuisAPIHostName' to the web.config file.", inputHint: InputHints.IgnoringInput), cancellationToken);
return(await stepContext.NextAsync(null, cancellationToken));
}
var luisResult = await _luisRecognizer.RecognizeAsync <Luis.Conversation>(stepContext.Context, cancellationToken);
var moduleDetails = new ModuleDetails()
{
ModuleName = luisResult.Entities.Module,
};
if (luisResult.TopIntent().Equals(Luis.Conversation.Intent.discussLecturer))
{
return(await stepContext.BeginDialogAsync(nameof(LecturerDialog), moduleDetails, cancellationToken));
}
if (luisResult.TopIntent().Equals(Luis.Conversation.Intent.discussExtracurricular))
{
return(await stepContext.BeginDialogAsync(nameof(ExtracurricularDialog), moduleDetails, cancellationToken));;
}
if (luisResult.TopIntent().Equals(Luis.Conversation.Intent.discussCampus))
{
return(await stepContext.BeginDialogAsync(nameof(CampusDialog), moduleDetails, cancellationToken));;
}
if (luisResult.TopIntent().Equals(Luis.Conversation.Intent.endConversation))
{
return(await stepContext.BeginDialogAsync(nameof(EndConversationDialog), moduleDetails, cancellationToken));;
}
if (luisResult.TopIntent().Equals(Luis.Conversation.Intent.None))
{
var didntUnderstandMessageText = $"Sorry, I didn't get that. Please try rephrasing your message(intent was {luisResult.TopIntent().intent})";
var didntUnderstandMessage = MessageFactory.Text(didntUnderstandMessageText, didntUnderstandMessageText, InputHints.IgnoringInput);
await stepContext.Context.SendActivityAsync(didntUnderstandMessage, cancellationToken);
}
var messageText = $"Would you spend much time on campus after your lectures and tutorials?";
var elsePromptMessage = MessageFactory.Text(messageText, messageText, InputHints.ExpectingInput);
return(await stepContext.BeginDialogAsync(nameof(ExtracurricularDialog), moduleDetails, cancellationToken));;
}
public ActionResult Index()
{
if (Session["modules"] != null)
{
List <ModuleDetails> md = Session["modules"] as List <ModuleDetails>;
ModuleDetails md1 = md.Find(x => x.Module.Equals("Training Schedule"));
ViewBag.Module = md1.Module;
ViewBag.Create = md1.Create;
ViewBag.Edit = md1.Edit;
ViewBag.Delete = md1.Delete;
}
List <Classes> cl = classOpt.getAllClasses();
List <Staff> st = staffOp.getAllStaff();
model.classes = cl;
model.staff = st;
TempData["stafflist"] = getList(st);
return(View(model));
}
public ActionResult Subscriptions()
{
if (Session["modules"] != null)
{
List <ModuleDetails> md = Session["modules"] as List <ModuleDetails>;
ModuleDetails md1 = md.Find(x => x.Module.Equals("Membership"));
ViewBag.Create = md1.Create;
ViewBag.Edit = md1.Edit;
ViewBag.Delete = md1.Delete;
}
List <Member> memdata = mOpt.getAllMembers();
List <Membership> mshOpt = memOpt.getAllMembership();
List <Subscriptions> sub1 = subs.getAllSubscriptions();
model.member = memdata;
model.membrshp = mshOpt;
model.subscription = sub1;
return(View(model));
}
public ActionResult FindSalesTax()
{
if (Session["modules"] != null)
{
List <ModuleDetails> md = Session["modules"] as List <ModuleDetails>;
ModuleDetails md1 = md.Find(x => x.Module.Equals("SalesTax"));
ViewBag.Module = md1.Module;
ViewBag.Create = md1.Create;
ViewBag.Edit = md1.Edit;
ViewBag.Delete = md1.Delete;
}
List <SalesTax> data = new List <SalesTax>();
var dt = taxOperations.getAllSalesTax();
data = dt.ToList();
model.salestax = data;
return(View(model));
}
public ActionResult AssignClass()
{
if (Session["modules"] != null)
{
List <ModuleDetails> md = Session["modules"] as List <ModuleDetails>;
ModuleDetails md1 = md.Find(x => x.Module.Equals("Training Schedule"));
ViewBag.Module = md1.Module;
ViewBag.Create = md1.Create;
ViewBag.Edit = md1.Edit;
ViewBag.Delete = md1.Delete;
}
List <ClassSubscriptions> list = classOpt.getAllClassSubs();
List <Member> memlist = memOpt.getAllMembers();
List <Classes> classlist = classOpt.getAllClasses();
model.classSubs = list;
model.members = memlist;
model.classlist = classlist;
return(View(model));
}
private async Task <DialogTurnResult> GetInfoAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
if (!_luisRecognizer.IsConfigured)
{
await stepContext.Context.SendActivityAsync(
MessageFactory.Text("NOTE: LUIS is not configured. To enable all capabilities, add 'LuisAppId', 'LuisAPIKey' and 'LuisAPIHostName' to the web.config file.", inputHint: InputHints.IgnoringInput), cancellationToken);
return(await stepContext.NextAsync(null, cancellationToken));
}
var luisResult = await _luisRecognizer.RecognizeAsync <Luis.Conversation>(stepContext.Context, cancellationToken);
var moduleDetails = new ModuleDetails()
{
Lecturer = luisResult.Entities.Lecturer,
Opinion = luisResult.Entities.Opinion,
};
switch (luisResult.TopIntent().intent)
{
case Luis.Conversation.Intent.None:
var didntUnderstandMessageText = $"I didn't understand that. Could you please rephrase";
var elsePromptMessage2 = new PromptOptions {
Prompt = MessageFactory.Text(didntUnderstandMessageText, didntUnderstandMessageText, InputHints.ExpectingInput)
};
stepContext.ActiveDialog.State[key : "stepIndex"] = (int)stepContext.ActiveDialog.State["stepIndex"] - 1;
return(await stepContext.PromptAsync(nameof(TextPrompt), elsePromptMessage2, cancellationToken));
case Luis.Conversation.Intent.endConversation:
return(await stepContext.BeginDialogAsync(nameof(EndConversationDialog)));;
default:
var messageText = $"Ok. Presumably they are not all like this?";
var messageFac = new PromptOptions {
Prompt = MessageFactory.Text(messageText, messageText, InputHints.ExpectingInput)
};
return(await stepContext.PromptAsync(nameof(TextPrompt), messageFac, cancellationToken));
}
}
/// <summary>
/// Builds an embed displaying module help and command list.
/// </summary>
/// <param name="context">The context of the command.</param>
/// <param name="module">The module to build the help for.</param>
/// <returns>The built embed.</returns>
public async Task <Embed> BuildModuleHelpAsync(ICommandContext context, ModuleDetails module, bool showAll)
{
var(prefix, lockContext) = await GetPrefixAndLockContextAsync(context).ConfigureAwait(false);
var embed = new EmbedBuilder {
Color = configParser.EmbedColor,
Title = FormatModuleTitle(lockContext, module),
Description = module.Summary,
};
List <CommandDetails> usableCommands = (showAll ? module : module.GetUsableCommands(context)).ToList();
embed.AddField("Commands", usableCommands.Any() ? FormatCommandList(usableCommands) : "*(no usable commands)*");
if (!string.IsNullOrWhiteSpace(module.Remarks))
{
embed.AddField("Remarks", module.Remarks);
}
return(embed.Build());
}
ModuleRuntimeInfo <T> GetModuleRuntimeInfo <T>(ModuleDetails moduleDetails)
{
ExitStatus exitStatus = moduleDetails.Status.ExitStatus;
if (exitStatus == null || !long.TryParse(exitStatus.StatusCode, out long exitCode))
{
exitCode = 0;
}
Option <DateTime> exitTime = exitStatus == null?Option.None <DateTime>() : Option.Some(exitStatus.ExitTime);
Option <DateTime> startTime = !moduleDetails.Status.StartTime.HasValue ? Option.None <DateTime>() : Option.Some(moduleDetails.Status.StartTime.Value);
if (!Enum.TryParse(moduleDetails.Status.RuntimeStatus.Status, true, out ModuleStatus status))
{
status = ModuleStatus.Unknown;
}
if (!(moduleDetails.Config.Settings is JObject jobject))
{
throw new InvalidOperationException($"Module config is of type {moduleDetails.Config.Settings.GetType()}. Expected type JObject");
}
var config = jobject.ToObject <T>();
var moduleRuntimeInfo = new ModuleRuntimeInfo <T>(
moduleDetails.Name,
moduleDetails.Type,
status,
moduleDetails.Status.RuntimeStatus.Description,
exitCode,
startTime,
exitTime,
config);
return(moduleRuntimeInfo);
}
private string FormatModuleTitle(IDbLockableContext lockContext, ModuleDetails module)
{
return($"{configParser.EmbedPrefix}{FormatLocked(lockContext, module)}**{module.Name} Module**");
}
/// <summary>
/// Formats a module to show the locked or not locked symbol when it is locked.
/// </summary>
private string FormatModuleLocked(IDbLockableContext lockContext, ModuleDetails module)
{
return(module.IsModuleLocked(lockContext) ? Locked : NotLocked);
}
public Task <ModuleDetails> CreateModuleAsync(string apiVersion, ModuleSpec module)
{
ModuleDetails createdModule = this.modules.GetOrAdd(module.Name, (n) => GetModuleDetails(module));
return(Task.FromResult(createdModule));
}
private string FormatLockable(ModuleDetails module)
{
return(module.IsLockable ? Lockable : NotLockable);
}
public async Task GetModulesTest()
{
// Arrange
string module1Hash = Guid.NewGuid().ToString();
var module1 = new ModuleDetails
{
Id = Guid.NewGuid().ToString(),
Name = "module1",
Status = new Status
{
StartTime = new DateTime(2010, 01, 02, 03, 04, 05),
RuntimeStatus = new RuntimeStatus {
Status = "Running", Description = "running"
},
ExitStatus = null
},
Type = "docker",
Config = new Config
{
Env = new ObservableCollection <EnvVar>(new List <EnvVar> {
new EnvVar {
Key = "k1", Value = "v1"
}
}),
Settings = JObject.FromObject(new TestConfig(module1Hash))
}
};
string module2Hash = Guid.NewGuid().ToString();
var module2 = new ModuleDetails
{
Id = Guid.NewGuid().ToString(),
Name = "module2",
Status = new Status
{
StartTime = new DateTime(2011, 02, 03, 04, 05, 06),
RuntimeStatus = new RuntimeStatus {
Status = "Stopped", Description = "stopped"
},
ExitStatus = new ExitStatus {
ExitTime = new DateTime(2011, 02, 03, 05, 06, 07), StatusCode = "5"
}
},
Type = "docker",
Config = new Config
{
Env = new ObservableCollection <EnvVar>(new List <EnvVar> {
new EnvVar {
Key = "k2", Value = "v2"
}
}),
Settings = JObject.FromObject(new TestConfig(module2Hash))
}
};
var modules = new List <ModuleDetails> {
module1, module2
};
var moduleManager = Mock.Of <IModuleManager>(m => m.GetModules(It.IsAny <CancellationToken>()) == Task.FromResult(modules.AsEnumerable()));
IRuntimeInfoProvider runtimeInfoProvider = new RuntimeInfoProvider <TestConfig>(moduleManager);
// Act
List <ModuleRuntimeInfo> runtimeInfos = (await runtimeInfoProvider.GetModules(CancellationToken.None)).ToList();
// Assert
Assert.NotNull(runtimeInfos);
Assert.Equal(2, runtimeInfos.Count);
ModuleRuntimeInfo runtimeInfo1 = runtimeInfos[0];
Assert.Equal("module1", runtimeInfo1.Name);
Assert.Equal(new DateTime(2010, 01, 02, 03, 04, 05), runtimeInfo1.StartTime.OrDefault());
Assert.Equal(ModuleStatus.Running, runtimeInfo1.ModuleStatus);
Assert.Equal("running", runtimeInfo1.Description);
Assert.Equal(0, runtimeInfo1.ExitCode);
Assert.False(runtimeInfo1.ExitTime.HasValue);
Assert.Equal((runtimeInfo1 as ModuleRuntimeInfo <TestConfig>)?.Config.ImageHash, module1Hash);
ModuleRuntimeInfo runtimeInfo2 = runtimeInfos[1];
Assert.Equal("module2", runtimeInfo2.Name);
Assert.Equal(new DateTime(2011, 02, 03, 04, 05, 06), runtimeInfo2.StartTime.OrDefault());
Assert.Equal(ModuleStatus.Stopped, runtimeInfo2.ModuleStatus);
Assert.Equal("stopped", runtimeInfo2.Description);
Assert.Equal(5, runtimeInfo2.ExitCode);
Assert.Equal(new DateTime(2011, 02, 03, 05, 06, 07), runtimeInfo2.ExitTime.OrDefault());
Assert.Equal((runtimeInfo2 as ModuleRuntimeInfo <TestConfig>)?.Config.ImageHash, module2Hash);
}
/// <summary>
/// Create the Runspace pool.
/// For remote runspaces, load the datatypes optionally to support serialization
/// For local commands, load the modules and snapins required or requested
/// </summary>
/// <param name="commandInfo"></param>
/// <param name="pSHost"></param>
/// <param name="maxRunspaces"></param>
/// <param name="debugStrings"></param>
/// <param name="useRemotePS"></param>
/// <param name="loadAllTypedata"></param>
/// <param name="modules"></param>
/// <param name="modulesPath"></param>
/// <param name="snapIns"></param>
/// <param name="variableEntries"></param>
/// <returns></returns>
internal static RunspacePool CreateRunspacePool(CommandInfo commandInfo,
PSHost pSHost,
int maxRunspaces,
out List <string> debugStrings,
PSSession useRemotePS,
bool loadAllTypedata,
string[] modules = null, string[] modulesPath = null, string[] snapIns = null, IList <SessionStateVariableEntry> variableEntries = null)
{
debugStrings = new List <string>();
RunspaceConnectionInfo runspaceConnectionInfo = null;
Hashtable modulePrivatedata = commandInfo.Module?.PrivateData as Hashtable;
ModuleDetails moduleDetails = GetModuleDetails(commandInfo, debugStrings);
//special handling for remote PSsession commands
if (moduleDetails.IsFromRemotingModule || useRemotePS != null)
{
if (useRemotePS != null)
{
debugStrings.Add("Using the supplied remote PSSession");
runspaceConnectionInfo = useRemotePS.Runspace.ConnectionInfo;
}
else
{
debugStrings.Add("Using remote PSSession to execute the command");
PSObject remotepSModule = ScriptBlock.Create(
string.Format("Get-Module {0}", commandInfo.ModuleName)).InvokeReturnAsIs() as PSObject;
if (remotepSModule.BaseObject is PSModuleInfo remotepSModuleInfo)
{
PSObject remotePs = ScriptBlock.Create(
string.Format("Get-PSSession | Where-Object{{$_.state -eq 'opened' -and (\"{0}\").Contains($_.ComputerName)}} | Select-Object -First 1",
remotepSModuleInfo.Description)).InvokeReturnAsIs() as PSObject;
if (remotePs.BaseObject is PSSession remotePSSession)
{
runspaceConnectionInfo = remotePSSession.Runspace.ConnectionInfo;
if (modules != null || modulesPath != null)
{
debugStrings.Add("Modules were specified to load, but they will not be loaded as the command supplied is from a remote PSSession");
}
}
else
{
debugStrings.Add(string.Format("Command - Get-PSSession | Where-Object{{$_.state -eq 'opened' -and (\"{0}\").Contains($_.ComputerName)}} " +
"| Select-Object -First 1 - was ran to find the PSSession", remotepSModuleInfo.Description));
throw new Exception("Unable to find a PSSession to use. You may try passing the PSSession to use using Parameter -UseRemotePSSession");
}
}
}
debugStrings.Add(string.Format("Using connection info {0}", runspaceConnectionInfo.ComputerName));
TypeTable typeTable = TypeTable.LoadDefaultTypeFiles();
if (loadAllTypedata)
{
Collection <PSObject> typeDatas = ScriptBlock.Create("Get-TypeData").Invoke();
foreach (PSObject typeData in typeDatas)
{
TypeData t = (TypeData)typeData.BaseObject;
try
{
typeTable.AddType(t);
debugStrings.Add(string.Format("Added typedata{0}", t.TypeName));
}
catch (Exception e)
{
debugStrings.Add(string.Format("Unable to add typeData {0}. Error {1}", t.TypeName, e.Message));
}
}
}
return(RunspaceFactory.CreateRunspacePool(1, Environment.ProcessorCount, runspaceConnectionInfo, pSHost, typeTable));
}
InitialSessionState iss = InitialSessionState.CreateDefault2();
List <string> modulesToLoad = new List <String>();
List <string> snapInsToLoad = new List <string>();
PSSnapInException pSSnapInException = new PSSnapInException();
if (modules?.Count() > 0)
{
modulesToLoad.AddRange(modules);
}
if (snapIns?.Count() > 0)
{
snapInsToLoad.AddRange(snapIns);
}
//Populate ISS with the snapins and modules from the moduleDetails
LoadISSWithModuleDetails(moduleDetails, iss);
//Load user specified snapins and modules
if (modules?.Count() > 0 && modules.Contains("All", StringComparer.OrdinalIgnoreCase))
{
var modulesAvailable = ScriptBlock.Create("Get-Module -ListAvailable | Select-Object -ExpandProperty Name").Invoke();
modulesToLoad.AddRange(from module in modulesAvailable select module.BaseObject as string);
debugStrings.Add(string.Format("Loaded all the available modules on this computer, {0} modules found", modulesToLoad.Count));
}
if (modules?.Count() > 0 && modules.Contains("Loaded", StringComparer.OrdinalIgnoreCase))
{
var modulesLoaded = ScriptBlock.Create("Get-Module | Select-Object -ExpandProperty Name").Invoke();
modulesToLoad.AddRange(from module in modulesLoaded select module.BaseObject as string);
debugStrings.Add(string.Format("Loaded the modules loaded on current Runspace, {0} modules found", modulesLoaded.Count));
}
debugStrings.Add("Loading Modules:");
debugStrings.AddRange(modulesToLoad);
iss.ImportPSModule(modulesToLoad.ToArray());
snapInsToLoad.ForEach(s => iss.ImportPSSnapIn(s, out pSSnapInException));
if (variableEntries != null)
{
iss.Variables.Add(variableEntries);
}
return(RunspaceFactory.CreateRunspacePool(1, maxRunspaces, iss, pSHost));
}
private async Task <DialogTurnResult> GetInfoAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
if (!_luisRecognizer.IsConfigured)
{
await stepContext.Context.SendActivityAsync(
MessageFactory.Text("NOTE: LUIS is not configured. To enable all capabilities, add 'LuisAppId', 'LuisAPIKey' and 'LuisAPIHostName' to the web.config file.", inputHint: InputHints.IgnoringInput), cancellationToken);
return(await stepContext.NextAsync(null, cancellationToken));
}
var luisResult = await _luisRecognizer.RecognizeAsync <Luis.Conversation>(stepContext.Context, cancellationToken);
var moduleDetails = new ModuleDetails()
{
Lecturer = luisResult.Entities.Lecturer,
Opinion = luisResult.Entities.Opinion,
};
if (luisResult.TopIntent().Equals(Luis.Conversation.Intent.endConversation))
{
string[] stringPos;
stringPos = new string[21] {
"yes", "ye", "yep", "ya", "yas", "totally", "sure", "ok", "k", "okey", "okay", "alright", "sounds good", "sure thing", "of course", "gladly", "definitely", "indeed", "absolutely", "yes please", "please"
};
string[] stringNeg;
stringNeg = new string[9] {
"no", "nope", "no thanks", "unfortunately not", "apologies", "nah", "not now", "no can do", "no thank you"
};
var messageText = $"Are you sure you want to end our conversation?";
var elsePromptMessage = new PromptOptions {
Prompt = MessageFactory.Text(messageText, messageText, InputHints.ExpectingInput)
};
await stepContext.PromptAsync(nameof(TextPrompt), elsePromptMessage, cancellationToken);
if (!_luisRecognizer.IsConfigured)
{
await stepContext.Context.SendActivityAsync(
MessageFactory.Text("NOTE: LUIS is not configured. To enable all capabilities, add 'LuisAppId', 'LuisAPIKey' and 'LuisAPIHostName' to the web.config file.", inputHint: InputHints.IgnoringInput), cancellationToken);
return(await stepContext.NextAsync(null, cancellationToken));
}
var luisResult2 = await _luisRecognizer.RecognizeAsync <Luis.Conversation>(stepContext.Context, cancellationToken);
if (stringPos.Any(luisResult2.Text.ToLower().Contains))
{
ConversationData.PromptedUserForName = true;
await stepContext.Context.SendActivityAsync(
MessageFactory.Text("Goodbye", inputHint: InputHints.IgnoringInput), cancellationToken);
return(await stepContext.EndDialogAsync(null, cancellationToken));
}
if (stringNeg.Any(luisResult2.Text.ToLower().Contains))
{
var messageTextNeg = $"Our conversation will continue.";
var elsePromptMessageNeg = new PromptOptions {
Prompt = MessageFactory.Text(messageTextNeg, messageTextNeg, InputHints.ExpectingInput)
};
await stepContext.PromptAsync(nameof(TextPrompt), elsePromptMessageNeg, cancellationToken);
}
// Transition to Campus Dialog
return(await stepContext.BeginDialogAsync(nameof(CampusDialog)));
}
if (luisResult.TopIntent().Equals(Luis.Conversation.Intent.discussExtracurricular))
{
var messageText = $"Ok. Should we discuss more on the topic of university?";
var elsePromptMessage = new PromptOptions {
Prompt = MessageFactory.Text(messageText, messageText, InputHints.ExpectingInput)
};
await stepContext.PromptAsync(nameof(TextPrompt), elsePromptMessage, cancellationToken);
}
if (luisResult.TopIntent().Equals(Luis.Conversation.Intent.None))
{
var didntUnderstandMessageText = $"I didn't understand that. Could you please rephrase";
var elsePromptMessage = new PromptOptions {
Prompt = MessageFactory.Text(didntUnderstandMessageText, didntUnderstandMessageText, InputHints.ExpectingInput)
};
stepContext.ActiveDialog.State[key : "stepIndex"] = (int)stepContext.ActiveDialog.State["stepIndex"] - 1;
return(await stepContext.PromptAsync(nameof(TextPrompt), elsePromptMessage, cancellationToken));
}
var messageText2 = $"Should we discuss more on the topic of university?";
var elsePromptMessage2 = new PromptOptions {
Prompt = MessageFactory.Text(messageText2, messageText2, InputHints.ExpectingInput)
};
return(await stepContext.PromptAsync(nameof(TextPrompt), elsePromptMessage2, cancellationToken));
}
public async Task ModulesTest()
{
// Arrange
IModuleManager client = new ModuleManagementHttpClient(this.serverUrl);
var moduleSpec = new ModuleSpec
{
Name = "Module1",
Type = "Docker",
Config = new Config
{
Env = new System.Collections.ObjectModel.ObservableCollection <EnvVar> {
new EnvVar {
Key = "E1", Value = "P1"
}
},
Settings = "{ \"image\": \"testimage\" }"
}
};
// Act
await client.CreateModuleAsync(moduleSpec);
ModuleDetails moduleDetails = (await client.GetModules(CancellationToken.None)).FirstOrDefault();
// Assert
Assert.NotNull(moduleDetails);
Assert.Equal("Module1", moduleDetails.Name);
Assert.NotNull(moduleDetails.Id);
Assert.Equal("Docker", moduleDetails.Type);
Assert.NotNull(moduleDetails.Status);
Assert.Equal("Created", moduleDetails.Status.RuntimeStatus.Status);
// Act
await client.StartModuleAsync(moduleSpec.Name);
moduleDetails = (await client.GetModules(CancellationToken.None)).FirstOrDefault();
// Assert
Assert.NotNull(moduleDetails);
Assert.Equal("Running", moduleDetails.Status.RuntimeStatus.Status);
// Act
await client.StopModuleAsync(moduleSpec.Name);
moduleDetails = (await client.GetModules(CancellationToken.None)).FirstOrDefault();
// Assert
Assert.NotNull(moduleDetails);
Assert.Equal("Stopped", moduleDetails.Status.RuntimeStatus.Status);
// Act - Stopping a stopped module should not throw
await client.StopModuleAsync(moduleSpec.Name);
moduleDetails = (await client.GetModules(CancellationToken.None)).FirstOrDefault();
// Assert
Assert.NotNull(moduleDetails);
Assert.Equal("Stopped", moduleDetails.Status.RuntimeStatus.Status);
// Act
await client.DeleteModuleAsync(moduleSpec.Name);
moduleDetails = (await client.GetModules(CancellationToken.None)).FirstOrDefault();
// Assert
Assert.Null(moduleDetails);
}
