protected override void Load(ContainerBuilder builder)
{
builder.RegisterType<TaskService>().Named<ITaskService>("taskService");
builder.RegisterDecorator<ITaskService>(inner => new LoggingTaskService(inner), fromKey: "taskService");
builder.RegisterControllers(typeof(CompositionModule).Assembly);
}
protected override void Load(ContainerBuilder builder)
{
//TvTamer.Core Types
builder.Register(c => ConfigurationManager.GetSection("episodeProcessorSettings") as EpisodeProcessorSettings);
builder.Register(c => ConfigurationManager.GetSection("scheduleSettings") as ScheduleSettings);
builder.Register(c => ConfigurationManager.GetSection("torrentSearchSettings") as TorrentSearchSettings);
builder.RegisterType<TvDbSearchService>().As<ITvSearchService>();
builder.RegisterType<DatabaseUpdater>().As<IDatabaseUpdater>();
builder.RegisterType<EpisodeDownloader>().As<IEpisodeDownloader>();
builder.RegisterType<WebClient>().As<IWebClient>();
builder.RegisterType<TvContext>().As<ITvContext>();
builder.RegisterType<TvService>().As<ITvService>();
builder.RegisterType<FileSystem>().As<IFileSystem>();
builder.RegisterType<AnalyticsService>().As<IAnalyticsService>();
builder.RegisterType<EpisodeProcessor>().As<IEpisodeProcessor>();
//Search Provider Registration
builder.RegisterType<NullSearchProvider>().Named<ISearchProvider>("searchProvider");
builder.RegisterDecorator<ISearchProvider>((c, inner) => new KickassSearchProvider(inner, c.Resolve<IWebClient>(), c.Resolve<IAnalyticsService>()),
fromKey: "searchProvider");
builder.RegisterType<TvTamerService>();
}
protected override void Load(ContainerBuilder moduleBuilder)
{
base.Load(moduleBuilder);
moduleBuilder
.Register<ProxyImplementation>(c => new ProxyImplementation(
c.Resolve<InterfaceType.Factory>(),
c.Resolve<Zetbox.API.Client.ZetboxService.IZetboxService>(),
c.Resolve<IPerfCounter>(),
c.Resolve<ZetboxStreamReader.Factory>(),
c.Resolve<ZetboxStreamWriter.Factory>()
))
.Named<IProxy>("implementor")
.InstancePerDependency(); // No singleton!
moduleBuilder
.RegisterDecorator<IProxy>(
(c, inner) => new InfoLoggingProxyDecorator(inner),
"implementor");
moduleBuilder
.Register<ClientDeploymentRestrictor>(c => new ClientDeploymentRestrictor())
.As<IDeploymentRestrictor>()
.SingleInstance();
moduleBuilder
.RegisterModule<Log4NetAppender.Module>();
moduleBuilder
.RegisterType<PerfCounterDispatcher>()
.As<IPerfCounter>()
.OnActivated(args => args.Instance.Initialize(args.Context.Resolve<IFrozenContext>()))
.OnRelease(obj => obj.Dump())
.SingleInstance();
}
private static void RegisterModel(ContainerBuilder builder)
{
builder
.RegisterDecorator<ITransferStatisticsFactory>((c, f) => new ObservableErrorsTransferStatisticsFactory(f))
.As<ITransferStatisticsFactory>();
builder
.RegisterType<DataAdapterConfigurationProvidersCollection>()
.As<IDataAdapterConfigurationProvidersCollection>()
.InstancePerLifetimeScope();
builder
.RegisterType<CommandLineProvider>()
.As<ICommandLineProvider>()
.SingleInstance();
builder
.RegisterType<DataTransferModel>()
.As<IDataTransferModel>()
.InstancePerLifetimeScope();
builder
.RegisterType<NavigationService>()
.As<INavigationService>()
.InstancePerLifetimeScope();
builder
.RegisterType<ErrorHandler>()
.As<IErrorHandler>()
.SingleInstance();
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType<FixItQueueManager>().As<IFixItQueueManager>();
builder.RegisterType<PhotoService>().As<IPhotoService>();
builder.RegisterType<MyFixItContext>().AsSelf();
builder.RegisterType<FixItTaskRepository>().Named<IFixItTaskRepository>("fixitRepo");
builder.RegisterDecorator<IFixItTaskRepository>((c, inner) => new LoggingFixtItRepository(inner, c.Resolve<ILogger>()), fromKey: "fixitRepo");
}
protected override void Load(ContainerBuilder builder)
{
MessageQueue.EnableConnectionCache = true;
// Register the specified message bus infrastructure.
switch (MessageBusType)
{
case MessageBusType.Inline:
builder.RegisterType<DirectMessageSender<EventEnvelope>>().AsSelf().As<ISendMessages<EventEnvelope>>().SingleInstance().AutoActivate();
break;
case MessageBusType.Optimistic:
builder.RegisterType<OptimisticMessageSender<EventEnvelope>>().AsSelf().As<ISendMessages<EventEnvelope>>().SingleInstance();
break;
case MessageBusType.MicrosoftMessageQueuing:
PurgeMessageQueue("processing", "poison");
builder.Register(resolver => new MessageSender<EventEnvelope>(MessageQueuePath, resolver.Resolve<ISerializeObjects>())).AsSelf().As<ISendMessages<EventEnvelope>>().SingleInstance().AutoActivate();
builder.Register(resolver => new MessageReceiver<EventEnvelope>(MessageQueuePath, resolver.Resolve<ISerializeObjects>(), resolver.Resolve<IProcessMessages<EventEnvelope>>())).AsSelf().SingleInstance().AutoActivate();
break;
default:
throw new NotSupportedException();
}
// Register common eventing infrastructure.
builder.RegisterType<TimeoutDispatcher>().As<PipelineHook>().SingleInstance();
builder.RegisterType<EventHandlerRegistry>().As<IRetrieveEventHandlers>().SingleInstance();
builder.RegisterType<EventPublisher>().Named<IPublishEvents>("EventPublisher").SingleInstance();
builder.RegisterType<EventProcessor>().Named<IProcessMessages<EventEnvelope>>("EventProcessor").SingleInstance();
// Register all event handlers.
builder.RegisterAssemblyTypes(AppDomain.CurrentDomain.GetAssemblies()).Where(type => type.GetCustomAttribute<EventHandlerAttribute>() != null);
// Register data store infrastructure.
builder.RegisterType<SqlSagaStoreDialect>().AsSelf().As<ISagaStoreDialect>().SingleInstance();
builder.RegisterType<SqlSagaStore>().AsSelf().Named<IStoreSagas>("SagaStore").SingleInstance();
// Register decorators.
builder.RegisterDecorator<IStoreSagas>((context, sagaStore) => new BenchmarkedSagaStore(sagaStore, context.Resolve<Statistics>()), "SagaStore").Named<IStoreSagas>("BenchmarkedSagaStore").SingleInstance();
builder.RegisterDecorator<IStoreSagas>((context, sagaStore) => new CachedSagaStore(sagaStore), "BenchmarkedSagaStore").Named<IStoreSagas>("CachedSagaStore").SingleInstance();
builder.RegisterDecorator<IStoreSagas>((context, sagaStore) => new HookableSagaStore(sagaStore, context.Resolve<IEnumerable<PipelineHook>>()), "CachedSagaStore").As<IStoreSagas>().SingleInstance();
builder.RegisterDecorator<IPublishEvents>((context, eventPublisher) => new EventPublisherWrapper(eventPublisher, context.Resolve<Statistics>()), "EventPublisher").As<IPublishEvents>().SingleInstance();
builder.RegisterDecorator<IProcessMessages<EventEnvelope>>((context, eventProcessor) => new EventProcessorWrapper(eventProcessor, context.Resolve<Statistics>()), "EventProcessor").As<IProcessMessages<EventEnvelope>>().SingleInstance();
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType<SerilogWrapper>()
.As<ILogger>()
.InstancePerLifetimeScope();
builder.Register(CreateLogger)
.Named<Serilog.ILogger>("Logger")
.SingleInstance();
builder.RegisterDecorator<Serilog.ILogger>((c, l) => l.ForContext("scope", new { Type = "global" }), "Logger")
.InstancePerLifetimeScope();
}
protected override void Load(ContainerBuilder builder)
{
base.Load(builder);
builder.RegisterDecorator<ITask>(
(c, t) => new TransactedTask(t, c.Resolve<ITransactionContext>()),
fromKey: null,
toKey: TransactedTaskServiceName);
builder.Register(c => new TaskRunner(
c.ResolveNamed<IEnumerable<Meta<TaskFactory,ITaskMetadata>>>(TransactedTaskServiceName),
c.Resolve<ILog<TaskRunner>>()))
.As<ITaskRunner>();
}
private void RegisterEventHandlers(ContainerBuilder builder)
{
foreach (EventElement eventElement in this.settings.Events)
{
builder.RegisterType<BuildCompletedEventHandler>()
.Keyed<IEventHandler>(eventElement.Id + "_1")
.WithMetadata("id", eventElement.Id)
.WithMetadata("event", eventElement.Name)
.WithMetadata("filter", eventElement.Filter); //"\\" + buildCompletedEventElement.TeamProject + "\\" + buildCompletedEventElement.BuildDefinition
builder.RegisterDecorator<IEventHandler>(i => new ExecuteScript(i), fromKey: eventElement.Id + "_1", toKey: eventElement.Id + "_2");
builder.RegisterDecorator<IEventHandler>((c, i) => new EventLogger(i, c.Resolve<ILog>()), fromKey: eventElement.Id + "_2");
//if (eventElement is BuildCompletedEventElement)
//{
// var buildCompletedEventElement = eventElement as BuildCompletedEventElement;
//}
}
//var eventHandlersMetadata = LoadEventHandlersMetadata();
//foreach (var metadata in eventHandlersMetadata)
//{
// if (true)
// {
// builder.RegisterDecorator<IEventHandler>(i => new ExecuteScript(i), fromKey: metadata.Id + "_1", toKey: metadata.Id + "_2");
// }
// if (true)
// {
// builder.RegisterDecorator<IEventHandler>((c, i) => new EventLogger(i, c.Resolve<ILog>()), fromKey: metadata.Id + "_2");
// }
//}
}
static void Main(string[] args)
{
var builder = new ContainerBuilder();
builder.RegisterModule <NLogModule>();
builder.RegisterType <Car>().As <ICar>();
builder.RegisterDecorator(typeof(CarDecorator), typeof(ICar));
var Container = builder.Build();
using (var scope = Container.BeginLifetimeScope())
{
var car = scope.Resolve <ICar>();
car.SpeedUp();
Console.ReadLine();
}
}
/// <summary>
/// Adds DAL module components registrations.
/// </summary>
/// <param name="builder">The container builder.</param>
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType<WeatherNsuRuTemperatureProvider>()
.FindConstructorsWith(AnyConstructorFinder.Instance)
.Named<ITemperatureProvider>("DataOrigin")
.As<ITemperatureDataSource>();
builder.RegisterType<WeatherNsuRuTemperatureParser>().AsImplementedInterfaces()
.FindConstructorsWith(AnyConstructorFinder.Instance);
builder.RegisterDecorator<ITemperatureProvider>(
(ctx, p) => new CachedTemperatureProvider(ctx.Resolve<ITemperatureHistoryRepository>(), p),
"DataOrigin");
builder.RegisterType<TemperatureHistoryRepository>().AsImplementedInterfaces();
builder.RegisterType<TemperatureSyncService>().FindConstructorsWith(AnyConstructorFinder.Instance)
.AsImplementedInterfaces();
}
private static void RegisterApiServices(IConfigurationService configService, ContainerBuilder builder)
{
var usersApiUri = configService.GetSetting<string>("UsersApiUri", null);
var identityServerUri = configService.GetSetting<string>("IdentityServerUri", null);
builder.RegisterType<UsersApiUserService>().As<IUserService>()
.WithParameter("usersApiUri", usersApiUri)
.WithParameter("identityServerUri", identityServerUri);
builder.RegisterType<X509SignedTokenProvider>()
.WithParameter("cert", Cert.Load(typeof(IOwinBootstrapper).Assembly, "Cert", "idsrv3test.pfx", "idsrv3test"))
.Named<ITokenProvider>("tokenProvider");
builder.RegisterDecorator<ITokenProvider>(p => new CachingTokenProvider(p), "tokenProvider");
builder.RegisterType<UsersApiIdentityManagerService>().As<IIdentityManagerService>()
.WithParameter("usersApiUri", usersApiUri)
.WithParameter("identityServerUri", identityServerUri);
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType<LocalizationService>().As<ILocalizationService>().SingleInstance();
builder.RegisterType<ResourceStringProvider>().As<IResourceStringProvider>().SingleInstance();
builder.RegisterType<DatabaseInsertLanguageService>().As<IDatabaseInsertService>().SingleInstance();
builder.RegisterType<LocaleResourceKeyGetAllQueryHandler>().As<IQueryHandler<LocaleResourceKeyGetAllQuery, IEnumerable<LocaleResourceKey>>>().SingleInstance();
builder.RegisterType<UpdateLocaleResourceCommandHandler>().As<ICommandHandler<UpdateLocaleResourceCommand>>().SingleInstance();
builder.RegisterType<LocaleResourceGetByKeyQueryHandler>().As<IQueryHandler<LocaleResourceGetByKeyQuery, LocaleResource>>().SingleInstance();
builder.RegisterType<LanguageGetByKeyQueryHandler>().As<IQueryHandler<LanguageGetByKeyQuery, Language>>().SingleInstance();
builder.RegisterType<LocaleResourceRowProcessor>().As<IRowProcessor<LocaleResourceRow>>().SingleInstance();
builder.RegisterType<LanguageService>().As<ILanguageService>().SingleInstance();
builder.RegisterType<LocalizationsDatabaseStore>().Named<ILocalizationsDatabaseStore>(LocalizationsStore);
builder.RegisterDecorator<ILocalizationsDatabaseStore>(
(c, inner) => new LocalizationsFromDatabaseStoreCached(new Lazy<ILocalizationsDatabaseStore>(() => inner),
c.Resolve<ICacheWrapper>(),
c.Resolve<ILocalizationCacheParameters>()), LocalizationsStore);
base.Load(builder);
}
private static void EventProjections(ContainerBuilder cb)
{
cb.RegisterType<InMemoryEventStore>()
.Named<IEventStore>("implementor")
.SingleInstance();
cb.RegisterDecorator<IEventStore>(
(c, inner) => new DelegatingEventStore(inner, c.Resolve<IEnumerable<IEventListner>>()),
fromKey: "implementor");
cb.RegisterType<GameDetailsProjection>()
.AsSelf()
.AsImplementedInterfaces()
.SingleInstance();
cb.RegisterType<OpenGamesProjection>()
.AsSelf()
.AsImplementedInterfaces()
.SingleInstance();
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType<NHibernateApplicationRepository>()
.As<IApplicationRepository>();
builder.Register(
c =>
new NHibernateConfiguration(ConfigurationManager.ConnectionStrings["ConfigCentral"].ConnectionString))
.SingleInstance();
builder.Register(c => c.Resolve<NHibernateConfiguration>()
.Configure())
.SingleInstance();
builder.Register(c => c.Resolve<Configuration>()
.BuildSessionFactory())
.As<ISessionFactory>()
.SingleInstance();
builder.Register(c => c.Resolve<ISessionFactory>()
.OpenSession())
.Named<ISession>("default")
.OnActivated(args => { args.Instance.FlushMode = FlushMode.Commit; })
.InstancePerLifetimeScope();
builder.Register(c => new NHibernateUnitOfWork(c.ResolveNamed<ISession>("default")))
.Named<NHibernateUnitOfWork>("default")
.InstancePerLifetimeScope();
builder.RegisterDecorator<NHibernateUnitOfWork>(
(c, inner) => new SqlServerCe40ExceptionTranslatingDecorator(inner),
fromKey: "default")
.As<NHibernateUnitOfWork>()
.As<IUnitOfWork>()
.InstancePerLifetimeScope();
builder.Register(c => c.Resolve<NHibernateUnitOfWork>().Session)
.As<ISession>()
.ExternallyOwned()
.InstancePerLifetimeScope();
}
protected override void Load(ContainerBuilder builder)
{
MessageQueue.EnableConnectionCache = true;
// Register the specified message bus infrastructure.
switch (MessageBusType)
{
case MessageBusType.Inline:
builder.RegisterType<DirectMessageSender<CommandEnvelope>>().AsSelf().As<ISendMessages<CommandEnvelope>>().SingleInstance().AutoActivate();
break;
case MessageBusType.Optimistic:
builder.RegisterType<OptimisticMessageSender<CommandEnvelope>>().AsSelf().As<ISendMessages<CommandEnvelope>>().SingleInstance();
break;
case MessageBusType.MicrosoftMessageQueuing:
PurgeMessageQueue("processing", "poison");
builder.Register(resolver => new MessageSender<CommandEnvelope>(MessageQueuePath, resolver.Resolve<ISerializeObjects>())).AsSelf().As<ISendMessages<CommandEnvelope>>().SingleInstance().AutoActivate();
builder.Register(resolver => new MessageReceiver<CommandEnvelope>(MessageQueuePath, resolver.Resolve<ISerializeObjects>(), resolver.Resolve<IProcessMessages<CommandEnvelope>>())).AsSelf().SingleInstance().AutoActivate();
break;
default:
throw new NotSupportedException();
}
// Register common commanding infrastructure.
builder.RegisterType<CommandHandlerRegistry>().As<IRetrieveCommandHandlers>().SingleInstance();
builder.RegisterType<CommandPublisher>().Named<IPublishCommands>("CommandPublisher").SingleInstance();
builder.RegisterType<CommandProcessor>().Named<IProcessMessages<CommandEnvelope>>("CommandProcessor").SingleInstance();
// Register data store infrastructure.
builder.RegisterType<SqlEventStoreDialect>().AsSelf().As<IEventStoreDialect>().SingleInstance();
builder.RegisterType<SqlEventStore>().AsSelf().Named<IStoreEvents>("EventStore").SingleInstance();
builder.RegisterType<SqlSnapshotStoreDialect>().AsSelf().As<ISnapshotStoreDialect>().SingleInstance();
builder.RegisterType<SqlSnapshotStore>().AsSelf().Named<IStoreSnapshots>("SnapshotStore").SingleInstance();
builder.RegisterType<AggregateUpdater>().AsSelf().As<IApplyEvents>().SingleInstance();
builder.RegisterType<AggregateStore>().AsSelf().Named<IStoreAggregates>("AggregateStore").SingleInstance();
// Register decorators.
builder.RegisterType<CommandHook>().AsSelf().As<PipelineHook>().SingleInstance();
builder.RegisterType<EventDispatcher>().AsSelf().As<PipelineHook>().SingleInstance();
builder.RegisterDecorator<IStoreAggregates>((context, aggregateStore) => new CachedAggregateStore(aggregateStore), "AggregateStore").Named<IStoreAggregates>("CachedAggregateStore").SingleInstance();
builder.RegisterDecorator<IStoreAggregates>((context, aggregateStore) => new HookableAggregateStore(aggregateStore, context.Resolve<IEnumerable<PipelineHook>>()), "CachedAggregateStore").As<IRetrieveAggregates>().As<IStoreAggregates>().SingleInstance();
builder.RegisterDecorator<IStoreSnapshots>((context, snapshotStore) => new BenchmarkedSnapshotStore(snapshotStore, context.Resolve<Statistics>()), "SnapshotStore").As<IStoreSnapshots>().SingleInstance();
builder.RegisterDecorator<IStoreEvents>((context, eventStore) => new BenchmarkedEventStore(eventStore, context.Resolve<Statistics>()), "EventStore").As<IStoreEvents>().SingleInstance();
builder.RegisterDecorator<IPublishCommands>((context, commandPublisher) => new CommandPublisherWrapper(commandPublisher, context.Resolve<Statistics>()), "CommandPublisher").As<IPublishCommands>().SingleInstance();
builder.RegisterDecorator<IProcessMessages<CommandEnvelope>>((context, commandProcessor) => new CommandProcessorWrapper(commandProcessor, context.Resolve<Statistics>()), "CommandProcessor").As<IProcessMessages<CommandEnvelope>>().SingleInstance();
}
protected override void Load(ContainerBuilder moduleBuilder)
{
base.Load(moduleBuilder);
moduleBuilder
.Register<ProxyImplementation>(c => new ProxyImplementation(
c.Resolve<InterfaceType.Factory>(),
c.Resolve<IImplementationTypeChecker>(),
c.Resolve<UnattachedObjectFactory>(),
c.Resolve<Zetbox.API.Client.ZetboxService.IZetboxService>(),
c.Resolve<IPerfCounter>(),
c.Resolve<ZetboxStreamReader.Factory>(),
c.Resolve<ZetboxStreamWriter.Factory>(),
c.Resolve<IEnumerable<SerializingTypeMap>>()
))
.Named<IProxy>("implementor")
.InstancePerDependency(); // No singleton!
moduleBuilder
.RegisterDecorator<IProxy>(
(c, inner) => new InfoLoggingProxyDecorator(inner),
"implementor");
moduleBuilder
.Register<ClientDeploymentRestrictor>(c => new ClientDeploymentRestrictor())
.As<IDeploymentRestrictor>()
.SingleInstance();
moduleBuilder
.RegisterType<PerfCounterDispatcher>()
.As<IPerfCounter>()
.OnRelease(obj => obj.Dump())
.SingleInstance();
moduleBuilder
.Register<TestScreenshotTool>(c => new TestScreenshotTool())
.As<IScreenshotTool>()
.SingleInstance();
}
public static IContainer Configure(IdentityServerOptions options)
{
if (options == null) throw new ArgumentNullException("options");
if (options.Factory == null) throw new InvalidOperationException("null factory");
IdentityServerServiceFactory fact = options.Factory;
fact.Validate();
var builder = new ContainerBuilder();
builder.RegisterInstance(options).AsSelf();
// mandatory from factory
builder.Register(fact.UserService, "inner");
builder.RegisterDecorator<IUserService>((s, inner) =>
{
var filter = s.Resolve<IExternalClaimsFilter>();
return new ExternalClaimsFilterUserService(filter, inner);
}, "inner");
builder.Register(fact.ScopeStore);
builder.Register(fact.ClientStore);
// optional from factory
if (fact.AuthorizationCodeStore != null)
{
builder.Register(fact.AuthorizationCodeStore, "inner");
}
else
{
var inmemCodeStore = new InMemoryAuthorizationCodeStore();
builder.RegisterInstance(inmemCodeStore).Named<IAuthorizationCodeStore>("inner");
}
builder.RegisterDecorator<IAuthorizationCodeStore>((s, inner) =>
{
return new KeyHashingAuthorizationCodeStore(inner);
}, "inner");
if (fact.TokenHandleStore != null)
{
builder.Register(fact.TokenHandleStore, "inner");
}
else
{
var inmemTokenHandleStore = new InMemoryTokenHandleStore();
builder.RegisterInstance(inmemTokenHandleStore).Named<ITokenHandleStore>("inner");
}
builder.RegisterDecorator<ITokenHandleStore>((s, inner) =>
{
return new KeyHashingTokenHandleStore(inner);
}, "inner");
if (fact.RefreshTokenStore != null)
{
builder.Register(fact.RefreshTokenStore, "inner");
}
else
{
var inmemRefreshTokenStore = new InMemoryRefreshTokenStore();
builder.RegisterInstance(inmemRefreshTokenStore).Named<IRefreshTokenStore>("inner");
}
builder.RegisterDecorator<IRefreshTokenStore>((s, inner) =>
{
return new KeyHashingRefreshTokenStore(inner);
}, "inner");
if (fact.ConsentStore != null)
{
builder.Register(fact.ConsentStore);
}
else
{
var inmemConsentStore = new InMemoryConsentStore();
builder.RegisterInstance(inmemConsentStore).As<IConsentStore>();
}
if (fact.ClaimsProvider != null)
{
builder.Register(fact.ClaimsProvider);
}
else
{
builder.RegisterType<DefaultClaimsProvider>().As<IClaimsProvider>();
}
if (fact.TokenService != null)
{
builder.Register(fact.TokenService);
}
else
{
builder.RegisterType<DefaultTokenService>().As<ITokenService>();
}
if (fact.RefreshTokenService != null)
{
builder.Register(fact.RefreshTokenService);
}
else
{
builder.RegisterType<DefaultRefreshTokenService>().As<IRefreshTokenService>();
}
if (fact.TokenSigningService != null)
{
builder.Register(fact.TokenSigningService);
}
else
{
builder.RegisterType<DefaultTokenSigningService>().As<ITokenSigningService>();
}
if (fact.CustomRequestValidator != null)
{
builder.Register(fact.CustomRequestValidator);
}
else
{
builder.RegisterType<DefaultCustomRequestValidator>().As<ICustomRequestValidator>();
}
if (fact.CustomGrantValidator != null)
{
builder.Register(fact.CustomGrantValidator);
}
else
{
builder.RegisterType<DefaultCustomGrantValidator>().As<ICustomGrantValidator>();
}
if (fact.ExternalClaimsFilter != null)
{
builder.Register(fact.ExternalClaimsFilter);
}
else
{
builder.RegisterType<NopClaimsFilter>().As<IExternalClaimsFilter>();
}
if (fact.CustomTokenValidator != null)
{
builder.Register(fact.CustomTokenValidator);
}
else
{
builder.RegisterType<DefaultCustomTokenValidator>().As<ICustomTokenValidator>();
}
if (fact.ConsentService != null)
{
builder.Register(fact.ConsentService);
}
else
{
builder.RegisterType<DefaultConsentService>().As<IConsentService>();
}
if (fact.EventService != null)
{
builder.Register(fact.EventService);
}
else
{
builder.RegisterType<DefaultEventService>().As<IEventService>();
}
if (fact.RedirectUriValidator != null)
{
builder.Register(fact.RedirectUriValidator);
}
else
{
builder.RegisterType<DefaultRedirectUriValidator>().As<IRedirectUriValidator>();
}
// this is more of an internal interface, but maybe we want to open it up as pluggable?
// this is used by the DefaultClientPermissionsService below, or it could be used
// by a custom IClientPermissionsService
builder.Register(ctx =>
{
var consent = ctx.Resolve<IConsentStore>();
var refresh = ctx.Resolve<IRefreshTokenStore>();
var code = ctx.Resolve<IAuthorizationCodeStore>();
var access = ctx.Resolve<ITokenHandleStore>();
return new AggregatePermissionsStore(
consent,
new TokenMetadataPermissionsStoreAdapter(refresh.GetAllAsync, refresh.RevokeAsync),
new TokenMetadataPermissionsStoreAdapter(code.GetAllAsync, code.RevokeAsync),
new TokenMetadataPermissionsStoreAdapter(access.GetAllAsync, access.RevokeAsync)
);
}).As<IPermissionsStore>();
if (fact.ClientPermissionsService != null)
{
builder.Register(fact.ClientPermissionsService);
}
else
{
builder.RegisterType<DefaultClientPermissionsService>().As<IClientPermissionsService>();
}
if (fact.ViewService != null)
{
builder.Register(fact.ViewService);
}
else
{
builder.RegisterType<DefaultViewService>().As<IViewService>();
}
// hosting services
builder.RegisterType<OwinEnvironmentService>();
// validators
builder.RegisterType<TokenRequestValidator>();
builder.RegisterType<AuthorizeRequestValidator>();
builder.RegisterType<ClientValidator>();
builder.RegisterType<TokenValidator>();
builder.RegisterType<EndSessionRequestValidator>();
builder.RegisterType<BearerTokenUsageValidator>();
builder.RegisterType<ScopeValidator>();
// processors
builder.RegisterType<TokenResponseGenerator>();
builder.RegisterType<AuthorizeResponseGenerator>();
builder.RegisterType<AuthorizeInteractionResponseGenerator>();
builder.RegisterType<UserInfoResponseGenerator>();
builder.RegisterType<EndSessionResponseGenerator>();
// for authentication
var authenticationOptions = options.AuthenticationOptions ?? new AuthenticationOptions();
builder.RegisterInstance(authenticationOptions).AsSelf();
// load core controller
builder.RegisterApiControllers(typeof(AuthorizeEndpointController).Assembly);
// add any additional dependencies from hosting application
foreach(var registration in fact.Registrations)
{
builder.Register(registration);
}
return builder.Build();
}
/// <summary>
/// Registers the modules type bindings
/// </summary>
/// <param name="builder">
/// The builder.
/// </param>
protected override void Load(ContainerBuilder builder)
{
// Logging
#if DEBUG
var logger = new TraceLogger(this.logCategoryName, this.logCategoryName, true); // Logger with debug output
builder.RegisterInstance<ILogger>(logger);
#else
var logger = new TraceLogger(this.logCategoryName, this.logCategoryName, false); // Logger without debug output
builder.RegisterInstance<ILogger>(logger);
#endif
// Binding
builder.RegisterType<EntitySchemaFactory>().Named<IEntitySchemaFactory>("decorated");
builder.RegisterDecorator<IEntitySchemaFactory>((c, inner) => new CachedEntitySchemaFactory(inner, c.Resolve<ILogger>()), fromKey: "decorated");
builder.RegisterType<SharePointEntityBinder>().As<ISharePointEntityBinder>().InstancePerSite(); // Singleton-per-site entity binder
builder.RegisterType<FieldValueWriter>().As<IFieldValueWriter>();
var writers = new[]
{
typeof(StringValueWriter),
typeof(BooleanValueWriter),
typeof(IntegerValueWriter),
typeof(DoubleValueWriter),
typeof(DateTimeValueWriter),
typeof(GuidValueWriter),
typeof(TaxonomyValueWriter),
typeof(TaxonomyValueCollectionWriter),
typeof(LookupValueWriter),
typeof(LookupValueCollectionWriter),
typeof(PrincipalValueWriter),
typeof(UserValueWriter),
typeof(UserValueCollectionWriter),
typeof(UrlValueWriter),
typeof(ImageValueWriter),
typeof(MediaValueWriter)
};
writers.ToList().ForEach(w => builder.RegisterType(w).As<IBaseValueWriter>().SingleInstance());
builder.RegisterType<FieldValueReader>().As<IFieldValueReader>();
var readers = new[]
{
typeof(StringValueReader),
typeof(BooleanValueReader),
typeof(IntegerValueReader),
typeof(DoubleValueReader),
typeof(DateTimeValueReader),
typeof(GuidValueReader),
typeof(TaxonomyValueReader),
typeof(TaxonomyValueCollectionReader),
typeof(LookupValueReader),
typeof(LookupValueCollectionReader),
typeof(PrincipalValueReader),
typeof(UserValueReader),
typeof(UserValueCollectionReader),
typeof(UrlValueReader),
typeof(ImageValueReader),
typeof(MediaValueReader)
};
readers.ToList().ForEach(r => builder.RegisterType(r).As<IBaseValueReader>().SingleInstance());
// Branding
builder.RegisterType<MasterPageHelper>().As<IMasterPageHelper>();
builder.RegisterType<ExtraMasterPageBodyCssClasses>().As<IExtraMasterPageBodyCssClasses>();
builder.RegisterType<ComposedLookRepository>().As<IComposedLookRepository>();
builder.RegisterType<DisplayTemplateHelper>().As<IDisplayTemplateHelper>();
builder.RegisterType<ImageRenditionHelper>().As<IImageRenditionHelper>();
// Cache
builder.RegisterType<CacheHelper>().As<ICacheHelper>();
// CAML query builder and utilities
builder.RegisterType<CamlBuilder>().As<ICamlBuilder>();
builder.RegisterType<CamlUtils>().As<ICamlUtils>();
builder.RegisterType<QueryHelper>().As<IQueryHelper>();
// Catalogs
builder.RegisterType<CatalogHelper>().As<ICatalogHelper>();
// Configuration
builder.RegisterType<PropertyBagHelper>().As<IPropertyBagHelper>();
builder.RegisterType<PropertyBagConfiguration>().As<IConfiguration>();
builder.RegisterType<WebConfigModificationHelper>().As<IWebConfigModificationHelper>();
// ContentTypes
builder.RegisterType<ContentTypeHelper>().As<IContentTypeHelper>();
// Documents
builder.RegisterType<ContentOrganizerHelper>().As<IContentOrganizerHelper>();
// Events
builder.RegisterType<EventReceiverHelper>().As<IEventReceiverHelper>();
// Fields
builder.RegisterType<FieldHelper>().As<IFieldHelper>();
builder.RegisterType<FieldLocator>().As<IFieldLocator>();
builder.RegisterType<FieldSchemaHelper>().As<IFieldSchemaHelper>();
builder.RegisterType<FieldLookupHelper>().As<IFieldLookupHelper>();
// Folders
builder.RegisterType<FolderHelper>().As<IFolderHelper>();
// Files
builder.RegisterType<FileHelper>().As<IFileHelper>();
// Globalization + Variations (with default en-CA as source + fr-CA as destination implementation)
builder.RegisterType<ResourceLocator>().As<IResourceLocator>();
// It's the container user's responsibility to register a IResourceLocatorConfig implementation
builder.RegisterType<DefaultResourceLocatorConfig>().As<IResourceLocatorConfig>();
builder.RegisterType<MuiHelper>().As<IMuiHelper>();
builder.RegisterType<VariationExpert>().As<IVariationExpert>();
builder.RegisterType<VariationHelper>().As<IVariationHelper>();
builder.RegisterType<VariationSyncHelper>().As<IVariationSyncHelper>();
// Lists
builder.RegisterType<ListHelper>().As<IListHelper>();
builder.RegisterType<ListLocator>().As<IListLocator>();
builder.RegisterType<ListSecurityHelper>().As<IListSecurityHelper>();
builder.RegisterType<PublishedLinksEditor>().As<IPublishedLinksEditor>();
// Monitoring
builder.RegisterType<AggregateTimeTracker>().As<IAggregateTimeTracker>().InstancePerSite();
// Navigation
builder.RegisterType<NavigationService>().As<INavigationService>();
builder.RegisterType<NavigationHelper>().As<INavigationHelper>();
builder.RegisterType<VariationNavigationHelper>().As<IVariationNavigationHelper>();
// Pages
builder.RegisterType<PageHelper>().As<IPageHelper>();
// Repositories
builder.RegisterType<ItemLocator>().As<IItemLocator>();
// Search
builder.RegisterType<SearchHelper>().As<ISearchHelper>();
builder.RegisterType<QueryRuleHelper>().As<IQueryRuleHelper>();
// Security
builder.RegisterType<SecurityHelper>().As<ISecurityHelper>();
builder.RegisterType<UserHelper>().As<IUserHelper>();
// Serializers
builder.RegisterType<XmlHelper>().As<IXmlHelper>();
builder.RegisterType<JsonNetSerializer>().As<ISerializer>().SingleInstance();
// Taxonomy
builder.RegisterType<PerRequestSiteTaxonomyCacheManager>().As<ISiteTaxonomyCacheManager>();
builder.RegisterType<TaxonomyService>().As<ITaxonomyService>();
//// Example of monitored (profiled) instance - a typical decorator pattern use case:
////builder.RegisterType<TaxonomyService>().Named<ITaxonomyService>("decorated").InstancePerSite();
////builder.RegisterDecorator<ITaxonomyService>((c, inner) => new MonitoredTaxonomyService(inner, c.Resolve<IAggregateTimeTracker>()), fromKey: "decorated");
builder.RegisterType<TaxonomyHelper>().As<ITaxonomyHelper>();
// Timer Jobs
builder.RegisterType<TimerJobHelper>().As<ITimerJobHelper>();
// Utils
builder.RegisterType<CustomActionHelper>().As<ICustomActionHelper>();
builder.RegisterType<CatchallExceptionHandler>().As<ICatchallExceptionHandler>();
// Web Parts
builder.RegisterType<WebPartHelper>().As<IWebPartHelper>();
// Features
builder.RegisterType<FeatureDependencyActivator>().As<IFeatureDependencyActivator>();
}
public static void RegisterDependencies(Action<ContainerBuilder> beforeBuild = null)
{
var builder = new ContainerBuilder();
builder.RegisterHttpRequestMessage(GlobalConfiguration.Configuration);
builder.RegisterAssemblyTypes(
Assembly.Load("EasyTeach.Web"),
Assembly.Load("EasyTeach.Data"),
Assembly.Load("EasyTeach.Core"))
.AsImplementedInterfaces()
.AsSelf()
.Except<EasyTeachContext>(x => x.AsSelf()) //TODO: find a way to create EF context one per API request
.Except<XmlDocumentationProvider>()
.Except<LessonService>()
.Except<GroupService>()
.Except<VisitService>()
.Except<ScoreService>()
.Except<AuthLessonServiceWrapper>()
.Except<LogLessonServiceWrapper>()
.Except<AuthGroupServiceWrapper>()
.Except<LogGroupServiceWrapper>()
.Except<AuthVisitServiceWrapper>()
.Except<AuthScoreServiceWrapper>();
builder.Register<Func<IAuthenticationManager>>(c => () =>
{
HttpRequestMessage message = ResolveRequestMessage();
return message.GetOwinContext().Authentication;
}).InstancePerRequest();
builder.Register(c =>
{
HttpRequestMessage message = ResolveRequestMessage();
return (ClaimsPrincipal)message.GetOwinContext().Request.User;
});
builder.Register<Func<object, ValidationContext>>(c => o => new ValidationContext(o, new Adapter(), null));
builder.RegisterType<UserManager<IUserDto, int>>().AsSelf().PropertiesAutowired(PropertyWiringOptions.PreserveSetValues);
builder.RegisterHttpRequestMessage(GlobalConfiguration.Configuration);
builder.RegisterType<LessonService>();
builder.Register<AuthLessonServiceWrapper>(c =>
new AuthLessonServiceWrapper(
c.Resolve<LessonService>(),
c.Resolve<ClaimsPrincipal>(),
c.Resolve<EntityValidator>(),
c.Resolve<IUserStore<IUserDto, int>>(),
c.Resolve<Core.Security.ClaimsAuthorizationManager>()
));
builder.Register<ILessonService>(c => new LogLessonServiceWrapper(c.Resolve<AuthLessonServiceWrapper>()));
builder.RegisterType<GroupService>();
builder.Register<AuthGroupServiceWrapper>(c =>
new AuthGroupServiceWrapper(
c.Resolve<GroupService>(),
c.Resolve<ClaimsPrincipal>(),
c.Resolve<EntityValidator>(),
c.Resolve<IUserStore<IUserDto, int>>(),
c.Resolve<Core.Security.ClaimsAuthorizationManager>()
));
builder.Register<IGroupService>(c => new LogGroupServiceWrapper(c.Resolve<AuthGroupServiceWrapper>()));
//builder.RegisterType<LessonService>().Named<ILessonService>("lessonService");
//builder.RegisterDecorator<ILessonService>(
// (c, inner) =>
// new AuthLessonServiceWrapper(
// inner,
// c.Resolve<ClaimsPrincipal>(),
// c.Resolve<EntityValidator>(),
// c.Resolve<IUserStore<IUserDto, int>>(),
// c.Resolve<Core.Security.ClaimsAuthorizationManager>()),
// "lessonService");
//builder.RegisterDecorator<IGroupService>(
// (c, inner) =>
// {
// return new AuthGroupServiceWrapper(
// inner,
// c.Resolve<ClaimsPrincipal>(),
// c.Resolve<EntityValidator>(),
// c.Resolve<IUserStore<IUserDto, int>>(),
// c.Resolve<Core.Security.ClaimsAuthorizationManager>());
// }, "authGroupsServiceWrapper", "groupService").Named<IGroupService>("logGroupsServiceWrapper");
//builder.RegisterDecorator<IGroupService>(
// (c, inner) => {
// return new LogGroupServiceWrapper(inner);
// }, null, "logGroupsServiceWrapper");
//builder.RegisterType<GroupService>().Named<IGroupService>("groupService");
//builder.RegisterDecorator<IGroupService>(
// (c, inner) =>
// new AuthGroupServiceWrapper(
// inner,
// c.Resolve<ClaimsPrincipal>(),
// c.Resolve<EntityValidator>(),
// c.Resolve<IUserStore<IUserDto, int>>(),
// c.Resolve<Core.Security.ClaimsAuthorizationManager>()),
// "groupService");
builder.RegisterType<VisitService>().Named<IVisitService>("visitService");
builder.RegisterDecorator<IVisitService>(
(c, inner) =>
new AuthVisitServiceWrapper(
inner,
c.Resolve<ClaimsPrincipal>(),
c.Resolve<EntityValidator>(),
c.Resolve<IUserStore<IUserDto, int>>(),
c.Resolve<Core.Security.ClaimsAuthorizationManager>()),
"visitService");
builder.RegisterType<ScoreService>().Named<IScoreService>("scoreService");
builder.RegisterDecorator<IScoreService>(
(c, inner) =>
new AuthScoreServiceWrapper(
inner,
c.Resolve<ClaimsPrincipal>(),
c.Resolve<EntityValidator>(),
c.Resolve<IUserStore<IUserDto, int>>(),
c.Resolve<Core.Security.ClaimsAuthorizationManager>()),
"scoreService");
if (beforeBuild != null)
{
beforeBuild(builder);
}
IContainer container = builder.Build();
var resolver = new AutofacWebApiDependencyResolver(container);
GlobalConfiguration.Configuration.DependencyResolver = resolver;
}
