public IList <UserEntity> FindUsersByDataType(string dataType, IEnumerable <string> dataValues, DateTime now, bool fetchCollections = true)
{
UserDataEntity userDataAlias = null;
UserDataTypeEntity userDataTypeAlias = null;
try
{
var session = GetSession();
var result = session.QueryOver <UserEntity>()
.JoinAlias(x => x.UserData, () => userDataAlias)
.JoinAlias(() => userDataAlias.UserDataType, () => userDataTypeAlias)
.Where(() => (userDataAlias.ActiveTo == null || userDataAlias.ActiveTo > now) && userDataTypeAlias.DataTypeValue == dataType)
.WhereRestrictionOn(() => userDataAlias.Value).IsIn(dataValues.ToList())
.Future <UserEntity>();
if (fetchCollections)
{
FetchCollections(session);
}
return(result.ToList());
}
catch (HibernateException ex)
{
throw new DatabaseException("Find user list by data type operation failed", ex);
}
}
public UserEntity GetUserByDataTypeWithMinLoa(string dataType, string dataValue, DateTime now, LevelOfAssuranceEnum levelOfAssurance, bool fetchCollections = true)
{
UserDataEntity userDataAlias = null;
UserDataTypeEntity userDataTypeAlias = null;
LevelOfAssuranceEntity levelOfAssuranceAlias = null;
try
{
var session = GetSession();
var result = session.QueryOver <UserEntity>()
.JoinAlias(x => x.UserData, () => userDataAlias)
.JoinAlias(() => userDataAlias.UserDataType, () => userDataTypeAlias)
.JoinAlias(x => userDataAlias.LevelOfAssurance, () => levelOfAssuranceAlias)
.Where(() => (userDataAlias.ActiveTo == null || userDataAlias.ActiveTo > now) && userDataTypeAlias.DataTypeValue == dataType && userDataAlias.Value == dataValue &&
levelOfAssuranceAlias.Level >= (int)levelOfAssurance)
.FutureValue <UserEntity>();
if (fetchCollections)
{
FetchCollections(session);
}
return(result.Value);
}
catch (HibernateException ex)
{
throw new DatabaseException("Find user by data type with min loa operation failed", ex);
}
}
public UserDataVersioningProxyTest()
{
var databaseFactory = new MemoryDatabaseFactory();
var mappings = new AuthorizationMappingProvider().GetMappings();
m_sessionManager = new MockDbFactory(databaseFactory, mappings).CreateSessionManager(true);
var mockFactory = new MockRepository(MockBehavior.Loose)
{
CallBase = true
};
m_userDataRepository = mockFactory.Create <UserDataRepository>(m_sessionManager).Object;
var userDataComparerMock = mockFactory.Create <UserDataEqualityComparer>();
var userDataStructureConvertorMock = mockFactory.Create <UserDataStructureConvertor>();
m_dateTimeProviderMock = mockFactory.Create <IDateTimeProvider>();
m_dateTimeProviderMock.Setup(x => x.UtcNow).Returns(DateTime.UtcNow);
m_dataVersioningProxy = new UserDataVersioningProxy(m_userDataRepository, userDataComparerMock.Object,
m_dateTimeProviderMock.Object, userDataStructureConvertorMock.Object);
m_testUser = CreateTestUser(Username);
m_lowLevelOfAssurance = CreateTestLoa(MediumLoa);
m_firstNameDataType = CreateTestDataType(FirstNameDataType);
m_lastNameDataType = CreateTestDataType(LastNameDataType);
m_userDataSource = CreateTestDataSource(DataSourceEnum.User);
}
private UserDataTypeEntity CreateTestDataType(string dataTypeValue)
{
var dataType = new UserDataTypeEntity {
DataTypeValue = dataTypeValue
};
var id = (int)m_sessionManager.OpenSession().Save(dataType);
var loadedDataType = m_sessionManager.OpenSession().Get <UserDataTypeEntity>(id);
return(loadedDataType);
}
private IQueryOver <UserEntity, UserEntity> AddSearchByNameToQuery(IQueryOver <UserEntity, UserEntity> query, string searchByName)
{
UserDataEntity userDataAlias = null;
UserDataTypeEntity userDataTypeAlias = null;
if (!string.IsNullOrEmpty(searchByName))
{
var usersWithNameStartingWith = QueryOver.Of <UserEntity>()
.JoinAlias(x => x.UserData, () => userDataAlias)
.JoinAlias(x => userDataAlias.UserDataType, () => userDataTypeAlias)
.Where(x => userDataAlias.Value.IsInsensitiveLike(searchByName, MatchMode.Start) && (userDataTypeAlias.DataTypeValue == UserDataTypes.LastName || userDataTypeAlias.DataTypeValue == UserDataTypes.FirstName))
.Select(Projections.Distinct(Projections.Property <UserEntity>(m => m.Id)));
query = query.WithSubquery.WhereProperty(x => x.Id)
.In(usersWithNameStartingWith);
}
return(query);
}
private UserDataEntity GenerateUserDataEntity(
DateTime activeFrom,
UserDataTypeEntity dataType,
UserEntity user,
DataSourceEntity dataSource,
LevelOfAssuranceEntity loa,
string value = null,
DateTime?activeTo = null)
{
return(new UserDataEntity
{
ActiveFrom = activeFrom,
ActiveTo = activeTo,
DataSource = dataSource,
LevelOfAssurance = loa,
Value = value,
UserDataType = dataType,
User = user,
});
}
private IQueryOver <UserEntity, UserEntity> AddOrderingByLastNameAndFirstNameToQuery(IQueryOver <UserEntity, UserEntity> query, UserEntity userAlias)
{
UserDataEntity userDataAlias = null;
UserDataTypeEntity userDataTypeAlias = null;
var lastNameUserData = QueryOver.Of(() => userDataAlias)
.JoinAlias(x => x.UserDataType, () => userDataTypeAlias)
.Where(x => userDataAlias.ActiveTo == null && userDataAlias.User.Id == userAlias.Id && userDataTypeAlias.DataTypeValue == UserDataTypes.LastName)
.Select(x => x.Value);
var firstNameUserData = QueryOver.Of(() => userDataAlias)
.JoinAlias(x => x.UserDataType, () => userDataTypeAlias)
.Where(x => userDataAlias.ActiveTo == null && userDataAlias.User.Id == userAlias.Id && userDataTypeAlias.DataTypeValue == UserDataTypes.FirstName)
.Select(x => x.Value);
query = query
.OrderBy(Projections.SubQuery(lastNameUserData)).Asc
.ThenBy(Projections.SubQuery(firstNameUserData)).Asc;
return(query);
}
public virtual int CreateUserDataType(UserDataTypeEntity userDataType)
{
var result = (int)m_userDataTypeRepository.Create(userDataType);
return(result);
}
private UserDataEntity GenerateOriginalIdUserData(DateTime now, DateTime activeTo, UserDataTypeEntity idDataType,
string value)
{
return(GenerateUserDataEntity(now, idDataType, m_testUser, m_userDataSource, m_lowLevelOfAssurance, value, activeTo));
}
