public override void Configure(Container container)
{
LogManager.LogFactory = new ConsoleLogFactory();
IAppSettings appSettings = new DictionarySettings(
new Dictionary<string, string>
{
{ "backup.history", "5" },
{ "auth.api-keys", "1337"}
});
container.Register(c => appSettings);
container.RegisterAutoWired<IISManager>();
container.RegisterAs<AppSettingsApiKeyValidator, IApiKeyValidator>();
Plugins.Add(new RequestLogsFeature { RequiredRoles = null });
}
public void Install(Container container)
{
container.RegisterAutoWired<DbManagementService>();
container.RegisterAutoWired<ImageCreator>();
container.RegisterAutoWired<OrderPersister>();
container.RegisterAutoWired<BagOfCandyPersister>();
}
public override void Configure(Container container)
{
Plugins.Add(new ValidationFeature());
container.RegisterValidators(typeof(AppHost).Assembly);
container.RegisterAutoWired<BicyleRepository>();
container.RegisterAutoWired<BicycleValidator>();
}
private static void ConfigureContainer(Container container, string redisUrl)
{
container.RegisterAutoWired<DanishTransportAuthorityScraper>();
container.RegisterAutoWired<DanishTransportAuthorityResponseParser>();
container.Register<IVehicleInspectionLookup>(
c => new CacheVehicleInspectionLookup(c.Resolve<ICacheClient>(), c.Resolve<DanishTransportAuthorityScraper>()));
container.Register<IRedisClientsManager>(c => new PooledRedisClientManager(redisUrl));
container.Register(c => c.Resolve<IRedisClientsManager>().GetCacheClient());
container.Register(c => c.Resolve<IRedisClientsManager>().GetClient());
container.RegisterAutoWired<ApiKeyFilter>();
}
public static void ConfigureDependencies(Container container, IDocumentStore documentStore)
{
container.Register<IDocumentStore>(documentStore);
container.RegisterAutoWired<NugetServerBridge>();
container.RegisterAutoWired<PackageService>();
container.RegisterAutoWired<DeployService>();
container.RegisterAutoWired<PhysicalFileSystem>();
container.Register<IFileSystem>(new PhysicalFileSystem());
container.Register<ServerSettings>(c => GetServerSettings(c.Resolve<IDocumentStore>())).ReusedWithin(ReuseScope.Request);
container.RegisterAutoWired<NugetPackageDownloader>();
}
public override void Configure(Container container)
{
container.RegisterAutoWired<EmailProvider>();
container.RegisterAutoWired<FacebookGateway>();
container.RegisterAutoWired<TwitterGateway>();
Plugins.Add(new RazorFormat());
Plugins.Add(new RequestLogsFeature());
var appSettings = new AppSettings();
Plugins.Add(new AuthFeature(() => new CustomSession(),
new IAuthProvider[] {
new CredentialsAuthProvider(appSettings),
new TwitterAuthProvider(appSettings),
new FacebookAuthProvider(appSettings),
}));
container.Register<IRedisClientsManager>(new PooledRedisClientManager("localhost:6379"));
container.Register(c => c.Resolve<IRedisClientsManager>().GetCacheClient());
container.Register<IDbConnectionFactory>(
new OrmLiteConnectionFactory("~/App_Data/db.sqlite".MapHostAbsolutePath(),
SqliteDialect.Provider) {
ConnectionFilter = x => new ProfiledDbConnection(x, Profiler.Current)
});
//Store User Data into above OrmLite database
container.Register<IAuthRepository>(c =>
new OrmLiteAuthRepository(c.Resolve<IDbConnectionFactory>()));
//If using and RDBMS to persist UserAuth, we must create required tables
var authRepo = container.Resolve<IAuthRepository>();
authRepo.InitSchema();
//Register MQ Service
var mqService = new RedisMqServer(container.Resolve<IRedisClientsManager>());
container.Register<IMessageService>(mqService);
container.Register(mqService.MessageFactory);
mqService.RegisterHandler<SMessage>(ServiceController.ExecuteMessage);
mqService.RegisterHandler<CallFacebook>(ServiceController.ExecuteMessage);
mqService.RegisterHandler<EmailMessage>(ServiceController.ExecuteMessage);
mqService.RegisterHandler<PostStatusTwitter>(ServiceController.ExecuteMessage);
mqService.Start();
if (appSettings.Get("ResetAllOnStartUp", false))
{
ResetAll(container, (OrmLiteAuthRepository)authRepo);
}
}
public override void Configure(Container container)
{
////var dbConnectionFactory = new OrmLiteConnectionFactory(HttpContext.Current.Server.MapPath("~/App_Data/db.sql"), SqliteDialect.Provider);
////container.Register<IDbConnectionFactory>(dbConnectionFactory);
IAppSettings appSettings = new AppSettings();
Plugins.Add(new SwaggerFeature());
//Plugins.Add(new RequestLogsFeature() { RequiredRoles = null });
container.Register(appSettings);
container.RegisterAutoWired<IISManager>();
container.RegisterAutoWired<AppSettingsApiKeyValidator>();
}
public override void Configure(Container container)
{
//ASP.NET MVC integration
ControllerBuilder.Current.SetControllerFactory(new FunqControllerFactory(container));
SetConfig(CreateEndpointHostConfig());
JsConfig.EmitCamelCaseNames = true;
Plugins.Add(new ValidationFeature());
container.RegisterValidators(typeof(AppHost).Assembly);
container.Register<ICacheClient>(new MemoryCacheClient());
container.RegisterAutoWired<BicyleRepository>();
Plugins.Add(new AuthFeature(
() => new AuthUserSession(),
new IAuthProvider[] {
new CredentialsAuthProvider()
}));
var userAuthRepository = new InMemoryAuthRepository();
userAuthRepository.CreateUserAuth(new UserAuth { Email = "*****@*****.**", DisplayName= "Admin User"}, "admin");
container.Register<IUserAuthRepository>(userAuthRepository);
}
public override void Configure(Funq.Container container)
{
var dbConnectionFactory = new OrmLiteConnectionFactory(HttpContext.Current.Server.MapPath("~/App_Data/data.txt"),
SqliteDialect.Provider);
container.Register <IDbConnectionFactory>(dbConnectionFactory);
container.RegisterAutoWired <TrackedRepository>();
}
public override void Configure(Container container)
{
SetConfig(CreateEndpointHostConfig());
JsConfig.EmitCamelCaseNames = true;
Plugins.Add(new ValidationFeature());
container.RegisterValidators(typeof(AppHost).Assembly);
container.RegisterAutoWired<BicyleRepository>();
}
public override void Configure(Container container)
{
Plugins.Add(new CorsFeature());
PreRequestFilters.Add((httpReq, httpResponse) =>
{
//httpReq.http
});
var dbConnectionFactory =
new OrmLiteConnectionFactory(HttpContext.Current.Server.MapPath("~/App_Data/BookData.txt"),
SqliteDialect.Provider);
container.Register<IDbConnectionFactory>(dbConnectionFactory);
container.RegisterAutoWired<DataRepository>();
}
private static void RegisterDependencies(Container container)
{
//Register all your dependencies
container.Register<ICacheClient>(new MemoryCacheClient());
container.Register<IAuth>(new PasswordAuth());
container.Register<IRepository>(AzureStorage.CreateSingleton(
RoleEnvironment.GetConfigurationSettingValue("StorageConnectionString")
));
container.RegisterAutoWired<XpmsAuthProvider>().ReusedWithin(ReuseScope.Hierarchy);
container.RegisterProcesses<AbstractProcess>();
container.RegisterValidators(typeof(SignupRequestValidator).Assembly);
container.RegisterDataRecords<IRepoData>(typeof(AzureStorage).Assembly);
}
public void Does_AutoWire_Funq_types()
{
var container = new Container();
container.RegisterAutoWiredAs<Foo, IFoo>();
container.RegisterAutoWired<FunqTest>();
var test = container.Resolve<FunqTest>();
Assert.That(test.CtorFoo, Is.Not.Null);
Assert.That(test.CtorFoo(), Is.Not.Null);
Assert.That(test.FunqFoo, Is.Not.Null);
Assert.That(test.FunqFoo(), Is.Not.Null);
}
public override void Configure(Container container)
{
//ASP.NET MVC integration
ControllerBuilder.Current.SetControllerFactory(new FunqControllerFactory(container));
SetConfig(CreateEndpointHostConfig());
JsConfig.EmitCamelCaseNames = true;
Plugins.Add(new ValidationFeature());
container.RegisterValidators(typeof(AppHost).Assembly);
container.RegisterAutoWired<BicyleRepository>();
}
void registerDependencies(Container container)
{
// ReuseScope.None disposes the Db connection.
// Needed for Sql Server
container.RegisterAutoWiredAs<Repository, IRepository>().ReusedWithin(ReuseScope.None);
container.RegisterAutoWired<BaseService>().ReusedWithin(ReuseScope.None);
container.RegisterAutoWired<HomeService>().ReusedWithin(ReuseScope.None);
container.RegisterAutoWired<SearchService>().ReusedWithin(ReuseScope.None);
container.RegisterAutoWiredAs<ProductsService, IProductsService>().ReusedWithin(ReuseScope.None);
// not exposing this on PublicMvc
//container.RegisterAutoWired<ProductsProcessorService>().ReusedWithin(ReuseScope.None);
var connectionString = ConfigurationManager
.ConnectionStrings["DiffStack"].ConnectionString;
container.Register<IDbConnectionFactory>(c =>
new OrmLiteConnectionFactory(
connectionString,
SqlServerDialect.Provider
)
);
}
public override void Configure(Funq.Container container)
{
ServiceStack.Text.JsConfig.EmitCamelCaseNames = true;
Plugins.Add(new RazorFormat());
var ormLiteConnectionFactory = new OrmLiteConnectionFactory(ConfigurationManager.ConnectionStrings["studentDbConn"].ConnectionString,
ServiceStack.OrmLite.SqlServer.SqlServerOrmLiteDialectProvider.Instance);
container.Register <IDbConnectionFactory>(ormLiteConnectionFactory);
container.Register(c => new StudentDbRepository()).ReusedWithin(ReuseScope.Request);
container.RegisterAutoWired <StudentDbRepository>();
DbInitializer.InitializeDb(ormLiteConnectionFactory);
}
public void ConfigureAppHost(Container container, bool useTestDatabase = false)
{
JsConfig.EmitCamelCaseNames = true;
_appHost.Plugins.Add(new ValidationFeature());
container.RegisterValidators(typeof (AppHost).Assembly);
container.Register<ICacheClient>(new MemoryCacheClient());
_appHost.Plugins.Add(new AuthFeature(
() => new AuthUserSession(),
new IAuthProvider[]
{
new CredentialsAuthProvider()
}));
if (useTestDatabase)
{
container.Register<IDbConnectionFactory>(
new OrmLiteConnectionFactory(
":memory:",
false,
SqliteDialect.Provider));
}
else
{
container.Register<IDbConnectionFactory>(
new OrmLiteConnectionFactory(
ConfigurationManager.ConnectionStrings["SqlLiteConnection"].ConnectionString.MapHostAbsolutePath(),
SqliteDialect.Provider));
}
container.RegisterAutoWired<BicyleRepository>().ReusedWithin(ReuseScope.Request);
container.Register<IUserAuthRepository>(c =>
new OrmLiteAuthRepository(c.Resolve<IDbConnectionFactory>()));
var userAuthRepository = (OrmLiteAuthRepository) container.Resolve<IUserAuthRepository>();
userAuthRepository.CreateMissingTables();
if (userAuthRepository.GetUserAuthByUserName("*****@*****.**") == null)
{
userAuthRepository.CreateUserAuth(
new UserAuth {Email = "*****@*****.**", DisplayName = "Admin User"}, "admin");
}
InitializeDatabase(container);
}
public override void Configure(Container container)
{
Plugins.Add(new CorsFeature());
RequestFilters.Add((httpReq, httpRes, requestDto) =>
{
//Handles Request and closes Responses after emitting global HTTP Headers
if (httpReq.HttpMethod == "OPTIONS")
httpRes.EndRequest();
});
var dbConnectionFactory =
new OrmLiteConnectionFactory(HttpContext.Current.Server.MapPath("~/App_Data/bookData.txt"),
SqliteDialect.Provider);
container.Register<IDbConnectionFactory>(dbConnectionFactory);
container.RegisterAutoWired<DataRepository>();
//Routes
// .Add<Book>("/Book");
}
public override void Configure(Container container)
{
container.Register(this);
LogManager.LogFactory = new NLogFactory();
container.RegisterAutoWired<AppSettings>();
container.RegisterAutoWired<FsService>();
container.RegisterAutoWired<AzureClient>();
container.RegisterAutoWired<CertService>();
container.RegisterAutoWired<CustomBasicAuthProvider>();
container.Register(LogManager.GetLogger(GetType()));
container.RegisterAutoWired<LoggingService>();
Plugins.Add(new AuthFeature(() => new AuthUserSession(), new IAuthProvider[] { container.Resolve<CustomBasicAuthProvider>() }) { HtmlRedirect = null, IncludeAssignRoleServices = false});
}
public override void Configure(Container container)
{
SetConfig(new EndpointHostConfig { ServiceStackHandlerFactoryPath = "api" });
container.Register(c => new Database("localDB")).ReusedWithin(ReuseScope.Request);
container.RegisterAutoWired<CommentRepository>().ReusedWithin(ReuseScope.Request);
container.RegisterAutoWired<PlayerRepository>().ReusedWithin(ReuseScope.Request);
container.RegisterAutoWired<Repository<Team>>().ReusedWithin(ReuseScope.Request);
container.RegisterAutoWired<UserRepository>().ReusedWithin(ReuseScope.Request);
container.RegisterAutoWired<AuthTokenRepository>().ReusedWithin(ReuseScope.Request);
container.RegisterAutoWired<Repository<ErrorLog>>().ReusedWithin(ReuseScope.Request);
container.RegisterAutoWired<FlaggedCommentRepository>().ReusedWithin(ReuseScope.Request);
ServiceExceptionHandler = (req, request, exception) =>
{
var errorLog = new ErrorLog
{
Application = "Scouting.RestService",
CreateDate = DateTimeOffset.Now,
Message = exception.Message,
StackTrace = exception.StackTrace
};
container.Resolve<Repository<ErrorLog>>().Add(errorLog);
return DtoUtils.CreateErrorResponse(request, exception, new ResponseStatus(HttpStatusCode.InternalServerError.ToString()));
};
//Handle Unhandled Exceptions occurring outside of Services
//E.g. Exceptions during Request binding or in filters:
ExceptionHandler = (req, res, operationName, ex) =>
{
var errorLog = new ErrorLog
{
Application = "Scouting.RestService",
CreateDate = DateTimeOffset.Now,
Message = ex.Message,
StackTrace = ex.StackTrace
};
container.Resolve<Repository<ErrorLog>>().Add(errorLog);
res.Write("Error: {0}: {1}".Fmt(ex.GetType().Name, ex.Message));
res.EndRequest(skipHeaders: true);
};
}
public override void Configure(Container container)
{
//ASP.NET MVC integration
ControllerBuilder.Current.SetControllerFactory(new FunqControllerFactory(container));
SetConfig(CreateEndpointHostConfig());
JsConfig.EmitCamelCaseNames = true;
Plugins.Add(new ValidationFeature());
container.RegisterValidators(typeof(AppHost).Assembly);
container.Register<ICacheClient>(new MemoryCacheClient());
Plugins.Add(new AuthFeature(
() => new AuthUserSession(),
new IAuthProvider[] {
new CredentialsAuthProvider()
}));
container.Register<IDbConnectionFactory>(
new OrmLiteConnectionFactory(
ConfigurationManager.ConnectionStrings["SqlLiteConnection"].ConnectionString.MapHostAbsolutePath(),
SqliteDialect.Provider));
container.RegisterAutoWired<BicyleRepository>().ReusedWithin(ReuseScope.Request);
container.Register<IUserAuthRepository>(c =>
new OrmLiteAuthRepository(c.Resolve<IDbConnectionFactory>()));
var userAuthRepository = (OrmLiteAuthRepository)container.Resolve<IUserAuthRepository>();
userAuthRepository.CreateMissingTables();
if (userAuthRepository.GetUserAuthByUserName("*****@*****.**") == null)
{
userAuthRepository.CreateUserAuth(
new UserAuth { Email = "*****@*****.**", DisplayName = "Admin User" }, "admin");
}
InitializeDatabase(container);
}
public void Does_AutoWire_MultiFunq_types()
{
var container = new Container();
container.RegisterAutoWiredAs<Foo, IFoo>();
container.RegisterAutoWiredAs<Bar, IBar>();
container.RegisterAutoWired<Test>();
var foo = container.Resolve<IFoo>();
Assert.That(foo, Is.Not.Null);
var bar = container.Resolve<IBar>();
Assert.That(bar, Is.Not.Null);
container.RegisterAutoWired<MultiFunqTest>();
var test = container.Resolve<MultiFunqTest>();
Assert.That(test.CtorFooBar, Is.Not.Null);
Assert.That(test.CtorFooBar(new Foo()), Is.Not.Null);
Assert.That(test.FunqFooBar, Is.Not.Null);
Assert.That(test.FunqFooBar(new Foo()), Is.Not.Null);
Assert.That(test.FunqTestFooBar, Is.Not.Null);
Assert.That(test.FunqTestFooBar(new Test(), new Foo()), Is.Not.Null);
}
public override void Configure(Container container)
{
//ServiceStack.Text.JsConfig.EmitCamelCaseNames = true; ! DO NOT USE THIS !
//Feature disableFeatures = Feature.Xml | Feature.Jsv | Feature.Csv | Feature.Soap11 | Feature.Soap12 | Feature.Soap;
SetConfig(new EndpointHostConfig
{
DebugMode = false,
UseCustomMetadataTemplates = true,
DefaultContentType = ContentType.Json,
EnableFeatures = Feature.Json | Feature.Metadata
//ServiceStackHandlerFactoryPath = "api"
});
CorsFeature cf = new CorsFeature(allowedOrigins: "*", allowedMethods: "GET, POST, PUT, DELETE", allowedHeaders: "Content-Type, Signature", allowCredentials: false);
this.Plugins.Add(cf);
string strConnectionString = GetConnectionString();
var dbConnectionFactory = new OrmLiteConnectionFactory(strConnectionString, SqlServerDialect.Provider)
{
ConnectionFilter =
x =>
new ProfiledDbConnection(x, Profiler.Current)
};
container.Register<IDbConnectionFactory>(dbConnectionFactory);
var connectString = new TmsWS.ServiceModel.ConnectStringFactory(strConnectionString);
container.Register<TmsWS.ServiceModel.IConnectString>(connectString);
var secretKey = new TmsWS.ServiceModel.SecretKeyFactory(strSecretKey);
container.Register<TmsWS.ServiceModel.ISecretKey>(secretKey);
container.RegisterAutoWired<TmsWS.ServiceModel.Auth>();
container.RegisterAutoWired<TmsWS.ServiceModel.Event.List_Login_Logic>();
container.RegisterAutoWired<TmsWS.ServiceModel.Event.List_JobNo_Logic>();
container.RegisterAutoWired<TmsWS.ServiceModel.Event.List_Container_Logic>();
container.RegisterAutoWired<TmsWS.ServiceModel.Event.List_Jmjm6_Logic>();
container.RegisterAutoWired<TmsWS.ServiceModel.Event.Update_Done_Logic>();
}
public override void Configure(Container container)
{
Plugins.Add(new CorsFeature());
Plugins.Add(new ValidationFeature());
Plugins.Add(new PostmanFeature());
// Build path for portability between win/linux
var dbPath =
Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)
.CombineWith("data")
.CombineWith("leaguedata.sqlite");
// SQLite
container.Register<IDbConnectionFactory>(new OrmLiteConnectionFactory(dbPath, SqliteDialect.Provider));
container.Register<IKeys>(new ApiKeys(AppSettings.GetList("apiKeys"))); // API Keys
container.RegisterAutoWiredAs<MlbBioProvider, IBioData>(); // Bios from MLB
container.RegisterAutoWiredAs<MlbStatProvider, IStatData>(); // Stats from MLB
container.RegisterAutoWiredAs<FunqServiceFactory, IServiceFactory>(); // Service Factory
container.RegisterAutoWired<Services>();
container.RegisterAutoWired<LeagueEngine>();
// Validators
container.RegisterValidators(typeof(TeamValidator).Assembly);
// Include type info for update options.
JsConfig<BioUpdateOptions>.IncludeTypeInfo = true;
JsConfig<StatUpdateOptions>.IncludeTypeInfo = true;
JsConfig<TeamUpdateOptions>.IncludeTypeInfo = true;
JsConfig.EmitCamelCaseNames = true;
OrmLiteConfig.InsertFilter = (dbCmd, row) =>
{
var auditRow = row as IAudit;
if (auditRow != null)
auditRow.Created = auditRow.Modified = DateTime.UtcNow;
};
// Update filter for IAudit
OrmLiteConfig.UpdateFilter = (dbCmd, row) =>
{
var auditRow = row as IAudit;
if (auditRow != null)
auditRow.Modified = DateTime.UtcNow;
};
// Setup tables
using (var db = container.Resolve<IDbConnectionFactory>().Open())
{
db.CreateTableIfNotExists(
typeof(Team), typeof(Player), typeof(Division), typeof(Teamate),
typeof(DivisionalPlayer), typeof(LeagueEvent), typeof(GameLog), typeof(PlayerTotals),
typeof(TeamTotals), typeof(Setting)
);
}
// Log any exception coming out of the services.
ServiceExceptionHandlers.Add((httpReq, request, exception) =>
{
LogManager.GetLogger(request.GetType()).Error($"{request.ToJson()}|{exception}");
return null; // continues default error handling
});
var game = container.Resolve<LeagueEngine>();
game.Start();
}
public override void Configure(Container container)
{
container.Adapter = containerAdapter;
#if DEBUG
container.Register<ICacheClient>(c => new MemoryCacheClient());
#else
container.Register<IRedisClientsManager>(c => new PooledRedisClientManager("localhost:30705"));
container.Register(c => c.Resolve<IRedisClientsManager>().GetCacheClient()).ReusedWithin(ReuseScope.None);
#endif
Plugins.Add(new RazorFormat());
container.Register<IDbConnectionFactory>(
new OrmLiteConnectionFactory(
@"Server=127.0.0.1;Port=5432;Database=PlayitForward;User Id=postgres;Password=swordfish;", PostgreSqlDialect.Provider));
using (var db = container.Resolve<IDbConnectionFactory>().OpenDbConnection())
{
db.CreateTable<App>();
db.CreateTable<Sub>();
db.CreateTable<User>();
db.CreateTable<Giveaway>();
db.CreateTable<Entry>();
db.CreateTable<Message>();
db.CreateTable<ModLog>();
}
container.RegisterAutoWired<GiveawayService>();
container.RegisterAutoWired<UserService>();
container.RegisterAutoWired<SecureUserService>();
container.RegisterAutoWired<GamesService>();
SetConfig(
new HostConfig
{
//CustomHttpHandlers =
//{
// { HttpStatusCode.NotFound, new RazorHandler("/404") },
// { HttpStatusCode.Unauthorized, new RazorHandler("/login") },
//},
GlobalResponseHeaders =
{
{ "Access-Control-Allow-Origin", "*" },
{ "Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS" },
},
EnableFeatures = Feature.All.Remove(GetDisabledFeatures()),
});
var appSettings = new AppSettings();
Plugins.Add(new RazorFormat());
Plugins.Add(
new AuthFeature(
() => new SteamUserSession(),
new IAuthProvider[] { new SteamOpenIdOAuthProvider(appSettings) }));
Plugins.Add(new SessionFeature());
ControllerBuilder.Current.SetControllerFactory(new FunqControllerFactory(container));
ServiceStackController.CatchAllController = reqCtx => container.TryResolve<HomeController>();
//log.InfoFormat("AppHost Configured: {0}", DateTime.Now);
}
public override void Configure(Container container)
{
//ServiceStack.Text.JsConfig.EmitCamelCaseNames = true; ! DO NOT USE THIS !
//Feature disableFeatures = Feature.Xml | Feature.Jsv | Feature.Csv | Feature.Soap11 | Feature.Soap12 | Feature.Soap;
SetConfig(new EndpointHostConfig
{
DebugMode = false,
UseCustomMetadataTemplates = true,
//DefaultContentType = ContentType.Json,
//GlobalResponseHeaders = {
// { "Access-Control-Allow-Origin", "*" },
// { "Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS" },
// { "Access-Control-Allow-Headers", "Content-Type, Signature" }
//},
EnableFeatures = Feature.Json | Feature.Metadata
//ServiceStackHandlerFactoryPath = "api"
});
CorsFeature cf = new CorsFeature(allowedOrigins: "*", allowedMethods: "GET, POST, PUT, DELETE, OPTIONS", allowedHeaders: "Content-Type, Signature", allowCredentials: false);
this.Plugins.Add(cf);
this.Plugins.Add(new SwaggerFeature());
//DB
var dbConnectionFactory = new OrmLiteConnectionFactory(GetConnectionString("Freight"), SqlServerDialect.Provider)
{
ConnectionFilter =
x =>
new ProfiledDbConnection(x, Profiler.Current)
};
dbConnectionFactory.RegisterConnection("TMS", GetConnectionString("TMS"), SqlServerDialect.Provider);
dbConnectionFactory.RegisterConnection("WMS", GetConnectionString("WMS"), SqlServerDialect.Provider);
container.Register<IDbConnectionFactory>(dbConnectionFactory);
//
var secretKey = new WebApi.ServiceModel.SecretKeyFactory(strSecretKey);
container.Register<WebApi.ServiceModel.ISecretKey>(secretKey);
//Auth
container.RegisterAutoWired<WebApi.ServiceModel.Auth>();
//WMS
container.RegisterAutoWired<WebApi.ServiceModel.Wms.Wms_Login_Logic>();
container.RegisterAutoWired<WebApi.ServiceModel.Wms.List_Rcbp1_Logic>();
container.RegisterAutoWired<WebApi.ServiceModel.Wms.List_Imgr1_Logic>();
container.RegisterAutoWired<WebApi.ServiceModel.Wms.List_Impr1_Logic>();
container.RegisterAutoWired<WebApi.ServiceModel.Wms.List_Imgr2_Logic>();
container.RegisterAutoWired<WebApi.ServiceModel.Wms.List_Imgi1_Logic>();
container.RegisterAutoWired<WebApi.ServiceModel.Wms.List_Imgi2_Logic>();
container.RegisterAutoWired<WebApi.ServiceModel.Wms.List_Imsn1_Logic>();
container.RegisterAutoWired<WebApi.ServiceModel.Wms.Confirm_Imgr1_Logic>();
//TMS
container.RegisterAutoWired<WebApi.ServiceModel.Tms.Jmjm_Logic>();
container.RegisterAutoWired<WebApi.ServiceModel.Tms.Sibl_Logic>();
//Event
container.RegisterAutoWired<WebApi.ServiceModel.Event.Event_Login_Logic>();
container.RegisterAutoWired<WebApi.ServiceModel.Event.List_Jmjm6_Logic>();
container.RegisterAutoWired<WebApi.ServiceModel.Event.List_JobNo_Logic>();
container.RegisterAutoWired<WebApi.ServiceModel.Event.Update_Done_Logic>();
container.RegisterAutoWired<WebApi.ServiceModel.Event.List_Container_Logic>();
//Freight
container.RegisterAutoWired<WebApi.ServiceModel.Freight.Freight_Login_Logic>();
container.RegisterAutoWired<WebApi.ServiceModel.Freight.Saus_Logic>();
container.RegisterAutoWired<WebApi.ServiceModel.Freight.Rcbp_Logic>();
container.RegisterAutoWired<WebApi.ServiceModel.Freight.Smsa_Logic>();
container.RegisterAutoWired<WebApi.ServiceModel.Freight.Smct_Logic>();
container.RegisterAutoWired<WebApi.ServiceModel.Freight.Plvi_Logic>();
container.RegisterAutoWired<WebApi.ServiceModel.Freight.Rcvy_Logic>();
container.RegisterAutoWired<WebApi.ServiceModel.Freight.Tracking_Logic>();
container.RegisterAutoWired<WebApi.ServiceModel.Freight.ViewPDF_Logic>();
}
public void Does_not_AutoWire_BuiltIn_BCL_and_ValueTypes()
{
var container = new Container();
container.Register<IFoo>(c => new Foo());
container.Register<IBar>(c => new Bar());
//Should not be autowired
container.Register<string>(c => "Replaced String");
container.Register<int>(c => 99);
container.RegisterAutoWired<DependencyWithBuiltInTypes>();
var test = container.Resolve<DependencyWithBuiltInTypes>();
Assert.That(test.Foo, Is.Not.Null);
Assert.That(test.Bar, Is.Not.Null);
Assert.That(test.String, Is.EqualTo("A String"));
Assert.That(test.Age, Is.EqualTo(27));
}
/// <summary>
/// Configure the container with the necessary routes for your ServiceStack application.
/// </summary>
/// <param name="container">The built-in IoC used with ServiceStack.</param>
public override void Configure(Container container)
{
JsConfig.EmitCamelCaseNames = true;
JsConfig.PropertyConvention = PropertyConvention.Lenient;
JsConfig.DateHandler = DateHandler.ISO8601;
LogManager.LogFactory = new Log4NetFactory();
container.RegisterAutoWired<JournalService>();
container.RegisterAutoWired<SessionService>();
container.RegisterAutoWired<TaskService>();
ConfigureAndSeedSqlLiteDataBase(container);
LogManager.GetLogger(typeof(SystematizeAppHost)).Debug("AppHost has started... (way to go copying kgobel)");
}
public override void Configure(Container container)
{
SetConfig(new HostConfig
{
DebugMode = false,
EnableFeatures = Feature.All.Remove(Feature.Xml | Feature.Jsv | Feature.Csv | Feature.Soap11 | Feature.Soap12 | Feature.Soap),
HandlerFactoryPath = "api"
});
CorsFeature cf = new CorsFeature(allowedOrigins: "*", allowedMethods: "GET, POST, PUT, DELETE, OPTIONS", allowedHeaders: "Content-Type, Signature", allowCredentials: false);
this.Plugins.Add(cf);
string strConnectionString = GetConnectionString();
var dbConnectionFactory = new OrmLiteConnectionFactory(strConnectionString, SqlServerDialect.Provider, true)
{
ConnectionFilter =
x =>
new ProfiledDbConnection(x, Profiler.Current)
};
container.Register<IDbConnectionFactory>(dbConnectionFactory);
var connectString = new WmsWS.ServiceModel.ConnectStringFactory(strConnectionString);
container.Register<WmsWS.ServiceModel.IConnectString>(connectString);
var secretKey = new WmsWS.ServiceModel.SecretKeyFactory(strSecretKey);
container.Register<WmsWS.ServiceModel.ISecretKey>(secretKey);
container.RegisterAutoWired<WmsWS.ServiceModel.Auth>();
container.RegisterAutoWired<WmsWS.ServiceModel.Wms.List_Login_Logic>();
container.RegisterAutoWired<WmsWS.ServiceModel.Wms.List_Imgr1_Logic>();
container.RegisterAutoWired<WmsWS.ServiceModel.Wms.List_Impr1_Logic>();
container.RegisterAutoWired<WmsWS.ServiceModel.Wms.List_Imgr2_Logic>();
container.RegisterAutoWired<WmsWS.ServiceModel.Wms.Confirm_Imgr1_Logic>();
container.RegisterAutoWired<WmsWS.ServiceModel.Wms.List_Imgi1_Logic>();
container.RegisterAutoWired<WmsWS.ServiceModel.Wms.List_Imgi2_Logic>();
container.RegisterAutoWired<WmsWS.ServiceModel.Wms.List_Imsn1_Logic>();
//container.RegisterAutoWired<WmsWS.ServiceModel.Wms.Update_Done_Logic>();
//container.RegisterAutoWired<WmsWS.ServiceModel.Wms.List_JobNo_Logic>();
container.RegisterAutoWired<WmsWS.ServiceModel.Wms.List_Rcbp1_Logic>();
container.RegisterAutoWired<WmsWS.ServiceModel.Wms.List_Rcbp3_Logic>();
}
/// <summary>
/// Configuración de los servicios web
/// </summary>
/// <param name="container">Contenedor IoC</param>
public override void Configure( Container container )
{
// Configuración JSON
JsConfig.EmitCamelCaseNames = true;
JsConfig.IncludeNullValues = false;
JsConfig.DateHandler = DateHandler.ISO8601;
JsConfig.EscapeUnicode = true;
//JsConfig<LinkRelationType>.SerializeFn = (text => text.ToString().ToLower());
// Configuración de ServiceStack
SetConfig(new HostConfig
{
DefaultContentType = MimeTypes.Json,
DebugMode = true,
ReturnsInnerException = true,
WebHostUrl = "http://localhost:2828"/*HttpContext.Current.Request.Url.ToString()*/
});
// Plugins
var queryPlugin = new QueryLanguageFeature();
queryPlugin.RegisterAssociation(typeof(Customer), typeof(CustomerEntity));
queryPlugin.RegisterAssociation(typeof(GetCustomers), typeof(CustomerEntity));
queryPlugin.RegisterAssociation(typeof(Order), typeof(OrderEntity));
queryPlugin.RegisterAssociation(typeof(GetOrders), typeof(OrderEntity));
Plugins.Add(queryPlugin as IPlugin);
Plugins.Add(new ValidationFeature());
Plugins.Add(new SwaggerFeature());
Plugins.Add(new RazorFormat());
Plugins.Add(new CorsFeature());
Plugins.Add(new AuthFeature(() => new NorthwindUserSession(),
new IAuthProvider[]
{
new NorthwindAuthProvider(),
})
{
HtmlRedirect = null
});
// Caché
container.Register(new MemoryCacheClient());
// Acceso a datos
var dbFactory = new OrmLiteConnectionFactory("~/Northwind.sqlite".MapHostAbsolutePath(), SqliteDialect.Provider);
container.Register(dbFactory);
container.Register<ICustomerEntityRepository>(c => new CustomerEntityRepository(dbFactory));
container.Register<IOrderEntityRepository>(c => new OrderEntityRepository(dbFactory));
container.Register<IUserEntityRepository>(c => new UserEntityRepository(dbFactory));
container.RegisterAutoWired<CustomersService>();
}
public void TestFixtureSetUp()
{
container = new Container();
container.Register<IDbConnectionFactory>(
new OrmLiteConnectionFactory(":memory:", false, SqliteDialect.Provider));
container.RegisterAutoWiredAs<RockstarRepository, IRockstarRepository>();
container.RegisterAutoWired<SimpleService>();
using (var db = container.Resolve<IDbConnectionFactory>().Open())
{
db.DropAndCreateTable<Rockstar>();
db.InsertAll(SeedData);
}
}
public void Does_Resolve_lazy_Func_types()
{
var container = new Container();
container.Register<Func<IFoo>>(c => () => new Foo());
container.RegisterAutoWired<FunqTest>();
var test = container.Resolve<FunqTest>();
Assert.That(test.CtorFoo, Is.Not.Null);
Assert.That(test.CtorFoo(), Is.Not.Null);
Assert.That(test.FunqFoo, Is.Not.Null);
Assert.That(test.FunqFoo(), Is.Not.Null);
}