/// <summary>
/// 设置联系方式的区域信息
/// </summary>
/// <param name="entity"></param>
/// <param name="areaInfo"></param>
private void SetContactAreaInfo(UserContactEntity entity, AreaSelectModel areaInfo)
{
if (areaInfo.Province == null)
{
return;
}
entity.ProvinceCode = areaInfo.Province.Code;
entity.ProvinceName = areaInfo.Province.Name;
if (areaInfo.City == null)
{
return;
}
entity.CityCode = areaInfo.City.Code;
entity.CityName = areaInfo.City.Name;
if (areaInfo.Area == null)
{
return;
}
entity.AreaCode = areaInfo.Area.Code;
entity.AreaName = areaInfo.Area.Name;
if (areaInfo.Town == null)
{
return;
}
entity.TownCode = areaInfo.Town.Code;
entity.TownName = areaInfo.Town.Name;
}
private void HydrateContactLevelOfAssurance(
UserContactEntity userContactEntity,
LevelOfAssuranceEnum levelOfAssuranceEnum
)
{
userContactEntity.LevelOfAssurance = m_levelOfAssuranceRepository.GetLevelOfAssuranceByName(
levelOfAssuranceEnum
);
}
public void EvictUserContact(UserContactEntity userContactEntity)
{
var session = GetSession();
if (session.Contains(userContactEntity))
{
session.Evict(userContactEntity);
}
}
public virtual void ChangeContact(int userId, UserContactEntity newContact)
{
var userContact = m_userContactRepository.GetUserContact(userId, newContact.Type);
if (userContact == null)
{
throw new NoResultException <UserContactEntity>();
}
UpdateContact(userContact, newContact);
}
/// <summary>
/// 清除联系方式的区域信息
/// </summary>
/// <param name="entity"></param>
private void ClearContactAreaInfo(UserContactEntity entity)
{
entity.ProvinceCode = "";
entity.ProvinceName = "";
entity.CityCode = "";
entity.CityName = "";
entity.AreaCode = "";
entity.AreaName = "";
entity.TownCode = "";
entity.TownName = "";
}
private void UpdateContact(UserContactEntity userContact, UserContactEntity newContact)
{
if (!userContact.Value.Equals(newContact.Value))
{
HydrateContactLevelOfAssurance(userContact, LevelsOfAssurance.ContactLoaAfterChange);
HydrateContactDataSource(userContact);
}
userContact.Value = newContact.Value;
userContact.ConfirmCode = newContact.ConfirmCode;
userContact.ConfirmCodeChangeTime = newContact.ConfirmCodeChangeTime;
m_userContactRepository.UpdateUserContact(userContact);
}
private UserContactEntity CreateNewVersion(UserContactEntity userContactEntity, DateTime now)
{
return(new UserContactEntity
{
ActiveFrom = now,
ConfirmCode = userContactEntity.ConfirmCode,
ConfirmCodeChangeTime = userContactEntity.ConfirmCodeChangeTime,
DataSource = userContactEntity.DataSource,
LevelOfAssurance = userContactEntity.LevelOfAssurance,
Type = userContactEntity.Type,
User = userContactEntity.User,
Value = userContactEntity.Value,
});
}
public bool Delete(int id)
{
var users = new UserContactEntity();
using (var con = new SqlConnection(connectionString))
{
con.Open();
var cmd = new SqlCommand("DELETE FROM UserContact WHERE id= @id", con);
cmd.Parameters.AddWithValue("@id", id);
int n = cmd.ExecuteNonQuery();
return(n > 0);
}
}
private void Update(UserContactEntity userContact, DateTime now)
{
m_userContactRepository.EvictUserContact(userContact);
var contact = m_userContactRepository.FindById <UserContactEntity>(userContact.Id);
//Create new version only if some property has changed
if (IsNewVersionNeeded(userContact, contact))
{
contact.ActiveTo = now;
m_userContactRepository.Update(contact);
var newVersion = CreateNewVersion(userContact, now);
m_userContactRepository.Create(newVersion);
}
}
public bool Create(int id, UserContactEntity user)
{
using (var con = new SqlConnection(connectionString))
{
con.Open();
var cmd = new SqlCommand("INSERT INTO UserContact (UserId,Type,Value,PrimaryContact) Values (@UserId,@type,@value,@primary)", con);
cmd.Parameters.AddWithValue("@UserId", id);
cmd.Parameters.AddWithValue("@type", user.ContactType);
cmd.Parameters.AddWithValue("@value", user.ContactValue);
cmd.Parameters.AddWithValue("@primary", user.PrimaryContact);
int n = cmd.ExecuteNonQuery();
return(n > 0);
}
}
public bool Update(int UserId, int id, UserContactEntity user)
{
using (var con = new SqlConnection(connectionString))
{
con.Open();
var cmd = new SqlCommand("UPDATE UserContact SET UserId=@UserId,Type=@type,Value=@value,PrimaryContact=@primary WHERE id=@id", con);
cmd.Parameters.AddWithValue("@id", id);
cmd.Parameters.AddWithValue("@UserId", UserId);
cmd.Parameters.AddWithValue("@type", user.ContactType);
cmd.Parameters.AddWithValue("@value", user.ContactValue);
cmd.Parameters.AddWithValue("@primary", user.PrimaryContact);
int n = cmd.ExecuteNonQuery();
return(n > 0);
}
}
private DataResult <bool> ChangeContact(int userId, string newValue, string code, ContactTypeEnum contactType)
{
var isValid = m_contactValidatorManager.ValidateContact(contactType, newValue);
if (!isValid)
{
return(Error <bool>(m_translator.Translate("save-contact-failed"),
contactType == ContactTypeEnum.Email
? DataResultErrorCode.EmailNotValid
: DataResultErrorCode.PhoneNumberNotValid));
}
var formattedValue = FormatContact(contactType, newValue);
var isUnique = m_contactValidatorManager.ValidateUniqueContact(contactType, formattedValue, userId);
if (!isUnique)
{
return(Error <bool>(m_translator.Translate("save-contact-failed"),
contactType == ContactTypeEnum.Email
? DataResultErrorCode.EmailNotUnique
: DataResultErrorCode.PhoneNumberNotUnique));
}
try
{
var newContact = new UserContactEntity
{
Value = formattedValue,
Type = contactType,
ConfirmCode = code,
ConfirmCodeChangeTime = DateTime.UtcNow,
};
m_userContactUoW.ChangeContact(userId, newContact);
return(Success(true));
}
catch (DatabaseException e)
{
m_logger.LogWarning(e);
return(Error <bool>(e.Message));
}
}
private bool ConfirmCode(UserContactEntity userContact, string code)
{
if (userContact == null)
{
throw new NoResultException <UserContactEntity>();
}
if (userContact.ConfirmCode == code)
{
userContact.ConfirmCode = null;
userContact.ConfirmCodeChangeTime = DateTime.UtcNow;
// if we can trust confirmation method, data is trustworthy
HydrateContactLevelOfAssurance(userContact, LevelsOfAssurance.ContactLoaAfterConfirmation);
m_userContactRepository.UpdateUserContact(userContact);
return(true);
}
return(false);
}
public bool Equals(UserContactEntity x, UserContactEntity y)
{
if (ReferenceEquals(x, y))
{
return(true);
}
if (ReferenceEquals(null, y))
{
return(false);
}
if (ReferenceEquals(x, null))
{
return(false);
}
return(Equals(x.User?.Id, y.User?.Id) && //User has to be same
Equals(x.Type, y.Type) && //Type has to be same
string.Equals(x.ConfirmCode, y.ConfirmCode) && //ConfirmCode has to be same
Equals(x.ConfirmCodeChangeTime, y.ConfirmCodeChangeTime) && //ConfirmCodeChangeTime has to be same
string.Equals(x.Value, y.Value) && //Value has to be same
Equals(x.LevelOfAssurance?.Id, y.LevelOfAssurance?.Id) && //Level of assurance has to be same
Equals(x.DataSource?.Id, y.DataSource?.Id)); //Data source has to be same
}
public UserContactEntity Get(int id)
{
var user = new UserContactEntity();
using (var con = new SqlConnection(connectionString))
{
con.Open();
var cmd = new SqlCommand("SELECT * FROM UserContact WHERE id= @id", con);
cmd.Parameters.AddWithValue("@id", id);
using (var dr = cmd.ExecuteReader())
{
while (dr.Read())
{
user.UserID = dr.GetInt32(1);
user.ContactType = dr.GetString(2);
user.ContactValue = dr.GetString(3);
user.PrimaryContact = dr.GetBoolean(4);
}
}
}
return(user);
}
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);
}
}
private void CheckUpdatedUserData(UserContactEntity updatedUserContact, UpdateUserContactParams data)
{
switch (data.UpdateType)
{
case UpdateType.Value:
Assert.Equal(data.Value, updatedUserContact.Value);
break;
case UpdateType.LevelOfAssurance:
Assert.Equal(data.LevelOfAssurance, updatedUserContact.LevelOfAssurance.Name);
break;
case UpdateType.ConfirmCode:
Assert.Equal(data.ConfirmCode, updatedUserContact.ConfirmCode);
break;
case UpdateType.ConfirmCodeChangeTime:
Assert.Equal(data.ConfirmCodeChangeTime, updatedUserContact.ConfirmCodeChangeTime);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public async Task <IResultModel> UpdateContact(UserContactUpdateViewModel model)
{
var entity = await _contactRepository.GetByUser(model.UserId);
if (entity == null)
{
entity = new UserContactEntity();
}
_mapper.Map(model, entity);
bool result;
if (entity.Id > 0)
{
result = await _contactRepository.UpdateAsync(entity);
}
else
{
result = await _contactRepository.AddAsync(entity);
}
return(ResultModel.Result(result));
}
private void SetUserContact(UserContactEntity loadedUserContact, UpdateUserContactParams data)
{
switch (data.UpdateType)
{
case UpdateType.Value:
loadedUserContact.Value = data.Value;
break;
case UpdateType.LevelOfAssurance:
loadedUserContact.LevelOfAssurance = CreateTestLoa(data.LevelOfAssurance);
break;
case UpdateType.ConfirmCode:
loadedUserContact.ConfirmCode = data.ConfirmCode;
break;
case UpdateType.ConfirmCodeChangeTime:
loadedUserContact.ConfirmCodeChangeTime = data.ConfirmCodeChangeTime;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public void UpdateUserContact(UserContactEntity userContact)
{
var now = m_dateTimeProvider.UtcNow;
Update(userContact, now);
}
private bool IsNewVersionNeeded(UserContactEntity userContact, UserContactEntity contact)
{
return(!m_userContactEqualityComparer.Equals(userContact, contact));
}
public bool Post(int userId, [FromBody] UserContactEntity user)
{
return(userContactModel.Create(userId, user));
}
public bool Put(int UserId, int id, [FromBody] UserContactEntity user)
{
return(userContactModel.Update(UserId, id, user));
}
/// <summary>
/// Model methods for updating user address details
/// </summary>
/// <returns>Boolean value verifies updated or not.</returns>
public bool Update(int uid, int id, UserContactEntity user)
{
return(userContactContext.Update(uid, id, user));
}
/// <summary>
/// Model methods for creating new user address
/// </summary>
/// <returns>Boolean value verifies inserted or not.</returns>
public bool Create(int userId, UserContactEntity user)
{
return(userContactContext.Create(userId, user));
}
private void HydrateContactDataSource(UserContactEntity userContactEntity)
{
userContactEntity.DataSource = m_dataSourceRepository.GetDataSourceByDataSource(
DataSourceEnum.User
);
}
