public static void ResetUsers(OrmLiteAuthRepository authRepo)
{
authRepo.DropAndReCreateTables();
CreateUser(authRepo, 1, "test", "test", new List<string> { "TheRole" }, new List<string> { "ThePermission" });
CreateUser(authRepo, 2, "test2", "test2");
}
public override IUserAuthRepository CreateAuthRepo()
{
var dbFactory = new OrmLiteConnectionFactory(":memory:", SqliteDialect.Provider);
var sqliteRepo = new OrmLiteAuthRepository(dbFactory);
sqliteRepo.InitSchema();
InitTest(sqliteRepo);
return sqliteRepo;
}
public object Post(ChangePsw request)
{
IAuthRepository authRepository = new OrmLiteAuthRepository(DbFactory);
IUserAuthRepository userAuthRepository = authRepository.AsUserAuthRepository(GetResolver());
var user = userAuthRepository.GetUserAuth(request.Id.ToString());
userAuthRepository.UpdateUserAuth(user, user, request.PassWord);
return true;
}
public override IUserAuthRepository CreateAuthRepo()
{
var connStr = @"Server={0};Database=test;User Id=test;Password=test;".Fmt(Environment.GetEnvironmentVariable("CI_HOST"));
var sqlServerFactory = new OrmLiteConnectionFactory(connStr, SqlServerDialect.Provider);
var sqlServerRepo = new OrmLiteAuthRepository(sqlServerFactory);
InitTest(sqlServerRepo);
sqlServerRepo.DropAndReCreateTables();
return sqlServerRepo;
}
public override IUserAuthRepository CreateAuthRepo()
{
var connStr = @"Server=localhost;Database=test;User Id=test;Password=test;";
var sqlServerFactory = new OrmLiteConnectionFactory(connStr, SqlServerDialect.Provider);
var sqlServerRepo = new OrmLiteAuthRepository(sqlServerFactory);
sqlServerRepo.InitSchema();
InitTest(sqlServerRepo);
return sqlServerRepo;
}
private static void ResetAll(Container container, OrmLiteAuthRepository authRepo)
{
authRepo.DropAndReCreateTables();
using (var db = container.Resolve<IDbConnectionFactory>().Open())
{
db.DropAndCreateTable<EmailRegistration>();
db.DropAndCreateTable<SMessageReceipt>();
}
container.Resolve<IRedisClientsManager>().Exec(r => r.FlushAll());
}
private void CreateAuthDb(Container container) {
var db = container.Resolve<ICredentialsDbConnectionFactory>();
var repo = new OrmLiteAuthRepository(db);
repo.DropAndReCreateTables();
var admin_user = repo.CreateUserAuth(new UserAuth {
UserName = "******",
Email = "*****@*****.**",
}, "password");
repo.SaveUserAuth(admin_user);
}
public object Post(DelUsers request)
{
IAuthRepository authRepository = new OrmLiteAuthRepository(DbFactory);
IUserAuthRepository userAuthRepository = authRepository.AsUserAuthRepository(GetResolver());
var user = userAuthRepository.GetUserAuth(request.Id.ToString());
if (user.Roles.Contains("Admin"))
{
throw new Exception("不能删除管理员");
}
userAuthRepository.DeleteUserAuth(request.Id.ToString());
return true;
}
private void CreateAuthDb(Container container) {
var db = container.Resolve<ICredentialsDbConnectionFactory>();
var repo = new OrmLiteAuthRepository(db);
repo.DropAndReCreateTables();
var userauth = repo.CreateUserAuth(new UserAuth
{
UserName = "******",
Email = "*****@*****.**"
}, "password");
repo.SaveUserAuth(userauth);
repo.AssignRoles(userauth, new [] { RoleNames.Admin });
}
public void CreateUsers(Container container)
{
var userRep = new OrmLiteAuthRepository(container.Resolve<IDbConnectionFactory>());
userRep.DropAndReCreateTables();
container.Register<IUserAuthRepository>(userRep);
var appSettings = container.Resolve<PlacesToVisitAppSettings>();
var dataRepository = container.Resolve<IPlacesToVisitRepository>();
userRep.DropAndReCreateTables();
string pwHash;
string pwSalt;
new SaltedHash().GetHashAndSaltString(
appSettings.Get("Salt", "debugSalt"),
out pwHash,
out pwSalt);
var userAuth1 = userRep.CreateUserAuth(new UserAuth
{
Email = "*****@*****.**",
DisplayName = "Darren",
UserName = "******",
FirstName = "Darren",
LastName = "Reid",
PasswordHash = pwHash,
Salt = pwSalt,
Roles = {"Admin"}
}, "abc123");
var user1 = userAuth1.ConvertTo<User>();
dataRepository.CreateUserIfNotExists(user1);
var userAuth2 = userRep.CreateUserAuth(new UserAuth
{
Email = "*****@*****.**",
DisplayName = "Kyle",
UserName = "******",
FirstName = "Kyle",
LastName = "Hodgson",
PasswordHash = pwHash,
Salt = pwSalt,
Roles = {"Admin"}
}, "123abc");
var user2 = userAuth2.ConvertTo<User>();
dataRepository.CreateUserIfNotExists(user2);
}
public void SetUp()
{
try
{
tests = new OAuthUserSessionTests();
appHost = new BasicAppHost().Init();
var inMemoryRepo = new InMemoryAuthRepository();
inMemoryRepo.Clear();
userAuthRepositorys.Add(inMemoryRepo);
var appSettings = new AppSettings();
var redisRepo = new RedisAuthRepository(new BasicRedisClientManager(new[] { appSettings.GetString("Redis.Host") ?? "localhost" }));
redisRepo.Clear();
userAuthRepositorys.Add(redisRepo);
if (OAuthUserSessionTestsBase.UseSqlServer)
{
var connStr = @"Data Source=.\SQLEXPRESS;AttachDbFilename=|DataDirectory|\App_Data\auth.mdf;Integrated Security=True;Connect Timeout=30;User Instance=True";
var sqlServerFactory = new OrmLiteConnectionFactory(connStr, SqlServerOrmLiteDialectProvider.Instance);
var sqlServerRepo = new OrmLiteAuthRepository(sqlServerFactory);
sqlServerRepo.DropAndReCreateTables();
}
else
{
var sqliteInMemoryRepo = new OrmLiteAuthRepository(dbFactory);
sqliteInMemoryRepo.InitSchema();
sqliteInMemoryRepo.Clear();
userAuthRepositorys.Add(sqliteInMemoryRepo);
var sqliteDbFactory = new OrmLiteConnectionFactory(
"~/App_Data/auth.sqlite".MapProjectPath());
var sqliteDbRepo = new OrmLiteAuthRepository(sqliteDbFactory);
sqliteDbRepo.InitSchema();
userAuthRepositorys.Add(sqliteDbRepo);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
throw;
}
}
public object Post(UpdateUsers request)
{
if (request.UserAuth.Id > 0)
{
if (request.UserAuth.LockedDate==DateTime.MinValue)
{
request.UserAuth.LockedDate = null;
}
Db.Update(request.UserAuth);
return request.UserAuth.Id;
}
else
{
IAuthRepository authRepository = new OrmLiteAuthRepository(DbFactory);
IUserAuthRepository userAuthRepository = authRepository.AsUserAuthRepository(GetResolver());
var user = userAuthRepository.CreateUserAuth(request.UserAuth, "123456");
return user.Id;
}
}
public override void Configure(Container container)
{
LogManager.LogFactory = new Log4NetFactory(true);
container.Register(_appDbConnectionFactory);
Plugins.Add(new AuthFeature(() => new AuthUserSession(),
new IAuthProvider[] {new BasicAuthProvider(), new CredentialsAuthProvider(),}) {HtmlRedirect = null});
//No use a custom one
//Plugins.Add(new RegistrationFeature());
var userRepo = new OrmLiteAuthRepository(_authDbConnectionFactory);
container.Register<IUserAuthRepository>(userRepo);
//wire-up a validator for the UserRegistrationService
var userRegistrationValidator = new UserRegistrationRequestValidator {UserAuthRepo = userRepo};
container.Register<IValidator<UserRegistrationRequest>>(userRegistrationValidator);
var currencyTypeRepository = new CurrencyTypeRepository { DbConnectionFactory = _appDbConnectionFactory };
var transactionTypeRepository = new TransactionTypeRepository { DbConnectionFactory = _appDbConnectionFactory };
var transactionStatusTypeRepository = new TransactionStatusTypeRepository { DbConnectionFactory = _appDbConnectionFactory };
var transactionNotificationStatusTypeRepository = new TransactionNotificationStatusTypeRepository { DbConnectionFactory = _appDbConnectionFactory };
var transactionRepository = new TransactionRepository { DbConnectionFactory = _appDbConnectionFactory };
var currencyTypeLogic = new CurrencyTypeLogic { Repository = currencyTypeRepository };
var transactionTypeLogic = new TransactionTypeLogic { Repository = transactionTypeRepository };
var transactionStatusTypeLogic = new TransactionStatusTypeLogic { Repository = transactionStatusTypeRepository };
var transactionNotificationStatusTypeLogic = new TransactionNotificationStatusTypeLogic { Repository = transactionNotificationStatusTypeRepository };
var transactionLogic = new TransactionLogic {Repository = transactionRepository};
container.Register<IRest<CurrencyType, GetCurrencyTypes>>(currencyTypeLogic);
container.Register<IRest<TransactionType, GetTransactionTypes>>(transactionTypeLogic);
container.Register<IRest<TransactionStatusType, GetTransactionStatusTypes>>(transactionStatusTypeLogic);
container.Register<IRest<TransactionNotificationStatusType, GetTransactionNotificationStatusTypes>>(transactionNotificationStatusTypeLogic);
container.Register<IRest<Transaction, GetTransactions>>(transactionLogic);
CatchAllHandlers.Add((httpMethod, pathInfo, filePath) => pathInfo.StartsWith("/favicon.ico") ? new FavIconHandler() : null);
}
private static void CreateUser(OrmLiteAuthRepository authRepo,
int id, string username, string password, List<string> roles = null, List<string> permissions = null)
{
string hash;
string salt;
new SaltedHash().GetHashAndSaltString(password, out hash, out salt);
authRepo.CreateUserAuth(new UserAuth
{
Id = id,
DisplayName = username + " DisplayName",
Email = username + "@gmail.com",
UserName = username,
FirstName = "First " + username,
LastName = "Last " + username,
PasswordHash = hash,
Salt = salt,
Roles = roles,
Permissions = permissions
}, password);
authRepo.AssignRoles(id.ToString(), roles, permissions);
}
public static void Main()
{
const string adminName = "Administrator";
const string adminPassword = "******";
const string userName = "******";
const string userPassword = "******";
var recreateAuthTables = ConfigurationManager.AppSettings["RecreateAuthTables"];
var dbConnectionFactory = new OrmLiteConnectionFactory(ConfigurationManager.ConnectionStrings["AuthDB"].ConnectionString, SqlServerDialect.Provider);
_authRepository = new OrmLiteAuthRepository(dbConnectionFactory);
if ("true".Equals(recreateAuthTables, StringComparison.CurrentCultureIgnoreCase))
{
_authRepository.DropAndReCreateTables(); //Drop and re-create all Auth and registration tables
CreateUser(1, adminName, "*****@*****.**", adminPassword, new List<string> {"Admin"}, new List<string> {"Administrator"});
CreateUser(2, userName, null, userPassword, new List<string> { "TheRole" }, new List<string> { "ThePermission" });
}
else
{
_authRepository.InitSchema(); //Create only the missing tables
}
}
/// <summary>
/// Configure ServiceStack Authentication plugin.
/// </summary>
/// <param name="container">The container.</param>
private void ConfigureAuth(Container container)
{
Plugins.Add(new AuthFeature(() => new AuthUserSession(),
new IAuthProvider[]
{
new BasicAuthProvider(AppSettings),
new ApiKeyAuthProvider(AppSettings),
})
{
ServiceRoutes = new Dictionary<Type, string[]> {
{ typeof(AuthenticateService), new[] { "/api/auth", "/api/auth/{provider}" } },
}
});
var authRepo = new OrmLiteAuthRepository(container.Resolve<IDbConnectionFactory>());
container.Register<IAuthRepository>(c => authRepo);
authRepo.InitSchema();
}
public override void Configure(Container container)
{
Plugins.Add(new RazorFormat());
Plugins.Add(new SwaggerFeature());
Plugins.Add(new MetadataFeature());
Plugins.Add(new RequestLogsFeature()
{
RequiredRoles = null,
});
Plugins.Add(new CsvFormat());
Plugins.Add(new AutoQueryFeature()
{
MaxLimit = 100,
});
Plugins.Add(
new CorsFeature(
(ConfigurationManager.AppSettings.Get("AllowOriginWhitelist") ?? "").Split(new char[] { ',' })));
//Plugins.Add(new ValidationFeature
//{
// ErrorResponseFilter = CustomValidationError
//});
// Plugins.Add(new RequestLogsFeature{});
SetConfig(new HostConfig { DebugMode = true });
SetConfig(new HostConfig
{
DefaultContentType = MimeTypes.Json,
EnableFeatures = Feature.All.Remove(Feature.Html),
GlobalResponseHeaders = { { "Access-Control-Allow-Origin", "*" }, },
AllowFileExtensions = { "json" },
});
LogManager.LogFactory=new NullLogFactory(true);
//SetConfig(new HostConfig
//{
// AddMaxAgeForStaticMimeTypes =
// {
// {"image/png", TimeSpan.FromHours(10)}
// }
//});
JsConfig.ExcludeTypeInfo = true;
JsConfig<DateTime>.SerializeFn =
time => new DateTime(time.Ticks, DateTimeKind.Local).ToString("yyyy-MM-dd HH:mm:ss");
// JsConfig.DateHandler =DateHandler.ISO8601;
this.ServiceExceptionHandlers.Add((httpReq, request, exception) =>
{
var builder = new StringBuilder();
builder.AppendLine(string.Format("{0}{1}", DateTime.Now, httpReq.AbsoluteUri));
builder.AppendLine(request.ToJsv());
builder.AppendLine(exception.Message);
builder.AppendLine(exception.StackTrace);
// Log.Error(builder);
return DtoUtils.CreateErrorResponse(request, exception);
});
this.UncaughtExceptionHandlers.Add((req, res, operationName, ex) =>
{
var builder = new StringBuilder("UncaughtException\r\n");
builder.AppendLine(string.Format("{0}{1}", DateTime.Now, req.AbsoluteUri));
builder.AppendLine(req.Dto.ToJson());
builder.AppendLine(ex.Message);
builder.AppendLine(ex.StackTrace);
// Log.Error(builder);
res.Write("Error: {0}: {1}".Fmt(ex.GetType().Name, ex.Message));
res.EndRequest(true);
});
#region 数据库连接创建
OrmLiteConnectionFactory dbFactory = null;
dbFactory = new OrmLiteConnectionFactory(
ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString,
SqlServerOrmLiteDialectProvider.Instance)
{
#if DEBUG
ConnectionFilter = x => new ProfiledDbConnection(x, Profiler.Current)
#endif
};
#endregion
container.Register<IDbConnectionFactory>(dbFactory);
#region Validators
//所有的验证方法放在一个类,这里不需要再加了
// container.RegisterValidators(typeof(ActivityFullReduceAddValidator).Assembly);
#endregion
JsConfig.DateHandler = DateHandler.ISO8601;
SetConfig(new HostConfig()
{
EnableFeatures = Feature.All.Remove(Feature.Metadata),
});
var appSettings = new AppSettings();
container.Register(appSettings);
Plugins.Add(new RegistrationFeature());
var redisFactory = new PooledRedisClientManager("localhost")
{
ConnectTimeout = 100,
//...
};
// container.Register<IDbConnectionFactory>(
//new OrmLiteConnectionFactory(":memory:",ServiceStack.OrmLite.SqlServer.SqlServerOrmLiteDialectProvider());
container.Register<IRedisClientsManager>(c => redisFactory
);
container.Register<ICacheClient>(new MemoryCacheClient());
container.Register(appSettings);
var ormLiteAuthRepository = new OrmLiteAuthRepository(dbFactory);
ormLiteAuthRepository.InitSchema();
container.Register<IUserAuthRepository>(c => ormLiteAuthRepository);
Plugins.Add(new AuthFeature(
() => new AuthUserSession(),
new IAuthProvider[] { new CustomCredentialsAuthProvider() }, "/views/login/login.html"
));
AlertTable(dbFactory);
}
/// <summary>
/// Application specific configuration
/// This method should initialize any IoC resources utilized by your web service classes.
/// </summary>
/// <param name="container"></param>
public override void Configure(Container container)
{
//Config examples
//this.Plugins.Add(new PostmanFeature());
//this.Plugins.Add(new CorsFeature());
this.Plugins.Add(new RazorFormat());
Plugins.Add(new AutoQueryFeature {MaxLimit = 10000});
Plugins.Add(new SwaggerFeature());
// Feature disableFeatures = Feature.Json| Feature.Html;
SetConfig(new HostConfig()
{
AllowFileExtensions = {"json"},
DefaultContentType = MimeTypes.Json,
GlobalResponseHeaders =
{
{"Access-Control-Allow-Origin", "*"},
{"Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS"},
{"Access-Control-Allow-Headers", "Content-Type"},
},
// DefaultRedirectPath = "/page/login"
});
JsConfig<DateTime>.SerializeFn =time => new DateTime(time.Ticks, DateTimeKind.Local).ToString("yyyy-MM-dd HH:mm:ss");
this.ServiceExceptionHandlers.Add((httpReq, request, exception) =>
{
var builder = new StringBuilder();
builder.AppendLine(httpReq.AbsoluteUri);
builder.AppendLine(request.ToJsv());
builder.AppendLine(exception.Message);
builder.AppendLine(exception.StackTrace);
return DtoUtils.CreateErrorResponse(request, exception);
}
);
this.UncaughtExceptionHandlers.Add((req, res, operationName, ex) =>
{
var builder = new StringBuilder("UncaughtException\r\n");
builder.AppendLine(req.AbsoluteUri);
builder.AppendLine(req.Dto.ToJson());
builder.AppendLine(req.GetRawBody());
builder.AppendLine(ex.Message);
builder.AppendLine(ex.StackTrace);
res.EndRequest(skipHeaders: true);
});
Plugins.Add(new RegistrationFeature());
var appSettings = new AppSettings();
container.Register(appSettings);
var dbFactory = new OrmLiteConnectionFactory(ConfigurationManager.ConnectionStrings["DefaultConnection"].ToString(), SqlServerDialect.Provider);
container.Register<IDbConnectionFactory>(c =>dbFactory);
var respo = new OrmLiteAuthRepository(dbFactory);
respo.InitSchema();
container.Register<IUserAuthRepository>(c => respo);
Plugins.Add(new AuthFeature(
() => new AuthUserSession(),
new IAuthProvider[] { new CustomCredentialsAuthProvider() }, "/#/page/login"
));
container.Register<IRedisClientsManager>(new PooledRedisClientManager(appSettings.GetString("redisHost")));
dbFactory.OpenDbConnection().CreateTable<Cost>();
dbFactory.OpenDbConnection().CreateTable<OrderCost>();
}
/// <summary>
/// Initialise the repositories.
/// </summary>
private void InitRepositories()
{
// Init OrmLite and LightSpeed repository
this.OrmLiteRepository = new OrmLiteAuthRepository(DbFactory);
this.LightSpeedRepository = new LightSpeedUserAuthRepository(this.UnitOfWork);
}
public static void Setup_Test_Database(IDbConnectionFactory appDbFactory = null, IDbConnectionFactory authDbFactory = null)
{
var appDbConnectionFactory = appDbFactory;
var authDbConnectionFactory = authDbFactory;
if (appDbConnectionFactory == null)
{
var connectionString = ConfigurationManager.ConnectionStrings["AppDb"].ConnectionString;
appDbConnectionFactory = new OrmLiteConnectionFactory(connectionString, SqlServerDialect.Provider);
}
if (authDbConnectionFactory == null)
{
var connectionString = ConfigurationManager.ConnectionStrings["AuthDb"].ConnectionString;
authDbConnectionFactory = new OrmLiteConnectionFactory(connectionString, SqlServerDialect.Provider);
}
using (var db = appDbConnectionFactory.OpenDbConnection())
{
if (db.TableExists("Transaction")) db.DropTable<Transaction>();
if (db.TableExists("CurrencyType")) db.DropTable<CurrencyType>();
if (db.TableExists("TransactionStatusType")) db.DropTable<TransactionStatusType>();
if (db.TableExists("TransactionNotificationStatusType")) db.DropTable<TransactionNotificationStatusType>();
if (db.TableExists("TransactionType")) db.DropTable<TransactionType>();
db.CreateTable<TransactionType>();
db.CreateTable<TransactionNotificationStatusType>();
db.CreateTable<TransactionStatusType>();
db.CreateTable<CurrencyType>();
db.CreateTable<Transaction>();
db.Insert(new TransactionType {Id = (long) TRANSACTION_TYPE.AuthorizeAndCapture, Description = "Authorize and Capture"});
db.Insert(new TransactionType {Id = (long) TRANSACTION_TYPE.AuthorizeOnly, Description = "Authorize Only"});
db.Insert(new TransactionType {Id = (long) TRANSACTION_TYPE.CapturePrior, Description = "Capture Prior Authorization"});
db.Insert(new TransactionType {Id = (long) TRANSACTION_TYPE.Refund, Description = "Refund"});
db.Insert(new TransactionType {Id = (long) TRANSACTION_TYPE.Void, Description = "Void"});
db.Insert(new TransactionType {Id = (long) TRANSACTION_TYPE.ZeroDollar, Description = "An internal zero dollar transaction"});
db.Insert(new TransactionType {Id = (long) TRANSACTION_TYPE.Unknown, Description = "The transaction type is unknown"});
db.Insert(new TransactionNotificationStatusType {Id = (long) TRANSACTION_NOTIFICATION_STATUS.None, Status = "Processing"});
db.Insert(new TransactionNotificationStatusType {Id = (long) TRANSACTION_NOTIFICATION_STATUS.DeclinedNotification, Status = "Declined Notification Sent"});
db.Insert(new TransactionNotificationStatusType {Id = (long) TRANSACTION_NOTIFICATION_STATUS.ErrorNotification, Status = "Error Notifications Sent"});
db.Insert(new TransactionNotificationStatusType {Id = (long) TRANSACTION_NOTIFICATION_STATUS.SettledNotification, Status = "Settled Notifications Sent"});
db.Insert(new TransactionNotificationStatusType {Id = (long) TRANSACTION_NOTIFICATION_STATUS.RefundedNotification, Status = "Refunded Notifications Sent"});
db.Insert(new TransactionNotificationStatusType {Id = (long) TRANSACTION_NOTIFICATION_STATUS.VoidedNotification, Status = "Voided Notifications Sent"});
db.Insert(new TransactionStatusType {Id = (long) TRANSACTION_STATUS.Pending, Status = "Transaction Approved but pending completion"});
db.Insert(new TransactionStatusType {Id = (long) TRANSACTION_STATUS.Settled, Status = "Transaction completed. Funds received."});
db.Insert(new TransactionStatusType {Id = (long) TRANSACTION_STATUS.Refunded, Status = "Transaction completed. Customer refunded."});
db.Insert(new TransactionStatusType {Id = (long) TRANSACTION_STATUS.Voided, Status = "Transaction voided."});
db.Insert(new TransactionStatusType {Id = (long) TRANSACTION_STATUS.Expired, Status = "Transaction has expired."});
db.Insert(new TransactionStatusType {Id = (long) TRANSACTION_STATUS.Declined, Status = "Transaction Declinded.", IsErrorStatus = true});
db.Insert(new TransactionStatusType {Id = (long) TRANSACTION_STATUS.Error, Status = "Transaction Error.", IsErrorStatus = true});
db.Insert(new CurrencyType {Id = (long) CURRENCY_TYPE.USDollar, Description = "US Dollar", Code = "USD", Symbol = "$"});
db.Insert(new CurrencyType {Id = (long) CURRENCY_TYPE.CandianDollar, Description = "Canadian Dollar", Code = "CAD", Symbol = "$"});
db.Insert(new CurrencyType {Id = (long) CURRENCY_TYPE.Peso, Description = "Mexican Peso", Code = "MXN", Symbol = "$"});
}
var userRepo = new OrmLiteAuthRepository(authDbConnectionFactory);
userRepo.DropAndReCreateTables();
var defaultAdmin = new UserAuth
{
DisplayName = DefaultAdmin.Email,
Email = DefaultAdmin.Email,
Roles = DefaultAdmin.Roles,
Permissions = DefaultAdmin.Permissions
};
CreateUser(userRepo, defaultAdmin, DefaultAdmin.Password);
var testUser = new UserAuth
{
DisplayName = TestUser.FirstName + " " + TestUser.LastName,
Email = TestUser.Email,
FirstName = TestUser.FirstName,
LastName = TestUser.LastName,
Roles = TestUser.Roles,
Permissions = TestUser.Permissions
};
CreateUser(userRepo, testUser, TestUser.Password);
}
public override void Configure(Container container)
{
LogManager.LogFactory = new Log4NetFactory(true);
container.Register(_dbConnectionFactory);
var basicAuthProvider = new BasicAuthProvider();
container.Register(basicAuthProvider);
Plugins.Add(new AuthFeature( () => new AuthUserSession(), new IAuthProvider[] {basicAuthProvider, }, SystemConstants.LoginUrl ));
var userRepo = new OrmLiteAuthRepository(_dbConnectionFactory);
container.Register<IAuthRepository>(userRepo);
var cacheClient = new MemoryCacheClient();
container.Register(cacheClient);
var currencyTypeRepository = new CurrencyTypeRepository { DbConnectionFactory = _dbConnectionFactory };
var transactionTypeRepository = new TransactionTypeRepository { DbConnectionFactory = _dbConnectionFactory };
var transactionStatusTypeRepository = new TransactionStatusTypeRepository { DbConnectionFactory = _dbConnectionFactory };
var transactionNotificationStatusTypeRepository = new TransactionNotificationStatusTypeRepository { DbConnectionFactory = _dbConnectionFactory };
var transactionRepository = new TransactionRepository { DbConnectionFactory = _dbConnectionFactory };
var currencyTypeLogic = new CurrencyTypeLogic { Repository = currencyTypeRepository };
var transactionTypeLogic = new TransactionTypeLogic { Repository = transactionTypeRepository };
var transactionStatusTypeLogic = new TransactionStatusTypeLogic { Repository = transactionStatusTypeRepository };
var transactionNotificationStatusTypeLogic = new TransactionNotificationStatusTypeLogic { Repository = transactionNotificationStatusTypeRepository };
var transactionLogic = new TransactionLogic {Repository = transactionRepository};
container.Register<IRest<CurrencyType, GetCurrencyTypes>>(currencyTypeLogic);
container.Register<IRest<TransactionType, GetTransactionTypes>>(transactionTypeLogic);
container.Register<IRest<TransactionStatusType, GetTransactionStatusTypes>>(transactionStatusTypeLogic);
container.Register<IRest<TransactionNotificationStatusType, GetTransactionNotificationStatusTypes>>(transactionNotificationStatusTypeLogic);
container.Register<IRest<Transaction, GetTransactions>>(transactionLogic);
CatchAllHandlers.Add((httpMethod, pathInfo, filePath) => pathInfo.StartsWith("/favicon.ico") ? new FavIconHandler() : null);
var redisLocation = ConfigurationManager.AppSettings["ReddisService"];
Container.Register<IRedisClientsManager>(new PooledRedisClientManager(redisLocation));
var mqService = new RedisMqServer(container.Resolve<IRedisClientsManager>());
var messagingHandlers = new MessageService { Log = new Logger(typeof(MessageService).Name) };
Func<IMessage, IMessage> filterSecureRequests = (message) =>
{
/*
var tag = message.Tag;
if (string.IsNullOrWhiteSpace(tag))
return message;
if (tag.StartsWith("basic ", StringComparison.InvariantCultureIgnoreCase))
{
var creds = Encoding.UTF8.GetString(Convert.FromBase64String(tag.Substring(5)));
var i = creds.IndexOf(':');
var userName = creds.Substring(0, i);
var userPass = creds.Substring(i + 1);
if (userName != SystemConstants.AllowedUser || userPass != SystemConstants.AllowedPass)
{
message.Tag = null;
return message;
}
_currentSessionGuid = Guid.NewGuid();
var sessionKey = userName + "/" + _currentSessionGuid.ToString("N");
SessionContext = new SessionContext { SessionKey = sessionKey, Username = userName };
container.Register(SessionContext);
message.Tag = sessionKey;
return message;
}
message.Tag = null;*/
return message;
};
mqService.RequestFilter = filterSecureRequests;
Func<IMessage<Transaction>, PostResponse<Transaction>> handlePostTransactions = (message) =>
{
var service = new TransactionWebService { Logic = transactionLogic };
var request = new BasicRequest {Message = message, Dto = message.GetBody()};
var response = new BasicResponse(request);
//userRepo.TryAuthenticate()
service.SessionFactory.GetOrCreateSession(request, response);
var session = service.GetSession();
session.UserName = "******";
var results = new PostResponse<Transaction> {Result = (Transaction) service.Post(message.GetBody())};
return results;
};
// Dto Get Operations
mqService.RegisterHandler<GetCurrencyTypes>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), currencyTypeLogic));
mqService.RegisterHandler<GetTransactions>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), transactionLogic));
mqService.RegisterHandler<GetTransactionStatusTypes>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), transactionStatusTypeLogic));
mqService.RegisterHandler<GetTransactionNotificationStatusTypes>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), transactionNotificationStatusTypeLogic));
mqService.RegisterHandler<GetTransactionTypes>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), transactionTypeLogic));
// Dto Post Operations
mqService.RegisterHandler<CurrencyType>(m => messagingHandlers.MessagingPostRequest(m.GetBody(), currencyTypeLogic.Post));
mqService.RegisterHandler<Transaction>(handlePostTransactions);
mqService.RegisterHandler<TransactionStatusType>(m => messagingHandlers.MessagingPostRequest(m.GetBody(), transactionStatusTypeLogic.Post));
mqService.RegisterHandler<TransactionNotificationStatusType>(m => messagingHandlers.MessagingPostRequest(m.GetBody(), transactionNotificationStatusTypeLogic.Post));
mqService.RegisterHandler<TransactionType>(m => messagingHandlers.MessagingPostRequest(m.GetBody(), transactionTypeLogic.Post));
// Dto Put Opertations
mqService.RegisterHandler<DeleteCurrencyType>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), currencyTypeLogic));
mqService.RegisterHandler<DeleteTransaction>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), transactionLogic));
mqService.RegisterHandler<DeleteTransactionStatusType>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), transactionStatusTypeLogic));
mqService.RegisterHandler<DeleteTransactionNotificationStatusType>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), transactionNotificationStatusTypeLogic));
mqService.RegisterHandler<DeleteTransactionType>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), transactionTypeLogic));
mqService.Start();
}
