Example #1
0
        public void Configuration(IAppBuilder app)
        {
            var listener = (HttpListener) app.Properties["System.Net.HttpListener"];

            listener.AuthenticationSchemeSelectorDelegate = r =>
            {
                Log.InfoFormat("Request from {0}", r.RemoteEndPoint);

                if (r.RemoteEndPoint != null && (_appSettings.IpAccessList.Contains(r.RemoteEndPoint.Address.ToString())))
                {
                    Log.InfoFormat("Ip listed, applying {0} authentication scheme", AuthenticationSchemes.Anonymous);
                    return AuthenticationSchemes.Anonymous;
                }

                Log.InfoFormat("Ip unknown, applying {0} authentication scheme", AuthenticationSchemes.IntegratedWindowsAuthentication);
                return AuthenticationSchemes.IntegratedWindowsAuthentication;
            };

            var builder = new ContainerBuilder();
            builder.RegisterApiControllers(Assembly.GetExecutingAssembly()).InstancePerRequest();
            builder.RegisterInstance(new DeployOption(_appSettings.InstallPath)).As<IDeployOption>();

            ;            var container = builder.Build();

            var config = new HttpConfiguration();
            config.MapHttpAttributeRoutes();

            var resolver = new AutofacWebApiDependencyResolver(container);
            config.DependencyResolver = resolver;

            app.UseAutofacMiddleware(container);
            app.UseWebApi(config);
        }
Example #2
0
        public static void Configure(IAppBuilder app)
        {
            if (app == null)
                throw new ArgumentNullException("app");

            IContainer container = IocConfiguration.BuildContainer(actorSystemName: "Wakka");
            app.UseAutofacMiddleware(container);

            HttpConfiguration webApiConfiguration = new HttpConfiguration
            {
                // Only used when mapping attribute routes.
                DependencyResolver = new AutofacWebApiDependencyResolver(container)
            };
            app.UseAutofacWebApi(webApiConfiguration); // Share OWIN lifetime scope.

            webApiConfiguration.MapHttpAttributeRoutes();
            webApiConfiguration.EnsureInitialized();

            app.UseWebApi(webApiConfiguration);

            // Explicitly start the actor system when the OWIN app is started.
            ActorSystem actorSystem = container.ResolveNamed<ActorSystem>("Wakka");

            // Try to gracefully shut down the actor system when the host is shutting down.
            AppProperties appProperties = new AppProperties(app.Properties);
            appProperties.OnAppDisposing.Register(() =>
            {
                actorSystem.Shutdown();
                actorSystem.AwaitTermination(
                    timeout: TimeSpan.FromSeconds(5)
                );
            });
        }
Example #3
0
        public static void Config(IAppBuilder app, HttpConfiguration config)
        {
            var builder = new ContainerBuilder();

            //register controllers
            builder.RegisterApiControllers(Assembly.GetExecutingAssembly()).InstancePerRequest();

            builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly()) //Register ***Services
                   .Where(t => t.Name.EndsWith("Service"))
                   .AsImplementedInterfaces();

            //Register Auth classes
            builder.RegisterType<AppDbContext>().As<DbContext>().InstancePerRequest();
            builder.RegisterType<UserStore<ApplicationUser>>().AsImplementedInterfaces().InstancePerRequest();
            builder.RegisterType<ApplicationUserManager>().AsSelf().InstancePerRequest();
            builder.RegisterType<RoleStore<IdentityRole>>().AsImplementedInterfaces().InstancePerRequest();
            builder.RegisterType<ApplicationRoleManager>().AsSelf().InstancePerRequest();

            //Register generics
            builder.RegisterGeneric(typeof(Repository<>)).AsImplementedInterfaces();

            // Register dependecy of MailerApiController from Postal dll
            builder.RegisterType<EmailService>().As<IEmailService>();

            var container = builder.Build();
            config.DependencyResolver = new AutofacWebApiDependencyResolver(container); //WebAPI

            app.UseAutofacMiddleware(container); //Register before MVC / WebApi
            app.UseAutofacWebApi(config);
        }
Example #4
0
        public void Configuration(IAppBuilder app)
        {
            var config = new HttpConfiguration();

            config.Routes.MapHttpRoute(
                "DefaultApi", "api/{controller}/{id}", new {id = RouteParameter.Optional});

            var builder = new ContainerBuilder();

            // Register Web API controller in executing assembly.
            builder.RegisterApiControllers(Assembly.GetExecutingAssembly());

            // Register a logger service to be used by the controller and middleware.
            builder.Register(c => new Logger()).As<ILogger>().InstancePerRequest();

            // Autofac will add middleware to IAppBuilder in the order registered.
            // The middleware will execute in the order added to IAppBuilder.
            builder.RegisterType<FirstMiddleware>().InstancePerRequest();
            builder.RegisterType<SecondMiddleware>().InstancePerRequest();

            var container = builder.Build();

            // Create and assign a dependency resolver for Web API to use.
            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);

            // This should be the first middleware added to the IAppBuilder.
            app.UseAutofacMiddleware(container);

            // Make sure the Autofac lifetime scope is passed to Web API.
            app.UseAutofacWebApi(config);

            app.UseWebApi(config);
        }
        public void ConfigureAutofac(IAppBuilder app)
        {
            var builder = new ContainerBuilder();

            builder.RegisterType<ConfigurationProvider>()
                .As<IConfigurationProvider>();

            builder.RegisterType<TelemetryService>()
                .As<ITelemetryService>();

            builder.RegisterType<IotHubRepository>()
               .As<IIotHubRepository>();

            builder.RegisterControllers(Assembly.GetExecutingAssembly());
            builder.RegisterApiControllers(Assembly.GetExecutingAssembly());

            var container = builder.Build();

            //Setup Autofac dependency resolver for MVC
            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

            //Setup Autofac dependency resolver for WebAPI
            HttpConfiguration.DependencyResolver = new AutofacWebApiDependencyResolver(container);

            app.UseAutofacMiddleware(container);
            app.UseAutofacWebApi(HttpConfiguration);


        }
Example #6
0
        public void Configuration(IAppBuilder app)
        {
            var builder = new ContainerBuilder();
            var config = new HttpConfiguration();
            // Identity Dependencies
            builder.RegisterType<ApplicationDbContext>().AsSelf().InstancePerLifetimeScope();
            builder.RegisterType<ApplicationUserStore>().As<IUserStore<ApplicationUser>>().InstancePerLifetimeScope();
            builder.RegisterType<ApplicationUserManager>().AsSelf().InstancePerLifetimeScope();
            builder.RegisterType<ApplicationSignInManager>().AsSelf().InstancePerLifetimeScope();
            builder.Register<IAuthenticationManager>(c => HttpContext.Current.GetOwinContext().Authentication);

            // Web Application Dependencies
            builder.RegisterType<StoreContext>().AsSelf().InstancePerRequest();
            builder.RegisterType<StoreItemService>().AsSelf();
            builder.RegisterType<ReceivingItemService>().AsSelf();

            // Autofac MVC Boilerplate
            builder.RegisterModule<AutofacWebTypesModule>();
            builder.RegisterFilterProvider();
            builder.RegisterControllers(typeof(MvcApplication).Assembly);

            //Autofac WebAPI2 Boilerplate
            builder.RegisterApiControllers(typeof(MvcApplication).Assembly);
            builder.RegisterWebApiFilterProvider(config);

            var container = builder.Build();
            GlobalConfiguration.Configuration.DependencyResolver = new AutofacWebApiDependencyResolver(container);

            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

            app.UseAutofacMiddleware(container);
            app.UseAutofacMvc();
            app.UseAutofacWebApi(config);
            ConfigureAuth(app);
        }
        public void Configuration(IAppBuilder app)
        {
            // Loads the config from our App.config
            XmlConfigurator.Configure();

            // MassTransit to use Log4Net
            Log4NetLogger.Use();

            var container = IocConfig.RegisterDependencies();

            // Sets the Mvc resolver
            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

            // Sets Mvc Owin resolver as well
            app.UseAutofacMiddleware(container);
            app.UseAutofacMvc();

            // Starts Mass Transit Service bus, and registers stopping of bus on app dispose
            var bus = container.Resolve<IBusControl>();
            var busHandle = bus.StartAsync().Result;

            if (app.Properties.ContainsKey("host.OnAppDisposing"))
            {
                var context = new OwinContext(app.Properties);
                var token = context.Get<CancellationToken>("host.OnAppDisposing");
                if (token != CancellationToken.None)
                {
                    token.Register(() => busHandle.Stop(TimeSpan.FromSeconds(30)));
                }
            }
        }
Example #8
0
        public void Configuration(IAppBuilder appBuilder)
        {
            var config = new HttpConfiguration();

            appBuilder.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);

            ContainerBuilder containerBuilder = new ContainerBuilder();

            containerBuilder.RegisterModule<HostingModule>();

            containerBuilder.RegisterApiControllers(Assembly.GetExecutingAssembly());

            var container = containerBuilder.Build();
            
            var resolver = new AutofacWebApiDependencyResolver(container);
            config.DependencyResolver = resolver;

            config.Formatters.Clear();
            config.Formatters.Add(new JsonMediaTypeFormatter());
            config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", new { id = RouteParameter.Optional });
            config.MapHttpAttributeRoutes();

            appBuilder.UseAutofacMiddleware(container);
            appBuilder.UseAutofacWebApi(config);
            appBuilder.UseWebApi(config);
        }
        public void ConfigureAutofac(IAppBuilder app)
        {
            var builder = new ContainerBuilder();

            // register the class that sets up bindings between interfaces and implementation
            builder.RegisterModule(new WebAutofacModule());

            // register configuration provider
            builder.RegisterType<ConfigurationProvider>().As<IConfigurationProvider>();

            // register Autofac w/ the MVC application
            builder.RegisterControllers(typeof(MvcApplication).Assembly);

            // Register the WebAPI controllers.
            builder.RegisterApiControllers(Assembly.GetExecutingAssembly());

            var container = builder.Build();

            // Setup Autofac dependency resolver for MVC
            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

            // Setup Autofac dependency resolver for WebAPI
            Startup.HttpConfiguration.DependencyResolver = new AutofacWebApiDependencyResolver(container);

            // 1.  Register the Autofac middleware 
            // 2.  Register Autofac Web API middleware,
            // 3.  Register the standard Web API middleware (this call is made in the Startup.WebApi.cs)
            app.UseAutofacMiddleware(container);
            app.UseAutofacWebApi(Startup.HttpConfiguration);
        }
Example #10
0
        public void Configuration(IAppBuilder app)
        {
            var builder = new ContainerBuilder();

            // STANDARD WEB API SETUP:

            // Get your HttpConfiguration. In OWIN, you'll create one
            // rather than using GlobalConfiguration.
            var config = new HttpConfiguration();

            // Register your Web API controllers.
            builder.RegisterApiControllers(Assembly.GetExecutingAssembly());

            // Run other optional steps, like registering filters,
            // per-controller-type services, etc., then set the dependency resolver
            // to be Autofac.
            //builder.RegisterType<StarWarsSchema>().As<ISchema>();
            builder.RegisterType<PlanningGameSchema>().As<ISchema>();

            var container = builder.Build();
            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);

            // OWIN WEB API SETUP:

            // Register the Autofac middleware FIRST, then the Autofac Web API middleware,
            // and finally the standard Web API middleware.
            app.UseAutofacMiddleware(container);
            app.UseAutofacWebApi(config);
            app.UseWebApi(config);
        }
Example #11
0
        public void Configuration(IAppBuilder app)
        {
            var builder = new ContainerBuilder();

            // REGISTER DEPENDENCIES
            builder.RegisterType<OnlineLibDbContext>().AsSelf().InstancePerRequest();
            builder.RegisterType<LibRoleStore>().As<IRoleStore<LibRole, Guid>>().InstancePerRequest();
            builder.RegisterType<LibUserStore>().As<IUserStore<LibUser, Guid>>().InstancePerRequest();
            builder.RegisterType<LibUserManager>().AsSelf().InstancePerRequest();
            builder.RegisterType<LinRoleManager>().AsSelf().InstancePerRequest();
            builder.RegisterType<LibSignInManager>().AsSelf().InstancePerRequest();
            builder.Register(c => HttpContext.Current.GetOwinContext().Authentication).InstancePerRequest();
            builder.Register(c => app.GetDataProtectionProvider()).InstancePerRequest();
            builder.RegisterType<LibraryRepository>().As<ILibraryRepository>().InstancePerRequest();
            builder.RegisterType<BooksRepository>().As<IBooksRepository>().InstancePerRequest();
            builder.RegisterType<EmailService>().As<IIdentityMessageService>().InstancePerRequest();

            // REGISTER CONTROLLERS
               // builder.RegisterControllers<AccountController>(typeof (ILibraryRepository)).AsSelf().InstancePerRequest();
            builder.RegisterControllers(typeof (MvcApplication).Assembly);

            // BUILD CONTAINER
            var container = builder.Build();

            // SET AUTOFAC DEPENDENCY RESOLVER
            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

            // REGISTER AUTOFAC WITH OWIN
            app.UseAutofacMiddleware(container);
            app.UseAutofacMvc();

            ConfigureAuth(app);
        }
Example #12
0
        public void Configuration(IAppBuilder app)
        {
            var builder = new ContainerBuilder();

            // REGISTER DEPENDENCIES
            builder.RegisterType<ApplicationDbContext>().AsSelf().InstancePerRequest();
            builder.RegisterType<ApplicationUserStore>().As<IUserStore<ApplicationUser>>().InstancePerRequest();
            builder.RegisterType<ApplicationUserManager>().AsSelf().InstancePerRequest();
            builder.RegisterType<ApplicationSignInManager>().AsSelf().InstancePerRequest();
            builder.Register<IAuthenticationManager>(c => HttpContext.Current.GetOwinContext().Authentication).InstancePerRequest();
            builder.Register<IDataProtectionProvider>(c => app.GetDataProtectionProvider()).InstancePerRequest();

            // REGISTER CONTROLLERS SO DEPENDENCIES ARE CONSTRUCTOR INJECTED
            builder.RegisterControllers(typeof(MvcApplication).Assembly);

            // BUILD THE CONTAINER
            var container = builder.Build();

            // REPLACE THE MVC DEPENDENCY RESOLVER WITH AUTOFAC
            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

            // REGISTER WITH OWIN
            app.UseAutofacMiddleware(container);
            app.UseAutofacMvc();

            ConfigureAuth(app);
        }
Example #13
0
        public void Configuration(IAppBuilder app)
        {
            // Setup db context for use in DI
            app.Use(async (context, next) =>
            {
                TestDbContext dbContext = _dbContextFactory(context);
                context.Set(DbContextKey, dbContext);

                await next();

                dbContext.Dispose();
            });

            var appContainerBuilder = new ContainerBuilder();
            appContainerBuilder.Register(ctx => HttpContext.Current.GetOwinContext()).As<IOwinContext>();
            appContainerBuilder.Register(c => c.Resolve<IOwinContext>().Get<TestDbContext>(DbContextKey)).As<TestDbContext>();
            appContainerBuilder.RegisterApiControllers(Assembly.GetExecutingAssembly());
            var appContainer = appContainerBuilder.Build();
            app.UseAutofacMiddleware(appContainer);

            var httpConfig = GetWebApiConfiguration();
            httpConfig.DependencyResolver = new AutofacWebApiDependencyResolver(appContainer);
            app.UseWebApi(httpConfig);
            app.UseAutofacWebApi(httpConfig);
        }
Example #14
0
        public void Configuration(IAppBuilder app)
        {
            var autoFacBuilder = new ContainerBuilder();
            HttpConfiguration config = new HttpConfiguration();

            ConfigureAutoFac(autoFacBuilder);
            autoFacBuilder.RegisterApiControllers(Assembly.GetExecutingAssembly());
            autoFacBuilder.RegisterWebApiFilterProvider(config);
            autoFacBuilder.RegisterWebApiModelBinders(Assembly.GetExecutingAssembly());
            var container = autoFacBuilder.Build();

            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);

            app.UseAutofacMiddleware(container);
            app.UseAutofacWebApi(config);
            ConfigureAuth(app);
            WebApiConfig.Register(config);


            app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
            app.UseWebApi(config);

            config.EnsureInitialized();

        }
Example #15
0
        public void Configuration(IAppBuilder app)
        {
            var config = new HttpConfiguration();
            ConfigureFilters(app, config);
            ConfigureWebApi(app, config);

            var container = ConfigureDI(app, config);

            app.UseAutofacWebApi(config);
            app.UseAutofacMiddleware(container);

            app.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions()
            {
                Provider = container.Resolve<IOAuthBearerAuthenticationProvider>()
            });

            app.UseOAuthAuthorizationServer(new OAuthAuthorizationServerOptions()
            {
                AllowInsecureHttp = true,
                TokenEndpointPath = new PathString("/api/auth/token"),
                AccessTokenExpireTimeSpan = TimeSpan.FromDays(7),
                Provider = container.Resolve<IOAuthAuthorizationServerProvider>()
            });

            app.UseWebApi(config);
        }
Example #16
0
        public void Configuration(IAppBuilder app)
        {
            var builder = new ContainerBuilder();
            builder.RegisterInstance(GetDbExecutor(ConnectionString)).As<IDbExecutor>();
            builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
            builder.RegisterType<SqlServerRepository>().As<IFeatureToggleRepository>().SingleInstance();
            builder.RegisterType<FeatureToggleValidator>().As<IFeatureToggleValidator>().SingleInstance();

            var container = builder.Build();

            app.UseCors(CorsOptions.AllowAll);
            app.UseAutofacMiddleware(container);

            var config = new HttpConfiguration();
            config.EnableSwagger(c => c.SingleApiVersion("v1", "Feature Toggle Service API"))
                  .EnableSwaggerUi();
            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);
            config.Formatters.Remove(config.Formatters.XmlFormatter);
            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            config.Services.Replace(typeof(IExceptionHandler), new UnhandledErrorService());

            app.Use(typeof(AuditMiddlware));
            app.UseWebApi(config);
        }
Example #17
0
        public void Configuration(IAppBuilder app)
        {
            var builder = new ContainerBuilder();
            var assemblies = BuildManager.GetReferencedAssemblies().Cast<Assembly>().ToArray();

            builder.RegisterType<Entities>().As<IDbContext>().InstancePerLifetimeScope();
            builder.RegisterType<ApplicationDbContext>().AsSelf().InstancePerLifetimeScope();

            builder.RegisterAssemblyTypes(typeof(IRepository<>).Assembly).AsClosedTypesOf(typeof(IRepository<>)).InstancePerRequest();

            builder.RegisterAssemblyTypes(ServiceAssembly).Where(type => typeof(ServiceBase).IsAssignableFrom(type) && !type.IsAbstract).AsImplementedInterfaces().InstancePerRequest();
            builder.RegisterAssemblyTypes(MapperAssembly).Where(type => typeof(MapperBase).IsAssignableFrom(type) && !type.IsAbstract).AsImplementedInterfaces().InstancePerRequest();

            builder.RegisterType<ApplicationUserStore>().As<IUserStore<ApplicationUser>>().InstancePerRequest();
            builder.RegisterType<ApplicationUserManager>().AsSelf().InstancePerRequest();
            builder.RegisterType<ApplicationSignInManager>().AsSelf().InstancePerRequest();
            builder.RegisterType<RoleStore<IdentityRole>>().As<IRoleStore<IdentityRole, string>>().InstancePerRequest();
            builder.RegisterType<ApplicationRoleManager>().AsSelf().InstancePerRequest();
            builder.Register(c => HttpContext.Current.GetOwinContext().Authentication).InstancePerRequest();
            builder.Register(c => app.GetDataProtectionProvider()).InstancePerRequest();

            builder.RegisterModule(new LoggingModule());

            builder.RegisterControllers(assemblies);

            var container = builder.Build();

            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

            app.UseAutofacMiddleware(container);
            app.UseAutofacMvc();

            ConfigureAuth(app);
        }
Example #18
0
        public void Configuration(IAppBuilder app)
        {
            var configuration = new ConfigurationService();

            var builder = new ContainerBuilder();
            builder.Register(c => configuration).As<ConfigurationService>().SingleInstance();
            builder.Register(c => configuration.CurrentConfiguration).As<IAppConfiguration>().SingleInstance();
            builder.Register(c => HttpContext.Current.GetOwinContext().Authentication).InstancePerRequest();

            var container = AutofacBootstrapper.Initialize(builder);

            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

            // Must register Autofac middleware FIRST!
            app.UseAutofacMiddleware(container);
            app.UseAutofacMvc();

            ConfigureAuth(app, configuration.CurrentConfiguration);

            AntiForgeryConfig.UniqueClaimTypeIdentifier = JwtClaimTypes.Subject;
            AntiForgeryConfig.RequireSsl = true;
            AntiForgeryConfig.CookieName = Prsd.Core.Web.Constants.CookiePrefix + Constants.AntiForgeryCookieName;

            MvcHandler.DisableMvcResponseHeader = true;

            AreaRegistration.RegisterAllAreas();
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);
            ModelBinders.Binders.DefaultBinder = new TrimModelBinder();
            DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(RequiredAttribute), typeof(WeeeRequiredAttributeAdapter));

            ApplicationVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString();
        }
        private void ConfigureDependencies(IAppBuilder app, 
            HttpConfiguration config)
        {
            // configure container
            ContainerBuilder builder = new ContainerBuilder();

            // bind all webapi controllers
            builder.RegisterApiControllers(Assembly.GetExecutingAssembly())
                .InstancePerRequest();

            // register context
            builder.RegisterType<TemplateAppContext>()
                .AsSelf()
                .InstancePerRequest();

            // register services
            builder.RegisterType<ConfigurationService>()
                .As<IConfigurationService>()
                .InstancePerLifetimeScope();
            builder.RegisterType<UserService>()
                .As<IUserService>()
                .InstancePerRequest();

            // create container
            IContainer container = builder.Build();

            // bind app to autofac
            app.UseAutofacMiddleware(container);
            app.UseAutofacWebApi(config);
        }
Example #20
0
        public void Configuration(IAppBuilder app)
        {
            // Loading a new configuration.
            var config = new HttpConfiguration();
            config.MapHttpAttributeRoutes();

            // Loading formatters.
            var jsonFormatter = config.Formatters.OfType<JsonMediaTypeFormatter>().First();
            jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
            jsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));

            // Resolving Dependencies
            var builder = new ContainerBuilder();
            builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
            builder.RegisterModule(new DataLayerModule());

            var container = builder.Build();
            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);

            // Configuring Mappings
            DataLayerMapping.AutoMapperStart();

            app.UseAutofacMiddleware(container);
            app.UseAutofacWebApi(config);
            app.UseWebApi(config);
        }
Example #21
0
        public static void Configure(IAppBuilder app)
        {
            var builder = new ContainerBuilder();

            // Register controllers
            builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
            builder.RegisterControllers(Assembly.GetExecutingAssembly());

            // Register repositories
            builder.RegisterType<ProductRepository>().As<IProductRepository>();
            builder.RegisterType<CurrencyRepository>().As<IRepositoryAsync<CurrencyRate>>();

            // Register services
            builder.RegisterType<CurrencyService>().As<ICurrencyService>();

            // Register data context
            builder.RegisterType<DHUEntities>().InstancePerRequest();
            builder.Register(c => new DHUEntities()).InstancePerLifetimeScope();

            var container = builder.Build();

            // Set the MVC and the WebApi dependency resolver.
            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
            GlobalConfiguration.Configuration.DependencyResolver = new AutofacWebApiDependencyResolver(container);

            app.UseAutofacMiddleware(container);
            app.UseAutofacMvc();
        }
        public static void Register(IAppBuilder app, HttpConfiguration config)
        {
            var aspNetIdentityAssembly = typeof(IMarkerAspNetIdentityInterface).Assembly;
            var cornhouseCoreAssembly = typeof (IMarkerCornhouseCoreInterface).Assembly;
            var executingAssembly = Assembly.GetExecutingAssembly();
            
            var builder = new ContainerBuilder();

            builder.Register(c => InitializeRavenDb.Initialize(aspNetIdentityAssembly)).As<IDocumentStore>().InstancePerLifetimeScope();
            builder.Register(c => c.Resolve<IDocumentStore>().OpenAsyncSession()).As<IAsyncDocumentSession>().InstancePerRequest();
            builder.Register(c => HttpContext.Current.User).InstancePerRequest();

            builder.RegisterType<ApplicationUserManager>().AsSelf().InstancePerRequest();
            builder.RegisterType<ApplicationRoleManager>().AsSelf().InstancePerRequest();
            builder.RegisterType<RavenUserStore>().AsSelf().InstancePerRequest();
            builder.RegisterType<RavenRoleStore>().AsSelf().InstancePerRequest();
            

            builder.Register(c => HttpContext.Current.GetOwinContext().Authentication).InstancePerRequest();
            builder.Register(c => app.GetDataProtectionProvider()).InstancePerRequest();

            builder.RegisterApiControllers(executingAssembly);
            builder.RegisterApiControllers(aspNetIdentityAssembly);

            builder.RegisterAssemblyTypes(executingAssembly).AsImplementedInterfaces().InstancePerRequest();
            builder.RegisterAssemblyTypes(aspNetIdentityAssembly).AsImplementedInterfaces().InstancePerRequest();
            builder.RegisterAssemblyTypes(cornhouseCoreAssembly).AsImplementedInterfaces().InstancePerRequest();
            
            
            var container = builder.Build();
            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);

            app.UseAutofacMiddleware(container);
            app.UseAutofacWebApi(config);            
        }
        public void ConfigureDI(IAppBuilder app, HttpConfiguration config)
        {
            // Start to build a container that will be able to produce objects
            var builder = new ContainerBuilder();

            // Register all the WebApi controllers in the Api assmebly, so that the container knows about them and can fill their dependencies when a controller is created.
            builder.RegisterApiControllers(typeof(Startup).Assembly);

             //Register the objects/types you want to be accessible from the container
            builder.Register(c => new UserDbContext()).As<UserDbContext>().InstancePerRequest();
            builder.Register(c =>
            {
                return new ApplicationUserManager(
                    new UserStore<ApplicationUser>(c.Resolve<UserDbContext>())
                );
            }).As<IApplicationUserManager>();

            // generate a container
            var container = builder.Build();

            // add a resolver to the WebApi framework so that it knows when it creates a controller it should ask the container for the controller.
            // before trying to create one with an empty constructor instead
            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);

            // Add container into the WebApi pipeline
            // Note: Not used in this project, but useful for creating custom Middleware and having their dependencies filled in.
            // See http://alexmg.com/owin-support-for-the-web-api-2-and-mvc-5-integrations-in-autofac/ for more information
            app.UseAutofacMiddleware(container);
            app.UseAutofacWebApi(config);
        }
Example #24
0
        public void Configuration(IAppBuilder app)
        {
            var configuration = new JsonApiConfiguration();
            configuration.RegisterEntityFrameworkResourceType<Building>();
            configuration.RegisterEntityFrameworkResourceType<City>();
            configuration.RegisterEntityFrameworkResourceType<Comment>();
            configuration.RegisterEntityFrameworkResourceType<Company>();
            configuration.RegisterEntityFrameworkResourceType<Language>();
            configuration.RegisterEntityFrameworkResourceType<LanguageUserLink>(c =>
            {
                c.OverrideDefaultFilterById(LanguageUserLinkFilterByIdFactory);
                c.OverrideDefaultSortById(LanguageUserLinkSortByIdFactory);
            });
            configuration.RegisterResourceType<Post>();
            configuration.RegisterEntityFrameworkResourceType<State>();
            configuration.RegisterEntityFrameworkResourceType<Tag>();
            configuration.RegisterEntityFrameworkResourceType<User>();
            configuration.RegisterEntityFrameworkResourceType<UserGroup>();
            configuration.RegisterResourceType<Sample>(); // Example of a resource type not controlled by EF
            configuration.RegisterMappedType<Starship, StarshipDto, StarshipDocumentMaterializer>(c =>
            {
                c.ConfigureRelationship(s => s.Officers,
                    rc => rc.UseMaterializer<StarshipOfficersRelatedResourceMaterializer>());
                c.ConfigureRelationship(s => s.ShipCounselor,
                    rc => rc.UseMaterializer<StarshipShipCounselorRelatedResourceMaterializer>());
            }); // Example of a resource that is mapped from a DB entity
            configuration.RegisterResourceType<StarshipOfficerDto>();

            var configurator = new JsonApiHttpAutofacConfigurator();
            configurator.OnApplicationLifetimeScopeCreating(builder =>
            {
                builder.Register(c => _dbContextFactory())
                    .AsSelf()
                    .As<DbContext>()
                    .InstancePerRequest();
                builder.RegisterModule<JsonApiAutofacEntityFrameworkModule>();
                builder.RegisterType<CustomEntityFrameworkResourceObjectMaterializer>()
                    .As<IEntityFrameworkResourceObjectMaterializer>();
                builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
            });
            configurator.OnApplicationLifetimeScopeBegun(applicationLifetimeScope =>
            {
                // TODO: is this a candidate for spinning into a JSONAPI.Autofac.WebApi.Owin package? Yuck
                app.UseAutofacMiddleware(applicationLifetimeScope);
            });

            var httpConfig = new HttpConfiguration
            {
                IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always
            };

            // Additional Web API routes
            httpConfig.Routes.MapHttpRoute("Samples", "samples", new { Controller = "Samples" });
            httpConfig.Routes.MapHttpRoute("Search", "search", new { Controller = "Search" });
            httpConfig.Routes.MapHttpRoute("Trees", "trees", new { Controller = "Trees" });

            configurator.Apply(httpConfig, configuration);
            app.UseWebApi(httpConfig);
            app.UseAutofacWebApi(httpConfig);
        }
Example #25
0
        public static void Configure(IAppBuilder app)
        {
            //Autofac configuration
            var builder = new ContainerBuilder();
            // Get your HttpConfiguration.
            var config = new HttpConfiguration();

            // Register your Web API controllers.
            builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
            builder.RegisterType<AccountController>().InstancePerRequest();
            builder.RegisterType<PhoneBookContext>().InstancePerRequest();

            //dependenses resolving
            builder.RegisterType<MainUserManager>().As<IMainUserManager>().InstancePerRequest();
            builder.Register(c => new UserStore<User>(c.Resolve<PhoneBookContext>())).AsImplementedInterfaces().InstancePerRequest();

            builder.RegisterType<ApplicationUserManager>().AsSelf();

            // Set the dependency resolver to be Autofac.
            var container = builder.Build();
            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);
            GlobalConfiguration.Configuration.DependencyResolver = new AutofacWebApiDependencyResolver(container);
            app.UseAutofacWebApi(config);
            app.UseAutofacMiddleware(container);
            app.UseAutofacWebApi(config);
            app.UseWebApi(config);
        }
        /// <summary>
        /// Configures the webApi dependency injection to start the service.
        /// </summary>
        /// <param name="app">The Azure app service mobile app to configure.</param>
        public static void ConfigureMobileApp(IAppBuilder app)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Services.Add(typeof(IExceptionLogger), new ApplicationInsightsExceptionLogger());

            IContainer container = ConfigureWebApiDependencies();
            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);
            config.MapHttpAttributeRoutes();

            new MobileAppConfiguration()
                .AddMobileAppHomeController()
                .MapApiControllers()
                .ApplyTo(config);

            app.UseAutofacMiddleware(container);
            app.UseAutofacWebApi(config);
            app.UseWebApi(config);

            // Configure Application Insights Telemetry.
            TelemetryConfiguration.Active.InstrumentationKey = SystemContext.Current.Environment.InstrumentationKey;

            var rootPath = HttpContext.Current.Server.MapPath("~");
            var serverPath = Path.Combine(rootPath, "bin");

            using (var scope = container.BeginLifetimeScope())
            {
                var repository = scope.Resolve<IRepository>();

                // Do database initialization synchronously
                repository.InitializeDatabaseIfNotExisting(serverPath).ConfigureAwait(false).GetAwaiter().GetResult();
            }
        }
Example #27
0
        protected virtual void Start(IAppBuilder app, IContainer container)
        {
            var config = CreateHttpConfiguration();

            ConfigureWebApi(config);

            if (Settings.ShowExceptionDetails)
            {
                app.UseErrorPage(new ErrorPageOptions
                {
                    ShowExceptionDetails = true,
                    ShowSourceCode = true
                });
            }
            
            app.UseAutofacMiddleware(container);
            app.UseAutofacWebApi(config);
            app.UseWebApi(config);
            RegisterSignalR(container, app);

            app.UseStageMarker(PipelineStage.MapHandler);

            RegisterServices(container, app, config);
            
            RegisterShutdown(app, container);

            StartIndexingIfConfigured(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 void Configuration(IAppBuilder app)
        {
            TI.trace("StartupServerAutofac", "Begin in memory server setup");
            Stopwatch sw = new Stopwatch();
            sw.Start();
            var configuration = new HttpConfiguration();
            //configuration.EnableSystemDiagnosticsTracing();
            //configuration.Routes.MapHttpRoute(
            //    name: "DefaultApi",
            //    routeTemplate: "api/{controller}/{id}",
            //    defaults: new { id = RouteParameter.Optional }
            //); 
            //add some temp route hacks
            configuration.Routes.MapHttpRoute(
                name: "Login1",
                routeTemplate: "Login/Login",
                defaults: new { controller = "Login", action = "LoginGet" });
             
            WebApiConfig.RegisterRoutes(configuration);
            WebApiConfig.RegisterIntegrationRoutes(configuration);
            DB_TestingHelper dbHelper = DefaultDbTestingHelper.GetDefaultDbTestingHelper();
            ContainerBuilder b = IOCHelper.InitializeServerWithAutofacContainer(dbHelper.Server_DistributrExmxConnection, dbHelper.MongoConnectionString, "win", dbHelper.MongoAuditingConnectionString);
            Assembly a = Assembly.GetAssembly(typeof(Distributr.WebApi.ApiControllers.CommandController));
            b.RegisterApiControllers(a);
            Autofac.IContainer c = b.Build();
            System.Web.Http.Dependencies.IDependencyResolver r = new AutofacWebApiDependencyResolver(c) ;
            configuration.DependencyResolver = r;
            app.UseAutofacMiddleware(c);
            app.UseAutofacWebApi(configuration);
            app.UseWebApi(configuration);
            sw.Stop();
            TI.trace("[StartupServerAutofac]",
                string.Format("Time taken to setup in memory server {0}", sw.ElapsedMilliseconds));

        }
Example #30
0
        public void Configuration(IAppBuilder app)
        {
            var builder = new ContainerBuilder();
            builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
            var container = builder.Build();


            app.UseAutofacMiddleware(container);

            var config = new HttpConfiguration();
            //config.EnableSwagger(c => c.SingleApiVersion("v1", "Feature Toggle Service API"))
            //      .EnableSwaggerUi();
            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);
            config.Formatters.Remove(config.Formatters.XmlFormatter);
            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            StartFeatureToggleService(container);

            //app.UseWebApi(config);
        }
Example #31
0
        /// <summary>
        /// Extension method to configure IdentityServer in the hosting application.
        /// </summary>
        /// <param name="app">The application.</param>
        /// <param name="options">The <see cref="IdentityServer.Core.Configuration.IdentityServerOptions"/>.</param>
        /// <returns></returns>
        /// <exception cref="System.ArgumentNullException">
        /// app
        /// or
        /// options
        /// </exception>
        public static IAppBuilder UseIdentityServer(this IAppBuilder app, IdentityServerOptions options)
        {
            if (app == null)
            {
                throw new ArgumentNullException("app");
            }
            if (options == null)
            {
                throw new ArgumentNullException("options");
            }

            options.Validate();

            // turn off weird claim mappings for JWTs
            JwtSecurityTokenHandler.InboundClaimTypeMap  = new Dictionary <string, string>();
            JwtSecurityTokenHandler.OutboundClaimTypeMap = new Dictionary <string, string>();

            if (options.RequireSsl)
            {
                app.Use <RequireSslMiddleware>();
            }

            if (options.LoggingOptions.EnableKatanaLogging)
            {
                app.SetLoggerFactory(new LibLogKatanaLoggerFactory());
            }

            app.UseEmbeddedFileServer();

            app.ConfigureRequestId();
            app.ConfigureDataProtectionProvider(options);
            app.ConfigureIdentityServerBaseUrl(options.PublicOrigin);
            app.ConfigureIdentityServerIssuer(options);

            app.ConfigureRequestBodyBuffer();

            // this needs to be earlier than the autofac middleware so anything is disposed and re-initialized
            // if we send the request back into the pipeline to render the logged out page
            app.ConfigureRenderLoggedOutPage();

            var container = AutofacConfig.Configure(options);

            app.UseAutofacMiddleware(container);

            app.UseCors();
            app.ConfigureCookieAuthentication(options.AuthenticationOptions.CookieOptions, options.DataProtector);

            // this needs to be before external middleware
            app.ConfigureSignOutMessageCookie();


            if (options.PluginConfiguration != null)
            {
                options.PluginConfiguration(app, options);
            }

            if (options.AuthenticationOptions.IdentityProviders != null)
            {
                options.AuthenticationOptions.IdentityProviders(app, Constants.ExternalAuthenticationType);
            }

            app.ConfigureHttpLogging(options.LoggingOptions);

            SignatureConversions.AddConversions(app);

            var httpConfig = WebApiConfig.Configure(options, container);

            app.UseAutofacWebApi(httpConfig);
            app.UseWebApi(httpConfig);

            using (var child = container.CreateScopeWithEmptyOwinContext())
            {
                var eventSvc = child.Resolve <IEventService>();
                // TODO -- perhaps use AsyncHelper instead?
                DoStartupDiagnosticsAsync(options, eventSvc).Wait();
            }

            return(app);
        }
Example #32
0
        public void Configuration(IAppBuilder app)
        {
            var dbConfiguration = MsSqlDbConfiguration("MSSQL");
            var assembly        = typeof(Startup).Assembly;
            var builder         = new ContainerBuilder();
            var container       = default(IContainer);

            IRegistrationBuilder <T, SimpleActivatorData, SingleRegistrationStyle>
            Register <T>(Func <IComponentContext, T> provider)
            => builder.Register <T>(provider).As <T>();

            Register(x =>
            {
                // конфигурирование FluentNH
                var fluentConfig = Fluently.Configure()
                                   .Database(dbConfiguration)
                                   .Mappings(m => m.FluentMappings.AddFromAssemblyOf <Users>())
                                   .CurrentSessionContext("call")
                                   .ExposeConfiguration(hConfig =>
                {
                    //SchemaMetadataUpdater.QuoteTableAndColumns(hConfig, MsSql2012Dialect.GetDialect());

                    var eventListeners = hConfig.EventListeners;

                    //eventListeners.PreUpdateEventListeners =
                    //    new IPreUpdateEventListener[] { new PreUpdateNoteListener() };

                    //eventListeners.PreInsertEventListeners =
                    //    new IPreInsertEventListener[] { new PreSaveNoteListener() };
                    // TODO: реализовать получение необходимых типов listener'ов
                });

                // сборка конфигурации
                var hibernateConfig = fluentConfig.BuildConfiguration();
                var schemaExport    = new SchemaUpdate(hibernateConfig);

                schemaExport.Execute(useStdOut: true, doUpdate: true);

                return(fluentConfig.BuildSessionFactory());
            }).SingleInstance();
            builder.RegisterControllers(typeof(ClientController).Assembly /*, ... Другие сборки*/);
            builder.RegisterModule(new AutofacWebTypesModule());

            builder.RegisterGeneric(typeof(Repository <>));

            // настройка процесса выдачи сессии
            {
                ISession createSession(IComponentContext x)
                => x.Resolve <ISessionFactory>().OpenSession();

                Register(createSession).InstancePerRequest();
                Register(createSession).InstancePerDependency();
            }

            // настройка разрешения зависимостей
            DependencyResolver.SetResolver(new AutofacDependencyResolver(container = builder.Build()));

            // настройка приложения
            app.UseAutofacMiddleware(container);

            ConfigureAuth(app);
        }
Example #33
0
        public void Configuration(IAppBuilder app)
        {
            var builder = new ContainerBuilder();

            builder.RegisterType <Scraper>()
            .As <IGatherDatabase>()
            .SingleInstance()
            .WithParameter(new TypedParameter(typeof(bool), ConfigurationManager.AppSettings["Environment"].ToString() == "Production"));

            builder.RegisterType <DatabaseFiller>()
            .As <IDatabaseFiller>()
            .SingleInstance();

            builder.RegisterType <DatabaseFactory>()
            .As <IDatabaseFactory>()
            .SingleInstance();

            builder.RegisterType <ApplicationUserRepository>()
            .As <IUserStore <ApplicationUser> >()
            .InstancePerRequest();

            builder.RegisterType <UniversityRepository>()
            .As <IUniversityRepository>()
            .InstancePerRequest();

            builder.RegisterType <FacultyRepository>()
            .As <IFacultyRepository>()
            .InstancePerRequest();

            builder.RegisterType <ReviewRepository>()
            .As <IReviewRepository>()
            .InstancePerRequest();

            builder.RegisterType <ProgrammeRepository>()
            .As <IProgrammeRepository>()
            .InstancePerRequest();

            builder.RegisterType <MapsEmbedApi>()
            .As <IMapsApi>()
            .InstancePerRequest();

            builder.RegisterType <PaginationHandler <University, UniversitySortOrder> >()
            .As <IPaginationHandler <University, UniversitySortOrder> >()
            .InstancePerRequest();

            builder.RegisterType <PaginationHandler <Review, ReviewSortOrder> >()
            .As <IPaginationHandler <Review, ReviewSortOrder> >()
            .InstancePerRequest();

            builder.RegisterType <ApplicationUserManager>()
            .AsSelf()
            .InstancePerRequest();

            builder.RegisterType <ApplicationSignInManager>()
            .AsSelf()
            .InstancePerRequest();

            builder.Register <IAuthenticationManager>(c => HttpContext.Current.GetOwinContext().Authentication)
            .InstancePerRequest();

            builder.Register <IDataProtectionProvider>(c => app.GetDataProtectionProvider())
            .InstancePerRequest();

            builder.RegisterType <RoleStore <IdentityRole> >()
            .As <IRoleStore <IdentityRole, string> >()
            .InstancePerRequest();

            builder.RegisterType <RoleManager <IdentityRole> >()
            .AsSelf()
            .InstancePerRequest();

            builder.RegisterControllers(typeof(MvcApplication).Assembly);

            var container = builder.Build();

            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

            app.UseAutofacMiddleware(container);
            app.UseAutofacMvc();

            InitializePaginationData();

            ConfigureAuth(app);
        }
Example #34
0
        public void Configuration(IAppBuilder app)
        {
            var configuration = new JsonApiConfiguration();

            configuration.RegisterEntityFrameworkResourceType <Building>();
            configuration.RegisterEntityFrameworkResourceType <City>();
            configuration.RegisterEntityFrameworkResourceType <Comment>();
            configuration.RegisterEntityFrameworkResourceType <Company>();
            configuration.RegisterEntityFrameworkResourceType <Language>();
            configuration.RegisterEntityFrameworkResourceType <LanguageUserLink>(c =>
            {
                c.OverrideDefaultFilterById(LanguageUserLinkFilterByIdFactory);
                c.OverrideDefaultSortById(LanguageUserLinkSortByIdFactory);
            });
            configuration.RegisterResourceType <Post>();
            configuration.RegisterEntityFrameworkResourceType <State>();
            configuration.RegisterEntityFrameworkResourceType <Tag>();
            configuration.RegisterEntityFrameworkResourceType <User>();
            configuration.RegisterEntityFrameworkResourceType <UserGroup>();
            configuration.RegisterResourceType <Sample>(); // Example of a resource type not controlled by EF
            configuration.RegisterMappedType <Starship, StarshipDto, StarshipDocumentMaterializer>(c =>
            {
                c.ConfigureRelationship(s => s.Officers,
                                        rc => rc.UseMaterializer <StarshipOfficersRelatedResourceMaterializer>());
                c.ConfigureRelationship(s => s.ShipCounselor,
                                        rc => rc.UseMaterializer <StarshipShipCounselorRelatedResourceMaterializer>());
            }); // Example of a resource that is mapped from a DB entity
            configuration.RegisterResourceType <StarshipOfficerDto>();

            var configurator = new JsonApiHttpAutofacConfigurator();

            configurator.OnApplicationLifetimeScopeCreating(builder =>
            {
                builder.Register(c => _dbContextFactory())
                .AsSelf()
                .As <DbContext>()
                .InstancePerRequest();
                builder.RegisterModule <JsonApiAutofacEntityFrameworkModule>();
                builder.RegisterType <CustomEntityFrameworkResourceObjectMaterializer>()
                .As <IEntityFrameworkResourceObjectMaterializer>();
                builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
            });
            configurator.OnApplicationLifetimeScopeBegun(applicationLifetimeScope =>
            {
                // TODO: is this a candidate for spinning into a JSONAPI.Autofac.WebApi.Owin package? Yuck
                app.UseAutofacMiddleware(applicationLifetimeScope);
            });

            var httpConfig = new HttpConfiguration
            {
                IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always
            };

            // Additional Web API routes
            httpConfig.Routes.MapHttpRoute("Samples", "samples", new { Controller = "Samples" });
            httpConfig.Routes.MapHttpRoute("Search", "search", new { Controller = "Search" });
            httpConfig.Routes.MapHttpRoute("Trees", "trees", new { Controller = "Trees" });

            configurator.Apply(httpConfig, configuration);
            app.UseWebApi(httpConfig);
            app.UseAutofacWebApi(httpConfig);
        }
Example #35
0
        public void Configuration(IAppBuilder app)
        {
            // In OWIN you create your own HttpConfiguration rather than
            // re-using the GlobalConfiguration.
            var config = new HttpConfiguration();

            SetCamelCaseForAllSerialzedObjects(config);

            config.Routes.MapHttpRoute(
                "DefaultApi",
                "{controller}/{action}");

            var builder = new ContainerBuilder();

            // Register Web API controller in executing assembly.
            var dataAccess = Assembly.GetExecutingAssembly();

            builder.RegisterApiControllers(dataAccess);

            // OPTIONAL - Register the filter provider if you have custom filters that need DI.
            // Also hook the filters up to controllers.
            builder.RegisterWebApiFilterProvider(config);
            builder.RegisterType <CustomActionFilter>()
            .AsWebApiActionFilterFor <ChannelController>()
            .InstancePerRequest();

            builder.RegisterAssemblyTypes(dataAccess)
            .Where(t => t.Name.EndsWith("Rep"))
            .AsImplementedInterfaces();

            // Register a logger service to be used by the controller and middleware.
            //builder.Register(c => new Logger()).As<ILogger>().InstancePerRequest();

            // Autofac will add middleware to IAppBuilder in the order registered.
            // The middleware will execute in the order added to IAppBuilder.
            builder.RegisterType <FirstMiddleware>().InstancePerRequest();
            builder.RegisterType <SecondMiddleware>().InstancePerRequest();

            // Create and assign a dependency resolver for Web API to use.
            var container = builder.Build();

            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);

            // The Autofac middleware should be the first middleware added to the IAppBuilder.
            // If you "UseAutofacMiddleware" then all of the middleware in the container
            // will be injected into the pipeline right after the Autofac lifetime scope
            // is created/injected.
            //
            // Alternatively, you can control when container-based
            // middleware is used by using "UseAutofacLifetimeScopeInjector" along with
            // "UseMiddlewareFromContainer". As long as the lifetime scope injector
            // comes first, everything is good.
            app.UseAutofacMiddleware(container);

            // Again, the alternative to "UseAutofacMiddleware" is something like this:
            app.UseAutofacLifetimeScopeInjector(container);
            //app.UseMiddlewareFromContainer<FirstMiddleware>();
            //app.UseMiddlewareFromContainer<SecondMiddleware>();

            // Make sure the Autofac lifetime scope is passed to Web API.
            app.UseAutofacWebApi(config);
            app.UseWebApi(config);
        }
Example #36
0
 /// <summary>
 /// Uses the IoC middleware.
 /// </summary>
 /// <param name="app">The application.</param>
 /// <param name="config">The configuration.</param>
 public static void UseIoCMiddleware(this IAppBuilder app, HttpConfiguration config)
 {
     app.UseAutofacMiddleware(IoC.Instance.Container);
     app.UseAutofacMvc();
     app.UseAutofacWebApi(config);
 }
Example #37
0
 public void Configuration(IAppBuilder app)
 {
     app.UseAutofacMiddleware(_container);
     ConfigureWebAPI(app);
 }
Example #38
0
        public void Configuration(IAppBuilder app)
        {
            var builder = new ContainerBuilder();

            builder.RegisterModule(new DataModule("FinalDBConn", app));

            // REGISTER CONTROLLERS SO DEPENDENCIES ARE CONSTRUCTOR INJECTED

            builder.RegisterControllers(typeof(MvcApplication).Assembly);

            // BUILD THE CONTAINER
            var container = builder.Build();

            // REPLACE THE MVC DEPENDENCY RESOLVER WITH AUTOFAC
            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

            // REGISTER WITH OWIN
            app.UseAutofacMiddleware(container);
            app.UseAutofacMvc();

            //Configuration(app);

            // Enable the application to use a cookie to store information for the signed in user
            // and to use a cookie to temporarily store information about a user logging in with a third party login provider
            // Configure the sign in cookie
            app.UseCookieAuthentication(MyOptions.OptionCookies());
            app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);

            // Enables the application to temporarily store user information when they are verifying the second factor in the two-factor authentication process.
            app.UseTwoFactorSignInCookie(DefaultAuthenticationTypes.TwoFactorCookie, TimeSpan.FromMinutes(5));

            // Enables the application to remember the second login verification factor such as phone or email.
            // Once you check this option, your second step of verification during the login process will be remembered on the device where you logged in from.
            // This is similar to the RememberMe option when you log in.
            app.UseTwoFactorRememberBrowserCookie(DefaultAuthenticationTypes.TwoFactorRememberBrowserCookie);

            // Uncomment the following lines to enable logging in with third party login providers
            //app.UseMicrosoftAccountAuthentication(
            //    clientId: "",
            //    clientSecret: "");

            //app.UseTwitterAuthentication(
            //   consumerKey: "",
            //   consumerSecret: "");


            app.UseFacebookAuthentication(new FacebookAuthenticationOptions()
            {
                AppId     = "1991172914492732",
                AppSecret = "00f559d9093d1a7c106b828d9b9715c9",
                BackchannelHttpHandler  = new HttpClientHandler(),
                UserInformationEndpoint = "https://graph.facebook.com/v2.8/me?fields=id,name,email,first_name,last_name,birthday",
                //Scope = { "email" },
                Provider = new FacebookAuthenticationProvider()
                {
                    OnAuthenticated = async context =>
                    {
                        context.Identity.AddClaim(new System.Security.Claims.Claim("FacebookAccessToken", context.AccessToken));
                        foreach (var claim in context.User)
                        {
                            var claimType     = string.Format("urn:facebook:{0}", claim.Key);
                            string claimValue = claim.Value.ToString();
                            if (!context.Identity.HasClaim(claimType, claimValue))
                            {
                                context.Identity.AddClaim(new System.Security.Claims.Claim(claimType, claimValue, "XmlSchemaString", "Facebook"));
                            }
                        }
                    }
                }
            });

            //var facebookOptions = new FacebookAuthenticationOptions()
            //{
            //    AppId = "1991172914492732",
            //    AppSecret = "00f559d9093d1a7c106b828d9b9715c9"
            //};

            //facebookOptions.Scope.Add("email");

            //facebookOptions.Fields.Add("name");
            //facebookOptions.Fields.Add("email");
            //facebookOptions.Fields.Add("first_name");
            //facebookOptions.Fields.Add("last_name");
            //facebookOptions.Fields.Add("birthday");

            //app.UseFacebookAuthentication(facebookOptions);



            //app.UseGoogleAuthentication(new GoogleOAuth2AuthenticationOptions()
            //{
            //    ClientId = "",
            //    ClientSecret = ""
            //});
        }
Example #39
0
        public void Configuration(IAppBuilder app)
        {
            var builder = new ContainerBuilder();

            builder.RegisterType <MongoContext>().AsImplementedInterfaces <MongoContext, ConcreteReflectionActivatorData>().SingleInstance();

            builder.RegisterType <AuthRepository>().SingleInstance();
            builder.RegisterType <CalculatorRepository>().SingleInstance();
            //builder.RegisterType<CalculatorRepository>()
            //    .WithParameters(new Parameter[]
            //    {
            //        new ResolvedParameter((info, context) => info.Name == "mongoContext",
            //            (info, context) => context.Resolve<IMongoContext>()),
            //        new ResolvedParameter((info, context) => info.Name == "userManager",
            //            (info, context) => context.Resolve<ApplicationUserManager>())
            //    }).SingleInstance();

            builder.RegisterType <ApplicationIdentityContext>()
            .SingleInstance();

            builder.RegisterType <UserStore <User> >()
            .AsImplementedInterfaces <IUserStore <User>, ConcreteReflectionActivatorData>()
            .SingleInstance();

            builder.RegisterType <RoleStore <Role> >()
            .AsImplementedInterfaces <IRoleStore <Role>, ConcreteReflectionActivatorData>()
            .SingleInstance();

            builder.RegisterType <ApplicationUserManager>()
            .SingleInstance();

            builder.RegisterType <ApplicationRoleManager>()
            .SingleInstance();

            builder.RegisterType <SimpleAuthorizationServerProvider>()
            .AsImplementedInterfaces <IOAuthAuthorizationServerProvider, ConcreteReflectionActivatorData>().SingleInstance();

            builder.RegisterType <SimpleRefreshTokenProvider>()
            .AsImplementedInterfaces <IAuthenticationTokenProvider, ConcreteReflectionActivatorData>().SingleInstance();

            //builder.RegisterType<SimpleAuthorizationServerProvider>()
            //    .AsImplementedInterfaces<IOAuthAuthorizationServerProvider, ConcreteReflectionActivatorData>()
            //    .WithParameters(new Parameter[]
            //    {
            //        new NamedParameter("publicClientId", "self"),
            //        new ResolvedParameter((info, context) => info.Name == "userManager",
            //            (info, context) => context.Resolve<ApplicationUserManager>())
            //    });

            builder.RegisterApiControllers(typeof(Startup).Assembly);

            var container = builder.Build();

            app.UseAutofacMiddleware(container);

            var webApiDependencyResolver = new AutofacWebApiDependencyResolver(container);

            var configuration = new HttpConfiguration
            {
                DependencyResolver = webApiDependencyResolver
            };

            ConfigureOAuth(app, container);

            WebApiConfig.Register(configuration);

            app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);

            app.UseWebApi(configuration);

            app.UseAutofacWebApi(configuration);

            InitializeData(container);
        }
Example #40
0
        public void Configuration(IAppBuilder app)
        {
            HttpConfiguration config = new HttpConfiguration();

            IContainer container = null;
            AutofacWebApiDependencyResolver dependencyResolver = null;
            var builder = new ContainerBuilder();

            builder.Register(context =>
            {
                var busControl = Bus.Factory.CreateUsingRabbitMq(cfg =>
                {
                    IRabbitMqHost rabbitMqHost = cfg.Host(new Uri(ConfigurationManager.AppSettings["RabbitMQHost"]), settings =>
                    {
                        settings.Username(ConfigurationManager.AppSettings["RabbitMQUser"]);
                        settings.Password(ConfigurationManager.AppSettings["RabbitMQPassword"]);
                    });
                });

                return(busControl);
            })
            .As <IBusControl>()
            .As <IBus>()
            .SingleInstance();

            builder.RegisterType <MyService>().As <IMyService>().InstancePerRequest();
            builder.RegisterAssemblyTypes(AppDomain.CurrentDomain.GetAssemblies())
            .AsClosedTypesOf(typeof(IHandle <>))
            .AsImplementedInterfaces()
            .InstancePerRequest();

            // builder.Register(c => new QueryProcessor(c.Resolve<IComponentContext>()))
            //builder.Register<IDomainEvents>(_ => new DomainEvents(container, "")).InstancePerRequest();
            //builder.Register<IDomainEvents>(_ => new DomainEvents(container)).InstancePerRequest();
            builder.RegisterType <DomainEvents>().As <IDomainEvents>().InstancePerRequest();

            // Register Web API controllers
            builder.RegisterApiControllers(Assembly.GetExecutingAssembly());

            // Resolve dependencies
            container                 = builder.Build();
            dependencyResolver        = new AutofacWebApiDependencyResolver(container);
            config.DependencyResolver = dependencyResolver;

            WebApiConfig.Register(config);
            SwaggerConfig.Register(config);
            app.UseCors(CorsOptions.AllowAll);

            // Register the Autofac middleware FIRST.
            app.UseAutofacMiddleware(container);
            app.UseWebApi(config);

            // Starts MassTransit Service bus, and registers stopping of bus on app dispose
            var bus        = container.Resolve <IBusControl>();
            var busHandle  = bus.StartAsync();
            var properties = new AppProperties(app.Properties);

            if (properties.OnAppDisposing != CancellationToken.None)
            {
                properties.OnAppDisposing.Register(() => busHandle.Result.StopAsync(TimeSpan.FromSeconds(30)));
            }
        }
Example #41
0
        public void Configuration(IAppBuilder app)
        {
            AntiForgeryConfig.UniqueClaimTypeIdentifier = Constants.ClaimTypes.Subject;
            JwtSecurityTokenHandler.InboundClaimTypeMap = new Dictionary <string, string>();
            Log.Logger = new LoggerConfiguration()
                         .MinimumLevel.Debug()
                         .WriteTo.File(@"c:\logs\sts.identityserver.txt")
                         .CreateLogger();

            IContainer container = AutofacConfig.ConfigureContainer();

            app.UseAutofacMiddleware(container);

            app.Map("/identity", coreApp =>
            {
                var factory = new IdentityServerServiceFactory()
                              .UseInMemoryClients(Clients.Get())
                              .UseInMemoryScopes(Scopes.Get());
                //.UseInMemoryUsers(Users.Get());


                factory.UserService = new Registration <IUserService, UserService>();

                var options = new IdentityServerOptions
                {
                    SiteName              = "Duy Tan Security Token Service",
                    SigningCertificate    = Certificate.Get(),
                    Factory               = factory,
                    RequireSsl            = false,
                    EnableWelcomePage     = true,
                    AuthenticationOptions = new IdentityServer3.Core.Configuration.AuthenticationOptions
                    {
                        EnablePostSignOutAutoRedirect = true,
                        EnableSignOutPrompt           = true
                    },
                    EventsOptions = new EventsOptions
                    {
                        RaiseSuccessEvents     = true,
                        RaiseErrorEvents       = true,
                        RaiseFailureEvents     = true,
                        RaiseInformationEvents = true
                    }
                };

                coreApp.UseIdentityServer(options);
            });

            app.UseResourceAuthorization(new AuthorizationManager());

            app.UseCookieAuthentication(new CookieAuthenticationOptions
            {
                AuthenticationType = CookieAuthenticationDefaults.AuthenticationType,
            });

            app.UseOpenIdConnectAuthentication(new OpenIdConnectAuthenticationOptions
            {
                Authority          = "http://localhost:58891/identity",
                AuthenticationType = "oidc",
                ClientId           = "mvc",
                Scope        = "openid profile roles sampleApi",
                ResponseType = "id_token token",
                RedirectUri  = "http://localhost:58891",
                // PostLogoutRedirectUri = "http://localhost:58891",
                SignInAsAuthenticationType = CookieAuthenticationDefaults.AuthenticationType,
                UseTokenLifetime           = false,

                Notifications = new OpenIdConnectAuthenticationNotifications
                {
                    SecurityTokenValidated = async n =>
                    {
                        var nid = new ClaimsIdentity(
                            n.AuthenticationTicket.Identity.AuthenticationType,
                            Constants.ClaimTypes.GivenName,
                            Constants.ClaimTypes.Role);

                        // get userinfo data
                        var userInfoClient = new UserInfoClient(
                            new Uri(n.Options.Authority + "/connect/userinfo"),
                            n.ProtocolMessage.AccessToken);

                        var userInfo = await userInfoClient.GetAsync();
                        userInfo.Claims.ToList().ForEach(ui => nid.AddClaim(new Claim(ui.Item1, ui.Item2)));

                        // keep the id_token for logout
                        nid.AddClaim(new Claim("id_token", n.ProtocolMessage.IdToken));

                        // add access token for sample API
                        nid.AddClaim(new Claim("access_token", n.ProtocolMessage.AccessToken));

                        // keep track of access token expiration
                        nid.AddClaim(new Claim("expires_at", DateTimeOffset.Now.AddSeconds(int.Parse(n.ProtocolMessage.ExpiresIn)).ToString()));

                        // add some other app specific claim
                        nid.AddClaim(new Claim("app_specific", "some data"));

                        n.AuthenticationTicket = new AuthenticationTicket(
                            nid,
                            n.AuthenticationTicket.Properties);
                    },

                    AuthenticationFailed = n => {
                        return(Task.FromResult(0));
                    },

                    RedirectToIdentityProvider = n =>
                    {
                        if (n.ProtocolMessage.RequestType == OpenIdConnectRequestType.LogoutRequest)
                        {
                            var idTokenHint = n.OwinContext.Authentication.User.FindFirst("id_token");

                            if (idTokenHint != null)
                            {
                                n.ProtocolMessage.IdTokenHint = idTokenHint.Value;
                            }
                        }

                        return(Task.FromResult(0));
                    }
                }
            });
        }
Example #42
0
        public void Configuration(IAppBuilder app)
        {
            Log.Logger = new LoggerConfiguration()
                         .MinimumLevel.Debug()
                         .WriteTo.RollingFile(HttpContext.Current.Request.PhysicalApplicationPath + @"\logs\sts.identityserver-{Date}.txt")
                         .CreateLogger();
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
            ServicePointManager.ServerCertificateValidationCallback = delegate(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) { return(true); };
            AntiForgeryConfig.UniqueClaimTypeIdentifier             = IdentityServer3Constants.ClaimTypes.Subject;
            JwtSecurityTokenHandler.InboundClaimTypeMap             = new Dictionary <string, string>();
            // Adjust the configuration for anti-CSRF protection to the new unique sub claim type
            JwtSecurityTokenHandler.InboundClaimTypeMap.Clear();

            IContainer container = AutofacConfig.ConfigureContainer();

            app.UseAutofacMiddleware(container);

            CustomLanguageManager customLanguageManager = new CustomLanguageManager(container.Resolve <ILanguageManager>());

            ValidatorOptions.LanguageManager = customLanguageManager;

            app.Use(async(context, next) =>
            {
                try
                {
                    await next();
                }
                catch (Exception ex)
                {
                    Log.Error(ex, "OWIN error.");
                }
            });

            app.Map("/windows", ConfigureWindowsTokenProvider);

            app.Map("/identity", idsrvApp =>
            {
                idsrvApp.UseAutofacMiddleware(container);
                IdentityServerServiceFactory factory = new IdentityServerServiceFactory();
                factory.CustomGrantValidators.Add(new Registration <ICustomGrantValidator>(typeof(WindowsGrantValidator)));
                factory.UserService = new Registration <IUserService, UserService>();
                factory.ScopeStore  = new Registration <IScopeStore>(container.Resolve <IScopeStore>());
                factory.ClientStore = new Registration <IClientStore>(container.Resolve <IClientStore>());
                IdentityModelEventSource.ShowPII       = true;
                IdentityModelEventSource.HeaderWritten = true;

                var cors = new DefaultCorsPolicyService
                {
                    AllowAll = true
                };
                factory.CorsPolicyService = new Registration <ICorsPolicyService>(cors);

                //var subjects = X509.LocalMachine.My.SubjectDistinguishedName;

                IdentityServerOptions options = new IdentityServerOptions
                {
                    SiteName              = "Duy Tan Security Token Service",
                    SigningCertificate    = Certificate.Get(), //X509.LocalMachine.My.SubjectDistinguishedName.Find("CN=localhost").First(),//Certificate.Get(),//X509.LocalMachine.My.SerialNumber.Find("CN =*.duytan.com OU=IT O=Duy Tan Plastics Manufacturing Corporation L=Ho Chi Minh C=VN").First(),//Certificate.Get(),
                    Factory               = factory,
                    RequireSsl            = false,
                    EnableWelcomePage     = true,
                    AuthenticationOptions = new IdentityServer3.Core.Configuration.AuthenticationOptions
                    {
                        EnablePostSignOutAutoRedirect = true,
                        EnableSignOutPrompt           = false,
                    },
                    EventsOptions = new EventsOptions
                    {
                        RaiseSuccessEvents     = true,
                        RaiseErrorEvents       = true,
                        RaiseFailureEvents     = true,
                        RaiseInformationEvents = true
                    },
                    LoggingOptions = new LoggingOptions
                    {
                        EnableWebApiDiagnostics    = true,
                        WebApiDiagnosticsIsVerbose = true,
                        EnableHttpLogging          = true,
                        EnableKatanaLogging        = true
                    }
                };

                if (Configs.WindowAuth)
                {
                    options.AuthenticationOptions = new IdentityServer3.Core.Configuration.AuthenticationOptions
                    {
                        EnablePostSignOutAutoRedirect = true,
                        EnableSignOutPrompt           = false,
                        EnableLocalLogin  = false,
                        IdentityProviders = ConfigureIdentityProviders,
                        EnableAutoCallbackForFederatedSignout = true,
                    };
                }

                idsrvApp.UseIdentityServer(options);
            });

            app.UseResourceAuthorization(new AuthorizationManager());

            app.UseKentorOwinCookieSaver();

            /*app.UseCookieAuthentication(new CookieAuthenticationOptions
             * {
             *  AuthenticationType = "Cookies",
             *  CookieManager = new SystemWebChunkingCookieManager()
             *
             * });*/



            /*object section = ConfigurationManager.GetSection("openIdConnectionOptionSection");
             *
             * if (section != null)
             * {
             *  OpenIdConnectionOption openIdConnectionOption = (section as OpenIdConnectionOptionSection).OpenIdConnectionOption;
             *  app.UseOpenIdConnectAuthentication(new OpenIdConnectAuthenticationOptions
             *  {
             *      Authority = openIdConnectionOption.Authority,
             *      ClientId = openIdConnectionOption.ClientId,
             *      Scope = openIdConnectionOption.Scopes,
             *      ResponseType = openIdConnectionOption.ResponseType,
             *      RedirectUri = openIdConnectionOption.RedirectUri,
             *      SignInAsAuthenticationType = openIdConnectionOption.SignInAsAuthenticationType,
             *      UseTokenLifetime = openIdConnectionOption.UseTokenLifetime,
             *      Notifications = new OpenIdConnectAuthenticationNotifications
             *      {
             *          AuthenticationFailed = context =>
             *          {
             *              context.HandleResponse();
             *              context.Response.Redirect("/Error?message=" + context.Exception.Message);
             *              return Task.FromResult(0);
             *          },
             *          MessageReceived = n => {
             *              return Task.FromResult(0);
             *          },
             *          SecurityTokenValidated = async n =>
             *              {
             *                  ClaimsIdentity nid = new ClaimsIdentity(
             *                   n.AuthenticationTicket.Identity.AuthenticationType,
             *                   ClaimTypes.GivenName,
             *                   ClaimTypes.Role);
             *
             *                      // get userinfo data
             #pragma warning disable CS0618 // Type or member is obsolete
             *                      UserInfoClient userInfoClient = new UserInfoClient(
             #pragma warning restore CS0618 // Type or member is obsolete
             *                  n.Options.Authority + "/connect/userinfo");
             *
             *                  UserInfoResponse userInfo = await userInfoClient.GetAsync(n.ProtocolMessage.AccessToken);
             *                  userInfo.Claims.ToList().ForEach(ui => nid.AddClaim(new Claim(ui.Type, ui.Value)));
             *
             *                      // keep the id_token for logout
             *                      nid.AddClaim(new Claim("id_token", n.ProtocolMessage.IdToken));
             *
             *                      // add access token for sample API
             *                      nid.AddClaim(new Claim("access_token", n.ProtocolMessage.AccessToken));
             *
             *                      // keep track of access token expiration
             *                      nid.AddClaim(new Claim("expires_at", DateTimeOffset.Now.AddSeconds(int.Parse(n.ProtocolMessage.ExpiresIn)).ToString()));
             *
             *                      // add some other app specific claim
             *                      nid.AddClaim(new Claim("app_specific", "some data"));
             *
             *                  n.AuthenticationTicket = new AuthenticationTicket(
             *                      nid,
             *                      n.AuthenticationTicket.Properties);
             *              },
             *
             *          RedirectToIdentityProvider = n =>
             *              {
             *                  if (n.ProtocolMessage.RequestType == Microsoft.IdentityModel.Protocols.OpenIdConnectRequestType.LogoutRequest)
             *                  {
             *                      string uri = ConfigurationManager.AppSettings["Host"].ToString();
             *                      n.ProtocolMessage.RedirectUri = $"{uri}/";
             *                      n.ProtocolMessage.PostLogoutRedirectUri = $"{uri}/";
             *                      Claim idTokenHint = n.OwinContext.Authentication.User.FindFirst("id_token");
             *
             *                      if (idTokenHint != null)
             *                      {
             *                          n.ProtocolMessage.IdTokenHint = idTokenHint.Value;
             *                      }
             *                  }
             *
             *                  return Task.FromResult(0);
             *              }
             *      }
             *  });
             * }*/
        }
Example #43
0
        public void Configuration(IAppBuilder app)
        {
            _container = ConfigureAndBuildContainer();

            app.UseAutofacMiddleware(_container);
            app.DisposeScopeOnAppDisposing(_container);

            var config = new HttpConfiguration
            {
                DependencyResolver = new AutofacWebApiDependencyResolver(_container)
            };

            // Add policy based authorization
            app.UseAuthorization(Policies.Configure);

            // Configure common options
            Api.ApiConfiguration.Configure(config);

            var apiExplorer = config.AddVersionedApiExplorer();

            config.EnableSwagger(
                "{apiVersion}/swagger",
                swagger =>
            {
                // build a swagger document and endpoint for each discovered API version
                swagger.MultipleApiVersions(
                    (apiDescription, version) =>
                    apiDescription.GetGroupName() == version,
                    info =>
                {
                    foreach (var group in apiExplorer.ApiDescriptions)
                    {
                        var apiVersion  = group.ApiVersion;
                        var description = "Cinematic api.";

                        if (group.IsDeprecated)
                        {
                            description += " This API version has been deprecated.";
                        }

                        info.Version(group.Name, $"Cinematic API {group.ApiVersion}")
                        .Contact(c => c.Name("Hugo Biarge").Email("*****@*****.**"))
                        .Description(description)
                        .License(l => l.Name("MIT").Url("https://opensource.org/licenses/MIT"))
                        .TermsOfService("Shareware");
                    }
                });


                // add a custom operation filter which documents the implicit API version parameter
                swagger.OperationFilter <SwaggerDefaultValues>();
                // swagger.OperationFilter<ImplicitApiVersionParameter>();

                // integrate xml comments
                // swagger.IncludeXmlComments(XmlCommentsFilePath);
            })
            .EnableSwaggerUi();

            // Configure middlewares pipeline

            // ### Temporal authentication middleware
            app.Use(async(context, next) =>
            {
                var identity = new ClaimsIdentity(new[]
                {
                    new Claim(ClaimTypes.Role, "Administrator"),
                    new Claim(ClaimTypes.Role, "Vendor"),
                    new Claim(ClaimTypes.Name, "Hugo")
                },
                                                  "Custom");
                context.Authentication.User = new ClaimsPrincipal(identity);
                await next();
            });
            // ####

            app.UseAutofacWebApi(config);
            app.UseWebApi(config);

            app.UseWelcomePage();
        }
Example #44
0
        public static void Configuration(IAppBuilder app)
        {
            AreaRegistration.RegisterAllAreas();
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);

            var connectionString = ConfigurationManager.ConnectionStrings["SMW_Base"];

            if (connectionString == null)
            {
                throw new Exception("Не найдена строка соединения");
            }

            var builder = new ContainerBuilder();

            var modelsAssembly = Assembly.GetAssembly(typeof(User));

            foreach (var type in modelsAssembly.GetTypes())
            {
                var attr = type.GetCustomAttribute <ListenerAttribute>();
                if (attr == null)
                {
                    continue;
                }
                var interfaces = type.GetInterfaces();
                var b          = builder.RegisterType(type);
                foreach (var inter in interfaces)
                {
                    b = b.As(inter);
                }
            }

            builder.Register(x =>
            {
                var cfg = Fluently.Configure()
                          .Database(MsSqlConfiguration.MsSql2012
                                    .ConnectionString(connectionString.ConnectionString)
                                    .Dialect <MsSql2012Dialect>())
                          .Mappings(m => m.FluentMappings.AddFromAssemblyOf <User>())
                          .ExposeConfiguration(c => {
                    SchemaMetadataUpdater.QuoteTableAndColumns(c);
                    c.EventListeners.PreInsertEventListeners = x.Resolve <IPreInsertEventListener[]>();
                    c.EventListeners.PreUpdateEventListeners = x.Resolve <IPreUpdateEventListener[]>();
                })
                          .CurrentSessionContext("call");
                var conf         = cfg.BuildConfiguration();
                var schemaExport = new SchemaUpdate(conf);
                schemaExport.Execute(true, true);
                return(cfg.BuildSessionFactory());
            }).As <ISessionFactory>().SingleInstance();
            builder.Register(x => x.Resolve <ISessionFactory>().OpenSession())
            .As <ISession>()
            .InstancePerRequest()
            .InstancePerDependency();

            foreach (var type in modelsAssembly.GetTypes())
            {
                var attr = type.GetCustomAttribute <RepositoryAttribute>();
                if (attr == null)
                {
                    continue;
                }
                builder.RegisterType(type);
            }

            builder.RegisterControllers(Assembly.GetAssembly(typeof(NoteController)));
            builder.RegisterModule(new AutofacWebTypesModule());
            var container = builder.Build();

            Locator.SetImpl(new AutofacLocatorImpl(container));
            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
            app.UseAutofacMiddleware(container);

            app.CreatePerOwinContext(() =>
                                     new UserManager(new IdentityStore(DependencyResolver.Current.GetServices <ISession>().FirstOrDefault())));
            app.CreatePerOwinContext <SignInManager>((options, context) =>
                                                     new SignInManager(context.GetUserManager <UserManager>(), context.Authentication));

            app.UseCookieAuthentication(new CookieAuthenticationOptions
            {
                AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
                LoginPath          = new PathString("/Account/Login"),
                Provider           = new CookieAuthenticationProvider()
            });
        }
Example #45
0
        /// <summary>
        /// This code configures Web API. The Startup class is specified as a type
        /// parameter in the WebApp.Start method.
        /// </summary>
        /// <param name="appBuilder">The application builder.</param>
        public void Configuration(IAppBuilder appBuilder)
        {
            // Configure Web API for self-host.
            HttpConfiguration config = CreateConfiguration();

            // Construct the Autofac container
            IContainer container = BuildContainer();

            // Use autofac's dependency resolver, not the OWIN one
            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);

            // Wait for the initialization to complete (setup the socket)
            config.EnsureInitialized();

            // If the config file specifies authentication, load up the certificates and use the JWT middleware.
            if (WebApiConfiguration.Instance.JwtAuthentication.Enabled)
            {
                X509Certificate2 cert = Certificate.ReadCertificate();

                appBuilder.UseJwtBearerAuthentication(
                    new JwtBearerAuthenticationOptions
                {
                    AllowedAudiences = new[]
                    {
                        WebApiConfiguration.Instance.JwtAuthentication.Audience
                    },
                    IssuerSecurityTokenProviders =
                        new[]
                    {
                        new X509CertificateSecurityTokenProvider(cert.Subject, cert)
                    },
                    AuthenticationType = "Bearer",
                    AuthenticationMode = AuthenticationMode.Active
                });
            }

            // If the config file specifies authentication, load up ApiKey middleware.
            if (WebApiConfiguration.Instance.ApiKeyAuthentication.Enabled)
            {
                appBuilder.UseApiKeyAuthentication(new ApiKeyAuthenticationOptions()
                {
                    Header    = WebApiConfiguration.Instance.ApiKeyAuthentication.Header ?? "Authorization",
                    HeaderKey = WebApiConfiguration.Instance.ApiKeyAuthentication.HeaderKey ?? "ApiKey",
                    Provider  = new ApiKeyAuthenticationProvider()
                    {
                        OnValidateIdentity = Authentication.ValidateIdentity,
                        OnGenerateClaims   = Authentication.GenerateClaims
                    }
                });
            }

            appBuilder.UseAutofacMiddleware(container);

            appBuilder.UseWebApi(config);

            var options = new FileServerOptions
            {
                RequestPath             = new PathString("/help"),
                EnableDirectoryBrowsing = false,
                EnableDefaultFiles      = true,
                DefaultFilesOptions     = { DefaultFileNames = { "index.html" } },
                FileSystem = new PhysicalFileSystem("Swagger-UI")
            };

            appBuilder.UseFileServer(options);

            appBuilder.UseAutofacWebApi(config);
        }
Example #46
0
 private void RegisterForOwin(IAppBuilder app, IContainer container)
 {
     app.UseAutofacMiddleware(container);
     app.UseAutofacMvc();
 }
Example #47
0
 public static IAppBuilder UseAutofac(this IAppBuilder app, HttpConfiguration httpConfig)
 {
     app.UseAutofacMiddleware(httpConfig.SetupAutofacContainer());
     app.UseAutofacWebApi(httpConfig);
     return(app);
 }
Example #48
0
        public void Configuration(IAppBuilder app)
        {
            var builder = new ContainerBuilder();

            // DataContext
            builder.Register(MultiTenantDataContextFactory.Create).As <GridDataContext>().As <IDbContext>().InstancePerRequest();
            builder.RegisterType <UnitOfWork>().As <IUnitOfWork>().InstancePerRequest();

            // Repositories

            // Attendance
            builder.RegisterType <AttendanceRepository>().As <IAttendanceRepository>().InstancePerRequest();

            // Auth
            builder.RegisterType <TokenRepository>().As <ITokenRepository>().InstancePerRequest();

            //Company
            builder.RegisterType <AwardRepository>().As <IAwardRepository>().InstancePerRequest();
            builder.RegisterType <EmailTemplateRepository>().As <IEmailTemplateRepository>().InstancePerRequest();
            builder.RegisterType <LocationRepository>().As <ILocationRepository>().InstancePerRequest();
            builder.RegisterType <PermissionRepository>().As <IPermissionRepository>().InstancePerRequest();
            builder.RegisterType <RoleMemberRepository>().As <IRoleMemberRepository>().InstancePerRequest();
            builder.RegisterType <RolePermissionRepository>().As <IRolePermissionRepository>().InstancePerRequest();
            builder.RegisterType <RoleRepository>().As <IRoleRepository>().InstancePerRequest();
            builder.RegisterType <TechnologyRepository>().As <ITechnologyRepository>().InstancePerRequest();

            // CRM
            builder.RegisterType <CRMAccountRepository>().As <ICRMAccountRepository>().InstancePerRequest();
            builder.RegisterType <CRMContactRepository>().As <ICRMContactRepository>().InstancePerRequest();
            builder.RegisterType <CRMLeadActivityRepository>().As <ICRMLeadActivityRepository>().InstancePerRequest();
            builder.RegisterType <CRMLeadCategoryRepository>().As <ICRMLeadCategoryRepository>().InstancePerRequest();
            builder.RegisterType <CRMLeadRepository>().As <ICRMLeadRepository>().InstancePerRequest();
            builder.RegisterType <CRMLeadSourceRepository>().As <ICRMLeadSourceRepository>().InstancePerRequest();
            builder.RegisterType <CRMLeadStatusRepository>().As <ICRMLeadStatusRepository>().InstancePerRequest();
            builder.RegisterType <CRMLeadTechnologyMapRepository>().As <ICRMLeadTechnologyMapRepository>().InstancePerRequest();
            builder.RegisterType <CRMPotentialActivityRepository>().As <ICRMPotentialActivityRepository>().InstancePerRequest();
            builder.RegisterType <CRMPotentialCategoryRepository>().As <ICRMPotentialCategoryRepository>().InstancePerRequest();
            builder.RegisterType <CRMPotentialRepository>().As <ICRMPotentialRepository>().InstancePerRequest();
            builder.RegisterType <CRMPotentialTechnologyMapRepository>().As <ICRMPotentialTechnologyMapRepository>().InstancePerRequest();
            builder.RegisterType <CRMSalesStageRepository>().As <ICRMSalesStageRepository>().InstancePerRequest();

            //HRMS
            builder.RegisterType <AccessRuleRepository>().As <IAccessRuleRepository>().InstancePerRequest();
            builder.RegisterType <CertificationRepository>().As <ICertificationRepository>().InstancePerRequest();
            builder.RegisterType <DepartmentRepository>().As <IDepartmentRepository>().InstancePerRequest();
            builder.RegisterType <DesignationRepository>().As <IDesignationRepository>().InstancePerRequest();
            builder.RegisterType <EmergencyContactRepository>().As <IEmergencyContactRepository>().InstancePerRequest();
            builder.RegisterType <EmployeeDependentRepository>().As <IEmployeeDependentRepository>().InstancePerRequest();
            builder.RegisterType <HobbyRepository>().As <IHobbyRepository>().InstancePerRequest();
            builder.RegisterType <LinkedAccountRepository>().As <ILinkedAccountRepository>().InstancePerRequest();
            builder.RegisterType <PersonRepository>().As <IPersonRepository>().InstancePerRequest();
            builder.RegisterType <ShiftRepository>().As <IShiftRepository>().InstancePerRequest();
            builder.RegisterType <SkillRepository>().As <ISkillRepository>().InstancePerRequest();
            builder.RegisterType <UserActivityRepository>().As <IUserActivityRepository>().InstancePerRequest();
            builder.RegisterType <UserAwardRepository>().As <IUserAwardRepository>().InstancePerRequest();
            builder.RegisterType <UserCertificationRepository>().As <IUserCertificationRepository>().InstancePerRequest();
            builder.RegisterType <UserDocumentRepository>().As <IUserDocumentRepository>().InstancePerRequest();
            builder.RegisterType <UserHobbyRepository>().As <IUserHobbyRepository>().InstancePerRequest();
            builder.RegisterType <UserRepository>().As <IUserRepository>().InstancePerRequest();
            builder.RegisterType <UserSkillRepository>().As <IUserSkillRepository>().InstancePerRequest();
            builder.RegisterType <UserTechnologyMapRepository>().As <IUserTechnologyMapRepository>().InstancePerRequest();

            // IMS
            builder.RegisterType <AssetAllocationRepository>().As <IAssetAllocationRepository>().InstancePerRequest();
            builder.RegisterType <AssetCategoryRepository>().As <IAssetCategoryRepository>().InstancePerRequest();
            builder.RegisterType <AssetDocumentRepository>().As <IAssetDocumentRepository>().InstancePerRequest();
            builder.RegisterType <AssetRepository>().As <IAssetRepository>().InstancePerRequest();
            builder.RegisterType <VendorRepository>().As <IVendorRepository>().InstancePerRequest();

            // IT
            builder.RegisterType <SoftwareCategoryRepository>().As <ISoftwareCategoryRepository>().InstancePerRequest();
            builder.RegisterType <SoftwareRepository>().As <ISoftwareRepository>().InstancePerRequest();
            builder.RegisterType <SystemSnapshotRepository>().As <ISystemSnapshotRepository>().InstancePerRequest();

            // KBS
            builder.RegisterType <ArticleAttachmentRepository>().As <IArticleAttachmentRepository>().InstancePerRequest();
            builder.RegisterType <ArticleRepository>().As <IArticleRepository>().InstancePerRequest();
            builder.RegisterType <ArticleVersionRepository>().As <IArticleVersionRepository>().InstancePerRequest();
            builder.RegisterType <CategoryRepository>().As <ICategoryRepository>().InstancePerRequest();
            builder.RegisterType <KeywordRepository>().As <IKeywordRepository>().InstancePerRequest();

            // LMS
            builder.RegisterType <HolidayRepository>().As <IHolidayRepository>().InstancePerRequest();
            builder.RegisterType <LeaveEntitlementRepository>().As <ILeaveEntitlementRepository>().InstancePerRequest();
            builder.RegisterType <LeaveEntitlementUpdateRepository>().As <ILeaveEntitlementUpdateRepository>().InstancePerRequest();
            builder.RegisterType <LeaveRepository>().As <ILeaveRepository>().InstancePerRequest();
            builder.RegisterType <LeaveTimePeriodRepository>().As <ILeaveTimePeriodRepository>().InstancePerRequest();
            builder.RegisterType <LeaveTypeRepository>().As <ILeaveTypeRepository>().InstancePerRequest();

            // Payroll
            builder.RegisterType <EmployeeSalaryRepository>().As <IEmployeeSalaryRepository>().InstancePerRequest();
            builder.RegisterType <SalaryComponentRepository>().As <ISalaryComponentRepository>().InstancePerRequest();

            //PMS
            builder.RegisterType <ProjectBillingRepository>().As <IProjectBillingRepository>().InstancePerRequest();
            builder.RegisterType <ProjectDocumentRepository>().As <IProjectDocumentRepository>().InstancePerRequest();
            builder.RegisterType <ProjectMemberRepository>().As <IProjectMemberRepository>().InstancePerRequest();
            builder.RegisterType <ProjectMileStoneRepository>().As <IProjectMileStoneRepository>().InstancePerRequest();
            builder.RegisterType <ProjectRepository>().As <IProjectRepository>().InstancePerRequest();
            builder.RegisterType <ProjectActivityRepository>().As <IProjectActivityRepository>().InstancePerRequest();
            builder.RegisterType <ProjectTechnologyMapRepository>().As <IProjectTechnologyMapRepository>().InstancePerRequest();
            builder.RegisterType <TaskEffortRepository>().As <ITaskEffortRepository>().InstancePerRequest();
            builder.RegisterType <TaskRepository>().As <ITaskRepository>().InstancePerRequest();
            builder.RegisterType <TimeSheetLineItemRepository>().As <ITimeSheetLineItemRepository>().InstancePerRequest();
            builder.RegisterType <TimeSheetRepository>().As <ITimeSheetRepository>().InstancePerRequest();
            builder.RegisterType <EstimateRepository>().As <IEstimateRepository>().InstancePerRequest();
            builder.RegisterType <EstimateLineItemRepository>().As <IEstimateLineItemRepository>().InstancePerRequest();
            builder.RegisterType <TimeSheetActivityRepository>().As <ITimeSheetActivityRepository>().InstancePerRequest();
            builder.RegisterType <TaskActivityRepository>().As <ITaskActivityRepository>().InstancePerRequest();

            //Recruit
            builder.RegisterType <CandidateActivityRepository>().As <ICandidateActivityRepository>().InstancePerRequest();
            builder.RegisterType <CandidateDesignationRepository>().As <ICandidateDesignationRepository>().InstancePerRequest();
            builder.RegisterType <CandidateDocumentRepository>().As <ICandidateDocumentRepository>().InstancePerRequest();
            builder.RegisterType <CandidateRepository>().As <ICandidateRepository>().InstancePerRequest();
            builder.RegisterType <CandidateTechnologyMapRepository>().As <ICandidateTechnologyMapRepository>().InstancePerRequest();
            builder.RegisterType <InterviewRoundRepository>().As <IInterviewRoundRepository>().InstancePerRequest();
            builder.RegisterType <InterviewRoundActivityRepository>().As <IInterviewRoundActivityRepository>().InstancePerRequest();
            builder.RegisterType <InterviewRoundDocumentRepository>().As <IInterviewRoundDocumentRepository>().InstancePerRequest();
            builder.RegisterType <JobOfferRepository>().As <IJobOfferRepository>().InstancePerRequest();
            builder.RegisterType <JobOpeningRepository>().As <IJobOpeningRepository>().InstancePerRequest();
            builder.RegisterType <ReferalRepository>().As <IReferalRepository>().InstancePerRequest();
            builder.RegisterType <RoundRepository>().As <IRoundRepository>().InstancePerRequest();

            // RMS
            builder.RegisterType <RequirementActivityRepository>().As <IRequirementActivityRepository>().InstancePerRequest();
            builder.RegisterType <RequirementCategoryRepository>().As <IRequirementCategoryRepository>().InstancePerRequest();
            builder.RegisterType <RequirementDocumentRepository>().As <IRequirementDocumentRepository>().InstancePerRequest();
            builder.RegisterType <RequirementRepository>().As <IRequirementRepository>().InstancePerRequest();
            builder.RegisterType <RequirementTechnologyMapRepository>().As <IRequirementTechnologyMapRepository>().InstancePerRequest();

            // Settings
            builder.RegisterType <GridUpdateRepository>().As <IGridUpdateRepository>().InstancePerRequest();
            builder.RegisterType <SettingRepository>().As <ISettingRepository>().InstancePerRequest();
            builder.RegisterType <UserFeedbackRepository>().As <IUserFeedbackRepository>().InstancePerRequest();
            builder.RegisterType <ApplicationRepository>().As <IApplicationRepository>().InstancePerRequest();

            // TicketDesk
            builder.RegisterType <TicketCategoryRepository>().As <ITicketCategoryRepository>().InstancePerRequest();
            builder.RegisterType <TicketSubCategoryRepository>().As <ITicketSubCategoryRepository>().InstancePerRequest();
            builder.RegisterType <TicketRepository>().As <ITicketRepository>().InstancePerRequest();
            builder.RegisterType <TicketActivityRepository>().As <ITicketActivityRepository>().InstancePerRequest();

            // TMS
            builder.RegisterType <MissedTimeSheetRepository>().As <IMissedTimeSheetRepository>().InstancePerRequest();

            //Social
            builder.RegisterType <PostRepository>().As <IPostRepository>().InstancePerRequest();
            builder.RegisterType <PostCommentRepository>().As <IPostCommentRepository>().InstancePerRequest();
            builder.RegisterType <PostLikeRepository>().As <IPostLikeRepository>().InstancePerRequest();

            // Business Services
            builder.RegisterType <CRMLeadService>().As <ICRMLeadService>().InstancePerRequest();
            builder.RegisterType <CRMPotentialService>().As <ICRMPotentialService>().InstancePerRequest();
            builder.RegisterType <CRMAccountService>().As <ICRMAccountService>().InstancePerRequest();
            builder.RegisterType <CRMContactService>().As <ICRMContactService>().InstancePerRequest();

            builder.RegisterType <RequirementService>().As <IRequirementService>().InstancePerRequest();
            builder.RegisterType <SettingsService>().As <ISettingsService>().InstancePerRequest();
            builder.RegisterType <UserService>().As <IUserService>().InstancePerRequest();
            builder.RegisterType <AssetService>().As <IAssetService>().InstancePerRequest();
            builder.RegisterType <LeaveService>().As <ILeaveService>().InstancePerRequest();
            builder.RegisterType <CandidateService>().As <ICandidateService>().InstancePerRequest();
            builder.RegisterType <RequirementService>().As <IRequirementService>().InstancePerRequest();
            builder.RegisterType <SettingsService>().As <ISettingsService>().InstancePerRequest();
            builder.RegisterType <TicketService>().As <ITicketService>().InstancePerRequest();
            builder.RegisterType <TimeSheetService>().As <ITimeSheetService>().InstancePerRequest();
            builder.RegisterType <TaskService>().As <ITaskService>().InstancePerRequest();
            builder.RegisterType <InterviewRoundService>().As <IInterviewRoundService>().InstancePerRequest();

            // Common Services
            builder.RegisterType <NotificationService>().As <INotificationService>().InstancePerRequest();
            builder.RegisterType <EmailComposerService>().As <EmailComposerService>().InstancePerRequest();

            // Register your MVC controllers.
            builder.RegisterControllers(typeof(MvcApplication).Assembly);
            builder.RegisterControllers(typeof(ApiAreaRegistration).Assembly);

            // Register Injection for Filters
            builder.Register(c => new GlobalIdentityInjector(c.Resolve <IUserRepository>(), c.Resolve <IRoleMemberRepository>(), c.Resolve <IRolePermissionRepository>())).AsActionFilterFor <Controller>().InstancePerRequest();
            builder.RegisterFilterProvider();

            builder.RegisterType <SubDomainTenantIdentificationStrategy>().As <ITenantIdentificationStrategy>();

            var appContainer     = builder.Build();
            var tenantIdentifier = new SubDomainTenantIdentificationStrategy();
            var mtc = new MultitenantContainer(tenantIdentifier, appContainer);

            DependencyResolver.SetResolver(new AutofacDependencyResolver(mtc));

            // Register the Autofac middleware FIRST, then the Autofac MVC middleware.
            app.UseAutofacMiddleware(mtc);
            app.UseAutofacMvc();
        }
Example #49
0
        public void Configuration(IAppBuilder app)
        {
            // In OWIN you create your own HttpConfiguration rather than
            // re-using the GlobalConfiguration.
            var config = new HttpConfiguration();

            app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);

            var cors = new EnableCorsAttribute("*", "*", "*");

            config.EnableCors(cors);

            config.Formatters.Clear();
            config.Formatters.Add(new JsonMediaTypeFormatter());
            config.Formatters.JsonFormatter.SerializerSettings =
                new JsonSerializerSettings
            {
                ContractResolver = new CamelCasePropertyNamesContractResolver()
            };

            config.Routes.MapHttpRoute(
                "DefaultApi",
                "api/{controller}/{action}/{id}",
                new { id = RouteParameter.Optional });
            //config.Routes.MapHttpRoute(
            //    "DefaultActionApi",
            //    "{controller}/{action}/{id}",
            //    new { id = RouteParameter.Optional });

            var builder = new ContainerBuilder();

            // Register Web API controller in executing assembly.
            builder.RegisterApiControllers(GetType().Assembly).PropertiesAutowired();

            //注册 ApplicationService
            builder.RegisterAssemblyTypes(GetType().Assembly)
            .Where(type => typeof(BaseDao).IsAssignableFrom(type))
            .AsSelf().PropertiesAutowired()
            .InstancePerRequest();

            //注册数据库对象
            builder.Register <IDapperConnection>(ctx => new DapperConnection(new SqlConnection("server=localhost;port=3306;user id=root; password=lyx123456; database=studyplan; pooling=true; charset=utf8mb4"))).InstancePerRequest();

            // Create and assign a dependency resolver for Web API to use.
            var container = builder.Build();

            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);

            DependencyResolver = config.DependencyResolver;

            // The Autofac middleware should be the first middleware added to the IAppBuilder.
            // If you "UseAutofacMiddleware" then all of the middleware in the container
            // will be injected into the pipeline right after the Autofac lifetime scope
            // is created/injected.
            //
            // Alternatively, you can control when container-based
            // middleware is used by using "UseAutofacLifetimeScopeInjector" along with
            // "UseMiddlewareFromContainer". As long as the lifetime scope injector
            // comes first, everything is good.
            app.UseAutofacMiddleware(container);

            // Again, the alternative to "UseAutofacMiddleware" is something like this:
            // app.UseAutofacLifetimeScopeInjector(container);
            //app.UseMiddlewareFromContainer<FirstMiddleware>();
            //app.UseMiddlewareFromContainer<ContextMiddleware>();

            // Make sure the Autofac lifetime scope is passed to Web API.

            app.UseAutofacWebApi(config);
            app.UseWebApi(config);

            app.UseStaticFile(new StaticFileMiddlewareOptions
            {
                RootDirectory           = "../web",
                DefaultFile             = "index.html",
                EnableETag              = true,
                EnableHtml5LocationMode = true
            });
        }
Example #50
0
        // This code configures Web API. The Startup class is specified as a type
        // parameter in the WebApp.Start method.
        public void Configuration(IAppBuilder app)
        {
            try
            {
                var httpConfig = new HttpConfiguration();
                var env        = Environment.GetEnvironmentVariable("ASPNET_ENVIRONMENT") ?? "development"; // standard variable in asp.net core for environment declaration

                var config = StartupHelper.Configuration;
                // var funnyQuotesConfig = new FunnyQuotesConfiguration();

                // config.GetSection("FunnyQuotes").Bind(funnyQuotesConfig);

                // -- container registration
                var builder = new ContainerBuilder();    // build up autofac container
                builder.RegisterOptions();               // allow injection of strongly typed config
                builder.RegisterOption <FunnyQuotesConfiguration>(config.GetSection("FunnyQuotes"));
                builder.RegisterDiscoveryClient(config); // register eureka service discovery
                builder.RegisterConfiguration(config);
                builder.RegisterCloudFoundryOptions(config);
                builder.RegisterMySqlConnection(config);
                builder.RegisterConsoleLogging();
                builder.Register(ctx => // register EF context
                {
                    var connString = ctx.Resolve <IDbConnection>().ConnectionString;
                    return(new FunnyQuotesCookieDbContext(connString));
                });
                builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); // register all controllers to be injectable
                builder.RegisterWebApiFilterProvider(httpConfig);                // register autofac support for webapi filters
                builder.RegisterType <LoggerExceptionFilterAttribute>()          // register global exception handler
                .AsWebApiExceptionFilterFor <ApiController>()
                .SingleInstance();
                builder.RegisterCloudFoundryActuators(config);

                var container = builder.Build(); // compile the container

                // -- configure owin server
                httpConfig.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html")); // default to json instead of xml
                httpConfig.Routes.MapHttpRoute(                                                                     // setup default routing for WebApi2
                    "DefaultApi",
                    "api/{controller}/{action}"
                    );
                httpConfig.Routes.MapHttpRoute("Health",
                                               "{controller}/{action}",
                                               new { controller = "health", action = "health" }); // map "/" to basic health endpoint so the default PCF health check for HTTP 200 response is satisfied
                httpConfig.DependencyResolver = new AutofacWebApiDependencyResolver(container);   // assign autofac to provide dependency injection on controllers
                var funnyQuotesConfig = container.Resolve <IOptionsMonitor <FunnyQuotesConfiguration> >().CurrentValue;

                // -- setup app pipeline
                app.UseAutofacMiddleware(container); // allows injection of dependencies into owin middleware
                if (funnyQuotesConfig.EnableSecurity)
                {
                    app.UseCloudFoundryJwtBearerAuthentication(config); // add security integration for PCF SSO
                }
                else
                {
                    app.Use <NoAuthenticationMiddleware>(); // dummy security provider which is necessary if you have secured actions on controllers
                }
                app.UseAutofacWebApi(httpConfig);           // merges owin pipeline with autofac request lifecycle
                app.UseWebApi(httpConfig);                  // standard OWIN WebAPI2
                app.UseCors(CorsOptions.AllowAll);
                container.StartDiscoveryClient();           // ensure that discovery client is started
                ContainerBuilderExtensions.StartActuators(container);
                var logger = container.Resolve <ILogger <Startup> >();

                container.MigrateDatabase();

                logger.LogInformation(">> App Started <<");
            }
            catch (Exception e)
            {
                // given that logging is DI controlled it may not be initialized, just write directly to console
                Console.Error.WriteLine(e);
                throw;
            }
        }
Example #51
0
        public static void Configure(IAppBuilder app, HttpConfiguration config)
        {
            var builder = new ContainerBuilder();

            // Listar os assemblies
            List <Assembly> assemblies = new List <Assembly>();

            assemblies.Add(typeof(WebDenunciaSSP.Atendimento.Global).Assembly);
            assemblies.Add(typeof(WDContext).Assembly);
            assemblies.Add(typeof(WebDenunciaSSP.CommonLibs.OData.CicatrizController).Assembly);

            // Registrar os assemblies
            foreach (Assembly assembly in assemblies)
            {
                builder.RegisterControllers(assembly);
                builder.RegisterApiControllers(assembly);
                builder.RegisterModelBinders(assembly);
            }

            // Carregar serviços

            // Autenticação OWIN
            builder.Register <IAuthenticationManager>(c => HttpContext.Current.GetOwinContext().Authentication).InstancePerRequest();
            builder.Register <IOwinContext>(c => HttpContext.Current.GetOwinContext()).InstancePerRequest();

            // Registrar contexto do banco
            builder.Register <WDContext>(c => new WDContext()).InstancePerLifetimeScope();

            builder.RegisterModelBinderProvider();
            // OPTIONAL: Enable property injection in view pages.
            builder.RegisterSource(new ViewRegistrationSource());
            // OPTIONAL: Enable property injection into action filters.
            builder.RegisterFilterProvider();

            var container = builder.Build();

            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);


            app.UseCookieAuthentication(new CookieAuthenticationOptions()
            {
                CookieName         = CookieAuthenticationDefaults.AuthenticationType,
                AuthenticationType = CookieAuthenticationDefaults.AuthenticationType,//"ApplicationCookie",//DefaultAuthenticationTypes.ApplicationCookie,
                LoginPath          = new PathString("/Atendimento/Login"),
                ExpireTimeSpan     = TimeSpan.FromDays(7),
                SlidingExpiration  = true,
                Provider           = new CookieAuthenticationProvider
                {
                    OnResponseSignIn = ctx => {
                        var ticks = ctx.Options.SystemClock.UtcNow.AddHours(10).UtcTicks;
                        ctx.Properties.Dictionary.Add("absolute", ticks.ToString());
                    },
                    OnValidateIdentity = ctx =>
                    {
                        bool reject = true;
                        string value;
                        if (ctx.Properties.Dictionary.TryGetValue("absolute", out value))
                        {
                            long ticks;
                            if (Int64.TryParse(value, out ticks))
                            {
                                reject = ctx.Options.SystemClock.UtcNow.UtcTicks > ticks;
                            }
                        }

                        if (reject)
                        {
                            ctx.RejectIdentity();
                            // optionally clear cookie
                            ctx.OwinContext.Authentication.SignOut(ctx.Options.AuthenticationType);
                        }

                        return(Task.FromResult(0));
                    }
                }
            });


            // OWIN MVC SETUP:
            // Register the Autofac middleware FIRST, then the Autofac MVC middleware.
            app.UseAutofacMiddleware(container);
            app.UseAutofacMvc();
            app.UseAutofacWebApi(config);
        }
Example #52
0
        public static void Configuration(IAppBuilder app)
        {
            // Get your HttpConfiguration.
            var config  = new HttpConfiguration();
            var builder = new ContainerBuilder();

            var corsOrigins = ConfigurationManager.AppSettings["CORSAllowedOrigins"];

            if (!string.IsNullOrEmpty(corsOrigins))
            {
                var cors = new EnableCorsAttribute(corsOrigins, " * ", "*");
                //var cors = new EnableCorsAttribute(corsOrigins, "accept,accesstoken,authorization,cache-control,pragma,content-type,origin", "GET,PUT,POST,DELETE,TRACE,HEAD,OPTIONS");

                config.EnableCors(cors);
            }

            // Web API routes
            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
                );

            //config.Filters.Add(new AuthorizeAttribute());

            OAuthAuthorizationServerOptions option = new OAuthAuthorizationServerOptions
            {
                TokenEndpointPath         = new PathString("/token"),
                Provider                  = new ApplicationOAuthProvider(),
                AccessTokenExpireTimeSpan = TimeSpan.FromMinutes(60),
                AllowInsecureHttp         = true
                                            //,AuthorizeEndpointPath =	new PathString("/api/Account/ExternalLogin"),
            };

            app.UseOAuthAuthorizationServer(option);
            app.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions());

            //builder.RegisterType<Mapper>()
            //	.As<IMapper>();

            //Get assemblies to register all Repositories and Services
            var assemblies      = BuildManager.GetReferencedAssemblies().Cast <Assembly>();
            var currentAssembly = Assembly.GetExecutingAssembly();

            //These can eventually be wild cards to pull in all assemblies for Repos Services and Web
            var assemblyList                = assemblies as IList <Assembly> ?? assemblies.ToList();
            var etmRepoAssembly             = assemblyList.Where(x => x.FullName.Contains("ETM.Repository,")).ToArray();
            var etmServiceAssembly          = assemblyList.Where(x => x.FullName.Contains("ETM.Service,")).ToArray();
            var etmServiceInterfaceAssembly = etmServiceAssembly[0].DefinedTypes.Where(x => x.Name.StartsWith("I")).ToArray();

            if (etmRepoAssembly.Length > 0)
            {
                builder.RegisterAssemblyModules(etmRepoAssembly);
            }
            if (etmServiceAssembly.Length > 0)
            {
                builder.RegisterAssemblyModules(etmServiceAssembly);
            }
            //if (etmServiceInterfaceAssembly.Length > 0)
            //{
            //	builder.RegisterAssemblyModules(etmServiceInterfaceAssembly);
            //}

            builder.RegisterAssemblyModules(currentAssembly);

            //builder.Register(c => new MapperConfiguration(cfg =>
            //{
            //	//add profiles
            //	foreach (var profile in c.Resolve<IEnumerable<Profile>>())
            //	{
            //		cfg.AddProfile(profile);
            //	}
            //})).AsSelf().SingleInstance();

            ////register mapper
            //builder.Register(c => c.Resolve<MapperConfiguration>().CreateMapper(c.Resolve)).As<IMapper>().InstancePerLifetimeScope();

            // Register your Web API controllers.
            builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
            builder.RegisterType <TimesheetService>()
            .As <ITimesheetService>()
            .InstancePerRequest();
            builder.RegisterType <ProjectService>()
            .As <IProjectService>()
            .InstancePerRequest();
            builder.RegisterType <ClientService>()
            .As <IClientService>()
            .InstancePerRequest();
            builder.RegisterType <TeamService>()
            .As <ITeamService>()
            .InstancePerRequest();
            builder.RegisterType <TaskService>()
            .As <ITaskService>()
            .InstancePerRequest();
            builder.RegisterType <EmployeeService>()
            .As <IEmployeeService>()
            .InstancePerRequest();
            builder.RegisterType <CategoryService>()
            .As <ICategoryService>()
            .InstancePerRequest();
            builder.RegisterType <DesignationService>()
            .As <IDesignationService>()
            .InstancePerRequest();
            builder.RegisterType <SkillSetService>()
            .As <ISkillSetService>()
            .InstancePerRequest();
            builder.RegisterType <DashboardService>()
            .As <IDashboardService>()
            .InstancePerRequest();
            builder.RegisterType <StatusService>()
            .As <IStatusService>()
            .InstancePerRequest();
            builder.RegisterType <MRFService>()
            .As <IMRFService>()
            .InstancePerRequest();
            //builder.RegisterType<OrgChartService>()
            //    .As<IOrgChartService>()
            //     .InstancePerRequest();

            ConfigureJsonSerialization(config);

            var container = builder.Build();

            app.UseAutofacMiddleware(container);
            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);

            app.UseAutofacWebApi(config);
            app.UseWebApi(config);

            //app.CreatePerOwinContext<UserManager<IdentityUser>>(CreateManager);
        }
Example #53
0
        public static void ConfigureApp(IAppBuilder app)
        {
            var builder = new ContainerBuilder();

            builder.Register(c => HttpContext.Current.GetOwinContext().Authentication).As <IAuthenticationManager>().InstancePerRequest();

            builder.RegisterType <ApplicationUserServices>().As <IApplicationUserServices>().InstancePerRequest();
            builder.RegisterType <ApplicationUserRepository>().As <IApplicationUserRepository>().InstancePerRequest();
            builder.RegisterType <RoleRepository>().As <IRoleRepository>().InstancePerRequest();
            builder.RegisterType <DateTimeRepository>().As <IDateTimeRepository>().InstancePerRequest();
            builder.RegisterType <CourseRepository>().As <IRepository2 <Course> >().InstancePerRequest();
            builder.RegisterType <PhotoAlbumRepository>().As <IRepository2 <PhotoAlbum> >().InstancePerRequest();
            builder.RegisterType <CourseCategoryRepository>().As <IRepository <CourseCategory> >().InstancePerRequest();
            builder.RegisterType <ForumRepository>().As <IRepository2 <Forum> >().InstancePerRequest();
            builder.RegisterType <ForumCategoryRepository>().As <IRepository <ForumCategory> >().InstancePerRequest();
            builder.RegisterType <ResearchRepository>().As <IRepository2 <Research> >().InstancePerRequest();
            builder.RegisterType <ResearchCategoryRepository>().As <IRepository <ResearchCategory> >().InstancePerRequest();
            builder.RegisterType <CommentRepository>().As <IRepository <Comment> >().InstancePerRequest();
            builder.RegisterType <CourseService>().As <ICourseService>().InstancePerRequest();
            builder.RegisterType <CurriculumRepository>().As <ICurriculumRepository>().InstancePerRequest();
            builder.RegisterType <StudentCourseRepository>().As <IStudentCourseRepository>().InstancePerRequest();
            builder.RegisterType <StudentScoreRepository>().As <IRepository <StudentScore> >().InstancePerRequest();
            builder.RegisterType <ConfigurationRepository>().As <IConfigurationRepository>().InstancePerRequest();
            builder.RegisterType <PhotoAlbumService>().As <IPhotoAlbumService>().InstancePerRequest();
            builder.RegisterType <PhotoRepository>().As <IRepository <Photo> >().InstancePerRequest();
            builder.RegisterType <CommentService>().As <ICommentService>().InstancePerRequest();
            builder.RegisterType <ForumService>().As <IForumService>().InstancePerRequest();
            builder.RegisterType <ResearchService>().As <IResearchService>().InstancePerRequest();
            builder.RegisterType <EventRepository>().As <IRepository <Event> >().InstancePerRequest();
            builder.RegisterType <VideoRepository>().As <IRepository <Video> >().InstancePerRequest();
            builder.RegisterType <NewsRepository>().As <IRepository <News> >().InstancePerRequest();
            builder.RegisterType <EmailSender>().As <IEmailSender>().InstancePerRequest();
            builder.RegisterType <PersonalFileService>().As <IPersonalFileService>().InstancePerRequest();
            builder.RegisterType <CurriculumService>().As <ICurriculumService>().InstancePerRequest();
            builder.RegisterType <StudentCourseService>().As <IStudentCourseService>().InstancePerRequest();
            builder.RegisterType <StudentScoreService>().As <IStudentScoreService>().InstancePerRequest();
            builder.RegisterType <EventService>().As <IEventService>().InstancePerRequest();
            builder.RegisterType <BannerService>().As <IBannerService>().InstancePerRequest();
            builder.RegisterType <BannerRepository>().As <IRepository <Banner> >().InstancePerRequest();
            builder.RegisterType <NewsService>().As <INewsService>().InstancePerRequest();
            builder.RegisterType <AlumniService>().As <IAlumniService>().InstancePerRequest();
            builder.RegisterType <AlumniRepository>().As <IRepository <Alumni> >().InstancePerRequest();

            builder.RegisterType <HandoutService>().As <IHandoutService>().InstancePerRequest();
            builder.RegisterType <HandoutRepository>().As <IRepository <Handout> >().InstancePerRequest();

            builder.RegisterType <ReferenceUserService>().As <IReferenceUserService>().InstancePerRequest();
            //builder.RegisterType<ReferenceUserRepository>().As<IRepository<ReferenceUser>>().InstancePerRequest();

            builder.RegisterApiControllers(typeof(ApiStartUp).Assembly);
            builder.RegisterControllers(typeof(Startup).Assembly);

            var container = builder.Build();

            app.UseAutofacMiddleware(container);
            var config = GlobalConfiguration.Configuration;

            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);
            DependencyResolver.SetResolver(new Autofac.Integration.Mvc.AutofacDependencyResolver(container));
            GlobalConfiguration.Configuration.DependencyResolver = new Autofac.Integration.WebApi.AutofacWebApiDependencyResolver(container);
        }
Example #54
0
        //public static OAuthAuthorizationServerOptions OAuthOptions { get; private set; }

        //public static Func<UserManager<IdentityUser>> UserManagerFactory { get; set; }

        //public static string PublicClientId { get; private set; }

        // For more information on configuring authentication, please visit http://go.microsoft.com/fwlink/?LinkId=301864
        public void ConfigureAuth(IAppBuilder app)
        {
            #region Generate view for improving performance and Migration DB
            ////Generate view in file
            //using (var ctx = new SGTSVNDBContext())
            //{
            //	InteractiveViews
            //		.SetViewCacheFactory(
            //			ctx,
            //			new FileViewCacheFactory(System.Web.Hosting.HostingEnvironment.MapPath("~/DBContextViews.xml")));
            //}

            //Generate view store in DB
            //using (var ctx = new SGTSVNDBContext())
            //{
            //	InteractiveViews
            //		.SetViewCacheFactory(
            //			ctx,
            //			new SqlServerViewCacheFactory(ctx.Database.Connection.ConnectionString));
            //}

            ////Migration DB
            //giam 2 giay
            //Database.SetInitializer<SGTSVNDBContext>(null);
            Database.SetInitializer(new MigrateDatabaseToLatestVersion <SGTSVNDBContext, Configuration>());
            #endregion


            // Branch the pipeline here for requests that start with "/signalr"
            app.Map("/signalr", map =>
            {
                // Setup the CORS middleware to run before SignalR.
                // By default this will allow all origins. You can
                // configure the set of origins and/or http verbs by
                // providing a cors options with a different policy.
                map.UseCors(CorsOptions.AllowAll);
                var hubConfiguration = new HubConfiguration
                {
                    // You can enable JSONP by uncommenting line below.
                    // JSONP requests are insecure but some older browsers (and some
                    // versions of IE) require JSONP to work cross domain
                    // EnableJSONP = true
                };
                // Run the SignalR pipeline. We're not using MapSignalR
                // since this branch already runs under the "/signalr"
                // path.
                map.RunSignalR(hubConfiguration);
            });

            var container = Bootstrapper.SetAutofacContainer();
            var config    = new HttpConfiguration();
            //WebApiConfig.Register(config);
            //config.Formatters.Clear();
            //config.Formatters.Add(new JsonMediaTypeFormatter());

            //config.Formatters.JsonFormatter.SerializerSettings =
            //	new JsonSerializerSettings
            //	{
            //		ContractResolver = new CamelCasePropertyNamesContractResolver()
            //	};
            //config.MessageHandlers.Add(new BufferNonStreamedContentHandler());

            // Web API routes
            config.MapHttpAttributeRoutes();
            log4net.Config.XmlConfigurator.Configure();
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
                );

            ConfigureOAuth(app);

            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);

            app.UseAutofacMiddleware(container);
            app.UseAutofacWebApi(config);

            app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
            app.UseWebApi(config);

            AreaRegistration.RegisterAllAreas();
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);
            Bootstrapper.Run();
        }
        public void Configuration(IAppBuilder appBuilder)
        {
            // In OWIN you create your own HttpConfiguration rather than re-using the GlobalConfiguration.
            var config = new HttpConfiguration();

            // Enable CORS
            // Look up "Enable CORS on Owin Web API" to see what NuGet to install
            //config.EnableCors(new EnableCorsAttribute("*","*","*"))

            // ROUTING
            config.MapHttpAttributeRoutes();
            config.Routes.MapHttpRoute("DefaultApi", "{controller}/{id}",
                                       new { controller = "Value", id = RouteParameter.Optional }
                                       );

            // HOOK UP SWASHBUCKLE SWAGGER HERE (alternative is NSwag)
            // Read documenation specific to Owin i.e. Only Swashbuckle.Core package is needed

            // AUTOFAC
            var containerBuilder = new ContainerBuilder();

            // Register Http Request message - what is this?
            containerBuilder.RegisterHttpRequestMessage(config);

            // Register controllers all at once using assembly scanning...
            containerBuilder.RegisterApiControllers(Assembly.GetExecutingAssembly());

            // Register Assembly modules - what is this?
            containerBuilder.RegisterAssemblyModules(Assembly.GetExecutingAssembly());

            // OPTIONAL - Register the filter provider if you have custom filters that need DI.
            // Also hook the filters up to controllers.
            //containerBuilder.RegisterWebApiFilterProvider(config);
            //containerBuilder.RegisterType<CustomActionFilter>()
            //    .AsWebApiActionFilterFor<TestController>()
            //    .InstancePerRequest();

            // Register my version of ILogger that wraps Serilog, its ILogger and sinks
            containerBuilder.Register(c => Logger.Instance).As <ILogger>().SingleInstance();

            // Entity Framework
            // how to register this? Use Repository pattern and/or Unit of Work pattern?
            // As in Serilog case, should EF be wrapped within Repository?

            // Autofac will add middleware to IAppBuilder in the order registered.
            // The middleware will execute in the order added to IAppBuilder.
            //containerBuilder.RegisterType<FirstMiddleware>().InstancePerRequest();
            //containerBuilder.RegisterType<SecondMiddleware>().InstancePerRequest();


            // Create and assign a dependency resolver for Web API to use.
            var container = containerBuilder.Build();

            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);

            // The Autofac middleware should be the first middleware added to the IAppBuilder.
            // If you "UseAutofacMiddleware" then all of the middleware in the container
            // will be injected into the pipeline right after the Autofac lifetime scope
            // is created/injected.
            //
            // Alternatively, you can control when container-based
            // middleware is used by using "UseAutofacLifetimeScopeInjector" along with
            // "UseMiddlewareFromContainer". As long as the lifetime scope injector
            // comes first, everything is good.
            appBuilder.UseAutofacMiddleware(container);
            // Again, the alternative to "UseAutofacMiddleware" is something like this:
            // app.UseAutofacLifetimeScopeInjector(container);
            // app.UseMiddlewareFromContainer<FirstMiddleware>();
            // app.UseMiddlewareFromContainer<SecondMiddleware>();

            // Make sure the Autofac lifetime scope is passed to Web API.
            // Sam: is this line necessary?
            appBuilder.UseAutofacWebApi(config);


            appBuilder.UseWebApi(config);
        }
        public void Configuration(IAppBuilder app)
        {
            string _domain_root = ConfigurationManager.AppSettings["IdentityServer:Domain"];

            IdentityServerSettings.DomainRoot = _domain_root;

            Log.Logger = new LoggerConfiguration()
                         .MinimumLevel.Debug()
                         .WriteTo.Trace()
                         .CreateLogger();

            var builder = new ContainerBuilder();

            ConfigureAuth(app);

            var path = HostingEnvironment.MapPath("~/App_Data");
            var cassandraUserStore = new CassandraUserStore(CassandraAspNetIdentityOptions.CassandraConfig,
                                                            CassandraAspNetApplicationConstants.TenantGuid);
            var userService = new Registration <IUserService>(new AspNetIdentityServerService(cassandraUserStore));

            userService = new Registration <IUserService>(new ArbitraryUserService());
            IdentityServerServiceFactory identityServerServiceFactory;



#if CASSANDRA_STORE
            app.UseAspNetCassandraStores(new CassandraOptions()
            {
                ContactPoints = new List <string> {
                    "cassandra"
                },
                Credentials = new CassandraCredentials()
                {
                    Password = "", UserName = ""
                },
                KeySpace = "aspnetidentity"
            });

            app.UseIdentityServerCassandraStores(userService, out identityServerServiceFactory,
                                                 new CassandraOptions()
            {
                ContactPoints = new List <string> {
                    "cassandra"
                },
                Credentials = new CassandraCredentials()
                {
                    Password = "", UserName = ""
                },
                KeySpace = "identityserver3"
            });

            /*
             * TODO: Cassandra may be down, need a robust app that can reconnect
             * foreach (var client in Clients.Get())
             * {
             *  IdentityServer3CassandraDao.UpsertClientAsync(
             *      new FlattenedClientRecord(new FlattenedClientHandle(client)));
             * }
             * foreach (var scope in Scopes.Get())
             * {
             *  IdentityServer3CassandraDao.UpsertScopeAsync(new FlattenedScopeRecord(new FlattenedScopeHandle(scope)));
             * }
             * */
#endif
#if BIGGY_STORE
            // Create and modify default settings
            StoreSettings settings = StoreSettings.DefaultSettings;
            settings.Folder = path;

            ClientStore myClientStore = new ClientStore(settings);
            foreach (var client in Clients.Get())
            {
                myClientStore.CreateAsync(new ClientHandle(client));
            }
            ScopeStore myScopeStore = new ScopeStore(settings);
            foreach (var scope in Scopes.Get())
            {
                myScopeStore.CreateAsync(new ScopeHandle(scope));
            }

            // Create the BiggyIdentityService factory
            identityServerServiceFactory = new ServiceFactory(userService, settings);
#endif
            identityServerServiceFactory.Register(new Registration <IDictionary <string, IClaimsProvider> >(resolver =>
            {
                var result = new Dictionary <string, IClaimsProvider>
                {
                    {
                        CustomClaimsProviderHub.WellKnown_DefaultProviderName,
                        new DefaultClaimsProvider(resolver.Resolve <IUserService>())
                    },
                    {
                        "openid-provider", new CustomOpenIdClaimsProvider(resolver.Resolve <IUserService>())
                    },
                    {
                        "arbitrary-provider", new ArbitraryClaimsProvider(resolver.Resolve <IUserService>())
                    }
                };
                return(result);
            }));

            identityServerServiceFactory.ClaimsProvider = new Registration <IClaimsProvider>(typeof(CustomClaimsProviderHub));

            var options = new IdentityServerOptions
            {
                Factory            = identityServerServiceFactory,
                RequireSsl         = false,
                SigningCertificate = Certificate.Get(),
                SiteName           = "P5 IdentityServer3"
            };


            app.Map("/idsrv3core", idsrvApp =>
            {
                idsrvApp.UseIdentityServer(options);
            });
            app.UseIdentityServerBearerTokenAuthentication(new IdentityServerBearerTokenAuthenticationOptions
            {
                Authority      = "http://localhost:55970/idsrv3core",
                ValidationMode = ValidationMode.ValidationEndpoint,

                RequiredScopes              = new[] { "api1" },
                PreserveAccessToken         = true,
                EnableValidationResultCache = true
            });

            HttpConfiguration config = new HttpConfiguration();

            /*          config.Routes.MapHttpRoute(
             *            name: "DefaultApi",
             *            routeTemplate: "api/{controller}/{id}",
             *            defaults: new {id = RouteParameter.Optional}
             *            );
             */
            // Register your Web API controllers.
            builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
            builder.RegisterType <ApplicationUserManager>();

            // Run other optional steps, like registering filters,
            // per-controller-type services, etc., then set the dependency resolver
            // to be Autofac.
            var container = builder.Build();
            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);

            config.Services.Replace(typeof(IAssembliesResolver), new WebApi2HubAssembliesResolver());
            WebApiConfig.Register(config); // NEW way

            // OWIN WEB API SETUP:

            // Register the Autofac middleware FIRST, then the Autofac Web API middleware,
            // and finally the standard Web API middleware.
            app.UseAutofacMiddleware(container);
            app.UseAutofacWebApi(config);
            app.UseWebApi(config);
        }
Example #57
0
        public void Configuration(IAppBuilder app)
        {
            var builder = new ContainerBuilder();

            builder.RegisterControllers(Assembly.GetExecutingAssembly());

            // REGISTER DEPENDENCIES
            builder.RegisterType <UnitOfWork>().As <IUnitOfWork>().InstancePerRequest();
            builder.RegisterType <DbFactory>().As <IDbFactory>().InstancePerRequest();
            builder.RegisterType <OZChatDbContext>().AsSelf().InstancePerRequest();
            builder.RegisterType <ApplicationUserStore>().As <IUserStore <ApplicationUser> >().InstancePerRequest();
            builder.RegisterType <ApplicationUserManager>().AsSelf().InstancePerRequest();
            builder.RegisterType <ApplicationSignInManager>().AsSelf().InstancePerRequest();
            builder.Register <IAuthenticationManager>(c => HttpContext.Current.GetOwinContext().Authentication).InstancePerRequest();
            builder.Register <IDataProtectionProvider>(c => app.GetDataProtectionProvider()).InstancePerRequest();

            // REGISTER CONTROLLERS SO DEPENDENCIES ARE CONSTRUCTOR INJECTED
            //builder.RegisterControllers(typeof(MvcApplication).Assembly);

            // Repositories
            builder.RegisterAssemblyTypes(typeof(ApplicationRoleRepository).Assembly)
            .Where(t => t.Name.EndsWith("Repository"))
            .AsImplementedInterfaces().InstancePerRequest();

            // BUILD THE CONTAINER
            var container = builder.Build();

            // REPLACE THE MVC DEPENDENCY RESOLVER WITH AUTOFAC
            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

            // REGISTER WITH OWIN
            app.UseAutofacMiddleware(container);
            app.UseAutofacMvc();

            ConfigureAuth(app);
            app.UseCors(CorsOptions.AllowAll);
            //app.MapSignalR();
            app.Map("/signalr", map =>
            {
                // Setup the CORS middleware to run before SignalR.
                // By default this will allow all origins. You can
                // configure the set of origins and/or http verbs by
                // providing a cors options with a different policy.
                map.UseCors(CorsOptions.AllowAll);

                map.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions()
                {
                    Provider = new QueryStringOAuthBearerProvider()
                });

                var hubConfiguration = new HubConfiguration
                {
                    // You can enable JSONP by uncommenting line below.
                    // JSONP requests are insecure but some older browsers (and some
                    // versions of IE) require JSONP to work cross domain
                    EnableJSONP          = true,
                    EnableDetailedErrors = true
                };
                // Run the SignalR pipeline. We're not using MapSignalR
                // since this branch already runs under the "/signalr"
                // path.
                map.RunSignalR(hubConfiguration);
                var authorizer = new CAuthorizeAttribute();
                var module     = new AuthorizeModule(authorizer, authorizer);
                GlobalHost.HubPipeline.AddModule(module);
            });
        }
        public void Configuration(IAppBuilder app)
        {
            // In OWIN you create your own HttpConfiguration rather than
            // re-using the GlobalConfiguration.
            var config = new HttpConfiguration();

            config.Routes.MapHttpRoute(
                "DefaultApi",
                "api/{controller}/{id}",
                new { id = RouteParameter.Optional });

            var builder = new ContainerBuilder();

            // Register Web API controller in executing assembly.
            builder.RegisterApiControllers(Assembly.GetExecutingAssembly());

            // OPTIONAL - Register the filter provider if you have custom filters that need DI.
            // Also hook the filters up to controllers.
            builder.RegisterWebApiFilterProvider(config);
            builder.RegisterType <CustomActionFilter>()
            .AsWebApiActionFilterFor <TestController>()
            .InstancePerRequest();

            // Register a logger service to be used by the controller and middleware.
            builder.Register(c => new Logger()).As <ILogger>().InstancePerRequest();

            // Autofac will add middleware to IAppBuilder in the order registered.
            // The middleware will execute in the order added to IAppBuilder.
            builder.RegisterType <FirstMiddleware>().InstancePerRequest();
            //builder.RegisterType<SecondMiddleware>().InstancePerRequest();

            //builder.RegisterType(typeof(IRequestHandler<GetSampleDataQuery, string>))
            //        .As<IRequestHandler<IRequestHandler<GetSampleDataQuery, string>()
            //        .AsImplementedInterfaces();
            //builder.AddMediatR(typeof(Startup1).Assembly);
            //builder.RegisterType<Mediator>().As<IMediator>();
            //  builder.AddMediatR(this.GetType().Assembly);


            // Create and assign a dependency resolver for Web API to use.
            var container = builder.Build();

            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);

            // The Autofac middleware should be the first middleware added to the IAppBuilder.
            // If you "UseAutofacMiddleware" then all of the middleware in the container
            // will be injected into the pipeline right after the Autofac lifetime scope
            // is created/injected.
            //
            // Alternatively, you can control when container-based
            // middleware is used by using "UseAutofacLifetimeScopeInjector" along with
            // "UseMiddlewareFromContainer". As long as the lifetime scope injector
            // comes first, everything is good.
            app.UseAutofacMiddleware(container);

            // Again, the alternative to "UseAutofacMiddleware" is something like this:
            // app.UseAutofacLifetimeScopeInjector(container);
            // app.UseMiddlewareFromContainer<FirstMiddleware>();
            // app.UseMiddlewareFromContainer<SecondMiddleware>();

            // Make sure the Autofac lifetime scope is passed to Web API.
            app.UseAutofacWebApi(config);
            app.UseWebApi(config);
        }
Example #59
0
        /// <summary>
        /// Configures the Web API application.
        /// </summary>
        /// <param name="app"><see cref="IAppBuilder"/> instance.</param>
        /// <param name="container"><see cref="IContainer"/> instance.</param>
        public static void Register(IAppBuilder app, IContainer container)
        {
            var settings = new JsonSerializerSettings()
            {
                // Add JSON serialiser settings to support camelCasing.
                ContractResolver      = new CamelCasePropertyNamesContractResolver(),
                Formatting            = Formatting.Indented,
                Converters            = { new StringEnumConverter() },
                NullValueHandling     = NullValueHandling.Ignore,
                MissingMemberHandling = MissingMemberHandling.Ignore
            };

            var config = new HttpConfiguration
            {
                DependencyResolver = new AutofacWebApiDependencyResolver(container),
            };

            var jsonFormatter = config.Formatters.JsonFormatter;

            jsonFormatter.SerializerSettings = settings;
            jsonFormatter.SupportedMediaTypes.Clear();
            jsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/json"));

            var xmlFormatter = config.Formatters.XmlFormatter;

            // Starts using XmlSerialiser rather than DataContractSerializer.
            xmlFormatter.UseXmlSerializer = true;
            xmlFormatter.SupportedMediaTypes.Clear();
            xmlFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/xml"));

            config.Formatters.Clear();
            config.Formatters.AddRange(new List <MediaTypeFormatter>()
            {
                jsonFormatter, xmlFormatter
            });

            // Web API configuration and services

            // Web API routes
            config.MapHttpAttributeRoutes();
            config.Routes.MapHttpRoute(
                name: "RootRedirectToSwagger",
                routeTemplate: string.Empty,
                defaults: null,
                constraints: null,
                handler: new RedirectHandler(SwaggerDocsConfig.DefaultRootUrlResolver, "swagger/ui/index"));
            config.Routes.MapHttpRoute(
                name: "SwaggerRedirect",
                routeTemplate: "swagger",
                defaults: null,
                constraints: null,
                handler: new RedirectHandler(SwaggerDocsConfig.DefaultRootUrlResolver, "swagger/ui/index"));
            config.Routes.MapHttpRoute(
                name: "SwaggerUiRedirect",
                routeTemplate: "swagger/ui",
                defaults: null,
                constraints: null,
                handler: new RedirectHandler(SwaggerDocsConfig.DefaultRootUrlResolver, "swagger/ui/index"));

            // Swagger
            SwaggerConfig.Register(config);

            // Middlewares
            app.UseAutofacMiddleware(container);
            app.UseAutofacWebApi(config);
            app.UseWebApi(config);
        }
Example #60
0
        public static void Configuration(IAppBuilder app)
        {
            var connectionSttring = ConfigurationManager.ConnectionStrings["MSSQL"];

            if (connectionSttring == null)
            {
                throw new Exception("not found");
            }
            var builder = new ContainerBuilder();

            builder.Register(x =>
            {
                var cfg = Fluently.Configure()
                          .Database(MsSqlConfiguration.MsSql2012
                                    .ConnectionString(connectionSttring.ConnectionString)
                                    .Dialect <MsSql2012Dialect>())
                          .Mappings(m => {
                    m.FluentMappings.AddFromAssemblyOf <User>();
                })
                          .CurrentSessionContext("call");
                var schemaExport = new SchemaUpdate(cfg.BuildConfiguration());
                schemaExport.Execute(true, true);

                return(cfg.BuildSessionFactory());
            }).As <ISessionFactory>().SingleInstance();
            builder.Register(x => x.Resolve <ISessionFactory>().OpenSession())
            .As <ISession>()
            .InstancePerRequest().InstancePerLifetimeScope();
            builder.RegisterControllers(Assembly.GetAssembly(typeof(AccountController)));
            builder.RegisterModule(new AutofacWebTypesModule());
            builder.RegisterGeneric(typeof(Repository <,>));
            builder.RegisterAssemblyTypes(Assembly.GetAssembly(typeof(UserRepository)))
            .AsSelf()
            .AsImplementedInterfaces();
            //builder.RegisterAssemblyTypes(Assembly.GetAssembly(typeof(UserManager)));


            var container = builder.Build().BeginLifetimeScope();

            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

            //builder.RegisterAssemblyTypes(Assembly.GetAssembly(typeof(UserManager)))
            //    .AsSelf()
            //    .AsImplementedInterfaces();


            //.AsSelf()
            //.AsImplementedInterfaces();

            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
            app.UseAutofacMiddleware(container);
            try
            {
                var CreateProcedure = @"CREATE PROCEDURE [dbo].[sp_InsertVacancy] @VacancyName nvarchar(100),
                                        @VacancyDescription nvarchar(1000), @Starts DateTime2,@Ends DateTime2, @Creator_id bigint, @Status nvarchar(255),
                                        @Company_id bigint AS INSERT INTO [Vacancy] (VacancyName, VacancyDescription, Starts, Ends, Creator_id, Status, Company_id )
                                        VALUES ( @VacancyName, @VacancyDescription, @Starts, @Ends, @Creator_id, @Status, @Company_id ) SELECT SCOPE_IDENTITY() ";

                var result = container.Resolve <ISession>().CreateSQLQuery(CreateProcedure);;
                result.ExecuteUpdate();
            }
            catch (Exception ex)
            { }
            app.CreatePerOwinContext(() => new UserManager(new App_Start.IdentityStore(DependencyResolver.Current.GetServices <ISession>().FirstOrDefault())));
            app.CreatePerOwinContext <ApplicationSignInManager>((options, context) => new ApplicationSignInManager(context.GetUserManager <UserManager>(), context.Authentication));

            app.UseCookieAuthentication(new CookieAuthenticationOptions
            {
                AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
                LoginPath          = new PathString("/Account/Login"),
                Provider           = new CookieAuthenticationProvider()
            });
        }