public override void Configure(Funq.Container container)
{
//Set JSON web services to return idiomatic JSON camelCase properties
ServiceStack.Text.JsConfig.EmitCamelCaseNames = true;
ApiRegistration.Register(Routes);
//Change the default ServiceStack configuration
SetConfig(new EndpointHostConfig
{
DebugMode = true, //Show StackTraces in responses in development
//enable CORS
GlobalResponseHeaders = { { "Access-Control-Allow-Origin", "*" },
{ "Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS" },
{ "Access-Control-Allow-Headers", "Content-Type" },
}
});
Plugins.Add(new ValidationFeature());
container.RegisterValidators(typeof(ApplicationRequestValidator).Assembly);
Plugins.Add(new RequestLogsFeature());
//Register In-Memory Cache provider.
//For Distributed Cache Providers Use: PooledRedisClientManager, BasicRedisClientManager or see: https://github.com/ServiceStack/ServiceStack/wiki/Caching
container.Register<ICacheClient>(new MemoryCacheClient());
//Set MVC to use the same Funq IOC as ServiceStack
ServiceRegistration.RegisterAllContainers(container);
}
public override void Configure(Funq.Container container)
{
//Resource manager
container.Register<IResourceManager>(new ConfigurationResourceManager());
var appSettings = container.Resolve<IResourceManager>();
Plugins.Add(new SessionFeature());
string redis = appSettings.GetString("redis_connection_string");
container.Register<IRedisClientsManager>(c => new BasicRedisClientManager(redis));
// Register storage for user sessions
container.Register<ICacheClient>(c => c.Resolve<IRedisClientsManager>().GetCacheClient()).ReusedWithin(Funq.ReuseScope.None);
container.Register<ISessionFactory>(c => new SessionFactory(c.Resolve<ICacheClient>()));
// Set JSON web services to return idiomatic JSON camelCase properties
ServiceStack.Text.JsConfig.EmitCamelCaseNames = true;
// Validation
Plugins.Add(new ValidationFeature());
container.RegisterValidators(typeof(Namespace_ApiProject).Assembly);
Plugins.Add(new AuthFeature(() => new CustomUserSession(),
new IAuthProvider[]
{
new FbOAuth2Provider(appSettings),
new VkOAuth2Provider(appSettings),
}));
//container.Register<ICacheClient>(new MemoryCacheClient());
Plugins.Add(new ServiceStack.Api.Swagger.SwaggerFeature());
container.Adapter = new StructureMapContainerAdapter();
}
public override void Configure(Funq.Container container)
{
//Set JSON web services to return idiomatic JSON camelCase properties
ServiceStack.Text.JsConfig.EmitCamelCaseNames = true;
container.Register<ICacheClient>(new MemoryCacheClient());
container.Register<IDbConnectionFactory>(
new OrmLiteConnectionFactory(ConfigurationManager.ConnectionStrings["Db"].ToString(), SqlServerDialect.Provider));
Plugins.Add(new ValidationFeature());
container.RegisterValidators(typeof(MeetingValidator).Assembly);
//https://github.com/ServiceStack/ServiceStack/wiki/Authentication-and-authorization#userauth-persistence---the-iuserauthrepository
//Use ServiceStacks authentication/authorization persistence
var userRep = new OrmLiteAuthRepository(container.Resolve<IDbConnectionFactory>());
container.Register<IUserAuthRepository>(userRep);
userRep.CreateMissingTables(); //Create missing Auth
var appSettings = new AppSettings();
Plugins.Add(new AuthFeature(() => new AuthUserSession(), new IAuthProvider[]
{
new CredentialsAuthProvider(),
new GoogleOpenIdOAuthProvider(appSettings),
}));
Plugins.Add(new RegistrationFeature());
//Set MVC to use the same Funq IOC as ServiceStack
ControllerBuilder.Current.SetControllerFactory(new FunqControllerFactory(container));
}
public override void Configure(Funq.Container container)
{
//register any dependencies your services use, e.g:
//container.Register<ICacheClient>(new MemoryCacheClient());
//register the routes, can be in the configure of the asax too
//Routes.Add<HelloWorld>("/Path");
//Add the auth feature
Plugins.Add(new AuthFeature(
() => new AuthUserSession(),
new IAuthProvider[] {new BasicAuthProvider()}));
//Register the Validation Plugin
Plugins.Add(new ValidationFeature());
container.RegisterValidators(typeof(UnitSoldService).Assembly);
//Register users
Plugins.Add(new RegistrationFeature());
//Add the cache container for the auth
//container.Register<ICacheClient>(new MemoryCacheClient());
//Caching with Redis
//container.Register<IRedisClientsManager>(c => new PooledRedisClientManager());
//container.Register<ICacheClient>(c => (ICacheClient) c.Resolve<IRedisClientsManager>().GetCacheClient());
//Defines the user repository
var userRepository = new InMemoryAuthRepository();
container.Register<IUserAuthRepository>(userRepository);
//Add User
//create hash and salt from password
string hash;
string salt;
const string password = "******";
new SaltedHash().GetHashAndSaltString(password, out hash, out salt);
userRepository.CreateUserAuth(new UserAuth
{
Id = 1,
DisplayName = "Rafael",
Email = "*****@*****.**",
UserName = "******",
FirstName = "Rafael",
LastName = "Miceli",
Roles = new List<string> {RoleNames.Admin},
//Permissions = new List<string>{"GetStatus"},
PasswordHash = hash,
Salt = salt
}, password);
//var dbConnectionFactory =
// new OrmLiteConnectionFactory(HttpContext.Current.Server.MapPath("~/App_Data/data.txt"), true, SqliteDialect.Provider);
//container.Register<IDbConnectionFactory>(dbConnectionFactory);
//container.RegisterAutoWired<UnitsRepository>();
}
public override void Configure(Funq.Container container)
{
container.RegisterAutoWired<PlayersRepository>();
Plugins.Add(new ValidationFeature());
container.RegisterValidators(typeof(AppHost).Assembly);
}
public override void Configure(Funq.Container container)
{
container.RegisterAutoWiredAs<RegistrationRepository, IRegistrationRepository>();
container.RegisterAutoWiredAs<GuidFactory, IGuidFactory>();
Plugins.Add(new ValidationFeature());
container.RegisterValidators(typeof (Global).Assembly);
}
public override void Configure(Funq.Container container)
{
//Set JSON web services to return idiomatic JSON camelCase properties
JsConfig.EmitCamelCaseNames = true;
//Register Typed Config some services might need to access
var appConfig = new AppConfig(new AppSettings());
//appconfig will contain properties from web.config
container.Register(appConfig);
//inform api that this will be using BasicAuth to authenticate/authorize users
Plugins.Add(new AuthFeature(
() => new AuthUserSession(),
new IAuthProvider[] { new BasicAuthProvider(), }));
//add registration functionality (user will need admin role to access this)
Plugins.Add(new RegistrationFeature());
//add validation using fluent validation package
Plugins.Add(new ValidationFeature());
//register service to validate
container.RegisterValidators(typeof(AwardService).Assembly);
if (appConfig.UseRedis){
//setup cache client to user redis
container.Register<IRedisClientsManager>(c => new PooledRedisClientManager(appConfig.RedisReadWriteHosts.ToArray()));
container.Register<ICacheClient>(c => c.Resolve<IRedisClientsManager>().GetCacheClient());
//setup redis for authentication repository
container.Register<IUserAuthRepository>(c => new RedisAuthRepository(c.Resolve<IRedisClientsManager>()));
}
else
{
//setup cache client to be InMemory
container.Register<ICacheClient>(c => new MemoryCacheClient());
//setup authentication repository to be InMemory
container.Register<IUserAuthRepository>(c => new InMemoryAuthRepository());
}
//seed possible users
SeedUsers(container.Resolve<IUserAuthRepository>());
//register any repository classes here
container.RegisterAutoWired<AwardRepository>();
}
public override void Configure(Funq.Container container)
{
ServiceStack.Text.JsConfig.EmitCamelCaseNames = true;
ServiceStack.Text.JsConfig.IncludeNullValues = true;
ServiceStack.Logging.LogManager.LogFactory = new NLogFactory();
Plugins.Add(new RazorFormat { LoadFromAssemblies = new List<Assembly> { typeof(AppHost).Assembly } });
Plugins.Add(new ValidationFeature());
container.RegisterValidators(typeof(AppHost).Assembly);
this.PreRequestFilters.Add((request, response) => Log.Info(request.AbsoluteUri));
this.GlobalRequestFilters.Add((request, response, dto) => Log.Info(request));
RewriteReturnVoidToNoContent();
}
public override void Configure(Funq.Container container)
{
RequestBinders.Clear();
JsConfig.EmitCamelCaseNames = true;
JsConfig.IncludeNullValues = true;
JsConfig.DateHandler = JsonDateHandler.ISO8601;
Plugins.Add(new ValidationFeature());
// Add custom request filter
RequestFilters.Add(GetRequestProcessor.DeserializeJsonFromGet);
container.Adapter = new AutofacContainerAdapter(containerProvider);
container.RegisterValidators(typeof(GetTagRequestValidator).Assembly);
}
public override void Configure(Funq.Container container)
{
Routes.Add<Resorts.ResortsRequest>("/api/resorts", "GET")
.Add<Resorts.Resort>("/api/resort", "GET,POST,PUT,DELETE")
.Add<Track>("/api/track", "GET,POST,PUT,DELETE")
.Add<Track>("/api/track/{Id}", "GET")
.Add<TracksRequest>("/api/resort/{ResortId}/tracks", "GET")
.Add<MapRequest>("/api/resort/{ResortId}/maps", "GET")
.Add<Map>("/api/map", "GET,POST,PUT,DELETE")
.Add<Map>("/api/map/{Id}", "GET");
//LogManager.LogFactory = new Log4NetFactory(true);
LogManager.LogFactory = new ServiceStack.Logging.Support.Logging.ConsoleLogFactory();
//container.Register<ServiceStack.CacheAccess.ICacheClient>(new MemoryCacheClient());
container.Register<IRedisClientsManager>(new PooledRedisClientManager("localhost"));
container.Register<ServiceStack.CacheAccess.ICacheClient>(c =>(ICacheClient)c.Resolve<IRedisClientsManager>().GetCacheClient());
container.Register<ILog>(x => LogManager.GetLogger(GetType()));
Plugins.Add(new RequestLogsFeature());
Plugins.Add(new ValidationFeature());
container.RegisterValidators(Assembly.GetCallingAssembly());
}
/// <summary>
/// The Configure method of the HelloAppHost is the central IoC container location.
/// All configured services, plugins and resources are centrally managed from here.
/// </summary>
/// <param name="container"></param>
public override void Configure(Funq.Container container)
{
string soon = DateTime.Now.AddSeconds(10).ToUniversalTime().ToString("ddd, dd MMM yyyy HH:mm:ss 'GMT'");
SetConfig(new EndpointHostConfig
{
GlobalResponseHeaders = {
{ "Access-Control-Allow-Origin", "*" },
{ "Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS" },
{ "Access-Control-Allow-Headers", "Content-Type" },
{ "Cache-Control", "no-cache, no-store, must-revalidate"},
{ "Pragma", "no-cache"},
{ "Expires", "0"},
{ "X-Powered-On", Environment.MachineName}
},
DefaultContentType = "application/json"
});
// Auto Add all Routes
Routes.AddFromAssembly(typeof(Person).Assembly);
// Fluent Validation
Plugins.Add(new ValidationFeature());
container.RegisterValidators(typeof(Person).Assembly);
// Database Connection
ConnectionStringSettingsCollection css = ConfigurationManager.ConnectionStrings;
string cs = css["storage"].ConnectionString;
container.Register<IDbConnectionFactory>(c =>
new OrmLiteConnectionFactory(cs, MySqlDialectProvider.Instance));
var loadStore = container.Resolve<StorageService>();
loadStore.Get(null);
}
private static void RegisterValidations(Funq.Container container)
{
container.RegisterValidators(typeof(UserRequestValidator).Assembly);
}
public override void Configure(Funq.Container container)
{
JsConfig.EmitCamelCaseNames = true;
JsConfig.IncludeNullValues = true;
JsConfig.DateHandler = JsonDateHandler.ISO8601;
LogManager.LogFactory = new DebugLogFactory();
SetConfig(new EndpointHostConfig
{
WsdlServiceNamespace = "",
AllowJsonpRequests = true,
DebugMode = true,
EnableFeatures = Feature.All.Remove(GetDisabledFeatures())
});
//Authentication (see: https://github.com/ServiceStack/ServiceStack/blob/master/tests/ServiceStack.WebHost.Endpoints.Tests/AuthTests.cs)
Plugins.Add(new AuthFeature(() => new AuthUserSession(),
new IAuthProvider[] {
new BasicAuthProvider(), //Sign-in with Basic Auth
}) { HtmlRedirect = null /* prevent redirect to login page, make the user login using basic auth prompt */ });
userRepository = new InMemoryAuthRepository();
container.Register<IUserAuthRepository>(userRepository);
CreateUser(userRepository, 1, UserName, "DisplayName", null, Password);
//NEW: Enable the validation feature and scans the service assembly for validators
Plugins.Add(new ValidationFeature());
container.RegisterValidators(typeof(Northwind.Data.Services.CategoryService).Assembly);
//Caching
container.Register<ICacheClient>(new MemoryCacheClient());
//Repositories
container.RegisterAs<CategoryServiceRepository, ICategoryServiceRepository>();
container.RegisterAs<CustomerServiceRepository, ICustomerServiceRepository>();
container.RegisterAs<CustomerCustomerDemoServiceRepository, ICustomerCustomerDemoServiceRepository>();
container.RegisterAs<CustomerDemographicServiceRepository, ICustomerDemographicServiceRepository>();
container.RegisterAs<EmployeeServiceRepository, IEmployeeServiceRepository>();
container.RegisterAs<EmployeeTerritoryServiceRepository, IEmployeeTerritoryServiceRepository>();
container.RegisterAs<OrderServiceRepository, IOrderServiceRepository>();
container.RegisterAs<OrderDetailServiceRepository, IOrderDetailServiceRepository>();
container.RegisterAs<ProductServiceRepository, IProductServiceRepository>();
container.RegisterAs<RegionServiceRepository, IRegionServiceRepository>();
container.RegisterAs<ShipperServiceRepository, IShipperServiceRepository>();
container.RegisterAs<SupplierServiceRepository, ISupplierServiceRepository>();
container.RegisterAs<TerritoryServiceRepository, ITerritoryServiceRepository>();
//DataAccess / OrmLite
var connectionString = ConfigurationManager.ConnectionStrings["ApiDbConnectionString"].ConnectionString;
container.Register<IDataAccessAdapterFactory>(c => new DataAccessAdapterFactory(connectionString));
container.Register<IDbConnectionFactory>(c => new OrmLiteConnectionFactory(connectionString, true, new SqlServerOrmLiteDialectProvider()));
}
public override void Configure(Funq.Container container)
{
//Set JSON web services to return idiomatic JSON camelCase properties
ServiceStack.Text.JsConfig.EmitCamelCaseNames = true;
//https://github.com/wordnik/swagger-core/wiki
//Document your code and expose it to the world
Plugins.Add(new SwaggerFeature());
//Registers authorization service and endpoints /auth and /auth{provider}
Plugins.Add(new AuthFeature(
() => new AuthUserSession(),
new IAuthProvider[] { new CredentialsAuthProvider() }
) {HtmlRedirect = null});
//Registers registartion service and endpoints /register, /assignroles, /unassignroles
Plugins.Add(new RegistrationFeature());
this.RegisterAs<MyRegistrationValidator, IValidator<Registration>>();
Plugins.Add(new ValidationFeature());
container.RegisterValidators(typeof(CreateOrderValidator).Assembly);
var dataFilePath = AppDomain.CurrentDomain.GetData("DataDirectory").ToString() + "\\data.db";
container.Register<IDbConnectionFactory>(new OrmLiteConnectionFactory(dataFilePath, SqliteDialect.Provider));
var userRep = new OrmLiteAuthRepository(container.Resolve<IDbConnectionFactory>());
container.Register<IUserAuthRepository>(userRep);
var redisCon = ConfigurationManager.AppSettings["redisUrl"].ToString();
container.Register<IRedisClientsManager>(new PooledRedisClientManager(20, 60, redisCon));
container.Register<ICacheClient>(c =>(ICacheClient)c.Resolve<IRedisClientsManager>().GetCacheClient());
//Set MVC to use the same Funq IOC as ServiceStack
ControllerBuilder.Current.SetControllerFactory(new FunqControllerFactory(container));
//https://github.com/ServiceStack/ServiceStack.Redis/wiki/RedisPubSub
//start threads that subscribe to Redis channels for Pub/Sub
new OrderSubscribers(container).StartSubscriberThreads();
new FulfillmentSubscribers(container).StartSubscriberThreads();
//https://github.com/ServiceStack/ServiceStack/wiki/Authentication-and-authorization#userauth-persistence---the-iuserauthrepository
//Use ServiceStacks authentication/authorization persistence
userRep.CreateMissingTables(); //Create missing Auth
//Re-Create Tables for the demo
using (var con = AppHostBase.Resolve<IDbConnectionFactory>().OpenDbConnection())
{
con.CreateTable<Order>(true);
con.CreateTable<Fulfillment>(true);
}
//clear redis
using (var redis = AppHostBase.Resolve<IRedisClientsManager>().GetClient())
{
}
//Create dummy user accounts (TestUser/Password)
foreach(var user in DummyUserAccounts.GetDummyAccounts())
{
if(userRep.GetUserAuthByUserName(user.UserName) == null)
userRep.CreateUserAuth(new UserAuth {UserName = user.UserName}, user.Password);
}
}
public override void Configure(Funq.Container container)
{
JsConfig.EmitCamelCaseNames = true;
JsConfig.IncludeNullValues = true;
JsConfig.DateHandler = JsonDateHandler.ISO8601;
LogManager.LogFactory = new ConsoleLogFactory();
SetConfig(new EndpointHostConfig
{
WsdlServiceNamespace = "",
AllowJsonpRequests = true,
DebugMode = true,
EnableFeatures = Feature.All.Remove(GetDisabledFeatures()),
CustomHttpHandlers = {
// Use the CmsRazorHandler to add theming capabilities
{ HttpStatusCode.NotFound, new CmsRazorHandler("/notfound") }
}
});
//Authentication (see: https://github.com/ServiceStack/ServiceStack/blob/master/tests/ServiceStack.WebHost.Endpoints.Tests/AuthTests.cs)
Plugins.Add(new AuthFeature(() => new AuthUserSession(),
new IAuthProvider[] {
new BasicAuthProvider(), //Sign-in with Basic Auth
}){ HtmlRedirect = null /* prevent redirect to login page, make the user login using basic auth prompt */ });
userRepository = new InMemoryAuthRepository();
container.Register<IUserAuthRepository>(userRepository);
CreateUser(userRepository, 1, UserName, "DisplayName", null, Password);
//Enable the validation feature and scan the service assembly for validators
Plugins.Add(new ValidationFeature());
container.RegisterValidators(typeof(Services.CategoryService).Assembly);
//Razor (use CmsRazorFormat to add theming capabilities)
Plugins.Add(new CmsRazorFormat());
//Caching
container.Register<ICacheClient>(new MemoryCacheClient());
//Entity Repositories
container.RegisterAs<CategoryServiceRepository, ICategoryServiceRepository>();
container.RegisterAs<CustomerServiceRepository, ICustomerServiceRepository>();
container.RegisterAs<CustomerCustomerDemoServiceRepository, ICustomerCustomerDemoServiceRepository>();
container.RegisterAs<CustomerDemographicServiceRepository, ICustomerDemographicServiceRepository>();
container.RegisterAs<EmployeeServiceRepository, IEmployeeServiceRepository>();
container.RegisterAs<EmployeeTerritoryServiceRepository, IEmployeeTerritoryServiceRepository>();
container.RegisterAs<OrderServiceRepository, IOrderServiceRepository>();
container.RegisterAs<OrderDetailServiceRepository, IOrderDetailServiceRepository>();
container.RegisterAs<ProductServiceRepository, IProductServiceRepository>();
container.RegisterAs<RegionServiceRepository, IRegionServiceRepository>();
container.RegisterAs<ShipperServiceRepository, IShipperServiceRepository>();
container.RegisterAs<SupplierServiceRepository, ISupplierServiceRepository>();
container.RegisterAs<TerritoryServiceRepository, ITerritoryServiceRepository>();
//TypedList Repositories
container.RegisterAs<TLSR.EmployeesByRegionAndTerritoryTypedListServiceRepository, TLSI.IEmployeesByRegionAndTerritoryTypedListServiceRepository>();
//TypedView Repositories
container.RegisterAs<TVSR.AlphabeticalListOfProductsTypedViewServiceRepository, TVSI.IAlphabeticalListOfProductsTypedViewServiceRepository>();
container.RegisterAs<TVSR.CategorySalesFor1997TypedViewServiceRepository, TVSI.ICategorySalesFor1997TypedViewServiceRepository>();
container.RegisterAs<TVSR.CurrentProductListTypedViewServiceRepository, TVSI.ICurrentProductListTypedViewServiceRepository>();
container.RegisterAs<TVSR.CustomerAndSuppliersByCityTypedViewServiceRepository, TVSI.ICustomerAndSuppliersByCityTypedViewServiceRepository>();
container.RegisterAs<TVSR.InvoicesTypedViewServiceRepository, TVSI.IInvoicesTypedViewServiceRepository>();
container.RegisterAs<TVSR.OrderDetailsExtendedTypedViewServiceRepository, TVSI.IOrderDetailsExtendedTypedViewServiceRepository>();
container.RegisterAs<TVSR.OrdersQryTypedViewServiceRepository, TVSI.IOrdersQryTypedViewServiceRepository>();
container.RegisterAs<TVSR.OrderSubtotalTypedViewServiceRepository, TVSI.IOrderSubtotalTypedViewServiceRepository>();
container.RegisterAs<TVSR.ProductsAboveAveragePriceTypedViewServiceRepository, TVSI.IProductsAboveAveragePriceTypedViewServiceRepository>();
container.RegisterAs<TVSR.ProductSalesFor1997TypedViewServiceRepository, TVSI.IProductSalesFor1997TypedViewServiceRepository>();
container.RegisterAs<TVSR.ProductsByCategoryTypedViewServiceRepository, TVSI.IProductsByCategoryTypedViewServiceRepository>();
container.RegisterAs<TVSR.QuarterlyOrderTypedViewServiceRepository, TVSI.IQuarterlyOrderTypedViewServiceRepository>();
container.RegisterAs<TVSR.SalesByCategoryTypedViewServiceRepository, TVSI.ISalesByCategoryTypedViewServiceRepository>();
container.RegisterAs<TVSR.SalesTotalsByAmountTypedViewServiceRepository, TVSI.ISalesTotalsByAmountTypedViewServiceRepository>();
container.RegisterAs<TVSR.SummaryOfSalesByQuarterTypedViewServiceRepository, TVSI.ISummaryOfSalesByQuarterTypedViewServiceRepository>();
container.RegisterAs<TVSR.SummaryOfSalesByYearTypedViewServiceRepository, TVSI.ISummaryOfSalesByYearTypedViewServiceRepository>();
//DataAccess / OrmLite
var connectionString = ConfigurationManager.ConnectionStrings["ApiDbConnectionString"].ConnectionString;
container.Register<IDataAccessAdapterFactory>(c => new DataAccessAdapterFactory(connectionString));
container.Register<IDbConnectionFactory>(c => new OrmLiteConnectionFactory(connectionString, true, new SqlServerOrmLiteDialectProvider()));
//DataAccess Caching (only for LLBLGen V4)
//CacheController.RegisterCache(string.Empty /* connectionString */, new ResultsetCache(5*60 /* will purge the cache every 5 minutes */));
}
public override void Configure(Funq.Container container)
{
Plugins.Add(
new AuthFeature(() =>
new AuthUserSession(),
new IAuthProvider[]
{
new DigestAuthProvider(),
new BasicAuthProvider()
}));
Plugins.Add(new RegistrationFeature());
Plugins.Add(new ValidationFeature());
Plugins.Add(new RazorFormat());
container.Register<ICaseRepository>(new InMemoryCaseRepository());
container.Register<IReferenceValidator>(new ReferenceValidator(new InMemoryCaseRepository()));
container.RegisterValidators(typeof(CaseValidator).Assembly);
container.Register<ICacheClient>(new MemoryCacheClient());
var userRep = new InMemoryAuthRepository();
container.Register<IUserAuthRepository>(userRep);
string hash;
string salt;
string password = "******";
new SaltedHash().GetHashAndSaltString(password, out hash, out salt);
userRep.CreateUserAuth(new UserAuth
{
Id = 1,
FirstName = "Joe",
LastName = "Bloggs",
DisplayName = "Joe Bloggs",
UserName = "******",
Email = "*****@*****.**",
Salt = salt,
PasswordHash = hash
}, password);
}
public override void Configure(Funq.Container container)
{
//to inject third-party IoC (for example for NInject use SrviceStack.ContainerAdapter.NInject)
//IKernel kernel=new StandartKernel();
//kernel.Bind<TrackedDataRepository>().ToSelf();
//container.Adapter=new NinjectContainerAdapter(kernel); -> provide a adapter layer for NInject to use in Funq
Plugins.Add(new AuthFeature(() => new AuthUserSession(),
new IAuthProvider[] { new BasicAuthProvider() ,
new TwitterAuthProvider(new AppSettings())}));
Plugins.Add(new RegistrationFeature());
//register validators
Plugins.Add(new ValidationFeature());
container.RegisterValidators(typeof(Common.Entry).Assembly, typeof(EntryService).Assembly);
//request logs
Plugins.Add(new RequestLogsFeature()); // added ability to view request via http:/..../requestlogs
//cache registration
container.Register<ICacheClient>(new MemoryCacheClient());
container.Register<IRedisClientsManager>(new PooledRedisClientManager("localhost:6379"));
//container.Register<ICacheClient>(r => (ICacheClient)r.Resolve<IRedisClientsManager>().GetCacheClient());
var userRepository = new InMemoryAuthRepository();
container.Register<IUserAuthRepository>(userRepository);
string hash;
string salt;
new SaltedHash().GetHashAndSaltString("password1", out hash, out salt);
userRepository.CreateUserAuth(new UserAuth()
{
Id = 1,
DisplayName = "Joe user",
Email = "*****@*****.**",
UserName = "******",
LastName = "jname",
PasswordHash = hash,
Salt = salt,
Roles = new List<string> { RoleNames.Admin }//,
//Permissions = new List<string> { "GetStatus", "AddStatus" }
}, "password1");
//automatically inject in all public properties
container.RegisterAutoWired<TrackedDataRepository>().ReusedWithin(Funq.ReuseScope.Default);
container.RegisterAutoWired<TrackedDataRepository2>().ReusedWithin(Funq.ReuseScope.Default);
var dbConFactory = new OrmLiteConnectionFactory(HttpContext.Current.Server.MapPath("~/App_Data/data.txt"), SqliteDialect.Provider)
{
ConnectionFilter = x => new ProfiledDbConnection(x, Profiler.Current)
};
container.Register<IDbConnectionFactory>(dbConFactory);
SetConfig(new EndpointHostConfig { DebugMode = true });
var mqService = new RedisMqServer(container.Resolve<IRedisClientsManager>());
mqService.RegisterHandler<Entry>(ServiceController.ExecuteMessage);
mqService.Start();
//install Razor
Plugins.Add(new RazorFormat());
}
