/// <summary>
/// 自定义数据库查询
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sql"></param>
/// <param name="dict"></param>
/// <returns></returns>
public IEnumerable <T> Query <T>(string sql, Dictionary <string, object> dict)
{
using (var conn = DbConnFactory.Open(DbName))
{
return(conn.Select <T>(sql, dict));
}
}
/// <summary>
/// 自定义数据库查询
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sql"></param>
/// <param name="param"></param>
/// <returns></returns>
public IEnumerable <T> Query <T>(string sql, object param)
{
using (var conn = DbConnFactory.Open(DbName))
{
return(conn.Select <T>(sql, param));
}
}
public IBaseUnitOfWorkAdo CreateUoW()
{
var connstring = @"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=..\..\dbAccess.mdb;";
var f = new DbConnFactory("System.Data.OleDb", connstring);
var u = new UoW(f);
return(u);
}
/// <summary>
/// 自定义数据库查询.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="expression"></param>
/// <returns></returns>
public IEnumerable <T> Query <T>(Action <SqlExp <T> > expression)
{
using (var conn = DbConnFactory.Open(DbName))
{
var exp = SqlExp <T> .GetSqlExp(conn);
expression(exp);
return(conn.Select(exp.GetExp()));
}
}
/// <summary>
/// 开启一次数据库回话
/// </summary>
/// <param name="db"></param>
/// <returns></returns>
public static DbSession Begin(string db)
{
if (_CurrentSession != null)
{
throw new NotSupportedException("当前已有打开的数据库事务");
}
var session = new DbSession();
session._Conn = DbConnFactory.Open(db);
session.DT = session._Conn.BeginTransaction();
_CurrentSession = session;
return(_CurrentSession);
}
public void CheckRoleAssignmentInUserAuthTable()
{
using (var appHost = new BasicAppHost
{
ConfigureContainer = container =>
{
container.Register <IDbConnectionFactory>(DbConnFactory);
container.Register <IAuthRepository>(c => new OrmLiteAuthRepository(c.Resolve <IDbConnectionFactory>()));
}
}.Init())
{
// Arrange
UserAuth userAuth;
var newRegistration = CreateNewUserRegistration();
var request = new BasicRequest(newRegistration);
var response = (RegisterResponse)appHost.ExecuteService(newRegistration, request);
var authRepo = appHost.Resolve <IAuthRepository>();
// Test #1: Check role and permission assignment
// ---------------------------------------------
// Act
using (var db = DbConnFactory.Open())
{
// Hydrate userAuth
userAuth = db.SingleById <UserAuth>(response.UserId);
}
var assignRoleRequest =
new AssignRoles
{
UserName = userAuth.UserName,
Roles = { TestRoleName },
Permissions = { TestPermissionName },
};
userAuth = (UserAuth)authRepo.GetUserAuthByUserName(assignRoleRequest.UserName);
authRepo.AssignRoles(userAuth, assignRoleRequest.Roles, assignRoleRequest.Permissions);
// Assert:
// Check UserAuth to contain roles and permissions
Assert.That(authRepo.GetRoles(userAuth).FirstOrDefault(), Is.EqualTo(TestRoleName));
Assert.That(authRepo.GetPermissions(userAuth).FirstOrDefault(), Is.EqualTo(TestPermissionName));
// Test #2: Check role and permission un-assignment
// ------------------------------------------------
// Act
using (var db = DbConnFactory.Open())
{
// Hydrate userAuth
userAuth = db.SingleById <UserAuth>(response.UserId);
}
var unassignRolesRequest =
new UnAssignRoles
{
UserName = userAuth.UserName,
Roles = { TestRoleName },
Permissions = { TestPermissionName },
};
userAuth = (UserAuth)authRepo.GetUserAuthByUserName(assignRoleRequest.UserName);
authRepo.UnAssignRoles(userAuth, unassignRolesRequest.Roles, unassignRolesRequest.Permissions);
// Assert:
// Check UserAuth not to contain roles and permissions above
Assert.That(authRepo.GetRoles(userAuth).FirstOrDefault(), Is.Null);
Assert.That(authRepo.GetPermissions(userAuth).FirstOrDefault(), Is.Null);
}
}
public void CheckRoleAssignmentInUserAuthTable()
{
using (var appHost = new BasicAppHost
{
ConfigureAppHost = host =>
{
host.Config.AdminAuthSecret = AdminAuthSecret;
},
ConfigureContainer = container =>
{
container.Register <IDbConnectionFactory>(DbConnFactory);
container.Register <IAuthRepository>(c => new OrmLiteAuthRepository(c.Resolve <IDbConnectionFactory>()));
}
}.Init())
{
// Arrange
UserAuth userAuth;
AssignRolesResponse assignRolesResponse;
var newRegistration = CreateNewUserRegistration();
var request = new BasicRequest(newRegistration);
request.QueryString["authSecret"] = AdminAuthSecret;
var response = (RegisterResponse)appHost.ExecuteService(newRegistration, request);
// Test #1: Check role and permission assignment
// ---------------------------------------------
// Act
using (var db = DbConnFactory.Open())
{
// Hydrate userAuth
userAuth = db.SingleById <UserAuth>(response.UserId);
}
var assignRoleRequest =
new AssignRoles
{
UserName = userAuth.UserName,
Roles = { TestRoleName },
Permissions = { TestPermissionName },
};
// Assert #1.1:
// Check AssignRoles response to contain roles and permissions
assignRolesResponse = (AssignRolesResponse)appHost.ExecuteService(assignRoleRequest, request);
Assert.That(assignRolesResponse.AllRoles[0], Is.EqualTo(TestRoleName));
Assert.That(assignRolesResponse.AllPermissions[0], Is.EqualTo(TestPermissionName));
// Assert #1.2:
// Check UserAuth to contain roles and permissions
using (var db = DbConnFactory.Open())
{
// Hydrate userAuth
userAuth = db.SingleById <UserAuth>(response.UserId);
}
Assert.That(userAuth.Roles[0], Is.EqualTo(TestRoleName));
Assert.That(userAuth.Permissions[0], Is.EqualTo(TestPermissionName));
// Test #2: Check role and permission un-assignment
// ------------------------------------------------
// Act
var unassignRolesRequest =
new UnAssignRoles
{
UserName = userAuth.UserName,
Roles = { TestRoleName },
Permissions = { TestPermissionName },
};
appHost.ExecuteService(unassignRolesRequest, request);
// Assert #2.1:
// Check UserAuth not to contain roles and permissions above
using (var db = DbConnFactory.Open())
{
// Hydrate userAuth
userAuth = db.SingleById <UserAuth>(response.UserId);
}
Assert.That(userAuth.Roles.Count, Is.EqualTo(0));
Assert.That(userAuth.Permissions.Count, Is.EqualTo(0));
}
}
