/// <summary>
/// 保存实体修改记录
/// </summary>
/// <param name="entityNew">修改后的实体对象</param>
/// <param name="entityOld">修改前的实体对象</param>
/// <param name="tableName">表名称</param>
public void SaveEntityChangeLog(BaseUserContactEntity entityNew, BaseUserContactEntity entityOld, string tableName = null)
{
if (string.IsNullOrEmpty(tableName))
{
//统一放在一个公共表 Troy.Cui 2016-08-17
tableName = BaseChangeLogEntity.CurrentTableName;
}
var manager = new BaseChangeLogManager(UserInfo, tableName);
foreach (var property in typeof(BaseUserContactEntity).GetProperties())
{
var oldValue = Convert.ToString(property.GetValue(entityOld, null));
var newValue = Convert.ToString(property.GetValue(entityNew, null));
var fieldDescription = property.GetCustomAttributes(typeof(FieldDescription), false).FirstOrDefault() as FieldDescription;
//不记录创建人、修改人、没有修改的记录
if (!fieldDescription.NeedLog || oldValue == newValue)
{
continue;
}
var entity = new BaseChangeLogEntity
{
TableName = CurrentTableName,
TableDescription = FieldExtensions.ToDescription(typeof(BaseUserContactEntity), "CurrentTableName"),
RecordKey = entityOld.Id.ToString(),
ColumnName = property.Name,
ColumnDescription = fieldDescription.Text,
NewValue = newValue,
OldValue = oldValue
};
manager.Add(entity, true, false);
}
}
/// <summary>
/// 添加, 这里可以人工干预，提高程序的性能
/// </summary>
/// <param name="entity">实体</param>
/// <param name="identity">自增量方式，表主键是否采用自增的策略</param>
/// <param name="returnId">返回主键，不返回程序允许速度会快，主要是为了主细表批量插入数据优化用的</param>
/// <returns>主键</returns>
public string Add(BaseChangeLogEntity entity, bool identity = true, bool returnId = true)
{
Identity = identity;
ReturnId = returnId;
entity.Id = AddEntity(entity).ToInt();
return(entity.Id.ToString());
}
/// <summary>
/// 添加或更新(主键是否为0)
/// </summary>
/// <param name="entity">实体</param>
/// <param name="identity">自增量方式，表主键是否采用自增的策略</param>
/// <param name="returnId">返回主键，不返回程序允许速度会快，主要是为了主细表批量插入数据优化用的</param>
/// <returns>主键</returns>
public string AddOrUpdate(BaseChangeLogEntity entity, bool identity = true, bool returnId = true)
{
Identity = identity;
ReturnId = returnId;
if (entity.Id == 0)
{
entity.Id = AddEntity(entity).ToInt();
return(entity.Id.ToString());
}
else
{
return(UpdateEntity(entity) > 0 ? entity.Id.ToString() : string.Empty);
}
}
/// <summary>
/// 保存实体修改记录
/// </summary>
/// <param name="recordKey">记录主键</param>
/// <param name="entityNew">修改后的实体对象</param>
/// <param name="entityOld">修改前的实体对象</param>
/// <param name="tableName">表名称</param>
/// <param name="systemCode">子系统编码</param>
public virtual void SaveEntityChangeLog(string recordKey, object entityOld, object entityNew, string tableName = null, string systemCode = null)
{
var oldType = entityOld.GetType();
var newType = entityNew.GetType();
if (newType.Equals(oldType) && oldType.IsClass && newType.IsClass)
{
if (string.IsNullOrEmpty(systemCode))
{
systemCode = BaseSystemInfo.SystemCode;
}
if (string.IsNullOrEmpty(tableName))
{
tableName = BaseChangeLogEntity.CurrentTableName;
}
var manager = new BaseChangeLogManager(UserInfo, tableName);
foreach (var property in oldType.GetProperties())
{
var oldValue = Convert.ToString(property.GetValue(entityOld, null));
var newValue = Convert.ToString(property.GetValue(entityNew, null));
var fieldDescription = property.GetCustomAttributes(typeof(FieldDescription), false).FirstOrDefault() as FieldDescription;
if (!fieldDescription.NeedLog || oldValue == newValue)
{
continue;
}
var entity = new BaseChangeLogEntity
{
SystemCode = systemCode,
TableName = CurrentTableName,
TableDescription = CurrentTableDescription,
ColumnName = property.Name,
ColumnDescription = fieldDescription.Text,
NewValue = newValue,
OldValue = oldValue,
RecordKey = recordKey,
SortCode = 1 // 不要排序了，加快写入速度
};
manager.Add(entity, true, false);
}
}
else
{
LogUtil.WriteLog("比较的实体类型不一样或非实体类型", "SaveEntityChangeLog");
//throw new ArgumentException();
}
}
/// <summary>
/// 设置实体
/// </summary>
/// <param name="sqlBuilder">Sql语句生成器</param>
/// <param name="entity">实体</param>
private void SetEntity(SqlBuilder sqlBuilder, BaseChangeLogEntity entity)
{
SetEntityExtend(sqlBuilder, entity);
sqlBuilder.SetValue(BaseChangeLogEntity.FieldSystemCode, entity.SystemCode);
sqlBuilder.SetValue(BaseChangeLogEntity.FieldTableName, entity.TableName);
sqlBuilder.SetValue(BaseChangeLogEntity.FieldTableDescription, entity.TableDescription);
sqlBuilder.SetValue(BaseChangeLogEntity.FieldColumnName, entity.ColumnName);
sqlBuilder.SetValue(BaseChangeLogEntity.FieldColumnDescription, entity.ColumnDescription);
sqlBuilder.SetValue(BaseChangeLogEntity.FieldRecordKey, entity.RecordKey);
sqlBuilder.SetValue(BaseChangeLogEntity.FieldOldKey, entity.OldKey);
sqlBuilder.SetValue(BaseChangeLogEntity.FieldOldValue, entity.OldValue);
sqlBuilder.SetValue(BaseChangeLogEntity.FieldNewKey, entity.NewKey);
sqlBuilder.SetValue(BaseChangeLogEntity.FieldNewValue, entity.NewValue);
sqlBuilder.SetValue(BaseChangeLogEntity.FieldSortCode, entity.SortCode);
sqlBuilder.SetValue(BaseChangeLogEntity.FieldDeleted, entity.Deleted);
sqlBuilder.SetValue(BaseChangeLogEntity.FieldEnabled, entity.Enabled);
}
/// <summary>
/// 更新实体
/// </summary>
/// <param name="entity">实体</param>
public int UpdateEntity(BaseChangeLogEntity entity)
{
var sqlBuilder = new SqlBuilder(DbHelper);
sqlBuilder.BeginUpdate(CurrentTableName);
SetEntity(sqlBuilder, entity);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseChangeLogEntity.FieldUpdateUserId, UserInfo.UserId);
sqlBuilder.SetValue(BaseChangeLogEntity.FieldUpdateUserName, UserInfo.UserName);
sqlBuilder.SetValue(BaseChangeLogEntity.FieldUpdateBy, UserInfo.RealName);
}
sqlBuilder.SetDbNow(BaseChangeLogEntity.FieldUpdateTime);
sqlBuilder.SetValue(BaseChangeLogEntity.FieldUpdateIp, Utils.GetIp());
sqlBuilder.SetWhere(PrimaryKey, entity.Id);
//return sqlBuilder.EndUpdate();
var result = sqlBuilder.EndUpdate();
if (result > 0)
{
RemoveCache(entity.Id);
}
return(result);
}
/// <summary>
/// 更新密码
/// </summary>
/// <param name="userId">用户主键、方便外部系统调用，若能传递参数过来</param>
/// <param name="oldPassword">原密码</param>
/// <param name="newPassword">新密码</param>
/// <returns>影响行数</returns>
public virtual BaseUserInfo ChangePassword(string userId, string oldPassword, string newPassword)
{
#if (DEBUG)
int milliStart = Environment.TickCount;
#endif
var encryptOldPassword = oldPassword;
var encryptNewPassword = newPassword;
BaseUserInfo userInfo = null;
// 密码强度检查
if (BaseSystemInfo.CheckPasswordStrength)
{
if (string.IsNullOrEmpty(newPassword))
{
Status = Status.PasswordCanNotBeNull;
StatusCode = Status.PasswordCanNotBeNull.ToString();
return(userInfo);
}
}
// 判断输入原始密码是否正确
var entity = new BaseUserLogonManager(DbHelper, UserInfo).GetEntityByUserId(UserInfo.UserId);
if (entity.UserPassword == null)
{
entity.UserPassword = string.Empty;
}
// 加密密码
if (BaseSystemInfo.ServerEncryptPassword)
{
encryptOldPassword = EncryptUserPassword(oldPassword, entity.Salt);
}
// 密码错误
if (!entity.UserPassword.Equals(encryptOldPassword, StringComparison.CurrentCultureIgnoreCase))
{
Status = Status.OldPasswordError;
StatusCode = Status.OldPasswordError.ToString();
return(userInfo);
}
// 对比是否最近2次用过这个密码
if (BaseSystemInfo.CheckPasswordStrength)
{
/*
* int i = 0;
* BaseParameterManager manager = new BaseParameterManager(this.DbHelper, this.UserInfo);
* var dt = manager.GetDataTableParameterCode("User", this.UserInfo.Id, "Password");
* foreach (DataRow dr in dt.Rows)
* {
* string parameter = dr[BaseParameterEntity.FieldParameterContent].ToString();
* if (parameter.Equals(newPassword))
* {
* this.StatusCode = Status.PasswordCanNotBeRepeat.ToString();
* return userInfo;
* }
* i++;
* {
* // 判断连续2个密码就是可以了
* if (i > 2)
* {
* break;
* }
* }
* }
*/
}
// 更改密码，同时修改密码的修改日期，这里需要兼容多数据库
var salt = string.Empty;
if (BaseSystemInfo.ServerEncryptPassword)
{
salt = RandomUtil.GetString(20);
encryptNewPassword = EncryptUserPassword(newPassword, salt);
}
var sqlBuilder = new SqlBuilder(DbHelper);
sqlBuilder.BeginUpdate(BaseUserLogonEntity.CurrentTableName);
if (BaseSystemInfo.ServerEncryptPassword)
{
sqlBuilder.SetValue(BaseUserLogonEntity.FieldSalt, salt);
}
// 宋彪：此处增加更新密码强度级别
sqlBuilder.SetValue(BaseUserLogonEntity.FieldPasswordStrength, SecretUtil.GetUserPassWordRate(newPassword));
sqlBuilder.SetValue(BaseUserLogonEntity.FieldUserPassword, encryptNewPassword);
// 2015-08-04 吉日嘎拉 修改了密码后,把需要修改密码字段设置为 0
sqlBuilder.SetValue(BaseUserLogonEntity.FieldNeedModifyPassword, 0);
sqlBuilder.SetDbNow(BaseUserLogonEntity.FieldChangePasswordTime);
sqlBuilder.SetDbNow(BaseUserLogonEntity.FieldUpdateTime);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseUserLogonEntity.FieldUpdateUserId, UserInfo.UserId);
sqlBuilder.SetValue(BaseUserLogonEntity.FieldUpdateBy, UserInfo.RealName);
}
sqlBuilder.SetWhere(BaseUserLogonEntity.FieldUserId, userId);
var result = sqlBuilder.EndUpdate();
if (result == 1)
{
// 2015-12-09 吉日嘎拉 确认已经记录了修改密码日志
// BaseLogonLogManager.AddLog(this.UserInfo, Status.ChangePassword.ToDescription());
// 2015-12-09 吉日嘎拉 增加日志功能、谁什么时候设置了谁的密码？
var record = new BaseChangeLogEntity
{
TableName = BaseUserLogonEntity.CurrentTableName,
TableDescription = FieldExtensions.ToDescription(typeof(BaseUserLogonEntity), "CurrentTableName"),
ColumnName = BaseUserLogonEntity.FieldUserPassword,
ColumnDescription = "用户密码",
RecordKey = userId.ToString(),
NewValue = "修改密码"
};
var changeLogManager = new BaseChangeLogManager(UserInfo);
changeLogManager.Add(record, true, false);
/*
* // 若是强类型密码检查，那就保存密码修改历史，防止最近2-3次的密码相同的功能实现。
* if (BaseSystemInfo.CheckPasswordStrength)
* {
* BaseParameterManager parameterManager = new BaseParameterManager(this.DbHelper, this.UserInfo);
* BaseParameterEntity parameterEntity = new BaseParameterEntity();
* parameterEntity.CategoryCode = "User";
* parameterEntity.ParameterId = this.UserInfo.Id;
* parameterEntity.ParameterCode = "Password";
* parameterEntity.ParameterContent = newPassword;
* parameterEntity.Deleted = 0;
* parameterEntity.Enabled = true;
* parameterManager.AddEntity(parameterEntity);
* }
*/
userInfo = LogonByOpenId(UserInfo.OpenId, UserInfo.SystemCode).UserInfo;
// 同步处理其他系统的密码修改动作
if (BaseSystemInfo.ServerEncryptPassword)
{
// AfterChangePassword(this.UserInfo.Id, salt, oldPassword, newPassword);
}
// 修改密码成功，写入状态
Status = Status.ChangePasswordOk;
StatusCode = Status.ChangePasswordOk.ToString();
}
else
{
// 数据可能被删除
Status = Status.ErrorDeleted;
StatusCode = Status.ErrorDeleted.ToString();
}
return(userInfo);
}
// 这个是声明扩展方法 partial void SetEntityExtend(SqlBuilder sqlBuilder, BaseChangeLogEntity entity);
/// <summary>
/// 添加实体
/// </summary>
/// <param name="entity">实体</param>
public string AddEntity(BaseChangeLogEntity entity)
{
var key = string.Empty;
if (entity.SortCode == 0)
{
var managerSequence = new BaseSequenceManager(DbHelper, Identity);
if (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.Db2)
{
key = managerSequence.Increment($"SC_{CurrentTableName}_SEQ");
}
else
{
key = managerSequence.Increment(CurrentTableName);
}
entity.SortCode = key.ToInt();
}
var sqlBuilder = new SqlBuilder(DbHelper, Identity, ReturnId);
sqlBuilder.BeginInsert(CurrentTableName, PrimaryKey);
if (!Identity)
{
// 这里已经是指定了主键了，所以不需要返回主键了
sqlBuilder.ReturnId = false;
sqlBuilder.SetValue(PrimaryKey, entity.Id);
}
else
{
if (!ReturnId && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.Db2))
{
if (DbHelper.CurrentDbType == CurrentDbType.Oracle)
{
sqlBuilder.SetFormula(PrimaryKey, $"{CurrentTableName}_SEQ.NEXTVAL");
}
if (DbHelper.CurrentDbType == CurrentDbType.Db2)
{
sqlBuilder.SetFormula(PrimaryKey, $"NEXT VALUE FOR {CurrentTableName}_SEQ");
}
}
else
{
if (Identity && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.Db2))
{
var managerSequence = new BaseSequenceManager(DbHelper);
entity.Id = managerSequence.Increment($"{CurrentTableName}_SEQ").ToInt();
sqlBuilder.SetValue(PrimaryKey, entity.Id);
}
}
}
SetEntity(sqlBuilder, entity);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseChangeLogEntity.FieldCreateUserId, UserInfo.UserId);
sqlBuilder.SetValue(BaseChangeLogEntity.FieldCreateUserName, UserInfo.UserName);
sqlBuilder.SetValue(BaseChangeLogEntity.FieldCreateBy, UserInfo.RealName);
}
else
{
sqlBuilder.SetValue(BaseChangeLogEntity.FieldCreateBy, entity.CreateBy);
sqlBuilder.SetValue(BaseChangeLogEntity.FieldCreateUserName, entity.CreateUserName);
}
sqlBuilder.SetDbNow(BaseChangeLogEntity.FieldCreateTime);
sqlBuilder.SetValue(BaseChangeLogEntity.FieldCreateIp, Utils.GetIp());
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseChangeLogEntity.FieldUpdateUserId, UserInfo.UserId);
sqlBuilder.SetValue(BaseChangeLogEntity.FieldUpdateUserName, UserInfo.UserName);
sqlBuilder.SetValue(BaseChangeLogEntity.FieldUpdateBy, UserInfo.RealName);
}
sqlBuilder.SetDbNow(BaseChangeLogEntity.FieldUpdateTime);
sqlBuilder.SetValue(BaseChangeLogEntity.FieldUpdateIp, Utils.GetIp());
if (Identity && (DbHelper.CurrentDbType == CurrentDbType.SqlServer || DbHelper.CurrentDbType == CurrentDbType.Access))
{
key = sqlBuilder.EndInsert().ToString();
}
else
{
sqlBuilder.EndInsert();
}
if (Identity && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.Db2))
{
key = entity.Id.ToString();
}
if (!string.IsNullOrWhiteSpace(key))
{
RemoveCache();
}
return(key);
}
/// <summary>
/// 更新
/// </summary>
/// <param name="entity">实体</param>
public int Update(BaseChangeLogEntity entity)
{
return(UpdateEntity(entity));
}
/// <summary>
/// 设置密码
/// </summary>
/// <param name="userId">被设置的用户主键</param>
/// <param name="newPassword">新密码(原始，未加密)</param>
/// <param name="unlock">解除锁定</param>
/// <param name="autoAdd">数据缺少自动补充登录信息</param>
/// <param name="changeLog">记录更改</param>
/// <returns>影响行数</returns>
public virtual int SetPassword(int userId, string newPassword, bool?unlock = null, bool?autoAdd = null, bool changeLog = true)
{
var result = 0;
// 密码强度检查
/*
* if (BaseSystemInfo.CheckPasswordStrength)
* {
* if (password.Length == 0)
* {
* this.StatusCode = StatusCode.PasswordCanNotBeNull.ToString();
* return result;
* }
* }
*/
var encryptPassword = newPassword;
var salt = string.Empty;
// 加密密码
if (BaseSystemInfo.ServerEncryptPassword)
{
salt = RandomUtil.GetString(20);
encryptPassword = EncryptUserPassword(newPassword, salt);
}
// 设置密码字段
var parameters = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>(BaseUserLogonEntity.FieldUserPassword, encryptPassword),
// 2016-05-20 吉日嘎拉 把修改的痕迹保留起来
new KeyValuePair <string, object>(BaseUserLogonEntity.FieldUpdateTime, DateTime.Now)
};
if (UserInfo != null)
{
parameters.Add(new KeyValuePair <string, object>(BaseUserLogonEntity.FieldUpdateUserId, UserInfo.UserId));
parameters.Add(new KeyValuePair <string, object>(BaseUserLogonEntity.FieldUpdateBy, UserInfo.RealName));
}
//需要重新登录才可以，防止正在被人黑中，阻止已经在线上的人
parameters.Add(new KeyValuePair <string, object>(BaseUserLogonEntity.FieldOpenId, Guid.NewGuid().ToString("N")));
if (BaseSystemInfo.ServerEncryptPassword)
{
parameters.Add(new KeyValuePair <string, object>(BaseUserLogonEntity.FieldSalt, salt));
}
parameters.Add(new KeyValuePair <string, object>(BaseUserLogonEntity.FieldChangePasswordTime, DateTime.Now));
if (unlock.HasValue && unlock.Value == true)
{
parameters.Add(new KeyValuePair <string, object>(BaseUserLogonEntity.FieldEnabled, 1));
parameters.Add(new KeyValuePair <string, object>(BaseUserLogonEntity.FieldLockStartTime, null));
parameters.Add(new KeyValuePair <string, object>(BaseUserLogonEntity.FieldLockEndTime, null));
}
var userLogonManager = new BaseUserLogonManager(DbHelper, UserInfo);
result = userLogonManager.SetProperty(new KeyValuePair <string, object>(BaseUserLogonEntity.FieldUserId, userId), parameters);
if (result == 0 && autoAdd.HasValue && autoAdd.Value == true)
{
var userLogonEntity = new BaseUserLogonEntity
{
UserId = userId,
ChangePasswordTime = DateTime.Now,
UserPassword = encryptPassword,
Salt = salt,
Enabled = 1,
CreateTime = DateTime.Now,
UpdateTime = DateTime.Now
};
if (UserInfo != null)
{
userLogonEntity.CreateUserId = UserInfo.UserId;
userLogonEntity.CreateBy = UserInfo.RealName;
}
userLogonManager.AddEntity(userLogonEntity);
result = 1;
}
// 2015-12-09 吉日嘎拉 增加日志功能、谁什么时候设置了谁的密码？
if (changeLog)
{
var record = new BaseChangeLogEntity
{
TableName = BaseUserLogonEntity.CurrentTableName,
TableDescription = FieldExtensions.ToDescription(typeof(BaseUserLogonEntity), "CurrentTableName"),
ColumnName = BaseUserLogonEntity.FieldUserPassword,
ColumnDescription = "用户密码",
RecordKey = userId.ToString(),
NewValue = "设置密码"
};
var changeLogManager = new BaseChangeLogManager(UserInfo);
changeLogManager.Add(record, true, false);
}
if (result == 1)
{
StatusCode = Status.SetPasswordOk.ToString();
// 调用扩展
if (BaseSystemInfo.OnInternet && BaseSystemInfo.ServerEncryptPassword)
{
// AfterSetPassword(userId, salt, password);
}
}
else
{
// 数据可能被删除
StatusCode = Status.ErrorDeleted.ToString();
}
return(result);
}
