private static void ConfigureAutofac(HttpConfiguration config, IIssueStore issueStore)
{
var builder = new ContainerBuilder();
if (issueStore == null)
{
builder.RegisterType<InMemoryIssueStore>()
.As<IIssueStore>()
.InstancePerLifetimeScope();
}
else
{
builder.RegisterInstance(issueStore);
}
builder.RegisterType<IssueStateFactory>()
.As<IStateFactory<Issue, IssueState>>()
.InstancePerLifetimeScope();
builder.RegisterType<IssueLinkFactory>()
.InstancePerLifetimeScope();
builder.RegisterHttpRequestMessage(config);
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
var container = builder.Build();
var resolver =
new AutofacWebApiDependencyResolver(container);
config.DependencyResolver = resolver;
}
public static void Register()
{
var builder = new ContainerBuilder();
var config = GlobalConfiguration.Configuration;
builder.RegisterControllers(Assembly.GetExecutingAssembly()); //Register MVC Controllers
builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); //Register WebApi Controllers
builder.RegisterHttpRequestMessage(GlobalConfiguration.Configuration);
builder.RegisterAssemblyTypes(typeof(StateRepository).Assembly)
.Where(t => t.Name.EndsWith("Repository"))
.AsImplementedInterfaces().InstancePerLifetimeScope();
builder.RegisterType<EdLightEntities>().As<IDataContextAsync>().InstancePerRequest();
builder.RegisterType<DateTimeHelper>().As<IDateTimeHelper>().InstancePerLifetimeScope();
builder.RegisterType<WorkflowSetup>().As<IWorkflowSetup>().InstancePerLifetimeScope();
builder.RegisterType<WorkflowService>().As<IWorkflowService>().InstancePerLifetimeScope();
builder.RegisterType<WorkflowExpression>().As<IWorkflowExpression>().InstancePerLifetimeScope();
builder.RegisterType<EntityFrameorkUnitOfWork>().As<IUnitOfWorkAsync>().InstancePerRequest();
builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepositoryAsync<>)).InstancePerRequest();
builder.RegisterAssemblyTypes(typeof(StateService).Assembly)
.Where(t => t.Name.EndsWith("Service"))
.AsImplementedInterfaces().InstancePerLifetimeScope();
var container = builder.Build();
config.DependencyResolver = new AutofacWebApiDependencyResolver(container);
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
}
/// <summary>
/// Registers the configuration
/// </summary>
public static IContainer Register(IAppBuilder app, HttpConfiguration configuration, IServiceFacade serviceFacade = null)
{
Condition.Requires(configuration, "configuration").IsNotNull();
var builder = new ContainerBuilder();
builder.RegisterModule(new ServiceModule(serviceFacade));
// controllers
builder.RegisterApiControllers(typeof (ControllerBase).Assembly);
// request
builder.RegisterHttpRequestMessage(configuration);
// authorization
builder.RegisterType<AuthorizationServerProvider>().As<IOAuthAuthorizationServerProvider>().SingleInstance();
// set resolver
var container = builder.Build();
// set the dependency resolver for Web API
var resolver = new AutofacWebApiDependencyResolver(container);
configuration.DependencyResolver = resolver;
app.UseAutofacMiddleware(container);
app.UseAutofacWebApi(configuration);
ConfigureOAuth(app, container);
app.UseWebApi(configuration);
return container;
}
public async Task UriMaker_is_ctor_injected_using_Autofac()
{
var config = new HttpConfiguration();
// Autofac
var builder = new ContainerBuilder();
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
// Web API routes
var uriMakerContext = config.MapHttpAttributeRoutesAndUseUriMaker();
builder.RegisterInstance(uriMakerContext).ExternallyOwned();
builder.RegisterHttpRequestMessage(config);
builder.RegisterGeneric(typeof(UriMaker<>)).AsSelf().InstancePerRequest();
var container = builder.Build();
var resolver = new AutofacWebApiDependencyResolver(container);
config.DependencyResolver = resolver;
var client = new HttpClient(new HttpServer(config));
var res = await client.GetAsync("http://www.example.net/api/autofac/resources");
Assert.Equal(HttpStatusCode.OK,res.StatusCode);
var body = await res.Content.ReadAsAsync<ResourceState>();
Assert.Equal("http://www.example.net/api/autofac/resources", body.self.ToString());
Assert.Equal("http://www.example.net/api/autofac/resources?page=1&count=10", body.next.ToString());
Assert.Equal("http://www.example.net/api/autofac/resources/0", body.first.ToString());
Assert.Equal("http://www.example.net/api/autofac/resources/0?detailed=True", body.first_alternative.ToString());
}
private void ConfigureDependencies()
{
var builder = new ContainerBuilder();
builder.RegisterHttpRequestMessage(_configuration);
builder.Register(c => _configuration.Routes).As<HttpRouteCollection>();
builder.RegisterType<InMemoryBookRepository>().As<IInMemoryBookRepository>().InstancePerApiRequest();
builder.RegisterType<InMemoryFineRepository>().As<IInMemoryFineRepository>().InstancePerApiRequest();
builder.RegisterType<GetBookQueryHandler>();
builder.RegisterType<GetFinesQueryHandler>();
builder.RegisterType<PayFinesCommandHandler>();
builder.RegisterType<AllBooksQueryHandler>();
builder.RegisterType<AddBookCommandHandler>();
builder.RegisterType<DeleteBookCommandHandler>();
builder.RegisterType<AllCheckedInBooksQueryHandler>();
builder.RegisterType<CheckInCommandHandler>();
builder.RegisterType<AllCheckedOutBooksQueryHandler>();
builder.RegisterType<CheckOutCommandHandler>();
builder.RegisterType<BookResourceMapper>();
builder.RegisterType<GetLibraryRootHandler>();
builder.RegisterType<HttpUrlProvider>().As<IHttpUrlProvider>();
builder.RegisterType<ResourceLinker>().As<IResourceLinker>();
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
var container = builder.Build();
var resolver = new AutofacWebApiDependencyResolver(container);
_configuration.DependencyResolver = resolver;
}
private static void RegisterDrum( HttpConfiguration config, ContainerBuilder builder )
{
// Web API routes
UriMakerContext uriMakerContext = config.MapHttpAttributeRoutesAndUseUriMaker();
builder.RegisterInstance( uriMakerContext ).ExternallyOwned();
builder.RegisterHttpRequestMessage( config );
builder.RegisterGeneric( typeof( UriMaker<> ) ).AsSelf().InstancePerRequest();
builder.RegisterType<DrumUrlProvider>().As<IUrlProvider>();
}
/// <summary>
/// Register types dependent on HTTP configuration
/// </summary>
/// <remarks>Utilizes extension methods of the nuget package Autofac.WebApi2</remarks>
protected void RegisterHttpConfigurationTypes(ContainerBuilder containerBuilder)
{
HttpConfiguration httpConfiguration = new HttpConfiguration();
httpConfiguration.Formatters.XmlFormatter.SupportedMediaTypes.Clear();
httpConfiguration.EnableCors();
httpConfiguration.EnableSystemDiagnosticsTracing();
httpConfiguration.MapHttpAttributeRoutes();
containerBuilder.RegisterInstance<HttpConfiguration>(httpConfiguration);
containerBuilder.RegisterWebApiFilterProvider(httpConfiguration); // http://goo.gl/P84rhB
containerBuilder.RegisterHttpRequestMessage(httpConfiguration); // supports usage of IHttpRequestMessageOperator instead of alternative IQueryString
containerBuilder.RegisterApiControllers(typeof(AddressesController).Assembly);
}
public static void Configure(HttpConfiguration config)
{
config.Routes.MapHttpRoute(
"default", "{controller}/{id}",
new { id = RouteParameter.Optional });
var builder = new ContainerBuilder();
builder.RegisterType<FakeFriendRepository>().As<IFriendRepository>();
builder.RegisterType<FriendDocumentWriter>().As<ICollectionJsonDocumentWriter<Friend>>();
builder.RegisterType<FriendDocumentReader>().As<ICollectionJsonDocumentReader<Friend>>();
builder.RegisterApiControllers(typeof(ServiceConfiguration).Assembly);
builder.RegisterHttpRequestMessage(config);
var container = builder.Build();
var resolver = new AutofacWebApiDependencyResolver(container);
config.DependencyResolver = resolver;
}
public static void ConfigureContainer()
{
var builder = new Autofac.ContainerBuilder();
var config = GlobalConfiguration.Configuration;
builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); // controller
builder.RegisterWebApiFilterProvider(config); // filter
builder.RegisterHttpRequestMessage(GlobalConfiguration.Configuration);
builder.Register(e => // HttpContextBase
HttpContext.Current != null
? new HttpContextWrapper(HttpContext.Current)
: e.Resolve <HttpRequestMessage>().Properties["MS_HttpContext"])
.As <HttpContextBase>()
.InstancePerRequest();
builder.RegisterModule(new ServiceModule()); // Moduel
var container = builder.Build();
config.DependencyResolver = new AutofacWebApiDependencyResolver(container);
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterApiControllers(ThisAssembly);
//builder.RegisterWebApiFilterProvider(_httpConfiguration);
builder.RegisterHttpRequestMessage(_httpConfiguration);
}
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;
}
public static void ConfigureWebApi(IAppBuilder app, IContainer container)
{
HttpConfiguration config = new HttpConfiguration();
ContainerBuilder builder = new ContainerBuilder();
builder.RegisterHttpRequestMessage(config);
builder.Update(container);
config.SuppressDefaultHostAuthentication();
config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
config.Formatters.JsonFormatter.SerializerSettings = JsonSerializerSettings;
// fix for ie9 not supporting json
config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
JsonConvert.DefaultSettings = () => JsonSerializerSettings;
config.Filters.Add(new NLogTraceFilter());
config.Filters.Add(new NLogExceptionFilter());
config.Filters.Add(new DomainErrorExceptionFilter());
config.Filters.Add(new NoCacheActionFilter());
config.MapHttpAttributeRoutes(new CustomDirectRouteProvider());
foreach (IWebApiConfig webApiConfig in container.Resolve<IEnumerable<IWebApiConfig>>())
{
webApiConfig.RegisterRoutes(config);
}
app.UseAutofacWebApi(config);
app.UseWebApi(config);
}