public void Activate(PluginContext ctx)
{
ToolStripMenuItem mitem = null;
Container = ctx.Container;
foreach (var item in ctx.Container.MainMenu.Items.OfType <ToolStripMenuItem>())
{
if (item.Text == "Games")
{
mitem = item;
break;
}
}
if (mitem == null)
{
mitem = new ToolStripMenuItem("Games")
{
};
ctx.Container.MainMenu.Items.Add(mitem);
}
var g = new ToolStripMenuItem("Lines");
g.Click += G_Click;
mitem.DropDownItems.Add(g);
g = new ToolStripMenuItem("Puzzle");
g.Click += G_Click2;
mitem.DropDownItems.Add(g);
}
public void Initialize(IAppContainer container)
{
_script = new Script(CoreModules.Preset_HardSandbox);
_script.Options.DebugPrint = OnDebugPrint;
// register classes to Script
UserData.RegisterType <IAppContainer>();
UserData.RegisterType <IScriptingService>();
UserData.RegisterType <ILicenseService>();
UserData.RegisterType <IAuthorizationService>();
UserData.RegisterType <LicenseData>();
UserData.RegisterType <LicenseResult>();
UserData.RegisterType <LicenseControlledFeatures>();
//Script.GlobalOptions.CustomConverters.SetClrToScriptCustomConversion<LicenseResult>((s, l) => {
// return DynValue.NewNumber((int)l);
//});
//Script.GlobalOptions.CustomConverters.SetClrToScriptCustomConversion<LicenseControlledFeatures>((s, l) => DynValue.NewNumber((int)l));
DynValue c = UserData.Create(container);
DynValue lr = UserData.CreateStatic <LicenseResult>();
DynValue lcf = UserData.CreateStatic <LicenseControlledFeatures>();
_script.Globals.Set(nameof(AppContainer), c);
_script.Globals.Set(nameof(LicenseResult), lr);
_script.Globals.Set(nameof(LicenseControlledFeatures), lcf);
}
public BeforeSteps(IObjectContainer objectContainer)
{
this.objectContainer = objectContainer;
// Inject solution container
this.objectContainer.RegisterTypeAs <AppContainer, IAppContainer>();
appContainer = this.objectContainer.Resolve <IAppContainer>();
// Inject resources
this.objectContainer.RegisterTypeAs <ResourcesMapper, IResourcesMapper>();
// Inject appsettings configuration
var configurationRoot = new ConfigurationBuilder()
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables()
.Build();
var environment = configurationRoot.GetSection("AppConfiguration")["Environment"];
var configurationEnvironment = new ConfigurationBuilder()
.AddJsonFile($"appsettings.{environment}.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables()
.Build();
this.objectContainer.RegisterInstanceAs(configurationEnvironment);
}
public static IServiceProvider GetServiceProvider(IAppContainer appContainer)
{
var concrete = appContainer as AppContainer;
if (concrete == null)
{
throw new ArgumentException($"Invalid container type", "appContainer");
}
return new AutofacServiceProvider(concrete.Container);
}
public MainViewModel()
{
_appContainer = new AppContainer();
_scriptingService = _appContainer.ScriptingService;
_scriptingService.DebugPrint += _scriptingService_DebugPrint;
_commandText = string.Empty;
_outputText = string.Empty;
_runCommand = new DelegateCommand(OnRunCommand);
}
public static TService GetService <TService>(this IAppContainer container)
{
var middleware = (TService)container.ObjectProvider.TryGetInstance <IServiceProxy <TService> >();
if (null != middleware)
{
return(middleware);
}
return(container.Get <TService>());
}
public BeforeSteps(IObjectContainer objectContainer)
{
this.objectContainer = objectContainer;
// Inject app containers.
this.RegisterAppContainerToObjectContainer();
this.appContainers = this.objectContainer.Resolve <IAppContainer>();
// Inject configuration to object container
this.RegisterConfigurationToObjectContainer();
}
public override IAppContainer Build(AppSetup setup)
{
AppContainerBuilderBuildEventArgs appContainerBuilderBuildEventArgs
= new AppContainerBuilderBuildEventArgs(setup);
this.Building?.Invoke(this, appContainerBuilderBuildEventArgs);
IAppContainer appContainer = this.BuildAppContainer(setup);
this.Built?.Invoke(this, appContainerBuilderBuildEventArgs);
return(appContainer);
}
/// <summary>
/// Reference to the container for which the configured test-logger
/// should be returned.
/// </summary>
/// <param name="container">The container configured with a test-logger.</param>
/// <returns>Reference to the test-loger.</returns>
public static TestLogger GetTestLogger(this IAppContainer container)
{
var factory = container.LoggerFactory as TestLoggerFactory;
if (factory == null)
{
throw new InvalidOperationException(
"The test-logger has not been configured.");
}
return(factory.Logger);
}
/// <summary>
/// Configures the application container to use a test-logger.
/// </summary>
/// <param name="container">The container to configure.</param>
/// <returns>Reference to the configured container.</returns>
public static IAppContainer UseTestLogger(this IAppContainer container)
{
Check.NotNull(container, nameof(container));
container.WithConfig <LoggerConfig>(config =>
{
var factory = new TestLoggerFactory();
config.LogExceptions = true;
config.UseLoggerFactory(factory);
});
return(container);
}
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
// Add framework services.
services.AddMvc(options => {
options.UseHalFormatter();
});
// Create, Build, and Start the NetFusion container.
AppContainer = TestAppContainer.Create(_hostPlugin, services);
AppContainer
.Build()
.Start();
// Integrate the NetFusion container.
return(new AutofacServiceProvider(AppContainer.Services));
}
// Sets mock broker settings and mock message broker. These specified instances will be
// registered overriding the default instances.
private ContainerTest AddTestMocks(IAppContainer container, BrokerSettings settings, IMessageBroker broker)
{
container.WithConfig <AutofacRegistrationConfig>(config =>
{
config.Build = builder =>
{
builder.RegisterInstance(settings)
.As <BrokerSettings>()
.SingleInstance();
builder.RegisterInstance(broker)
.As <IMessageBroker>()
.SingleInstance();
};
});
return(new ContainerTest((AppContainer)container));
}
public IAppContainerFixture()
{
var licenseService = new Mock <ILicenseService>();
var licenseModules = new HashSet <LicenseModules>()
{
LicenseModules.MODULE1
};
licenseService.Setup(l => l.Modules).Returns(licenseModules);
var appContainer = new Mock <IAppContainer>();
appContainer.Setup(c => c.LicenseService).Returns(licenseService.Object);
var authService = new AuthorizationService();
appContainer.Setup(c => c.AuthorizationService).Returns(authService);
authService.Initialize(appContainer.Object);
authService.SetLicenseControlledFeatures();
AppContainer = appContainer.Object;
}
public void Initialize(IAppContainer container)
{
_licenseService = container.LicenseService;
}
public ContainerTest(IAppContainer container)
{
Check.NotNull(container, nameof(container));
_container = container;
}
public void Initialize(IAppContainer container)
{
_licenseService = container.LicenseService;
SetAccessToFeatures();
}
public void Initialize(IAppContainer container)
{
}
public static ISignalRService <TDto, TRequest> GetSignalRService <TDto, TRequest>(this IAppContainer container)
where TRequest : IHubRequest <TDto>
{
return(container.ObjectProvider.GetInstance <ISignalRService <TDto, TRequest> >());
}
public static ISignalRService <TDto, TRequest> GetSignalRService <TDto, TRequest>(this IAppContainer container, TRequest request)
where TRequest : IHubRequest <TDto>
{
var explicitArg = new ExplicitArguments();
explicitArg.Set(request);
return(container.ObjectProvider.GetInstance <ISignalRService <TDto, TRequest> >(explicitArg));
}
