/// <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 ); }