/// <summary>
/// 服务器端检查在线状态
/// </summary>
/// <param name="taskId">任务标识</param>
/// <returns>离线人数</returns>
public int ServerCheckOnline(string taskId)
{
var result = 0;
using (var dbHelper = DbHelperFactory.Create(BaseSystemInfo.UserCenterDbType))
{
try
{
dbHelper.Open(BaseSystemInfo.UserCenterWriteDbConnection);
var userLogonManager = new BaseUserLogonManager(dbHelper);
result = userLogonManager.CheckOnline();
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
throw;
}
finally
{
dbHelper.Close();
}
}
return(result);
}
/// <summary>
/// 根据OpenId获取用户实体
/// </summary>
/// <param name="openId"></param>
/// <returns></returns>
public BaseUserEntity GetEntityByOpenId(string openId)
{
BaseUserEntity userEntity = null;
// 用户没有找到状态
StatusCode = Status.UserNotFound.ToString();
StatusMessage = GetStateMessage(StatusCode);
// 检查是否有效的合法的参数
if (!string.IsNullOrEmpty(openId))
{
var userLogonManager = new BaseUserLogonManager();
var parameters = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>(BaseUserLogonEntity.FieldOpenId, openId)
};
var id = userLogonManager.GetId(parameters);
if (!string.IsNullOrEmpty(id))
{
parameters = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>(BaseUserEntity.FieldId, id),
new KeyValuePair <string, object>(BaseUserEntity.FieldDeleted, 0),
new KeyValuePair <string, object>(BaseUserEntity.FieldEnabled, 1)
};
var dt = GetDataTable(parameters);
if (dt != null && dt.Rows.Count == 1)
{
userEntity = BaseEntity.Create <BaseUserEntity>(dt);
}
}
}
return(userEntity);
}
/// <summary>
/// 通过 openId 获取用户信息
/// </summary>
/// <param name="openId">唯一键</param>
/// <returns>用户实体</returns>
public static BaseUserEntity GetEntityByOpenIdByCache(string openId)
{
BaseUserEntity result = null;
var userId = string.Empty;
var key = "OpenId";
if (!string.IsNullOrWhiteSpace(openId))
{
key += openId;
result = CacheUtil.Cache(key, () =>
{
// 到数据库里查一次
userId = new BaseUserLogonManager().GetIdByOpenId(openId);
if (!string.IsNullOrWhiteSpace(userId))
{
return(new BaseUserManager().GetEntity(userId));
}
else
{
return(null);
}
}, true);
}
return(result);
}
/// <summary>
/// 按用户名登录(LDAP专用)
/// </summary>
/// <param name="taskId">任务标识</param>
/// <param name="systemCode">子系统编码</param>
/// <param name="userInfo">用户</param>
/// <param name="userName">用户名</param>
/// <returns>用户实体</returns>
public UserLogonResult LogonByUserName(string taskId, string systemCode, BaseUserInfo userInfo, string userName)
{
var result = new UserLogonResult();
var parameter = ServiceInfo.Create(taskId, userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
// 先侦测是否在线
//userLogonManager.CheckOnline();
// 然后获取用户密码
var userManager = new BaseUserManager(userInfo);
// 是否从角色判断管理员
userManager.CheckIsAdministrator = true;
//根据用户名获取用户信息
var userEntity = userManager.GetByUserName(userName);
if (userEntity != null)
{
var baseUserLogonManager = new BaseUserLogonManager(userInfo);
//获取密码
var userLogonEntity = baseUserLogonManager.GetEntityByUserId(userEntity.Id);
var password = userLogonEntity.UserPassword;
//再进行登录，这里密码不能是AD的密码，所以不检验密码
result = userManager.LogonByUserName(userName, password, systemCode, null, null, null, false, false);
//可以登录，但不建议，没有登录日志等
//result = userManager.LogonByOpenId(openId, string.Empty, string.Empty);
}
// 登录时会自动记录进行日志记录，所以不需要进行重复日志记录
//BaseLogManager.Instance.Add(userInfo, this.serviceName, MethodBase.GetCurrentMethod());
});
return(result);
}
/// <summary>
/// 锁定用户
/// </summary>
/// <param name="taskId">任务标识</param>
/// <param name="userInfo">用户</param>
/// <param name="userName">用户名</param>
/// <returns>是否成功锁定</returns>
public bool LockUser(string taskId, BaseUserInfo userInfo, string userName)
{
var result = false;
var parameter = ServiceInfo.Create(taskId, userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
// BaseLogManager.Instance.Add(result, this.serviceName, AppMessage.LogonService_LockUser, MethodBase.GetCurrentMethod());
var userManager = new BaseUserManager(userInfo);
var parameters = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>(BaseUserEntity.FieldUserName, userName),
new KeyValuePair <string, object>(BaseUserEntity.FieldEnabled, 1),
new KeyValuePair <string, object>(BaseUserEntity.FieldDeleted, 0)
};
var userEntity = BaseEntity.Create <BaseUserEntity>(userManager.GetDataTable(parameters));
// 判断是否为空的
if (userEntity != null && userEntity.Id > 0)
{
// 被锁定15分钟，不允许15分钟内登录，这时间是按服务器的时间来的。
var userLogonManager = new BaseUserLogonManager();
var userLogonEntity = userLogonManager.GetEntityByUserId(userEntity.Id);
userLogonEntity.LockStartTime = DateTime.Now;
userLogonEntity.LockEndTime = DateTime.Now.AddMinutes(BaseSystemInfo.PasswordErrorLockCycle);
result = userLogonManager.UpdateEntity(userLogonEntity) > 0;
}
});
return(result);
}
/// <summary>
/// 检查IP地址
/// </summary>
/// <param name="userId"></param>
/// <param name="ipAddress"></param>
/// <param name="autoAdd"></param>
/// <returns></returns>
public static bool CheckIpAddressByCache(string userId, string ipAddress, bool autoAdd = false)
{
// 判断用户是否限制ip访问，有的是不限制访问的
var userLogonManager = new BaseUserLogonManager();
var userLogonEntity = userLogonManager.GetEntityByUserId(userId);
return(CheckIpAddressByCache(userId, userLogonEntity, ipAddress, autoAdd));
}
/// <summary>
/// 重新设置数据
/// </summary>
/// <returns>影响行数</returns>
public int Reset()
{
var result = 0;
result += ResetData();
var manager = new BaseUserLogonManager(DbHelper, UserInfo);
result += manager.ResetVisitInfo();
return(result);
}
/// <summary>
/// 用户现在
/// </summary>
/// <param name="taskId">任务标识</param>
/// <param name="userInfo">用户</param>
/// <param name="onLineState">用户在线状态</param>
public void Online(string taskId, BaseUserInfo userInfo, int onLineState = 1)
{
var parameter = ServiceInfo.Create(taskId, userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var userLogonManager = new BaseUserLogonManager();
userLogonManager.Online(userInfo.UserId, onLineState);
});
}
/// <summary>
/// 检查用户的登录许可信息
/// </summary>
/// <param name="userId">用户主键</param>
/// <returns>用户登录信息</returns>
public UserLogonResult CheckUser(string userId)
{
// 这个从缓存获取，效率高，一般不会有经常在修改的事情，缓存的时间很短才可以，否则读取脏数据了
var userEntity = GetEntity(userId);
// 获取登录状态表
var userLogonManager = new BaseUserLogonManager(UserInfo, UserLogonTable);
var userLogonEntity = userLogonManager.GetEntityByUserId(userId);
return(CheckUser(userEntity, userLogonEntity));
}
/// <summary>
/// 用户离线(退出)
/// </summary>
/// <param name="taskId">任务标识</param>
/// <param name="userInfo">用户</param>
public void SignOut(string taskId, BaseUserInfo userInfo)
{
var parameter = ServiceInfo.Create(taskId, userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
// 2015-12-14 吉日嘎拉 用户的登录日志不用重复写日志
var userLogonManager = new BaseUserLogonManager();
userLogonManager.SignOut(userInfo.OpenId);
});
}
//
// 获取用户的最新 OpenId 的方法
//
/// <summary>
///
/// </summary>
/// <param name="userInfo"></param>
/// <param name="cachingSystemCode"></param>
/// <param name="useCaching"></param>
/// <param name="useDataBase"></param>
/// <param name="useUserCenterHost"></param>
/// <returns></returns>
public static string GetUserOpenId(BaseUserInfo userInfo, string cachingSystemCode = null, bool useCaching = false, bool useDataBase = true, bool useUserCenterHost = false)
{
var result = string.Empty;
if (useCaching && userInfo != null && userInfo.UserId > 0)
{
var key = string.Empty;
if (string.IsNullOrEmpty(cachingSystemCode))
{
key = "userId:" + userInfo.Id;
}
else
{
key = "userId:" + cachingSystemCode + ":" + userInfo.Id;
}
result = CacheUtil.Get <string>(key);
// 2016-04-05 吉日嘎拉 这里代码有错误，不为空时进行处理
if (!string.IsNullOrWhiteSpace(result))
{
userInfo.OpenId = result;
HttpContext.Current.Session[SessionName] = userInfo;
HttpContext.Current.Session["openId"] = userInfo.OpenId;
// 2016-04-05 吉日嘎拉，这里可以提前结束了，提高效率
return(result);
}
if (useDataBase)
{
var userLogonManager = new BaseUserLogonManager(userInfo);
result = userLogonManager.GetUserOpenId(userInfo, cachingSystemCode);
}
if (string.IsNullOrEmpty(result) && useUserCenterHost)
{
//停用远程获取 Troy.Cui 2018.07.23
//result = LogonHttpUtil.GetUserOpenId(userInfo, cachingSystemCode);
}
// 从数据库获取,这里要考虑读写分离的做法
if (!string.IsNullOrWhiteSpace(result))
{
userInfo.OpenId = result;
HttpContext.Current.Session[SessionName] = userInfo;
HttpContext.Current.Session["openId"] = userInfo.OpenId;
// 这里这样处理一下，提高下次处理的效率
SetUserOpenId(userInfo.Id.ToString(), userInfo.OpenId, cachingSystemCode);
}
}
return(result);
}
/// <summary>
/// 获取新的OpenId
/// </summary>
/// <param name="taskId">任务标识</param>
/// <param name="userInfo">用户</param>
/// <returns>OpenId</returns>
public string CreateOpenId(string taskId, BaseUserInfo userInfo)
{
var result = string.Empty;
var parameter = ServiceInfo.Create(taskId, userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var userLogonManager = new BaseUserLogonManager(userInfo);
result = userLogonManager.CreateOpenId();
});
return(result);
}
/// <summary>
/// 重置用户访问情况
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="ids">用户主键</param>
/// <returns>影响行数</returns>
public int ResetVisitInfo(BaseUserInfo userInfo, string[] ids)
{
var result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDbWithTransaction(userInfo, parameter, (dbHelper) =>
{
var manager = new BaseUserLogonManager(dbHelper, userInfo);
// 重置访问情况
result = manager.ResetVisitInfo(ids);
});
return(result);
}
/// <summary>
/// 重新设置缓存（重新强制设置缓存）可以提供外部调用的
/// 20151007 吉日嘎拉，需要在一个连接上进行大量的操作
/// </summary>
/// <param name="userId">主键</param>
/// <returns>用户信息</returns>
public static BaseUserLogonEntity SetCache(string userId)
{
BaseUserLogonEntity result = null;
var manager = new BaseUserLogonManager();
result = manager.GetEntityByUserId(userId);
if (result != null)
{
SetCache(result);
}
return(result);
}
/// <summary>
/// 判断证码是否正确
/// </summary>
/// <param name="taskId">任务标识</param>
/// <param name="userInfo">用户</param>
/// <param name="code">验证码</param>
/// <returns>正确</returns>
public bool ValidateVerificationCode(string taskId, BaseUserInfo userInfo, string code)
{
var result = false;
var userLogonManager = new BaseUserLogonManager();
var verificationCode = userLogonManager.GetProperty(userInfo.Id, BaseUserLogonEntity.FieldVerificationCode);
if (!string.IsNullOrEmpty(verificationCode))
{
result = verificationCode.Equals(code);
}
return(result);
}
/// <summary>
/// 更新实体
/// </summary>
/// <param name="taskId">任务标识</param>
/// <param name="userInfo">用户</param>
/// <param name="entity">实体</param>
/// <returns>影响行数</returns>
public int Update(string taskId, BaseUserInfo userInfo, BaseUserLogonEntity entity)
{
var result = 0;
var parameter = ServiceInfo.Create(taskId, userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
// 调用方法，并且返回运行结果
var userLogonManager = new BaseUserLogonManager();
result = userLogonManager.Update(entity, true);
});
return(result);
}
/// <summary>
/// 设置用户审核状态
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="ids">主键数组</param>
/// <param name="auditStates">审核状态</param>
/// <returns>影响行数</returns>
public int SetUserAuditStates(BaseUserInfo userInfo, string[] ids, AuditStatus auditStates)
{
var result = 0;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var parameters = new List <KeyValuePair <string, object> >();
var userManager = new BaseUserManager(dbHelper, userInfo);
// 被审核通过
if (auditStates == AuditStatus.AuditPass)
{
parameters.Add(new KeyValuePair <string, object>(BaseUserEntity.FieldAuditStatus, auditStates.ToString()));
parameters.Add(new KeyValuePair <string, object>(BaseUserEntity.FieldEnabled, 1));
result = userManager.SetProperty(ids, parameters);
// 锁定时间需要去掉
// 密码错误次数需要修改掉
var userLogonManager = new BaseUserLogonManager(dbHelper, userInfo);
parameters = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>(BaseUserLogonEntity.FieldLockStartTime, null),
new KeyValuePair <string, object>(BaseUserLogonEntity.FieldLockEndTime, null),
new KeyValuePair <string, object>(BaseUserLogonEntity.FieldUserOnline, 0),
new KeyValuePair <string, object>(BaseUserLogonEntity.FieldPasswordErrorCount, 0)
};
result = userLogonManager.SetProperty(ids, parameters);
// var staffManager = new BaseStaffManager(dbHelper, result);
// string[] staffIds = staffManager.GetIds(BaseStaffEntity.FieldUserId, ids);
// staffManager.SetProperty(staffIds, new KeyValuePair<string, object>(BaseStaffEntity.FieldEnabled, 1));
}
// 被退回
if (auditStates == AuditStatus.AuditReject)
{
parameters.Add(new KeyValuePair <string, object>(BaseUserEntity.FieldAuditStatus, auditStates.ToString()));
parameters.Add(new KeyValuePair <string, object>(BaseUserEntity.FieldEnabled, 0));
// parameters.Add(new KeyValuePair<string, object>(BaseUserEntity.FieldAuditStatus, Status.UserLocked.ToString()));
result = userManager.SetProperty(ids, parameters);
}
});
return(result);
}
/// <summary>
/// 激活用户
/// </summary>
/// <param name="taskId">任务标识</param>
/// <param name="userInfo">用户</param>
/// <param name="openId">唯一识别码</param>
/// <returns>用户实体</returns>
public BaseUserInfo AccountActivation(string taskId, BaseUserInfo userInfo, string openId)
{
BaseUserInfo result = null;
var parameter = ServiceInfo.Create(taskId, userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var userLogonManager = new BaseUserLogonManager(dbHelper, userInfo);
// 先侦测是否在线
userLogonManager.CheckOnline();
// 再进行登录
var userManager = new BaseUserManager(dbHelper, userInfo);
result = userManager.AccountActivation(openId);
});
return(result);
}
/// <summary>
/// 按唯一识别码登录
/// </summary>
/// <param name="taskId">任务标识</param>
/// <param name="userInfo">用户</param>
/// <param name="openId">唯一识别码</param>
/// <returns>用户实体</returns>
public UserLogonResult LogonByOpenId(string taskId, BaseUserInfo userInfo, string openId)
{
var result = new UserLogonResult();
var parameter = ServiceInfo.Create(taskId, userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
// 先侦测是否在线
var userLogonManager = new BaseUserLogonManager();
userLogonManager.CheckOnline();
// 若是单点登录，那就不能判断ip地址，因为不是直接登录，是间接登录
var userManager = new BaseUserManager(userInfo);
result = userManager.LogonByOpenId(openId, userInfo.SystemCode, string.Empty, string.Empty);
});
return(result);
}
/// <summary>
/// 获取实体
/// </summary>
/// <param name="taskId">任务标识</param>
/// <param name="userInfo">用户</param>
/// <param name="id">主键</param>
/// <returns>实体</returns>
public BaseUserLogonEntity GetEntity(string taskId, BaseUserInfo userInfo, string id)
{
BaseUserLogonEntity result = null;
var parameter = ServiceInfo.Create(taskId, userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
var userManager = new BaseUserManager(dbHelper, userInfo);
// 判断是否已经登录的用户？
if (userManager.UserIsLogon(userInfo))
{
var userLogonManager = new BaseUserLogonManager();
result = userLogonManager.GetEntity(id);
}
});
return(result);
}
/// <summary>
/// 扮演用户
/// </summary>
/// <param name="id">用户主键</param>
/// <param name="status">状态</param>
/// <returns>用户类</returns>
public BaseUserInfo Impersonation(int id, out Status status)
{
BaseUserInfo userInfo = null;
// 获得登录信息
var entity = new BaseUserLogonManager(DbHelper, UserInfo).GetEntityByUserId(id.ToString());
// 只允许登录一次，需要检查是否自己重新登录了，或者自己扮演自己了
if (!UserInfo.Id.Equals(id))
{
if (BaseSystemInfo.CheckOnline)
{
if (entity.UserOnline > 0)
{
status = Status.ErrorOnline;
return(userInfo);
}
}
}
var userEntity = GetEntity(id);
userInfo = ConvertToUserInfo(userEntity);
if (userEntity.IsStaff.Equals("1"))
{
// 获得员工的信息
var staffEntity = new BaseStaffEntity();
var staffManager = new BaseStaffManager(DbHelper, UserInfo);
var dataTableStaff = staffManager.GetDataTableById(id.ToString());
staffEntity.GetSingle(dataTableStaff);
userInfo = staffManager.ConvertToUserInfo(userInfo, staffEntity);
}
status = Status.Ok;
// 登录、重新登录、扮演时的在线状态进行更新
var userLogonManager = new BaseUserLogonManager(DbHelper, UserInfo);
userLogonManager.ChangeOnline(id);
return(userInfo);
}
/// <summary>
/// 离职处理
/// </summary>
/// <param name="userEntity"></param>
/// <param name="userLogonEntity"></param>
/// <param name="comment"></param>
/// <returns>影响行数</returns>
public int Leave(BaseUserEntity userEntity, BaseUserLogonEntity userLogonEntity, string comment)
{
var result = 0;
if (userEntity != null)
{
// 更新用户实体
UpdateEntity(userEntity);
}
// 更新登录信息
if (userLogonEntity != null)
{
var userLogonManager = new BaseUserLogonManager(UserInfo);
userLogonManager.UpdateEntity(userLogonEntity);
}
// 2016-03-17 吉日嘎拉 停止吉信的号码
if (userEntity != null && !string.IsNullOrEmpty(userEntity.NickName))
{
//AfterLeaveStopIm(userEntity);
}
// 2016-03-17 吉日嘎拉 停止吉信的号码
if (userEntity != null && userEntity.Id > 0)
{
BaseUserContactEntity userContactEntity = null;
// 2015-12-08 吉日嘎拉 提高效率、从缓存获取数据
userContactEntity = BaseUserContactManager.GetEntityByCache(userEntity.Id);
if (userContactEntity != null && !string.IsNullOrEmpty(userContactEntity.CompanyEmail))
{
ChangeUserMailStatus(userContactEntity.CompanyEmail, true);
}
}
return(result);
}
/// <summary>
/// 获得用户列表
/// </summary>
/// <param name="taskId">任务标识</param>
/// <param name="userInfo">用户</param>
/// <returns>数据表</returns>
public DataTable GetUserDT(string taskId, BaseUserInfo userInfo)
{
var result = new DataTable(BaseUserEntity.CurrentTableName);
var parameter = ServiceInfo.Create(taskId, userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
{
// 检查用户在线状态(服务器专用)
var userLogonManager = new BaseUserLogonManager();
userLogonManager.CheckOnline();
var userManager = new BaseUserManager(dbHelper, userInfo);
// 获取允许登录列表
var parameters = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>(BaseUserEntity.FieldEnabled, 1),
new KeyValuePair <string, object>(BaseUserEntity.FieldDeleted, 0)
};
result = userManager.GetDataTable(parameters, BaseUserEntity.FieldSortCode);
result.TableName = BaseUserEntity.CurrentTableName;
});
return(result);
}
/// <summary>
/// 缓存预热,强制重新缓存
/// </summary>
/// <returns>影响行数</returns>
public static int CachePreheating()
{
var result = 0;
// 把所有的数据都缓存起来的代码
var manager = new BaseUserLogonManager();
// 基础用户的登录信息重新缓存起来
// 2016-04-25 吉日嘎拉 提高性能、读取最少的数据
var commandText = "SELECT " + BaseUserLogonEntity.FieldUserId + "," + BaseUserLogonEntity.FieldOpenId
+ " FROM " + BaseUserLogonEntity.CurrentTableName + " T WHERE T." + BaseUserLogonEntity.FieldUserPassword + " IS NOT NULL AND T." + BaseUserLogonEntity.FieldOpenIdTimeoutTime + " IS NOT NULL AND T." + BaseUserLogonEntity.FieldEnabled + " = 1 AND T." + BaseUserLogonEntity.FieldOpenIdTimeoutTime + " - sysdate < 0.5";
var dataReader = manager.ExecuteReader(commandText);
if (dataReader != null && !dataReader.IsClosed)
{
while (dataReader.Read())
{
var userId = dataReader[BaseUserLogonEntity.FieldUserId].ToString();
var openId = dataReader[BaseUserLogonEntity.FieldOpenId].ToString();
//暂停Redis缓存 Troy.Cui 2018.07.24，根本没用到Redis，分离DotNet.Business.Web后，就更没必要了
CacheUtil.Set(userId, openId);
result++;
if (result % 500 == 0)
{
Console.WriteLine(result + " : OpenIdClient User : "******" : 完成 ");
return(result);
}
/// <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);
}
/// <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);
}
/// <summary>
/// 更新用户
/// </summary>
/// <param name="userInfo">用户信息</param>
/// <param name="entity">用户实体</param>
/// <param name="userLogonEntity">用户登录实体</param>
/// <param name="userContactEntity">用户联系方式实体</param>
/// <param name="status">状态</param>
/// <param name="statusMessage">状态信息</param>
/// <returns>影响行数</returns>
public int UpdateUser(BaseUserInfo userInfo, BaseUserEntity entity, BaseUserLogonEntity userLogonEntity, BaseUserContactEntity userContactEntity, out Status status, out string statusMessage)
{
var result = 0;
var returnCode = Status.Ok;
var returnMessage = string.Empty;
var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
var userManager = new BaseUserManager(dbHelper, userInfo);
// 调用方法，并且返回运行结果，判断重复
// result = userManager.Update(entity, out StatusCode);
// 不判断重复直接更新
if (entity != null)
{
// 2015-12-09 吉日嘎拉 确认更新日志功能
result = userManager.Update(entity);
// 若是超级管理员，就是名字编号重复了，也应该能修改数据比较好，否则有些事情无法办理下去了，由于历史原因导致数据重复的什么的，也需要能修改才可以。
if (BaseUserManager.IsAdministrator(userInfo.Id))
{
if (userManager.StatusCode == Status.ErrorUserExist.ToString() ||
userManager.StatusCode == Status.ErrorCodeExist.ToString())
{
result = userManager.UpdateEntity(entity);
}
}
}
//用户登录 Troy.Cui 2018-10-06增加
if (userLogonEntity != null)
{
var userLogonManager = new BaseUserLogonManager(dbHelper, userInfo);
userLogonManager.Update(userLogonEntity, true);
}
if (userContactEntity != null)
{
var userContactManager = new BaseUserContactManager(dbHelper, userInfo);
userContactManager.SetEntity(userContactEntity);
}
if (result == 1)
{
userManager.Status = Status.OkUpdate;
userManager.StatusCode = Status.OkUpdate.ToString();
returnCode = userManager.Status;
}
userManager.StatusMessage = userManager.GetStateMessage(returnCode);
// 更新员工信息
if (entity != null)
{
if (entity.IsStaff == 0)
{
//BaseStaffManager staffManager = new BaseStaffManager(dbHelper, result);
//string staffId = staffManager.GetIdByUserId(entity.Id);
//if (!string.IsNullOrEmpty(staffId))
//{
// BaseStaffEntity staffEntity = staffManager.GetEntity(staffId);
// staffEntity.Code = entity.Code;
// staffEntity.Birthday = entity.Birthday;
// staffEntity.Gender = entity.Gender;
// staffEntity.UserName = entity.UserName;
// staffEntity.RealName = entity.RealName;
// staffEntity.QQ = entity.QQ;
// staffEntity.Mobile = entity.Mobile;
// staffEntity.Telephone = entity.Telephone;
// staffEntity.Email = entity.Email;
// staffEntity.CompanyId = entity.CompanyId;
// staffEntity.SubCompanyId = entity.SubCompanyId;
// staffEntity.DepartmentId = entity.DepartmentId;
// staffEntity.WorkgroupId = entity.WorkgroupId;
// staffManager.Update(staffEntity);
//}
}
}
returnCode = userManager.Status;
returnMessage = userManager.StatusMessage;
});
status = returnCode;
statusMessage = returnMessage;
return(result);
}
/// <summary>
/// 验证用户的令牌openId
/// </summary>
/// <param name="userId">用户主键</param>
/// <param name="openId">用户的令牌</param>
/// <param name="systemCode">子系统</param>
/// <param name="useCaching">采用缓存</param>
/// <param name="useDataBase">采用数据库</param>
/// <param name="useUserCenterHost">采用用户中心接口</param>
/// <returns>验证通过</returns>
public static bool ValidateOpenId(string userId, string openId, string systemCode = null, bool useCaching = true, bool useDataBase = false, bool useUserCenterHost = false)
{
var result = false;
if (string.IsNullOrEmpty(systemCode))
{
systemCode = string.Empty;
}
// 2016-03-14 吉日嘎拉、PDA系统的单独处理、其他的都认为是一样的。
if (!systemCode.Equals("PDA"))
{
systemCode = string.Empty;
}
if (!string.IsNullOrWhiteSpace(openId))
{
// 使用缓存进行验证、效率高，减少数据库的I/O压力。
if (useCaching)
{
var key = string.Empty;
if (string.IsNullOrEmpty(systemCode))
{
key = "openId:" + openId;
}
else
{
key = "openId:" + systemCode + ":" + openId;
}
result = string.IsNullOrEmpty(CacheUtil.Get <string>(key));
}
// 用数据库的方式进行验证
if (!result && useDataBase)
{
var userLogonManager = new BaseUserLogonManager();
result = userLogonManager.ValidateOpenId(userId, openId, systemCode);
if (result)
{
// 提高缓存效率、若读取到了，写入到缓存里去
if (!string.IsNullOrWhiteSpace(userId) && useCaching)
{
SetUserOpenId(userId, openId, systemCode);
}
result = true;
}
}
// 不能访问数据库时、通过远程用户中心服务进行验证OpenId、通过服务方式进行验证
if (!result && useUserCenterHost)
{
var url = BaseSystemInfo.UserCenterHost + "/UserCenterV42/LogonService.ashx";
var webClient = new WebClient();
var postValues = new NameValueCollection();
if (!string.IsNullOrEmpty(systemCode))
{
postValues.Add("systemCode", systemCode);
}
postValues.Add("ipAddress", Utils.GetIp());
postValues.Add("securityKey", BaseSystemInfo.SecurityKey);
postValues.Add("function", "ValidateOpenId");
postValues.Add("userId", userId);
postValues.Add("openId", openId);
// 向服务器发送POST数据
var responseArray = webClient.UploadValues(url, postValues);
var response = Encoding.UTF8.GetString(responseArray);
if (!string.IsNullOrEmpty(response))
{
result = response.Equals(true.ToString(), StringComparison.InvariantCultureIgnoreCase);
}
}
}
return(result);
}
/// <summary>
/// 导入用户
/// </summary>
/// <param name="dataReader"></param>
/// <param name="organizationManager"></param>
/// <param name="userLogonManager"></param>
/// <param name="userContactManager"></param>
/// <returns></returns>
public int ImportUser(IDataReader dataReader, BaseOrganizationManager organizationManager, BaseUserLogonManager userLogonManager, BaseUserContactManager userContactManager)
{
var result = 0;
var userEntity = GetEntity(dataReader["ID"].ToString());
if (userEntity == null)
{
userEntity = new BaseUserEntity
{
Id = dataReader["ID"].ToString().ToInt()
};
}
userEntity.Id = dataReader["ID"].ToString().ToInt();
userEntity.UserFrom = "K8";
userEntity.UserName = dataReader["USER_NAME"].ToString();
userEntity.IdCard = dataReader["ID_Card"].ToString();
userEntity.Code = dataReader["EMPLOYEE_CODE"].ToString();
userEntity.RealName = dataReader["REAL_NAME"].ToString();
if (string.IsNullOrWhiteSpace(userEntity.RealName))
{
userEntity.RealName = dataReader["EMPLOYEE_NAME"].ToString();
}
userEntity.NickName = dataReader["ONLY_USER_NAME"].ToString();
userEntity.CompanyName = dataReader["OWNER_SITE"].ToString();
userEntity.Description = dataReader["REMARK"].ToString();
// 把被删除的数据恢复过来
userEntity.Deleted = 0;
if (userEntity.CompanyId > 0)
{
if (string.IsNullOrEmpty(organizationManager.GetProperty(new KeyValuePair <string, object>(BaseOrganizationEntity.FieldName, userEntity.CompanyName), BaseOrganizationEntity.FieldId)))
{
Console.WriteLine("无CompanyId " + userEntity.Id + ":" + userEntity.UserName + ":" + userEntity.RealName);
return(0);
}
}
// 不是内部组织机构的才进行调整
if (userEntity.DepartmentId > 0)
{
userEntity.DepartmentName = dataReader["DEPT_NAME"].ToString();
}
if (!string.IsNullOrEmpty(dataReader["IM_NAME"].ToString()))
{
// userEntity.QQ = dataReader["IM_NAME"].ToString();
}
userEntity.Enabled = int.Parse(dataReader["BL_LOCK_FLAG"].ToString());
Console.WriteLine("ImportK8User:"******":" + userEntity.RealName);
// 02：可以把读取到的数据能写入到用户中心的。
result = UpdateEntity(userEntity);
if (result == 0)
{
AddEntity(userEntity);
}
// 添加用户密码表
var userLogonEntity = userLogonManager.GetEntityByUserId(userEntity.Id);
if (userLogonEntity == null)
{
userLogonEntity = new BaseUserLogonEntity
{
UserId = userEntity.Id,
// 邦定mac地址
CheckIpAddress = 1,
UserPassword = dataReader["USER_PASSWD"].ToString(),
Salt = dataReader["SALT"].ToString()
};
// 是否检查机器码 MAC地址
var checkIpAddress = 1;
int.TryParse(dataReader["BL_CHECK_COMPUTER"].ToString(), out checkIpAddress);
userLogonEntity.CheckIpAddress = checkIpAddress;
if (!string.IsNullOrEmpty(dataReader["CHANGEPASSWORDDATE"].ToString()))
{
userLogonEntity.ChangePasswordTime = DateTime.Parse(dataReader["CHANGEPASSWORDDATE"].ToString());
}
userLogonManager.AddEntity(userLogonEntity);
}
else
{
userLogonEntity.UserId = userEntity.Id;
userLogonEntity.UserPassword = dataReader["USER_PASSWD"].ToString();
userLogonEntity.Salt = dataReader["SALT"].ToString();
if (!string.IsNullOrEmpty(dataReader["CHANGEPASSWORDDATE"].ToString()))
{
userLogonEntity.ChangePasswordTime = DateTime.Parse(dataReader["CHANGEPASSWORDDATE"].ToString());
}
result = userLogonManager.UpdateEntity(userLogonEntity);
}
// 用户的联系方式
var userContactEntity = userContactManager.GetEntityByUserId(userEntity.Id.ToString());
if (userContactEntity == null)
{
userContactEntity = new BaseUserContactEntity
{
UserId = userEntity.Id,
Qq = dataReader["QQ"].ToString(),
Mobile = dataReader["Mobile"].ToString(),
Email = dataReader["Email"].ToString()
};
userContactManager.AddEntity(userContactEntity);
}
else
{
if (!string.IsNullOrEmpty(dataReader["QQ"].ToString()))
{
userContactEntity.Qq = dataReader["QQ"].ToString();
}
if (!string.IsNullOrEmpty(dataReader["Mobile"].ToString()))
{
userContactEntity.Mobile = dataReader["Mobile"].ToString();
}
if (!string.IsNullOrEmpty(dataReader["Email"].ToString()))
{
userContactEntity.Email = dataReader["Email"].ToString();
}
userContactManager.AddOrUpdate(userContactEntity);
}
return(result);
}
/// <summary>
/// 导入员工
/// </summary>
/// <param name="dataReader"></param>
/// <param name="staffManager"></param>
/// <param name="userManager"></param>
/// <param name="userLogonManager"></param>
/// <returns></returns>
//public int ImportStaff(IDataReader dataReader, BaseStaffManager staffManager, BaseUserExpressManager sTaffExpressManager, BaseUserManager userManager, BaseUserLogonManager userLogonManager)
public int ImportStaff(IDataReader dataReader, BaseStaffManager staffManager, BaseUserManager userManager, BaseUserLogonManager userLogonManager)
{
var result = 0;
/*
* BaseStaffEntity staffEntity = staffManager.GetEntity(dataReader["Id"].ToString());
* if (staffEntity == null)
* {
* staffEntity = new BaseStaffEntity();
* }
* staffEntity.Id = int.Parse(dataReader["Id"].ToString());
* staffEntity.Code = dataReader["EMPLOYEE_CODE"].ToString();
* staffEntity.RealName = dataReader["EMPLOYEE_NAME"].ToString();
* staffEntity.Telephone = dataReader["PHONE"].ToString();
* staffEntity.HomeAddress = dataReader["ADDRESS"].ToString();
* staffEntity.IDCard = dataReader["ID_CARD"].ToString();
*
* // staffEntity.CompanyId = dataReader["OWNER_SITE"].ToString();
* staffEntity.CompanyName = dataReader["OWNER_SITE"].ToString();
* // staffEntity.DepartmentId = dataReader["DEPT_NAME"].ToString();
* staffEntity.DepartmentName = dataReader["DEPT_NAME"].ToString();
* // staffEntity.WorkgroupId = dataReader["GROUP_NAME"].ToString();
* staffEntity.WorkgroupName = dataReader["GROUP_NAME"].ToString();
*
* System.Console.WriteLine("ImportK8Staff:" + staffEntity.Id + ":" + staffEntity.RealName);
* // 02：可以把读取到的数据能写入到用户中心的。
* result = staffManager.UpdateEntity(staffEntity);
* if (result == 0)
* {
* staffManager.AddEntity(staffEntity);
* }
*/
/*
* BaseUserExpressEntity sTAFF_EXPRESSEntity = sTAFF_EXPRESSManager.GetEntity(dataReader["Id"].ToString());
* if (sTAFF_EXPRESSEntity == null)
* {
* sTAFF_EXPRESSEntity = new BaseUserExpressEntity();
* }
* sTAFF_EXPRESSEntity.Id = int.Parse(dataReader["Id"].ToString());
* sTAFF_EXPRESSEntity.OWNER_RANGE = dataReader["OWNER_RANGE"].ToString();
* Decimal tRANSFER_ADD_FEE = 0;
* if (!string.IsNullOrEmpty(dataReader["TRANSFER_ADD_FEE"].ToString()) && ValidateUtil.IsDouble(dataReader["TRANSFER_ADD_FEE"].ToString()))
* {
* tRANSFER_ADD_FEE = Decimal.Parse(dataReader["TRANSFER_ADD_FEE"].ToString());
* }
* sTAFF_EXPRESSEntity.TRANSFER_ADD_FEE = tRANSFER_ADD_FEE;
* Decimal dISPATCH_ADD_FEE = 0;
* if (!string.IsNullOrEmpty(dataReader["DISPATCH__ADD_FEE"].ToString()) && ValidateUtil.IsDouble(dataReader["DISPATCH__ADD_FEE"].ToString()))
* {
* dISPATCH_ADD_FEE = Decimal.Parse(dataReader["DISPATCH__ADD_FEE"].ToString());
* }
* sTAFF_EXPRESSEntity.DISPATCH_ADD_FEE = dISPATCH_ADD_FEE;
*
* System.Console.WriteLine("ImportK8Staffexpress:" + staffEntity.Id + ":" + staffEntity.RealName);
* // 02：可以把读取到的数据能写入到用户中心的。
* result = sTAFF_EXPRESSManager.Update(sTAFF_EXPRESSEntity);
* if (result == 0)
* {
* sTAFF_EXPRESSManager.Add(sTAFF_EXPRESSEntity);
* }
*/
var userEntity = new BaseUserEntity
{
Id = dataReader["ID"].ToString().ToInt(),
UserFrom = "PDA",
Code = dataReader["EMPLOYEE_CODE"].ToString(),
UserName = dataReader["EMPLOYEE_NAME"].ToString(),
RealName = dataReader["REAL_NAME"].ToString(),
Description = dataReader["PHONE"].ToString(),
CompanyName = dataReader["OWNER_SITE"].ToString()
};
if (userEntity.CompanyId > 0)
{
if (BaseOrganizationManager.GetEntityByNameByCache(userEntity.CompanyName) == null)
{
Console.WriteLine("无CompanyId " + userEntity.Id + ":" + userEntity.UserName + ":" + userEntity.RealName);
return(0);
}
}
userEntity.DepartmentName = dataReader["DEPT_NAME"].ToString();
userEntity.WorkgroupName = dataReader["GROUP_NAME"].ToString();
userEntity.HomeAddress = dataReader["ADDRESS"].ToString();
userEntity.IdCard = dataReader["ID_CARD"].ToString();
if (!string.IsNullOrEmpty(dataReader["cardnum"].ToString()))
{
userEntity.IdCard = dataReader["cardnum"].ToString();
}
userEntity.Signature = dataReader["EMPLOYEE_TYPE"].ToString();
userEntity.SortCode = int.Parse(dataReader["ID"].ToString());
if (userEntity.UpdateTime == null)
{
userEntity.UpdateTime = DateTime.Parse(dataReader["UPDATETIME"].ToString());
}
else
{
if (userEntity.UpdateTime < DateTime.Parse(dataReader["UPDATETIME"].ToString()))
{
userEntity.UpdateTime = DateTime.Parse(dataReader["UPDATETIME"].ToString());
}
}
// 修改日期需要同步
// result = userManager.UpdateEntity(userEntity);
if (result == 0)
{
userManager.AddEntity(userEntity);
var userContactEntity = new BaseUserContactEntity
{
UserId = dataReader["ID"].ToString().ToInt(),
Telephone = dataReader["PHONE"].ToString()
};
new BaseUserContactManager().AddEntity(userContactEntity);
var userLogonEntity = new BaseUserLogonEntity
{
UserId = dataReader["ID"].ToString().ToInt(),
UserPassword = dataReader["BAR_PASSWORD"].ToString()
};
userLogonManager.AddEntity(userLogonEntity);
}
// 处理角色
/*
* string roleName = dataReader["EMPLOYEE_TYPE"].ToString();
* // 看是否在这个角色里，若没有增加上去。
* userManager.AddToRole("PDA", userEntity.Id, roleName);
*
* // 添加用户密码表
* BaseUserLogonEntity userLogonEntity = userLogonManager.GetEntity(userEntity.Id);
* if (userLogonEntity == null)
* {
* userLogonEntity = new BaseUserLogonEntity();
* userLogonEntity.Id = userEntity.Id;
* userLogonEntity.UserPassword = dataReader["BAR_PASSWORD"].ToString();
* //userLogonEntity.Salt = dataReader["SALT"].ToString();
* //if (!string.IsNullOrEmpty(dataReader["CHANGEPASSWORDDATE"].ToString()))
* //{
* // userLogonEntity.ChangePasswordTime = DateTime.Parse(dataReader["CHANGEPASSWORDDATE"].ToString());
* //}
* userLogonManager.AddEntity(userLogonEntity);
* }
* else
* {
* userLogonEntity.Id = userEntity.Id;
* userLogonEntity.UserPassword = dataReader["BAR_PASSWORD"].ToString();
* //userLogonEntity.Salt = dataReader["SALT"].ToString();
* //if (!string.IsNullOrEmpty(dataReader["CHANGEPASSWORDDATE"].ToString()))
* //{
* // userLogonEntity.ChangePasswordTime = DateTime.Parse(dataReader["CHANGEPASSWORDDATE"].ToString());
* //}
* result = userLogonManager.UpdateEntity(userLogonEntity);
* }
*/
return(result);
}
