public static IServiceCollection AddWebFileSystems(this IServiceCollection services)
        {
            services.AddSingleton<IClientFolder, WebSiteFolder>();
            services.AddSingleton<IVirtualPathProvider, DefaultVirtualPathProvider>();

            return services;
        }
        public static void AddDD4T(this IServiceCollection services)
        {
            //var configuration = new Configuration()
            //     .AddJsonFile("config.json")
            //     .AddEnvironmentVariables();

            //var config = JsonConvert.DeserializeObject<DD4TConfiguration>()
            //var x = configuration.GetSubKey("DD4TAppSettings");

            services.AddSingleton<IPublicationResolver, DefaultPublicationResolver>();
            services.AddSingleton<ILogger, NullLogger>();
            services.AddSingleton<ICacheAgent, NullCacheAgent>();
            services.AddSingleton<IDD4TConfiguration, DD4TConfiguration>();
            //services.Configure<DD4TConfiguration>(configuration.GetSubKey("DD4TAppSettings"));

            services.AddTransient<ISerializerService, JSONSerializerService>();

            services.AddTransient<IPageProvider, TridionPageProvider>();
            services.AddTransient<IComponentPresentationProvider, ComponentPresentationProvider>();
            services.AddTransient<ILinkProvider, LinkProvider>();

            services.AddTransient<IFactoriesFacade, FactoriesFacade>();
            services.AddTransient<IPageFactory, PageFactory>();
            services.AddTransient<IComponentFactory, ComponentFactory>();
            services.AddTransient<IComponentPresentationFactory, ComponentPresentationFactory>();
            services.AddTransient<IBinaryFactory, BinaryFactory>();
            services.AddTransient<ILinkFactory, LinkFactory>();
            services.AddTransient<IFactoriesFacade, FactoriesFacade>();
        }
Example #3
0
        public static void ConfigureAuthorization(this IServiceCollection services)
        {
            services.AddIdentity<ApplicationUser, IdentityRole>()
                .AddEntityFrameworkStores<SecurityDbContext>()
                .AddDefaultTokenProviders();

            services.AddAuthorization(options =>
            {
                options.AddPolicy("RequireClimePolicyTest", policy =>
                {
                    policy.RequireClaim("RequireClimePolicyTest");
                });

                options.AddPolicy("RequireRolePolicyTest", policy =>
                {
                    policy.RequireRole("RequireRolePolicyTest");
                });

                options.AddPolicy("RequirementBasedPolicyTest", policy =>
                {
                    policy.AddRequirements(new TestRequirement(preSatisfied: true));
                });
            });

            services.AddSingleton<IAuthorizationHandler, ResourceBasedAuthorizationHandler>();
            services.AddSingleton<IAuthorizationHandler, RequirementBasedAuthorizationHandler>();
        }
        public static IServiceCollection AddFileSystems(this IServiceCollection services)
        {
            services.AddSingleton<IAppDataFolderRoot, AppDataFolderRoot>();
            services.AddSingleton<IAppDataFolder, PhysicalAppDataFolder>();

            return services;
        }
        public static void AddBrickPile(this IServiceCollection services)
        {
            _serviceProvider = services.BuildServiceProvider();

            services.AddMvc().ConfigureApplicationPartManager(manager =>
            {
                var feature = new ControllerFeature();
                manager.PopulateFeature(feature);
                services.AddSingleton<IControllerMapper>(new ControllerMapper(feature));
            });

            services.AddRouting(options =>
            {
                options.AppendTrailingSlash = true;
                options.LowercaseUrls = true;
            });

            services.Configure<MvcOptions>(options =>
            {
                options.ModelBinderProviders.Insert(0, new DefaultModelBinderProvider(DocumentStore));
                options.Filters.Add(typeof(PublishedFilterAttribute), 1);
                options.Filters.Add(typeof(AuthorizeFilterAttribute), 2);
            });

            services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
            services.AddSingleton(DocumentStore);
            services.AddTransient<IRouteResolverTrie>(provider => new RouteResolverTrie(provider.GetService<IDocumentStore>()));
            services.AddTransient<IBricsContextAccessor>(provider => new BricsContextAccessor(provider.GetService<IHttpContextAccessor>(), provider.GetService<IDocumentStore>()));
        }
 public static IServiceCollection AddOnlineTvDatabase(this IServiceCollection services)
 {
     services.AddSingleton<IOnlineTvDatabase, OnlineTvDatabaseClient>();
     services.AddScoped<IHttpClient, HttpClient>();
     services.AddSingleton<IObjectUrlFactory, ObjectUrlFactory>();
     services.AddScoped<IObjectUrlBuilder<GetSeriesInput>, GetSeriesUrlBuilder>();
     return services;
 }
Example #7
0
        public static IServiceCollection AddUmbracoCore(this IServiceCollection services)
        {
            services.AddSingleton<IUmbracoAssemblyProvider, ReferencedAssemblyProvider>();
            services.AddSingleton<TypeHelper>();
            services.AddSingleton<ITypeFinder, TypeFinder>();

            return services;
        }
Example #8
0
        public static IServiceCollection AddOgnAnalyserServices(this IServiceCollection sp, OGNClientSettings settings)
        {
            sp.AddSingleton<APRSClient>();
            sp.AddSingleton<AircraftTrackAnalyser>();
            sp.AddSingleton<OGNClientSettings>(r => settings);

            return sp;
        }
Example #9
0
 public static IServiceCollection AddDomainEntity(this IServiceCollection service)
 {
     service.AddSingleton<IRepository<Item>, Repository<Item>>();
     service.AddSingleton<IRepository<ItemType>, Repository<ItemType>>();
     service.AddSingleton<IRepository<Menu>, Repository<Menu>>();
     service.AddSingleton<IRepository<ItemTrace>, Repository<ItemTrace>>();
     return service;
 }
        public static IServiceCollection AddOpenIdConnectServer(this IServiceCollection services)
        {
            services.AddWebEncoders();
            services.AddSingleton<HtmlEncoder>();
            services.AddSingleton<UrlEncoder>();

            return services;
        }
 /// <summary>
 /// 添加Log4Net日志功能相关映射信息
 /// </summary>
 public static void AddLog4NetServices(this IServiceCollection services)
 {
     if (OSharpConfig.LoggingConfigReseter == null)
     {
         OSharpConfig.LoggingConfigReseter = new Log4NetLoggingConfigReseter();
     }
     services.AddSingleton<IBasicLoggingInitializer, Log4NetLoggingInitializer>();
     services.AddSingleton<Log4NetLoggerAdapter>();
 }
Example #12
0
        public static void UseSmtp4dev(this IServiceCollection services)
        {
            SettingsStore settingsStore = new SettingsStore();
            services.AddSingleton<ISettingsStore>(settingsStore);

            MessageStore messageStore = new MessageStore();
            services.AddSingleton<IMessageStore>(messageStore);

            services.AddTransient<ISmtp4devEngine, Smtp4devEngine>();
        }
 public static IServiceCollection AddJsonLocalization(this IServiceCollection services, Action<JsonStringLocalizerOptions> options)
 {
     if (options != null)
     {
         services.Configure(options);
     }
     services.AddSingleton<IStringLocalizerFactory, JsonStringLocalizerFactory>();
     services.AddSingleton(typeof(IStringLocalizer<>), typeof(JsonStringLocalizer<>));
     return services;
 }
        /// <summary>
        /// Adds ExternalTemplates services.
        /// </summary>
        public static IServiceCollection AddExternalTemplates(this IServiceCollection services)
        {
            services.AddSingleton<IGeneratorOptions, GeneratorOptions>(
                provider => provider.GetRequiredService<IOptions<GeneratorOptions>>().Value);
            services.AddSingleton<IFilesProvider, FilesProvider>();
            services.AddSingleton<ICoreGenerator, CoreGenerator>();
            services.AddSingleton<IGenerator, Generator>();

            return services;
        }
        public static IServiceCollection AddContextAccessor(this IServiceCollection self)
        {
            if (self.Count(x => x.ServiceType == typeof(IHttpContextAccessor)) == 0)
                self.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();

            if (self.Count(x => x.ServiceType == typeof(IActionContextAccessor)) == 0)
                self.AddSingleton<IActionContextAccessor, ActionContextAccessor>();

            return self;
        }
        /// <summary>
        /// 添加OAuth服务映射令牌
        /// </summary>
        public static void AddOAuthServices(this IServiceCollection services)
        {
            services.CheckNotNull("services");
            services.AddSingleton<IOAuthAuthorizationServerProvider, OsharpAuthorizationServerProvider>();
            services.AddSingleton<IAuthorizationCodeProvider, OsharpAuthorizationCodeProvider>();
            services.AddSingleton<IRefreshTokenProvider, OsharpRefreshTokenProvider>();

            services.AddSingleton<IOAuthClientIdProvider, DatetimeOAuthClientIdProvider>();
            services.AddSingleton<IOAuthClientSecretProvider, GuidOAuthClientSecretProvider>();
        }
Example #17
0
        public static IServiceCollection AddSmidge(this IServiceCollection services)
        {
            //services.AddNodeServices(NodeHostingModel.Http);

            services.AddTransient<IConfigureOptions<SmidgeOptions>, SmidgeOptionsSetup>();
            services.AddTransient<IConfigureOptions<Bundles>, BundlesSetup>();
            services.AddSingleton<PreProcessPipelineFactory>();
            services.AddSingleton<BundleManager>();
            services.AddSingleton<FileSystemHelper>();
            services.AddSingleton<PreProcessManager>();
            services.AddSingleton<ISmidgeConfig, SmidgeConfig>();
            services.AddScoped<SmidgeContext>();
            services.AddScoped<SmidgeHelper>();
            services.AddSingleton<IUrlManager, DefaultUrlManager>();
            services.AddSingleton<IHasher, Crc32Hasher>();

            //pre-processors
            services.AddSingleton<IPreProcessor, JsMin>();
            services.AddSingleton<IPreProcessor, CssMinifier>();
            //services.AddSingleton<IPreProcessor, NodeMinifier>();
            services.AddScoped<IPreProcessor, CssImportProcessor>();
            services.AddScoped<IPreProcessor, CssUrlProcessor>();


            //Add the controller models as DI services - these get auto created for model binding
            services.AddTransient<BundleModel>();
            services.AddTransient<CompositeFileModel>();

            return services;
        }
		public static void AddDeps(this IServiceCollection services)
		{
			if (services == null)
			{
				throw new ArgumentNullException(nameof(services));
			}

			services.AddSingleton<IAppRootFileProviderAccessor, PhysicalAppRootFileProviderAccessor>();
			services.AddTransient<Matcher>();
			services.AddSingleton<DepsManager>();
		}
Example #19
0
 public static void AddDaniel15Config(this IServiceCollection services, IConfiguration config)
 {
     services.AddSingleton(_ => config);
     services.Configure<SiteConfiguration>(config.GetSection("Site"));
     services.Configure<GalleryConfiguration>(config.GetSection("Gallery"));
     services.AddSingleton<ISiteConfiguration>(
         provider => provider.GetRequiredService<IOptions<SiteConfiguration>>().Value
     );
     services.AddSingleton<IGalleryConfiguration>(
         provider => provider.GetRequiredService<IOptions<GalleryConfiguration>>().Value
     );
 }
        /// <summary>
        /// Adds the MVC widgets services to the services collection.
        /// </summary>
        /// <param name="services">The collection of services.</param>
        /// <returns>The collection of services.</returns>
        public static IServiceCollection AddMvcWidgets(this IServiceCollection services)
        {
            services.AddSingleton<IWidgetSelector, DefaultWidgetSelector>();
            services.AddSingleton<IWidgetActivator, DefaultWidgetActivator>();
            services.AddSingleton<IWidgetDescriptorCollectionProvider, DefaultWidgetDescriptorCollectionProvider>();
            services.AddSingleton<IWidgetInvokerFactory, DefaultWidgetInvokerFactory>();
            services.AddSingleton<IWidgetArgumentBinder, DefaultWidgetArgumentBinder>();

            services.AddTransient<IWidgetDescriptorProvider, DefaultWidgetDescriptorProvider>();
            services.AddTransient<IWidgetHelper, DefaultWidgetHelper>();

            return services;
        }
Example #21
0
 public static IServiceCollection AddLxFrameWork(this IServiceCollection service)
 {
     service.AddSingleton<ILxFrameWorkFactory, LxFrameWorkFactory>();
     service.AddSingleton<IHandlerFactory, HandlerFactory.HandlerFactory>();
     service.AddSingleton<ICrubFactory, CrubFactory.CrubFactory>();
     service.AddSingleton<IUnitOfWork, UnitOfWork.UnitOfWork>();
         //此处无须注册。也可注册,这样的话就去掉工厂中累赘的数组,加上类型映射也可
         //.AddSingleton<IDeleteCrubProvider, DeleteCrubProvider>()
         //.AddSingleton<IInsertCrubProvider, InsertCrubProvider>()
         //.AddSingleton<IUpdateCrubProvider, UpdateCrubProvider>()
         //.AddSingleton<IQueryCrubProvider, QueryCrubProvider>();
     return service;
 }
 public static IServiceCollection AddObjectValidator(this IServiceCollection sc)
 {
     sc.AddSingleton(c => new Validation(c));
     sc.AddSingleton<IRuleSelector, RuleSelector>();
     sc.AddTransient(typeof(IRuleBuilder<,>), typeof(RuleBuilder<,>));
     sc.AddTransient(c => new ValidateContext() { RuleSelector = c.GetService<IRuleSelector>() });
     sc.AddTransient<IValidateRule, ValidateRule>();
     sc.AddTransient<IValidateResult, ValidateResult>();
     sc.AddTransient(typeof(IValidatorBuilder<>), typeof(ValidatorBuilder<>));
     sc.AddTransient<IValidatorSetter, Validator>();
     sc.AddTransient<CollectionValidateRule>();
     sc.AddTransient(typeof(EachChecker<,>));
     sc.AddTransient(typeof(CollectionRuleBuilder<,>));
     return sc;
 }
 public static void ConfigureSignalrServices(this IServiceCollection services) {
     services.AddSignalR(cfg => {
         cfg.Hubs.EnableDetailedErrors = true;
         cfg.Hubs.PipelineModules.Add(new HubErrorLoggingPipelineModule());
     });
     services.AddSingleton<IAssemblyLocator, MyAssemblyLocator>();
     var serializer = CreateJsonSerializer();
     services.AddSingleton(serializer);
     services.AddSingleton<IMyHubHost, MyHubHost>();
     var resolver = new Resolver(serializer);
     services.AddSingleton<IParameterResolver>(resolver);
     //var sp = services.BuildServiceProvider();
     //ConnectionManager = new HCGetter(sp);
     //HubPipeline.AddModule(new HubErrorLoggingPipelineModule());
 }
        public static void AddWebpack(this IServiceCollection services,
           string configFile = "webpack.config.js",
           string publicPath = "/",
           string webRoot = "wwwroot",
           WebpackLogLevel logLevel = WebpackLogLevel.Normal)
        {
            var options = new WebpackOptions();
            options.ConfigFile = configFile;
            options.PublicPath = publicPath;
            options.WebRoot = webRoot;
            options.LogLevel = logLevel;
            options.Heartbeat = 10000;

            services.AddSingleton<WebpackOptions>(options);
            services.AddSingleton<IWebpackService, WebpackService>();
        }
        public static IServiceCollection AddZeroMq(this IServiceCollection services, IConfigurationSection queueConfig)
        {
            var options = new Options();
            queueConfig.Bind(options);

            return services.AddSingleton<IMessageQueueFactory>(sp => ActivatorUtilities.CreateInstance<ZeroMqQueueFactory>(sp, options.Queues.OfType<IMessageQueueConnection>().ToList()));
        }
Example #26
0
        public static IServiceCollection AddEndpoints(this IServiceCollection services, EndpointOptions endpoints)
        {
            var map = new Dictionary<string, Type>();
            if (endpoints.EnableTokenEndpoint)
            {
                map.Add(Constants.RoutePaths.Oidc.Token, typeof(TokenEndpoint));
            }
            if (endpoints.EnableDiscoveryEndpoint)
            {
                map.Add(Constants.RoutePaths.Oidc.DiscoveryConfiguration, typeof(DiscoveryEndpoint));
            }
            if (endpoints.EnableUserInfoEndpoint)
            {
                map.Add(Constants.RoutePaths.Oidc.UserInfo, typeof(UserInfoEndpoint));
            }
            if (endpoints.EnableIntrospectionEndpoint)
            {
                map.Add(Constants.RoutePaths.Oidc.Introspection, typeof(IntrospectionEndpoint));
            }
            if (endpoints.EnableAuthorizeEndpoint)
            {
                map.Add(Constants.RoutePaths.Oidc.Authorize, typeof(AuthorizeEndpoint));
            }

            services.AddSingleton<IEndpointRouter>(new EndpointRouter(map));
            foreach (var item in map)
            {
                services.AddTransient(item.Value);
            }

            return services;
        }
 public static IContainerBuilder ConfigureODataServices(this IContainerBuilder builder)
 {
     builder.AddSingleton<ODataWriterValidator>();
     builder.AddScoped<ODataMessageWriter>();
     builder.AddScoped<ODataRequestContext>();
     return builder;
 }
        public static void AddNHibernateSessionFactory(this IServiceCollection services)
        {
            // By default NHibernate looks for hibernate.cfg.xml
            // otherwise for Web it will fallback to web.config
            // we got one under wwwroot/web.config
            Configuration config = new Configuration();
            config.Configure();

            // Auto load entity mapping class
            ModelMapper mapper = new ModelMapper();
            mapper.AddMappings(Assembly.GetAssembly(typeof(Employee)).GetExportedTypes());

            HbmMapping mapping = mapper.CompileMappingForAllExplicitlyAddedEntities();
            config.AddDeserializedMapping(mapping, "NHibernate.Mapping");

            SchemaMetadataUpdater.QuoteTableAndColumns(config);

            // Drop & Recreate database schema
            new SchemaExport(config).Drop(false, true);
            new SchemaExport(config).Create(false, true);

            // Register services
            services.AddSingleton<ISessionFactory>(provider => config.BuildSessionFactory());
            services.AddTransient<ISession>(provider => services.BuildServiceProvider().GetService<ISessionFactory>().OpenSession());
        }
 public static void ConfigureApplicationDataAccess(this IServiceCollection services, string redisConnectionString)
 {
     services.AddSingleton(serviceProvider =>
         ConnectionMultiplexer.Connect(redisConnectionString));
     services.AddTransient<IShortUrlRepository, ShortUrlRepository>();
     services.AddTransient<IUserRepository, UserRepository>();
 }
Example #30
0
 public static void AddNodeServices(this IServiceCollection serviceCollection, NodeHostingModel hostingModel = NodeHostingModel.Http)
 {
     serviceCollection.AddSingleton(typeof(INodeServices), (serviceProvider) => {
         var appEnv = serviceProvider.GetRequiredService<IApplicationEnvironment>();
         return CreateNodeServices(hostingModel, appEnv.ApplicationBasePath);
     });
 }