public IList <UserDataEntity> FindCurrentVersionOfUserDataWithLoaGreaterThan(string value, string dataTypeValue,
LevelOfAssuranceEnum levelOfAssurance, DateTime now)
{
LevelOfAssuranceEntity levelOfAssuranceAlias = null;
try
{
var session = GetSession();
var query = session.QueryOver <UserDataEntity>()
.JoinAlias(x => x.LevelOfAssurance, () => levelOfAssuranceAlias)
.Where(x => x.Value == value && (x.ActiveTo == null || x.ActiveTo > now) &&
levelOfAssuranceAlias.Level > (int)levelOfAssurance);
var result = query.JoinQueryOver(x => x.UserDataType)
.Where(x => x.DataTypeValue == dataTypeValue)
.Future <UserDataEntity>();
FetchCollections(session);
return(result.ToList());
}
catch (HibernateException ex)
{
throw new DatabaseException("Find user data by value and type operation failed", ex);
}
}
private void HydrateContactLevelOfAssurance(
UserContactEntity userContactEntity,
LevelOfAssuranceEnum levelOfAssuranceEnum
)
{
userContactEntity.LevelOfAssurance = m_levelOfAssuranceRepository.GetLevelOfAssuranceByName(
levelOfAssuranceEnum
);
}
private LevelOfAssuranceEntity CreateTestLoa(LevelOfAssuranceEnum levelOfAssurance)
{
var loa = new LevelOfAssuranceEntity()
{
Level = (int)levelOfAssurance, Name = levelOfAssurance
};
var id = (int)m_sessionManager.OpenSession().Save(loa);
var loadedLoa = m_sessionManager.OpenSession().Get <LevelOfAssuranceEntity>(id);
return(loadedLoa);
}
public LevelOfAssuranceEntity GetLevelOfAssuranceByName(LevelOfAssuranceEnum levelOfAssuranceEnum)
{
var criterion = Restrictions.Where <LevelOfAssuranceEntity>(x => x.Name == levelOfAssuranceEnum);
try
{
return(GetSingleValue <LevelOfAssuranceEntity>(null, criterion));
}
catch (HibernateException ex)
{
throw new DatabaseException("Get level of assurance by name operation failed", ex);
}
}
public DataResult <UserModel> GetUserByPhone(string phoneNumber, LevelOfAssuranceEnum minLevelOfAssurance)
{
var formattedPhoneNumber = m_contactFormatterManager.FormatPhoneNumber(phoneNumber);
try
{
var user = m_userUoW.GetUserByContact(formattedPhoneNumber, ContactTypeEnum.Phone, minLevelOfAssurance);
var viewModel = m_mapper.Map <UserModel>(user);
return(Success(viewModel));
}
catch (NoResultException <UserEntity> e)
{
m_logger.LogWarning(e);
return(Error <UserModel>(m_translator.Translate("invalid-phone"), DataResultErrorCode.UserNotExistPhone));
}
catch (DatabaseException e)
{
m_logger.LogWarning(e);
return(Error <UserModel>(e.Message));
}
}
private DataResult <UserModel> GetUserByEmail(string email, LevelOfAssuranceEnum minLevelOfAssurance)
{
var formattedEmail = m_contactFormatterManager.FormatEmail(email);
try
{
var user = m_userUoW.GetUserByContact(formattedEmail, ContactTypeEnum.Email, minLevelOfAssurance);
var viewModel = m_mapper.Map <UserModel>(user);
return(Success(viewModel));
}
catch (NoResultException <UserEntity> e)
{
m_logger.LogWarning(e);
return(Error <UserModel>(m_translator.Translate("invalid-email"), DataResultErrorCode.UserNotExistEmail));
}
catch (DatabaseException e)
{
m_logger.LogWarning(e);
return(Error <UserModel>(e.Message));
}
}
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 UserEntity GetUserByValidContact(string contactValue, ContactTypeEnum contactType, LevelOfAssuranceEnum minLevelOfAssurance)
{
LevelOfAssuranceEntity levelOfAssuranceAlias = null;
UserContactEntity userContactAlias = null;
try
{
var session = GetSession();
var result = session.QueryOver <UserEntity>()
.JoinAlias(x => x.UserContacts, () => userContactAlias)
.JoinAlias(() => userContactAlias.LevelOfAssurance, () => levelOfAssuranceAlias)
.Where(x => userContactAlias.Type == contactType && userContactAlias.Value == contactValue && userContactAlias.ActiveTo == null && levelOfAssuranceAlias.Level >= (int)minLevelOfAssurance)
.FutureValue <UserEntity>();
FetchCollections(session);
return(result.Value);
}
catch (HibernateException ex)
{
throw new DatabaseException("Find user by contact operation failed", ex);
}
}
public LevelOfAssuranceEntity GetByEnum(LevelOfAssuranceEnum levelOfAssuranceEnum)
{
return(m_cache.GetOrAdd(levelOfAssuranceEnum, key => m_levelOfAssuranceRepository.GetLevelOfAssuranceByName(
key
)));
}
public IList <UserDataEntity> FindUserDataWithLoaGreaterThan(string value, string type, LevelOfAssuranceEnum levelOfAssurance)
{
var userData =
m_userDataRepository.FindCurrentVersionOfUserDataWithLoaGreaterThan(value, type, levelOfAssurance,
m_dateTimeProvider.UtcNow);
return(userData);
}
public virtual UserEntity GetUserByContact(string contactValue, ContactTypeEnum contactType, LevelOfAssuranceEnum minLevelOfAssurance)
{
var user = m_userRepository.GetUserByValidContact(contactValue, contactType, minLevelOfAssurance);
if (user == null)
{
throw new NoResultException <UserEntity>();
}
HydrateUserWithUserDataAndContacts(user);
return(user);
}
public IList <UserContactEntity> GetActualVersionOfUserContactWithLoaGreaterThan(string contactValue, ContactTypeEnum contactTypeEnum, LevelOfAssuranceEnum levelOfAssurance)
{
LevelOfAssuranceEntity levelOfAssuranceAlias = null;
try
{
var session = GetSession();
var result = session.QueryOver <UserContactEntity>()
.JoinAlias(x => x.LevelOfAssurance, () => levelOfAssuranceAlias)
.Where(x => x.Type == contactTypeEnum && x.Value == contactValue && x.ActiveTo == null &&
levelOfAssuranceAlias.Level > (int)levelOfAssurance)
.Future <UserContactEntity>();
FetchCollections(session);
return(result.ToList());
}
catch (HibernateException ex)
{
throw new DatabaseException("Find user contact operation failed", ex);
}
}
public IList <UserContactEntity> GetUserContactsWithLoaGreaterThan(string contactValue, ContactTypeEnum contactTypeEnum, LevelOfAssuranceEnum levelOfAssurance)
{
return(m_userContactRepository.GetActualVersionOfUserContactWithLoaGreaterThan(contactValue, contactTypeEnum, levelOfAssurance));
}
