private void ConfigureHttpInterfaces(ConfigurationExpression x)
{
// Woot!! Interfaces for HttpContext stuff! Goodbye to nasty unmockable
// abstract base classes.
// http://haacked.com/archive/2007/09/09/ihttpcontext-and-other-interfaces-for-your-duck-typing-benefit.aspx
// Update: the third party library in that post causes problems in production if multiple
// requests during the bootstrapping process. I made hand-rolled proxies instead, which you can get here:
// http://github.com/jonkruger/httpinterfaces
x.For<IHttpApplication>().Use(
c => WebContext.Cast(HttpContext.Current.ApplicationInstance));
x.For<IHttpApplicationState>().Use(
c => WebContext.Cast(HttpContext.Current.Application));
x.For<IHttpCachePolicy>().Use(
c => WebContext.Cast(HttpContext.Current.Response.Cache));
x.For<IHttpClientCertificate>().Use(
c => WebContext.Cast(HttpContext.Current.Request.ClientCertificate));
x.For<IHttpContext>().Use(
c => WebContext.Cast(HttpContext.Current));
x.For<IHttpFileCollection>().Use(
c => WebContext.Cast(HttpContext.Current.Request.Files));
x.For<IHttpModuleCollection>().Use(
c => WebContext.Cast(HttpContext.Current.ApplicationInstance.Modules));
x.For<IHttpRequest>().Use(
c => WebContext.Cast(HttpContext.Current.Request));
x.For<IHttpResponse>().Use(
c => WebContext.Cast(HttpContext.Current.Response));
x.For<IHttpServerUtility>().Use(
c => WebContext.Cast(HttpContext.Current.Server));
x.For<IHttpSession>().Use(
c => WebContext.Cast(HttpContext.Current.Session));
x.For<ITraceContext>().Use(
c => WebContext.Cast(HttpContext.Current.Trace));
}
private static void ConfigureContainer(ConfigurationExpression container)
{
//Swap out the default ContentRenderer for our custom
container.For<IContentRenderer>().Use<ErrorHandlingContentRenderer>();
//Implementations for custom interfaces can be registered here.
}
public void Configure(ConfigurationExpression cfg, IFoundationConfigurator foundationConfigurator)
{
if (foundationConfigurator.UseQueryContainer)
{
cfg.AddRegistry(new QueryRegistery());
cfg.For<IQueryRegistery>().Use<QueryRegistery>();
}
if (foundationConfigurator.UseBuseinssManagers)
{
cfg.AddRegistry(new BusinessManagerRegistery());
cfg.For<IBusinessManagerRegistery>().Use<BusinessManagerRegistery>();
cfg.For<IBusinessManagerInvocationLogger>(foundationConfigurator.Business.BusinessInvocationLogger, true);
}
if (foundationConfigurator.UseEmailing)
{
cfg.AddRegistry(new EmailRegistery());
cfg.For<IEmailLogger>(foundationConfigurator.Business.EmailLogger);
}
if (foundationConfigurator.Web.FlashMessenger != null)
{
cfg.For<IFlashMessenger>(foundationConfigurator.Web.FlashMessenger);
}
cfg.AddRegistry(new SecurityRegistery());
}
protected virtual void InitializeActivityLogging(ConfigurationExpression x)
{
x.For<IActivityLogPathProvider>().HybridHttpOrThreadLocalScoped().Use<ActivityLogPathProvider>();
x.For<ILogManager>().HybridHttpOrThreadLocalScoped().Use<TpLogManager>();
x.For<Log4NetFileRepositoryMock>().Singleton().Use<Log4NetFileRepositoryMock>();
x.Forward<Log4NetFileRepositoryMock, ILog4NetFileRepository>();
}
public static void AddGitChangeTypes(ConfigurationExpression initializer)
{
initializer.For<IGitChangedFile>().Use<Add>().Named("A");
initializer.For<IGitChangedFile>().Use<Modify>().Named("M");
initializer.For<IGitChangedFile>().Use<Delete>().Named("D");
initializer.For<IGitChangedFile>().Use<RenameEdit>().Named("R");
}
private static void SetDefaultClickatellClient(ClickatellConfigFileSettings clickatellConfigFileSettings,
ConfigurationExpression x)
{
var clickatellClient = new ClickatellClient(clickatellConfigFileSettings);
x.For<ClickatellClient>()
.Use(new IgnoreAuthErrorClickatellClient(clickatellConfigFileSettings,
new IgnoreNoCreditErrorClickatellClient(clickatellConfigFileSettings, clickatellClient)));
}
protected override void Configure(ConfigurationExpression cfg)
{
cfg.Scan(x =>
{
x.TheCallingAssembly();
x.LookForRegistries();
});
}
public static IPipelineGraph For(Action<ConfigurationExpression> action)
{
var expression = new ConfigurationExpression();
action(expression);
var graph = expression.BuildGraph();
return BuildRoot(graph);
}
public static RootPipelineGraph For(Action<ConfigurationExpression> action)
{
var expression = new ConfigurationExpression();
action(expression);
PluginGraph graph = expression.BuildGraph();
return new RootPipelineGraph(graph);
}
private SecurityContext(ConfigurationExpression configurationExpression)
{
_data = new ExpandoObject();
_isAuthenticated = configurationExpression.IsAuthenticated;
_roles = configurationExpression.Roles;
var modifyer = configurationExpression.Advanced.SecurityContextModifyer;
if (modifyer != null) modifyer.Invoke(this);
}
private static void SetupContainer(ConfigurationExpression x)
{
x.Scan(i =>
{
i.TheCallingAssembly();
i.Convention<SettingsScanner>();
});
x.SetAllProperties(s => s.Matching(p => p.Name.EndsWith("Settings")));
}
public void Configure(ConfigurationExpression cfg, IFoundationConfigurator foundationConfigurator)
{
if (foundationConfigurator.UsePresistence)
{
cfg.AddRegistry(new PersistenceRegistery());
cfg.For<IConnectionString>()
.Use(new ConnectionString(foundationConfigurator.Persistence.ConnectionStringKeyName));
}
}
private static void ConfigureContainer(ConfigurationExpression container)
{
//Swap out the default ContentRenderer for our custom
//container.For<IContentRenderer>().Use<ErrorHandlingContentRenderer>();
container.For<ContentAreaRenderer>().Use<ContentAreaWithDefaultsRenderer>();
container.For<ICustomerAddressRepository>().Use<CustomerAddressRepository>();
container.For<IOrderRepository>().Use<OrderRepository>();
container.For<IExportOrderService>().Use<ExportOrderService>();
}
private static void RegisterComplex(ConfigurationExpression r)
{
r.For<IFirstService>().Singleton().Use<FirstService>();
r.For<ISecondService>().Singleton().Use<SecondService>();
r.For<IThirdService>().Singleton().Use<ThirdService>();
r.For<ISubObjectOne>().Transient().Use<SubObjectOne>();
r.For<ISubObjectTwo>().Transient().Use<SubObjectTwo>();
r.For<ISubObjectThree>().Transient().Use<SubObjectThree>();
r.For<IComplex>().Transient().Use<Complex>();
}
private static void Initialize(ConfigurationExpression initializer)
{
var tfsPlugin = TfsPlugin.Find();
initializer.Scan(x => { Initialize(x); tfsPlugin.Initialize(x); });
initializer.For<TextWriter>().Use(() => Console.Out);
initializer.For<IGitRepository>().Add<GitRepository>();
AddGitChangeTypes(initializer);
DoCustomConfiguration(initializer);
tfsPlugin.Initialize(initializer);
}
private static void DoCustomConfiguration(ConfigurationExpression initializer)
{
foreach(var type in typeof(Program).Assembly.GetTypes())
{
foreach(ConfiguresStructureMap attribute in type.GetCustomAttributes(typeof(ConfiguresStructureMap), false))
{
attribute.Initialize(initializer, type);
}
}
}
private static void ConfigureContainer(ConfigurationExpression container)
{
container.For<IFormSerializer>().Use<FormSerializer>();
container.For<IFormFieldSerializeUtils>().Use<FormFieldSerializeUtils>();
container.For<IFormFieldModelBuilder>().Use<FormFieldModelBuilder>();
container.For<IXFormBuilder>().Use<XFormBuilder>();
container.For<IFormTypeModelSynchronizer>().Use<FormTypeModelSynchronizer>();
container.For<IFormFieldTypeSynchronizer>().Use<FormFieldTypeSynchronizer>();
}
private static void SetupContainer(ConfigurationExpression x)
{
x.For<IHttpSession>().Use<CurrentHttpContextSession>();
x.Scan(i =>
{
i.TheCallingAssembly();
i.Convention<SettingsScanner>();
});
x.For<ISettingsProvider>().Use<AppSettingsProvider>();
x.SetAllProperties(s => s.Matching(p => p.Name.EndsWith("Settings")));
}
static void Configure(ConfigurationExpression x)
{
x.AddRegistry(new MyAppRegistry());
x.For<IObjectContainer>()
.Singleton()
.Use(Db4oEmbedded.OpenFile(Db4oEmbedded.NewConfiguration(), DbPath));
x.For(typeof (IRepository<>))
.Use(typeof (Repository<>));
}
private static void ConfigureContainer(ConfigurationExpression container)
{
container.For<IEpiServerDependenciesResolver>().Use<EpiServerDependenciesResolver>();
container.For<IBlockHelper>().Use<BlockHelper>();
container.For<IContextResolver>().Use<ContextResolver>();
container.For<ILinkResolver>().Use<LinkResolver>()
.Ctor<IEpiServerDependenciesResolver>().Is<EpiServerDependenciesResolver>();
container.For<IEpiServerDependencies>()
.Use<EpiServerDependencies>();
}
/// <summary>
/// Configures WebAPI controller.
/// </summary>
/// <param name="ce">The configuration currently executing.</param>
private static void ConfigureControllers(ConfigurationExpression ce)
{
// NOTE: controllers must be Transient (the default), NOT HttpContextScoped
ce.ForSingletonOf<StructureMapDependencyResolver>();
ce.Forward<StructureMapDependencyResolver, IServiceLocator>();
ce.Forward<StructureMapDependencyResolver, System.Web.Http.Dependencies.IDependencyResolver>();
ce.ForSingletonOf<IHttpControllerActivator>().Use<StructureMapHttpControllerActivator>();
ce.ForSingletonOf<HttpConfiguration>().Use(GlobalConfiguration.Configuration);
ce.For<HttpContext>().LifecycleIs<HttpContextLifecycle>().Use(() => HttpContext.Current);
}
public static void AddGitChangeTypes(ConfigurationExpression initializer)
{
// See git-diff-tree(1).
initializer.For<IGitChangedFile>().Use<Add>().Named(GitChangeInfo.ChangeType.ADD);
initializer.For<IGitChangedFile>().Use<Copy>().Named(GitChangeInfo.ChangeType.COPY);
initializer.For<IGitChangedFile>().Use<Modify>().Named(GitChangeInfo.ChangeType.MODIFY);
//initializer.For<IGitChangedFile>().Use<TypeChange>().Named(GitChangeInfo.GitChange.TYPECHANGE);
initializer.For<IGitChangedFile>().Use<Delete>().Named(GitChangeInfo.ChangeType.DELETE);
initializer.For<IGitChangedFile>().Use<RenameEdit>().Named(GitChangeInfo.ChangeType.RENAMEEDIT);
//initializer.For<IGitChangedFile>().Use<Unmerged>().Named(GitChangeInfo.GitChange.UNMERGED);
//initializer.For<IGitChangedFile>().Use<Unknown>().Named(GitChangeInfo.GitChange.UNKNOWN);
}
public static void AddGitChangeTypes(ConfigurationExpression initializer)
{
// See git-diff-tree(1).
initializer.For<IGitChangedFile>().Use<Add>().Named("A");
initializer.For<IGitChangedFile>().Use<Copy>().Named("C");
initializer.For<IGitChangedFile>().Use<Modify>().Named("M");
//initializer.For<IGitChangedFile>().Use<TypeChange>().Named("T");
initializer.For<IGitChangedFile>().Use<Delete>().Named("D");
initializer.For<IGitChangedFile>().Use<RenameEdit>().Named("R");
//initializer.For<IGitChangedFile>().Use<Unmerged>().Named("U");
//initializer.For<IGitChangedFile>().Use<Unknown>().Named("X");
}
private static void RegisterServices(ConfigurationExpression c)
{
c.For<DbContext>().HttpContextScoped().Use<DigitalGraveContext>();
c.For<DigitalGraveContext>().HttpContextScoped().Use<DigitalGraveContext>();
c.For<IdentityDbContext>().HttpContextScoped().Use<DigitalGraveContext>();
c.For<IUserStore<IdentityUser, string>>().HttpContextScoped().Use<UserStore>();
c.For<IRoleStore<IdentityRole, string>>().HttpContextScoped().Use<RoleStore>();
c.For<UserManager>().HttpContextScoped().Use<UserManager>();
}
private static void AssertAllControllerActionsHasContainer(ConfigurationExpression configurationExpression)
{
Assert.That(configurationExpression.Count(), Is.EqualTo(9));
Assert.That(configurationExpression.GetContainerFor("Blog", "Index"), Is.Not.Null);
Assert.That(configurationExpression.GetContainerFor("Blog", "ListPosts"), Is.Not.Null);
Assert.That(configurationExpression.GetContainerFor("Blog", "AddPost"), Is.Not.Null);
Assert.That(configurationExpression.GetContainerFor("Blog", "EditPost"), Is.Not.Null);
Assert.That(configurationExpression.GetContainerFor("Blog", "DeletePost"), Is.Not.Null);
Assert.That(configurationExpression.GetContainerFor("Blog", "AjaxList"), Is.Not.Null);
Assert.That(configurationExpression.GetContainerFor("Admin", "Index"), Is.Not.Null);
Assert.That(configurationExpression.GetContainerFor("Admin", "LogIn"), Is.Not.Null);
Assert.That(configurationExpression.GetContainerFor("Admin", "LogOut"), Is.Not.Null);
}
public SecurityConfiguration(Action<ConfigurationExpression> configurationExpression)
{
if (configurationExpression == null)
throw new ArgumentNullException("configurationExpression");
var expression = new ConfigurationExpression();
configurationExpression(expression);
Expression = expression;
ExternalServiceLocator = Expression.ExternalServiceLocator;
IgnoreMissingConfiguration = Expression.ShouldIgnoreMissingConfiguration;
PolicyContainers = Expression;
}
/// <summary>
/// Configures all injections.
/// </summary>
/// <param name="obj"></param>
private static void ConfigureInjections(ConfigurationExpression configuration)
{
configuration.For<IRepository<UserDto>>().HttpContextScoped().Use<Repository<UserDto>>();
configuration.For<IUserRepository>().HttpContextScoped().Use<UserRepository>(); // this is necessary if we would like to use EF for example and make sure no 2 threads will access one DbContext.
// For demo purposes, Im using a single source throughout the whole app.
configuration.For<IFeedSource>().Singleton().Use((() =>
{
var source = new FeedSource<SimpleNewsGator>();
source.Subscribe(new FeedDispatcher(new FeedItemHub()));
source.Start();
return source;
}));
}
private static void OnConfigure(ConfigurationExpression x)
{
x.Scan(cfg =>
{
cfg.TheCallingAssembly();
x.For(typeof(IReportingRepository<>)).Use(typeof(InMemoryRepository<>));
cfg.WithDefaultConventions();
});
// include the LixRegistry
x.IncludeRegistry(new LixRegistry());
}
/// <summary>
/// Registers base option types with the StructureMap Container.
///
/// The intent of this method is to provide registration of base option types
/// when used outside the context of an Asp.Net Core Web application as
/// use of StructureMap with web apps would typically use the AddOptions() extension
/// method and rely upon StructureMap's Populate() method to register services from
/// the ServiceCollection.
/// </summary>
/// <param name="configurationExpression"></param>
/// <returns></returns>
public static ConfigurationExpression AddOptions(this ConfigurationExpression configurationExpression)
{
if (configurationExpression == null)
{
throw new ArgumentNullException(nameof(configurationExpression));
}
configurationExpression.For(typeof(IOptions <>)).Use(typeof(OptionsManager <>)).Singleton();
configurationExpression.For(typeof(IOptionsSnapshot <>)).Use(typeof(OptionsManager <>)).ContainerScoped();
configurationExpression.For(typeof(IOptionsMonitor <>)).Use(typeof(OptionsMonitor <>)).Singleton();
configurationExpression.For(typeof(IOptionsFactory <>)).Use(typeof(OptionsFactory <>)).Transient();
configurationExpression.For(typeof(IOptionsMonitorCache <>)).Use(typeof(OptionsCache <>)).Singleton();
return(configurationExpression);
}
private static void SetupContainer(ConfigurationExpression map)
{
map.Scan(x =>
{
x.TheCallingAssembly();
x.WithDefaultConventions();
x.LookForRegistries();
x.AddAllTypesOf<IPropertyBinder>();
x.ConnectImplementationsToTypesClosing(typeof (IValidator<>));
PackageRegistry.PackageAssemblies.Each(x.Assembly);
});
map.For<IContinuationDirector>().Use<ContinuationHandler>();
}
private static void InjectRmqMessageBus(
IConfigurationRoot configurationRoot,
ConfigurationExpression expression)
{
expression.
For <IMessageBus>().
Use <RmqMessageBus>().
Named(nameof(RmqMessageBus)).
Ctor <string>().
Is(() => GetRmqConnectionString(configurationRoot)).
Ctor <IMessageBus>().
IsNamedInstance(nameof(InMemoryMessageBus)).
Singleton();
expression.Forward <IMessageBus, IInitializable>();
}
public static void ReactiveConfig(this ConfigurationExpression config, Action <IReactiveConfigRegistry> action)
{
config.Scan(s =>
{
s.AssemblyContainingType <IConfigured>();
s.Convention <ReactiveConfig>();
s.WithDefaultConventions();
});
config.For <IConfigurationResultStore>().Singleton().Use <ConfigurationResultStore>();
config.For <IKeyPathProvider>().Use <NamespaceKeyPathProvider>();
var configRegsitry = new ReactiveConfigRegsitry(config);
action(configRegsitry);
}
/// <summary>
/// Adds JustSaying services to the registry.
/// </summary>
/// <param name="registry">The <see cref="ConfigurationExpression"/> to add JustSaying services to.</param>
/// <param name="region">The AWS region to configure.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="registry"/> or <paramref name="region"/> is <see langword="null"/>.
/// </exception>
public static void AddJustSaying(this ConfigurationExpression registry, string region)
{
if (registry == null)
{
throw new ArgumentNullException(nameof(registry));
}
if (string.IsNullOrWhiteSpace(region))
{
throw new ArgumentException("region must not be null or empty", nameof(region));
}
registry.AddJustSaying(
(builder) => builder.Messaging(
(options) => options.WithRegion(region)));
}
protected override void InitializeContainer(ConfigurationExpression configuration)
{
configuration.For <IdentityMarkerService>();
configuration.For <IUserValidator <User> >().Use <UserValidator <User> >();
configuration.For <IPasswordValidator <User> >().Use <PasswordValidator <User> >();
configuration.For <IPasswordHasher <User> >().Use <PasswordHasher <User> >();
configuration.For <ILookupNormalizer>().Use <UpperInvariantLookupNormalizer>();
configuration.For <IRoleValidator <Role> >().Use <RoleValidator <Role> >();
//configuration.For<IdentityErrorDescriber>(services);
configuration.For <ISecurityStampValidator>().Use <SecurityStampValidator <User> >();
configuration.For <IUserClaimsPrincipalFactory <User> >().Use <UserClaimsPrincipalFactory <User, Role> >();
configuration.For <UserManager <User> >().Use <UserManager <User> >();
configuration.For <SignInManager <User> >().Use <SignInManager <User> >();
configuration.For <RoleManager <Role> >().Use <RoleManager <Role> >();
configuration.AddRegistry <MembershipRegistry>();
}
public static void Configure(ConfigurationExpression configuration)
{
configuration.For <SecurityController>().DenyAnonymousAccess();
configuration.For <PermissionController>().DenyAnonymousAccess();
configuration.For <PasswordController>(x => x.ForgotPasswordAsync(null)).AllowAny();
configuration.For <PasswordController>(x => x.ResetPasswordAsync(null)).AllowAny();
configuration.For <PasswordController>(x => x.ChangeMyPasswordAsync(null)).AddPolicy(new PermissionPolicy(Permissions.userChangePassword));
configuration.For <PasswordController>(x => x.ChangeMyPasswordExpiredAsync(null)).AllowAny();
configuration.For <SettingsController>(t => t.Get(false)).DenyAnonymousAccess();
configuration.For <SettingsController>(t => t.GetLayoutSkin(false)).AllowAny();
configuration.For <SettingsController>(t => t.Set(null)).AddPolicy(new PermissionPolicy(Permissions.manageGeneralSettings));
configuration.For <LogController>().AllowAny();
configuration.For <LogController>(l => l.Get(null)).AllowAny();
configuration.For <RoleController>(t => t.List()).AddPolicy(new PermissionPolicy(Permissions.managerProfile));
var permissionPolicyUserList = new PermissionPolicy(Permissions.manageUser);
permissionPolicyUserList.Add(Permissions.managerProfile);
configuration.For <UserController>(x => x.GetList(null)).AddPolicy(permissionPolicyUserList);
configuration.For <UserController>(x => x.GetItem(0)).AddPolicy(new PermissionPolicy(Permissions.manageUser));
configuration.For <UserController>(x => x.GetEmail(0)).DenyAuthenticatedAccess();
configuration.For <UserController>(x => x.GetMyAccount()).DenyAnonymousAccess();
configuration.For <UserController>(x => x.GetMyAvatar()).DenyAnonymousAccess();
configuration.For <UserController>(x => x.CreateAsync(null)).AddPolicy(new PermissionPolicy(Permissions.manageUser));
configuration.For <UserController>(x => x.UpdateAsync(null)).AddPolicy(new PermissionPolicy(Permissions.manageUser));
configuration.For <UserController>(x => x.UpdateMyAccountAsync(null)).DenyAnonymousAccess();
configuration.For <GroupController>(x => x.List()).AddPolicy(new PermissionPolicy(Permissions.managerProfile));
configuration.For <GroupController>(x => x.CreateAsync(null)).AddPolicy(new PermissionPolicy(Permissions.managerProfile));
configuration.For <GroupController>(x => x.UpdateAsync(null)).AddPolicy(new PermissionPolicy(Permissions.managerProfile));
configuration.For <GroupController>(x => x.UpdatePermissionsAsync(null)).AddPolicy(new PermissionPolicy(Permissions.managerProfile));
configuration.For <GroupController>(x => x.UpdateUsersAsync(null)).AddPolicy(new PermissionPolicy(Permissions.managerProfile));
configuration.For <APIClientController>(p => p.Delete(null)).AddPolicy(new PermissionPolicy(Permissions.manageApiClients));
configuration.For <APIClientController>(p => p.Post(null)).AddPolicy(new PermissionPolicy(Permissions.manageApiClients));
configuration.For <APIClientController>(p => p.Put(null)).AddPolicy(new PermissionPolicy(Permissions.manageApiClients));
configuration.For <APIClientController>(p => p.PutSecret(null)).AddPolicy(new PermissionPolicy(Permissions.manageApiClients));
configuration.For <APIClientController>(t => t.Get(null)).AddPolicy(new PermissionPolicy(Permissions.manageApiClients));
configuration.For <FilesController>(t => t.Index(null)).AllowAny();
}
public static void AddDatabaseRegistration(this ConfigurationExpression config, string environment, string sqlConnectionString)
{
config.For <IDbConnection>().Use($"Build IDbConnection", c => {
var azureServiceTokenProvider = new AzureServiceTokenProvider();
return(environment.Equals("LOCAL", StringComparison.CurrentCultureIgnoreCase)
? new SqlConnection(sqlConnectionString)
: new SqlConnection
{
ConnectionString = sqlConnectionString,
AccessToken = azureServiceTokenProvider.GetAccessTokenAsync(AzureResource).Result
});
});
var option = new DbContextOptionsBuilder <AssessorDbContext>();
config.For <AssessorDbContext>().Use(c => new AssessorDbContext(c.GetInstance <IDbConnection>(), option.Options));
}
public static ConfigurationExpression ResolveDbContext(this ConfigurationExpression expression, DatabaseEngine engine)
{
switch (engine)
{
case DatabaseEngine.SqlServer:
expression.For(typeof(DbContext)).Use(typeof(SqlServerDbContext));
break;
case DatabaseEngine.MySql:
expression.For(typeof(DbContext)).Use(typeof(MySqlDbContext));
break;
case DatabaseEngine.PostgreSql:
expression.For(typeof(DbContext)).Use(typeof(PostgreSqlDbContext));
break;
}
return(expression);
}
public void Configure(ConfigurationExpression cfg, IFoundationConfigurator foundationConfigurator)
{
if (foundationConfigurator.UseWeb)
{
cfg.AddRegistry(new WebRegistery(foundationConfigurator));
cfg.For <IResourcesLocator>().Use(foundationConfigurator.Web);
// this.RegisterPagingAndSortingModelBinders(foundationConfigurator.Web.ViewModelsAssemblyHookType);
ControllerBuilder.Current.SetControllerFactory(new StructureMapControllerFactory(ObjectFactory.Container));
DependencyResolver.SetResolver(new StructureMapDependencyResolver(ObjectFactory.Container));
if (foundationConfigurator.Web.PagingConfigurations != null)
{
WebConfigurations.PagingConfigurations =
foundationConfigurator.Web.PagingConfigurations;
}
}
}
public void Configure(ConfigurationExpression cfg, IFoundationConfigurator foundationConfigurator)
{
if (foundationConfigurator.UseWeb)
{
cfg.AddRegistry(new WebRegistery(foundationConfigurator));
cfg.For<IResourcesLocator>().Use(foundationConfigurator.Web);
// this.RegisterPagingAndSortingModelBinders(foundationConfigurator.Web.ViewModelsAssemblyHookType);
ControllerBuilder.Current.SetControllerFactory(new StructureMapControllerFactory(ObjectFactory.Container));
DependencyResolver.SetResolver(new StructureMapDependencyResolver(ObjectFactory.Container));
if (foundationConfigurator.Web.PagingConfigurations != null)
{
WebConfigurations.PagingConfigurations =
foundationConfigurator.Web.PagingConfigurations;
}
}
}
public static ConfigurationExpression ConfigureDbContexts(this ConfigurationExpression expression, Tenant tenant, IConfiguration configuration)
{
var catalogEngine = configuration.GetSection("MultitenancyOptions").GetValue <DatabaseEngine>("CatalogEngine");
var deploymentMode = configuration.GetSection("MultitenancyOptions").GetValue <DeploymentModes>("DeploymentMode");
if (deploymentMode == DeploymentModes.Multi)
{
if (tenant != null)
{
expression.ResolveDbContext(tenant.Engine);
}
expression.ResolveCatalogDataSource(catalogEngine, configuration);
}
else if (deploymentMode == DeploymentModes.Single)
{
expression.ResolveDbContext(catalogEngine);
expression.ResolveHybridDataSource(catalogEngine, configuration);
// expression.For<ICatalogDataSource>().Use<CatalogDataSource>();
// expression.For<ICatalogDataSource>().Use(provider => new CatalogDataSource(provider.GetInstance<DbContext>())).ContainerScoped();
}
else if (deploymentMode == DeploymentModes.Hybrid)
{
var engine = catalogEngine;
if (tenant != null)
{
if (tenant.IsIsolated)
{
engine = tenant.Engine;
expression.ResolveDbContext(engine);
}
else
{
expression.ResolveDbContext(engine);
}
}
expression.ResolveHybridDataSource(catalogEngine, configuration);
}
return(expression);
}
private static void ConfigureDependencies(ConfigurationExpression cfg)
{
cfg.AddRegistry(new PersistenceRegistery());
cfg.AddRegistry(new WebRegistery());
cfg.AddRegistry(new QueryRegistery());
cfg.AddRegistry(new BusinessManagerRegistery());
cfg.For <IQueryRegistery>().Use <QueryRegistery>();
cfg.For <IBusinessManagerRegistery>().Use <BusinessManagerRegistery>();
cfg.For <IBusinessManagerInvocationLogger>().Singleton().Use <SqlProcBusinessManagerInvocationLogger>();
cfg.For <ITypeHolder>().Use <TypeHolder>();
cfg.For <IConnectionString>().Use(new ConnectionString("KafalaDB"));
}
private void ConfigureContainer(
IConfigurationRoot configurationRoot,
string dataDirectory,
ConfigurationExpression expression)
{
UseTelegramApiSettings(configurationRoot, expression);
expression.For <IRunable>().Use <UpdatesPuller>().Singleton();
expression.For <IHttpClient>().Use <HttpClient>().Singleton();
expression.For <ITelegramClient>().Use <TelegramHttpClient>().Singleton();
InjectUpdatePositionRepository(dataDirectory, expression);
InjectMessageBusses(configurationRoot, expression);
foreach (var commandHandler in GetCommandHandlers())
{
expression.For(commandHandler);
}
}
/// <summary>
/// Carries out default configuration of the IoC container. Override if you don't want to do this
/// </summary>
protected virtual void DefaultConfigureIoC(ConfigurationExpression config)
{
var viewManagerConfig = new ViewManagerConfig()
{
ViewFactory = this.GetInstance,
ViewAssemblies = new List <Assembly>()
{
this.GetType().Assembly
}
};
config.For <IViewManager>().Add(new ViewManager(viewManagerConfig));
// Trick it into not taking ownership of (and disposing) the instance
config.For <IWindowManagerConfig>().Add(c => this).LifecycleIs <UniquePerRequestLifecycle>();
config.For <IWindowManager>().Add <WindowManager>().LifecycleIs <SingletonLifecycle>();
config.For <IEventAggregator>().Add <EventAggregator>().LifecycleIs <SingletonLifecycle>();
config.For <IMessageBoxViewModel>().Add <MessageBoxViewModel>().LifecycleIs <UniquePerRequestLifecycle>();
config.Scan(x => x.Assembly(this.GetType().Assembly));
}
public ConfigurationExpressionBusConfigurator(ConfigurationExpression expression)
: base(new StructureMapContainerRegistrar(expression))
{
_expression = expression;
expression.For <IBusDepot>()
.Use <BusDepot>()
.Singleton();
_expression.For <ISendEndpointProvider>()
.Use(context => GetCurrentSendEndpointProvider(context))
.ContainerScoped();
_expression.For <IPublishEndpoint>()
.Use(context => GetCurrentPublishEndpoint(context))
.ContainerScoped();
_expression.For <IClientFactory>()
.Use(context => ClientFactoryProvider(context.GetInstance <IConfigurationServiceProvider>(), context.GetInstance <IBus>()))
.Singleton();
_expression.For <BusHealth>()
.Use(context => new BusHealth(nameof(IBus)))
.Singleton();
_expression.For <IBusHealth>()
.Use <BusHealth>()
.Singleton();
expression.For <IConsumerScopeProvider>()
.Use(context => CreateConsumerScopeProvider(context))
.Singleton();
expression.For <IConfigurationServiceProvider>()
.Use(context => new StructureMapConfigurationServiceProvider(context.GetInstance <IContainer>()))
.Singleton();
expression.For <IBusRegistrationContext>()
.Use(context => CreateRegistrationContext(context))
.Singleton();
}
private static void ConfigureContainer(ConfigurationExpression container)
{
container.For <IContentRepositoryFactory>().Use <ContentRepositoryFactory>();
container.For <ILinkResolverFactory>().Use <LinkResolverFactory>();
container.For <IContextResolverFactory>().Use <ContextResolverFactory>();
container.For <IBlockHelper>().Use <BlockHelper>();
container.For <ILinkResolver>().Use(ctx => new LinkResolver(
new UrlResolverFactory(),
new ContentRepositoryFactory()));
container.For <IContextResolver>().Use(ctx => new ContextResolver());
container.For <IEpiServerDependencies>()
.Use(ctx => new EpiServerDependencies(
new ContentRepositoryFactory(),
new LinkResolverFactory(),
new ContextResolverFactory()
));
}
private void ConfigureRest(ConfigurationExpression config, ApiGatewaySettings settings)
{
var httpConfig = config.ForConcreteType <HttpServiceOptions>().Configure
.Ctor <string>().Is(settings.Http.BaseUrl)
.Setter(m => m.PermissionedApplications).Is(settings.PermissionedApplications)
.Setter(m => m.DependencyResolver).IsTheDefault()
.Setter(m => m.DisableAuthorization).Is(settings.DisableAuthorization)
.Setter(m => m.DefaultTokenExpiry).Is(settings.Http.DefaultTokenExpiry)
.Setter(m => m.AllowTokenAsUrlParameter).Is(settings.Http.AllowTokenAsUrlParameter);
config.For <IService>().Add <HttpService>()
.Named(nameof(HttpService))
.Ctor <HttpServiceOptions>().Is(httpConfig);
config
.ForConcreteType <ApiGatewayService>().Configure
.Ctor <IService>("httpService").Is(ctx => ctx.GetInstance <IService>(nameof(HttpService)));
//controllers
config.ForConcreteType <Http.Controller.TestController>();
}
public static ConfigurationExpression ConfigureCatalogDbContexts(this ConfigurationExpression expression, IConfiguration configuration)
{
var catalogEngine = configuration.GetSection("MultitenancyOptions").GetValue <DatabaseEngine>("CatalogEngine");
var deploymentMode = configuration.GetSection("MultitenancyOptions").GetValue <DeploymentModes>("DeploymentMode");
if (deploymentMode == DeploymentModes.Multi)
{
expression.ResolveCatalogDataSource(catalogEngine, configuration);
}
else if (deploymentMode == DeploymentModes.Single)
{
expression.ResolveDbContext(catalogEngine);
expression.For <ICatalogDataSource>().Use <CatalogDataSource>();
}
else if (deploymentMode == DeploymentModes.Hybrid)
{
expression.ResolveHybridDataSource(catalogEngine, configuration);
}
return(expression);
}
private static void ConfigureDataAccess(ConfigurationExpression i, IPersistenceConfigurer databaseConfigurer)
{
ValidatorEngine validatorEngine;
//Configura o IoC para session factory do nhibernate ser singleton por toda a aplicação
i.For <ISessionFactory>()
.Singleton()
.Use(ConfigureNHibernate(databaseConfigurer, out validatorEngine));
//Configura o IoC para criar uma nova sessão a cada requisição
i.For <ISession>()
.LifecycleIs(Lifecycles.GetLifecycle(InstanceScope.PerRequest))
.Use(() =>
ObjectFactory.GetInstance <ISessionFactory>
().OpenSession());
//Configura o validador de entidades do nhibernate
i.For <ValidatorEngine>()
.Singleton()
.Use(validatorEngine);
}
protected override void InitializeContainer(ConfigurationExpression configuration)
{
configuration.For <IdentityMarkerService>();
configuration.For <IUserValidator <User> >().Use <UserValidator <User> >();
configuration.For <IPasswordValidator <User> >().Use <PasswordValidator <User> >();
configuration.For <IPasswordHasher <User> >().Use <PasswordHasher <User> >();
configuration.For <ILookupNormalizer>().Use <UpperInvariantLookupNormalizer>();
configuration.For <IRoleValidator <Role> >().Use <RoleValidator <Role> >();
//configuration.For<IdentityErrorDescriber>(services);
configuration.For <ISecurityStampValidator>().Use <SecurityStampValidator <User> >();
configuration.For <IUserClaimsPrincipalFactory <User> >().Use <UserClaimsPrincipalFactory <User, Role> >();
configuration.For <UserManager <User> >().Use <UserManager <User> >();
configuration.For <SignInManager <User> >().Use <SignInManager <User> >();
configuration.For <RoleManager <Role> >().Use <RoleManager <Role> >();
configuration.For <IOptions <IdentityOptions> >().Use <OptionsProvider>();
configuration.For <IOptions <PasswordHasherOptions> >().Use <OptionsProvider>();
configuration.For <IServiceProvider>().Use(context => new ServiceProviderWrapper(context));
configuration.For <IHttpContextAccessor>().Use <DummyHttpContextAccessor>();
configuration.For(typeof(ILogger <>)).Use(typeof(DummyLogger <>));
configuration.AddRegistry <MembershipRegistry>();
}
public ConfigurationExpressionMediatorConfigurator(ConfigurationExpression expression)
: base(new StructureMapContainerMediatorRegistrar(expression))
{
_expression = expression;
_expression.For <IMediator>()
.Use(context => MediatorFactory(context))
.Singleton();
expression.For <IConsumerScopeProvider>()
.Use(context => CreateConsumerScopeProvider(context))
.Singleton();
expression.For <IConfigurationServiceProvider>()
.Use(context => new StructureMapConfigurationServiceProvider(context.GetInstance <IContainer>()))
.Singleton();
expression.For <IMediatorRegistrationContext>()
.Use(context => CreateRegistrationContext(context))
.Singleton();
}
private static void AssertAllControllerActionsHasContainer(ConfigurationExpression configurationExpression)
{
Assert.That(configurationExpression.Count(), Is.EqualTo(12));
var blog = NameHelper.Controller <BlogController>();
var admin = NameHelper.Controller <AdminController>();
var root = NameHelper.Controller <TestData.AssemblyScannerControllers.RootController>();
var include = NameHelper.Controller <TestData.AssemblyScannerControllers.Include.IncludedController>();
var exclude = NameHelper.Controller <TestData.AssemblyScannerControllers.Exclude.ExcludedController>();
Assert.That(configurationExpression.GetContainerFor(blog, "Index"), Is.Not.Null);
Assert.That(configurationExpression.GetContainerFor(blog, "ListPosts"), Is.Not.Null);
Assert.That(configurationExpression.GetContainerFor(blog, "AddPost"), Is.Not.Null);
Assert.That(configurationExpression.GetContainerFor(blog, "EditPost"), Is.Not.Null);
Assert.That(configurationExpression.GetContainerFor(blog, "DeletePost"), Is.Not.Null);
Assert.That(configurationExpression.GetContainerFor(blog, "AjaxList"), Is.Not.Null);
Assert.That(configurationExpression.GetContainerFor(admin, "Index"), Is.Not.Null);
Assert.That(configurationExpression.GetContainerFor(admin, "LogIn"), Is.Not.Null);
Assert.That(configurationExpression.GetContainerFor(admin, "LogOut"), Is.Not.Null);
Assert.That(configurationExpression.GetContainerFor(root, "Index"), Is.Not.Null);
Assert.That(configurationExpression.GetContainerFor(include, "Index"), Is.Not.Null);
Assert.That(configurationExpression.GetContainerFor(exclude, "Index"), Is.Not.Null);
}
private void InjectMessageBusses(IConfigurationRoot configurationRoot, ConfigurationExpression expression)
{
// ВАЖНО! Не использовать DecorateAllWith для IMessageBus.
// По непонятной причине тест зависает после исполнения TearDown,
// когда больше одного декоратора!
expression.
For <IMessageBus>().
Use <InMemoryMessageBus>().
Named(nameof(InMemoryMessageBus)).
Ctor <IEnumerable>().
Is(ctx => GetCommandHandlers().Select(ctx.GetInstance)).
Singleton();
expression.
For <IMessageBus>().
Use <MessageBusLogger>().
Ctor <IMessageBus>().
IsNamedInstance(nameof(RmqMessageBus)).
Singleton();
InjectRmqMessageBus(configurationRoot, expression);
}
public static ConfigurationExpression AddMultitenancy(
this ConfigurationExpression expression,
IServiceCollection services, IContainer container,
IConfiguration configuration)
{
//expression.AddMultitenancy<Tenant, CachedDomainTenantResolver>();
expression.ConfigureCatalogDbContexts(configuration);
expression.ConfigureTenants <Tenant>(container, (tenant, cfg) =>
{
cfg.ConfigureDbContexts(tenant, configuration);
if (tenant != null)
{
cfg.For <IActiveDbContext>().Use <TenantActiveDbContext>();
}
else
{
cfg.For <IActiveDbContext>().Use <CatalogActiveDbContext>();
}
});
return(expression);
}
private static void RegisterPropertyInjection(ConfigurationExpression r)
{
r.For <IServiceA>().Singleton().Use <ServiceA>();
r.For <IServiceB>().Singleton().Use <ServiceB>();
r.For <IServiceC>().Singleton().Use <ServiceC>();
r.For <ISubObjectA>().Transient().Use <SubObjectA>()
.Setter(x => x.ServiceA).IsTheDefault();
r.For <ISubObjectB>().Transient().Use <SubObjectB>()
.Setter(x => x.ServiceB).IsTheDefault();
r.For <ISubObjectC>().Transient().Use <SubObjectC>()
.Setter(x => x.ServiceC).IsTheDefault();
r.For <IComplexPropertyObject1>().Transient().Use <ComplexPropertyObject1>()
.Setter(x => x.ServiceA).IsTheDefault()
.Setter(x => x.ServiceB).IsTheDefault()
.Setter(x => x.ServiceC).IsTheDefault()
.Setter(x => x.SubObjectA).IsTheDefault()
.Setter(x => x.SubObjectB).IsTheDefault()
.Setter(x => x.SubObjectC).IsTheDefault();
r.For <IComplexPropertyObject2>().Transient().Use <ComplexPropertyObject2>()
.Setter(x => x.ServiceA).IsTheDefault()
.Setter(x => x.ServiceB).IsTheDefault()
.Setter(x => x.ServiceC).IsTheDefault()
.Setter(x => x.SubObjectA).IsTheDefault()
.Setter(x => x.SubObjectB).IsTheDefault()
.Setter(x => x.SubObjectC).IsTheDefault();
r.For <IComplexPropertyObject3>().Transient().Use <ComplexPropertyObject3>()
.Setter(x => x.ServiceA).IsTheDefault()
.Setter(x => x.ServiceB).IsTheDefault()
.Setter(x => x.ServiceC).IsTheDefault()
.Setter(x => x.SubObjectA).IsTheDefault()
.Setter(x => x.SubObjectB).IsTheDefault()
.Setter(x => x.SubObjectC).IsTheDefault();
}
public static void ConfigureDependencies(ConfigurationExpression cfg)
{
cfg.AddRegistry(new PersistenceRegistery());
cfg.AddRegistry(new QueryRegistery());
cfg.AddRegistry(new BusinessManagerRegistery());
cfg.For <IQueryRegistery>().Use <QueryRegistery>();
cfg.For <IBusinessManagerRegistery>().Use <BusinessManagerRegistery>();
cfg.For <IBusinessManagerInvocationLogger>().Singleton().Use <SqlProcBusinessManagerInvocationLogger>();
cfg.For <IConnectionString>().Use(new ConnectionString("KafalaDBTest"));
cfg.For <IEmailMessageSender>().Use <SwllowEmailService>();
cfg.For <IAuthenticationService>().Use <AuthenticationService>();
cfg.For <IPasswordHelper>().Use <PasswordHelper>();
}
public static void Configure(ConfigurationExpression configuration)
{
//OBSERVAÇÃO: O fato de uma nova controller herdar de BaseController
//não indica que os usuários autenticados terão acessos aos métodos.
//O Deny na BaseController serve apenas para negar o acesso a usuários
//não auenticados, ou seja, ainda se faz necessário configurar o tipo
//de acesso a sua controller. Caso a sua controller tenha acesso a qualquer
//usuário autenticado basta configurar como configuration.For<MyController>().DenyAnonymousAccess()
configuration.For <BaseController>().DenyAnonymousAccess();
configuration.For <CheckupController>().AllowAny();
configuration.For <NotificationController>().DenyAnonymousAccess();
//configuration.For<UserController>(t => t.PostUserImage(null, 0)).AllowAny();
configuration.For <CountryController>(p => p.Delete(0)).AddPolicy(new PermissionPolicy(Permissions.manageCountry));
configuration.For <CountryController>(p => p.Post(null)).AddPolicy(new PermissionPolicy(Permissions.manageCountry));
configuration.For <CountryController>(p => p.Put(null)).AddPolicy(new PermissionPolicy(Permissions.manageCountry));
configuration.For <CountryController>(p => p.Get(0, false, false)).DenyAnonymousAccess();
configuration.For <ClientController>().AllowAny();
configuration.For <EventController>().AllowAny();
configuration.For <EventController>(e => e.Get(null)).DenyAnonymousAccess();
}
public static ConfigurationExpression ResolveCatalogDataSource(this ConfigurationExpression expression, DatabaseEngine engine, IConfiguration configuration)
{
switch (engine)
{
case DatabaseEngine.SqlServer:
expression.For <ICatalogDataSource>().Use(new CatalogDataSource(
new SqlServerCatalogDbContext(configuration, new DbContextOptions <SqlServerCatalogDbContext>())));
break;
case DatabaseEngine.MySql:
expression.For <ICatalogDataSource>()
.Use(new CatalogDataSource(
new MySqlCatalogDbContext(configuration, new DbContextOptions <MySqlCatalogDbContext>())));
break;
case DatabaseEngine.PostgreSql:
expression.For <ICatalogDataSource>()
.Use(new CatalogDataSource(
new PostgreSqlCatalogDbContext(configuration, new DbContextOptions <PostgreSqlCatalogDbContext>())));
break;
}
return(expression);
}
public ConfigurationExpressionRegistrationConfigurator(ConfigurationExpression expression)
: base(new StructureMapContainerRegistrar(expression))
{
_expression = expression;
expression.For <IConsumerScopeProvider>()
.Use(context => CreateConsumerScopeProvider(context))
.Singleton();
expression.For <ISagaRepositoryFactory>()
.Use(context => CreateSagaRepositoryFactory(context))
.Singleton();
expression.For <IConfigurationServiceProvider>()
.Use(context => new StructureMapConfigurationServiceProvider(context.GetInstance <IContainer>()))
.Singleton();
expression.For <IRegistrationConfigurator>()
.Use(this);
expression.For <IRegistration>()
.Use(provider => CreateRegistration(provider.GetInstance <IConfigurationServiceProvider>()))
.Singleton();
}
private static void AssertAllControllerActionsHasContainer(ConfigurationExpression configurationExpression)
{
var policyContainers = configurationExpression.Runtime.PolicyContainers;
Assert.That(policyContainers.Count(), Is.EqualTo(21));
var blog = NameHelper.Controller <BlogController>();
var admin = NameHelper.Controller <AdminController>();
var root = NameHelper.Controller <RootController>();
var include = NameHelper.Controller <IncludedController>();
var exclude = NameHelper.Controller <ExcludedController>();
Assert.That(policyContainers.GetContainerFor(blog, "Index"), Is.Not.Null);
Assert.That(policyContainers.GetContainerFor(blog, "ListPosts"), Is.Not.Null);
Assert.That(policyContainers.GetContainerFor(blog, "AddPost"), Is.Not.Null);
Assert.That(policyContainers.GetContainerFor(blog, "EditPost"), Is.Not.Null);
Assert.That(policyContainers.GetContainerFor(blog, "DeletePost"), Is.Not.Null);
Assert.That(policyContainers.GetContainerFor(blog, "AjaxList"), Is.Not.Null);
Assert.That(policyContainers.GetContainerFor(admin, "Index"), Is.Not.Null);
Assert.That(policyContainers.GetContainerFor(admin, "LogIn"), Is.Not.Null);
Assert.That(policyContainers.GetContainerFor(admin, "LogOut"), Is.Not.Null);
Assert.That(policyContainers.GetContainerFor(root, "Index"), Is.Not.Null);
Assert.That(policyContainers.GetContainerFor(include, "Index"), Is.Not.Null);
Assert.That(policyContainers.GetContainerFor(exclude, "Index"), Is.Not.Null);
}
public static void Register(ConfigurationExpression registry)
{
registry.Scan(x =>
{
x.Assembly(ASSEMBLY);
x.WithDefaultConventions();
});
var nhConfig = Fluently.Configure()
.Mappings(map => map.FluentMappings
.AddFromAssembly(Assembly.Load(ASSEMBLY)))
.BuildConfiguration();
var cfg = new Configuration();
cfg.Configure();
cfg.AddAssembly(Assembly.Load(ASSEMBLY));
new SchemaExport(cfg).Execute(true, true, false);
registry.For <Configuration>().Use(nhConfig).Singleton();
registry.For <ISessionFactory>().Use(nhConfig.BuildSessionFactory()).Singleton();
registry.For <ISession>().Use(ctx => ctx.GetInstance <ISessionFactory>().OpenSession());
registry.For <IStatelessSession>().Use(ctx => ctx.GetInstance <ISessionFactory>().OpenStatelessSession());
}
