/// <summary>
/// 按用户名登录(LDAP专用)
/// </summary>
/// <param name="userInfo">用户</param>
/// <param name="userName">用户名</param>
/// <param name="statusCode">返回状态码</param>
/// <param name="statusMessage">返回状消息</param>
/// <returns>用户实体</returns>
public BaseUserInfo LogOnByUserName(BaseUserInfo userInfo, string userName, out string statusCode, out string statusMessage)
{
var parameter = ServiceParameter.CreateWithLog(userInfo
, MethodBase.GetCurrentMethod());
BaseUserInfo returnUserInfo = null;
string returnCode = string.Empty;
string returnMessage = string.Empty;
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
// 先侦测是否在线
userLogOnManager.CheckOnLine();
// 然后获取用户密码
var userManager = new BaseUserManager(userInfo);
// 是否从角色判断管理员
userManager.CheckIsAdministrator = true;
BaseUserEntity userEntity = userManager.GetByUserName(userName);
BaseUserLogOnEntity userLogOnEntity = userLogOnManager.GetObject(userEntity.Id);
string password = userLogOnEntity.UserPassword;
// 再进行登录
returnUserInfo = userManager.LogOnByUserName(userName, password, null, false, userInfo.IPAddress, userInfo.MACAddress, false);
returnCode = userManager.StatusCode;
returnMessage = userManager.GetStateMessage();
// 登录时会自动记录进行日志记录，所以不需要进行重复日志记录
// BaseLogManager.Instance.Add(userInfo, this.serviceName, MethodBase.GetCurrentMethod());
});
statusCode = returnCode;
statusMessage = returnMessage;
return(returnUserInfo);
}
/// <summary>
/// 缓存预热,强制重新缓存
/// </summary>
/// <returns>影响行数</returns>
public static int CachePreheating()
{
int result = 0;
// 把所有的数据都缓存起来的代码
BaseUserLogOnManager manager = new BaseUserLogOnManager();
// 基础用户的登录信息重新缓存起来
string commandText = "SELECT * FROM baseuserlogon t WHERE t.userpassword IS NOT NULL AND t.openidtimeout IS NOT NULL AND t.enabled = 1 AND t.openidtimeout - sysdate < 0.5";
using (IDataReader dataReader = manager.ExecuteReader(commandText))
{
using (var redisClient = PooledRedisHelper.GetClient())
{
while (dataReader.Read())
{
BaseUserLogOnEntity entity = BaseEntity.Create <BaseUserLogOnEntity>(dataReader, false);
# if Redis
Utilities.SetUserOpenId(redisClient, entity.Id, entity.OpenId);
#else
Utilities.SetUserOpenId(entity.Id, entity.OpenId);
# endif
result++;
System.Console.WriteLine(result.ToString() + " : User : " + entity.Id);
}
dataReader.Close();
}
public string UpdateVisitDate(BaseUserLogOnEntity userLogOnEntity, bool createOpenId = false)
{
string result = string.Empty;
// 不管要不要生成、先默认不生成，超过8个小时的再生成
// 2016-03-18 吉日嘎拉 让强制生成新OpneId生肖。
// createOpenId = false;
if (userLogOnEntity.OpenIdTimeout.HasValue)
{
//TimeSpan timeSpan = DateTime.Now - userLogOnEntity.OpenIdTimeout.Value;
TimeSpan timeSpan = userLogOnEntity.OpenIdTimeout.Value - DateTime.Now;
if ((timeSpan.TotalHours) < 0)
{
createOpenId = true;
}
}
else
{
createOpenId = true;
}
if (createOpenId)
{
result = Guid.NewGuid().ToString("N");
}
else
{
result = userLogOnEntity.OpenId;
}
// 抛出一个线程
UpdateVisitDateTask(userLogOnEntity, createOpenId, result);
// new Thread(UpdateVisitDateTask).Start(new Tuple<BaseUserLogOnEntity, bool, string>(userLogOnEntity, createOpenId, result));
return(result);
}
public static BaseUserLogOnEntity GetUserLogOnObject(BaseUserInfo userInfo, string id)
{
BaseUserLogOnEntity result = null;
string url = BaseSystemInfo.UserCenterHost + "/UserCenterV42/UserService.ashx";
WebClient webClient = new WebClient();
NameValueCollection postValues = new NameValueCollection();
postValues.Add("system", BaseSystemInfo.SoftFullName);
postValues.Add("systemCode", BaseSystemInfo.SystemCode);
postValues.Add("securityKey", BaseSystemInfo.SecurityKey);
// 2015-11-25 吉日嘎拉，这个要看看，有没有必要设置缓存？
postValues.Add("function", "GetUserLogOnObject");
postValues.Add("userInfo", userInfo.Serialize());
postValues.Add("encrypted", true.ToString());
postValues.Add("id", SecretUtil.Encrypt(id));
// 向服务器发送POST数据
byte[] responseArray = webClient.UploadValues(url, postValues);
string response = Encoding.UTF8.GetString(responseArray);
if (!string.IsNullOrEmpty(response))
{
result = JsonConvert.DeserializeObject <BaseUserLogOnEntity>(response);
}
return(result);
}
/// <summary>
/// 设置实体
/// </summary>
/// <param name="entity">实体</param>
private void SetObject(SQLBuilder sqlBuilder, BaseUserLogOnEntity entity)
{
// 2016-03-02 吉日嘎拉 增加按公司可以区别数据的功能。
if (this.DbHelper.CurrentDbType == CurrentDbType.MySql)
{
sqlBuilder.SetValue(BaseUserContactEntity.FieldCompanyId, entity.CompanyId);
}
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldUserPassword, entity.UserPassword);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldPasswordErrorCount, entity.PasswordErrorCount);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldMultiUserLogin, entity.MultiUserLogin);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldOpenId, entity.OpenId);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldQuestion, entity.Question);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldAnswerQuestion, entity.AnswerQuestion);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldChangePasswordDate, entity.ChangePasswordDate);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldSystemCode, entity.SystemCode);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldEnabled, entity.Enabled);
//sqlBuilder.SetValue(BaseUserLogOnEntity.FieldCommunicationPassword, entity.CommunicationPassword);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldAllowStartTime, entity.AllowStartTime);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldAllowEndTime, entity.AllowEndTime);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldLockStartDate, entity.LockStartDate);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldLockEndDate, entity.LockEndDate);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldFirstVisit, entity.FirstVisit);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldPreviousVisit, entity.PreviousVisit);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldLastVisit, entity.LastVisit);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldCheckIPAddress, entity.CheckIPAddress);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldShowCount, entity.ShowCount);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldLogOnCount, entity.LogOnCount);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldUserOnLine, entity.UserOnLine);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldIPAddress, entity.IPAddress);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldIPAddressName, entity.IPAddressName);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldMACAddress, entity.MACAddress);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldSalt, entity.Salt);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldPasswordStrength, entity.PasswordStrength);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldNeedModifyPassword, entity.NeedModifyPassword);
}
/// <summary>
/// 添加用户
/// </summary>
/// <param name="entity">用户实体</param>
/// <returns>主键</returns>
public string Add(BaseUserEntity entity)
{
string result = string.Empty;
this.BeforeAdd(entity);
if (this.StatusCode == Status.OKAdd.ToString())
{
result = this.AddObject(entity);
// 用户访问表里，插入一条记录
BaseUserLogOnEntity userLogOnEntity = new BaseUserLogOnEntity();
userLogOnEntity.Id = entity.Id;
userLogOnEntity.CompanyId = entity.CompanyId;
// 把一些默认值读取到，系统的默认值，这样增加用户时可以把系统的默认值带入
userLogOnEntity.MultiUserLogin = BaseSystemInfo.CheckOnLine ? 0 : 1;
userLogOnEntity.CheckIPAddress = BaseSystemInfo.CheckIPAddress ? 1 : 0;
//此处设置密码强度级别
userLogOnEntity.PasswordStrength = SecretUtil.GetUserPassWordRate(userLogOnEntity.UserPassword);
// 若是系统需要用加密的密码，这里需要加密密码。
if (BaseSystemInfo.ServerEncryptPassword)
{
userLogOnEntity.UserPassword = this.EncryptUserPassword(entity.UserPassword);
// 安全通讯密码、交易密码也生成好
// userLogOnEntity.UserPassword = this.EncryptUserPassword(entity.CommunicationPassword);
}
new BaseUserLogOnManager(this.DbHelper, this.UserInfo).Add(userLogOnEntity);
this.AfterAdd(entity);
}
return(result);
}
/// <summary>
/// 保存实体修改记录
/// </summary>
/// <param name="newEntity">修改前的实体对象</param>
/// <param name="oldEntity">修改后的实体对象</param>
/// <param name="tableName">表名称</param>
public void UpdateEntityLog(BaseUserLogOnEntity newEntity, BaseUserLogOnEntity oldEntity, string tableName = null)
{
if (string.IsNullOrEmpty(tableName))
{
tableName = BaseUserEntity.TableName + "_LOG";
}
BaseModifyRecordManager manager = new BaseModifyRecordManager(this.UserInfo, tableName);
foreach (var property in typeof(BaseUserLogOnEntity).GetProperties())
{
var oldValue = Convert.ToString(property.GetValue(oldEntity, null));
var newValue = Convert.ToString(property.GetValue(newEntity, null));
var fieldDescription = property.GetCustomAttributes(typeof(FieldDescription), false).FirstOrDefault() as FieldDescription;
//不记录创建人、修改人、没有修改的记录
if (!fieldDescription.NeedLog || oldValue == newValue)
{
continue;
}
var record = new BaseModifyRecordEntity();
record.ColumnCode = property.Name.ToUpper();
record.ColumnDescription = fieldDescription.Text;
record.NewValue = newValue;
record.OldValue = oldValue;
record.TableCode = this.CurrentTableName.ToUpper();
record.TableDescription = FieldExtensions.ToDescription(typeof(BaseUserLogOnEntity), "TableName");
record.RecordKey = oldEntity.Id.ToString();
record.IPAddress = Utilities.GetIPAddress(true);
manager.Add(record, true, false);
}
}
public virtual bool CommunicationPassword(string communicationPassword)
{
bool result = false;
// 密码强度检查
if (BaseSystemInfo.CheckPasswordStrength)
{
if (String.IsNullOrEmpty(communicationPassword))
{
return(result);
}
}
// 加密密码
if (BaseSystemInfo.ServerEncryptPassword)
{
communicationPassword = this.EncryptUserPassword(communicationPassword);
}
// 判断输入原始密码是否正确
BaseUserLogOnEntity entity = new BaseUserLogOnEntity();
entity.GetSingle(this.GetDataTableById(UserInfo.Id));
if (entity.CommunicationPassword == null)
{
entity.CommunicationPassword = string.Empty;
}
if (entity.CommunicationPassword.Equals(communicationPassword))
{
result = true;
}
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)
{
bool 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);
List <KeyValuePair <string, object> > parameters = new List <KeyValuePair <string, object> >();
parameters.Add(new KeyValuePair <string, object>(BaseUserEntity.FieldUserName, userName));
parameters.Add(new KeyValuePair <string, object>(BaseUserEntity.FieldEnabled, 1));
parameters.Add(new KeyValuePair <string, object>(BaseUserEntity.FieldDeletionStateCode, 0));
BaseUserEntity userEntity = BaseEntity.Create <BaseUserEntity>(userManager.GetDataTable(parameters));
// 判断是否为空的
if (userEntity != null && !string.IsNullOrEmpty(userEntity.Id))
{
// 被锁定15分钟，不允许15分钟内登录，这时间是按服务器的时间来的。
var userLogOnManager = new BaseUserLogOnManager();
BaseUserLogOnEntity userLogOnEntity = userLogOnManager.GetObject(userEntity.Id);
userLogOnEntity.LockStartDate = DateTime.Now;
userLogOnEntity.LockEndDate = DateTime.Now.AddMinutes(BaseSystemInfo.PasswordErrorLockCycle);
result = userLogOnManager.UpdateObject(userLogOnEntity) > 0;
}
});
return(result);
}
public static bool CheckIPAddressByCache(string userId, string ipAddress, bool autoAdd = false)
{
// 判断用户是否限制ip访问，有的是不限制访问的
BaseUserLogOnManager userLogOnManager = new BaseUserLogOnManager();
BaseUserLogOnEntity userLogOnEntity = userLogOnManager.GetObject(userId);
return(CheckIPAddressByCache(userLogOnEntity, ipAddress, autoAdd));
}
/// <summary>
/// 离职处理
/// </summary>
/// <param name="id">主键</param>
/// <returns>影响行数</returns>
public int Leave(BaseUserEntity userEntity, BaseUserLogOnEntity userLogOnEntity, string comment)
{
int result = 0;
if (userEntity != null)
{
// 更新用户实体
this.UpdateObject(userEntity);
}
// 更新登录信息
if (userLogOnEntity != null)
{
BaseUserLogOnManager userLogOnManager = new BaseUserLogOnManager(this.UserInfo);
userLogOnManager.UpdateObject(userLogOnEntity);
}
// 填写评论
if (!string.IsNullOrWhiteSpace(comment))
{
SQLBuilder sqlBuilder = new SQLBuilder(BaseSystemInfo.ServerDbType);
sqlBuilder.BeginInsert(BaseCommentEntity.TableName);
sqlBuilder.SetValue(BaseCommentEntity.FieldId, System.Guid.NewGuid().ToString("N"));
sqlBuilder.SetValue(BaseCommentEntity.FieldCategoryCode, BaseUserEntity.TableName);
sqlBuilder.SetValue(BaseCommentEntity.FieldObjectId, userEntity.Id);
sqlBuilder.SetValue(BaseCommentEntity.FieldContents, comment);
sqlBuilder.SetValue(BaseCommentEntity.FieldWorked, 1);
sqlBuilder.SetValue(BaseCommentEntity.FieldDepartmentId, userEntity.DepartmentId);
sqlBuilder.SetValue(BaseCommentEntity.FieldDepartmentName, userEntity.DepartmentName);
sqlBuilder.SetValue(BaseCommentEntity.FieldCreateUserId, this.UserInfo.Id);
sqlBuilder.SetValue(BaseCommentEntity.FieldCreateBy, this.UserInfo.RealName);
sqlBuilder.SetDBNow(BaseCommentEntity.FieldCreateOn);
sqlBuilder.SetValue(BaseCommentEntity.FieldIPAddress, this.UserInfo.IPAddress);
sqlBuilder.SetValue(BaseCommentEntity.FieldEnabled, 1);
sqlBuilder.SetValue(BaseCommentEntity.FieldDeletionStateCode, 0);
sqlBuilder.EndInsert();
}
// 2016-03-17 吉日嘎拉 停止吉信的号码
if (userEntity != null && !string.IsNullOrEmpty(userEntity.NickName))
{
AfterLeaveStopIM(userEntity);
}
// 2016-03-17 吉日嘎拉 停止吉信的号码
if (userEntity != null && !string.IsNullOrEmpty(userEntity.Id))
{
BaseUserContactEntity userContactEntity = BaseUserContactManager.GetObjectByCache(userEntity.Id);
{
if (userContactEntity != null && !string.IsNullOrEmpty(userContactEntity.CompanyMail))
{
ChangeUserMailStatus(userContactEntity.CompanyMail, true);
}
}
}
return(result);
}
public void UpdateVisitDateTask(object param)
{
var tuple = param as Tuple <BaseUserLogOnEntity, bool, string>;
BaseUserLogOnEntity userLogOnEntity = tuple.Item1;
bool createOpenId = tuple.Item2;
string openId = tuple.Item3;
UpdateVisitDateTask(userLogOnEntity, createOpenId, openId);
}
/// <summary>
/// 更新数字签名密码
/// </summary>
/// <param name="oldPassword">原密码</param>
/// <param name="newPassword">新密码</param>
/// <param name="statusCode">返回状态码</param>
/// <returns>影响行数</returns>
public virtual int ChangeSignedPassword(string oldPassword, string newPassword, out string statusCode)
{
#if (DEBUG)
int milliStart = Environment.TickCount;
#endif
int result = 0;
// 密码强度检查
if (BaseSystemInfo.CheckPasswordStrength)
{
if (String.IsNullOrEmpty(newPassword))
{
statusCode = Status.PasswordCanNotBeNull.ToString();
return(result);
}
}
// 加密密码
if (BaseSystemInfo.ServerEncryptPassword)
{
oldPassword = this.EncryptUserPassword(oldPassword);
newPassword = this.EncryptUserPassword(newPassword);
}
// 判断输入原始密码是否正确
BaseUserLogOnEntity entity = new BaseUserLogOnEntity();
entity.GetSingle(this.GetDataTableById(UserInfo.Id));
if (entity.SignedPassword == null)
{
entity.SignedPassword = string.Empty;
}
// 密码错误
if (!entity.SignedPassword.Equals(oldPassword))
{
statusCode = Status.OldPasswordError.ToString();
return(result);
}
// 更改密码
result = this.SetProperty(UserInfo.Id, new KeyValuePair <string, object>(BaseUserLogOnEntity.FieldSignedPassword, newPassword));
if (result == 1)
{
statusCode = Status.ChangePasswordOK.ToString();
}
else
{
// 数据可能被删除
statusCode = Status.ErrorDeleted.ToString();
}
// 写入调试信息
#if (DEBUG)
BaseUserManager userManager = new BaseUserManager(DbHelper, UserInfo);
BaseUserEntity userEntity = userManager.GetObject(this.UserInfo.Id);
int milliEnd = Environment.TickCount;
Trace.WriteLine(DateTime.Now.ToString(BaseSystemInfo.TimeFormat) + " Ticks: " + TimeSpan.FromMilliseconds(milliEnd - milliStart).ToString() + " " + " BaseUserManager.ChangePassword(" + userEntity.Id + ")");
#endif
return(result);
}
/// <summary>
/// 检查用户的登录许可信息
/// </summary>
/// <param name="userId">用户主键</param>
/// <returns>用户登录信息</returns>
public UserLogOnResult CheckUser(string userId)
{
// 这个从缓存获取，效率高，一般不会有经常在修改的事情，缓存的时间很短才可以，否则读取脏数据了
BaseUserEntity userEntity = this.GetObject(userId);
// 获取登录状态表
BaseUserLogOnManager userLogOnManager = new BaseUserLogOnManager(this.UserInfo, this.UserLogOnTable);
BaseUserLogOnEntity userLogOnEntity = userLogOnManager.GetObject(userId);
return(CheckUser(userEntity, userLogOnEntity));
}
/// <summary>
/// 更新
/// </summary>
/// <param name="entity">实体</param>
public int Update(BaseUserLogOnEntity entity)
{
int result = 0;
// 获取原始实体信息
var entityOld = this.GetObject(entity.Id);
// 保存修改记录
this.UpdateEntityLog(entity, entityOld);
// 更新数据
result = this.UpdateObject(entity);
// 重新缓存
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)
{
int result = 0;
var parameter = ServiceInfo.Create(taskId, userInfo, MethodBase.GetCurrentMethod());
ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
{
// 调用方法，并且返回运行结果
BaseUserLogOnManager userLogOnManager = new BaseUserLogOnManager();
result = userLogOnManager.Update(entity);
});
return(result);
}
/// <summary>
/// 更新实体
/// </summary>
/// <param name="entity">实体</param>
public int UpdateObject(BaseUserLogOnEntity entity)
{
SQLBuilder sqlBuilder = new SQLBuilder(DbHelper);
sqlBuilder.BeginUpdate(this.CurrentTableName);
this.SetObject(sqlBuilder, entity);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldModifiedUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldModifiedBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseUserLogOnEntity.FieldModifiedOn);
sqlBuilder.SetWhere(BaseUserLogOnEntity.FieldId, entity.Id);
return(sqlBuilder.EndUpdate());
}
/// <summary>
/// 获取实体
/// </summary>
/// <param name="taskId">任务标识</param>
/// <param name="userInfo">用户</param>
/// <param name="id">主键</param>
/// <returns>实体</returns>
public BaseUserLogOnEntity GetObject(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))
{
BaseUserLogOnManager userLogOnManager = new BaseUserLogOnManager();
result = userLogOnManager.GetObject(id);
}
});
return(result);
}
public int ChangeEnabled(string id)
{
BaseUserEntity userEntity = this.GetObject(id);
if (userEntity.Enabled != 1)
{
// 若用户要生效了，那就需要修改锁定的时间了，否则被锁定的用户有效后也无法登录系统了
BaseUserLogOnManager manager = new BaseUserLogOnManager(this.DbHelper, this.UserInfo);
BaseUserLogOnEntity entity = manager.GetObject(id);
entity.LockStartDate = null;
entity.LockEndDate = null;
manager.Update(entity);
userEntity.AuditStatus = string.Empty;
userEntity.DeletionStateCode = 0;
userEntity.Enabled = 1;
}
else
{
// 若是有效的用户直接修改为无效的用户
userEntity.Enabled = 0;
}
return(this.UpdateObject(userEntity));
}
public int ImportStaff(System.Data.IDataReader dataReader, BaseStaffManager staffManager, BaseUserExpressManager sTAFF_EXPRESSManager, BaseUserManager userManager, BaseUserLogOnManager userLogOnManager)
{
int result = 0;
/*
* BaseStaffEntity staffEntity = staffManager.GetObject(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.UpdateObject(staffEntity);
* if (result == 0)
* {
* staffManager.AddObject(staffEntity);
* }
*/
/*
* BaseUserExpressEntity sTAFF_EXPRESSEntity = sTAFF_EXPRESSManager.GetObject(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);
* }
*/
BaseUserEntity userEntity = new BaseUserEntity();
userEntity.Id = dataReader["ID"].ToString();
userEntity.UserFrom = "PDA";
userEntity.Code = dataReader["EMPLOYEE_CODE"].ToString();
userEntity.UserName = dataReader["EMPLOYEE_NAME"].ToString();
userEntity.RealName = dataReader["REAL_NAME"].ToString();
userEntity.Description = dataReader["PHONE"].ToString();
userEntity.CompanyName = dataReader["OWNER_SITE"].ToString();
if (string.IsNullOrEmpty(userEntity.CompanyId))
{
userEntity.CompanyId = BaseOrganizeManager.GetObjectByNameByCache(userEntity.CompanyName).Id.ToString();
if (string.IsNullOrEmpty(userEntity.CompanyId))
{
System.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.ModifiedOn.HasValue)
{
userEntity.ModifiedOn = DateTime.Parse(dataReader["UPDATETIME"].ToString());
}
else
{
if (userEntity.ModifiedOn.Value < DateTime.Parse(dataReader["UPDATETIME"].ToString()))
{
userEntity.ModifiedOn = DateTime.Parse(dataReader["UPDATETIME"].ToString());
}
}
// 修改日期需要同步
// result = userManager.UpdateObject(userEntity);
if (result == 0)
{
userManager.AddObject(userEntity);
BaseUserContactEntity userContactEntity = new BaseUserContactEntity();
userContactEntity.Id = dataReader["ID"].ToString();
userContactEntity.Telephone = dataReader["PHONE"].ToString();
new BaseUserContactManager().AddObject(userContactEntity);
BaseUserLogOnEntity userLogOnEntity = new BaseUserLogOnEntity();
userLogOnEntity.Id = dataReader["ID"].ToString();
userLogOnEntity.UserPassword = dataReader["BAR_PASSWORD"].ToString();
userLogOnManager.AddObject(userLogOnEntity);
}
// 处理角色
/*
* string roleName = dataReader["EMPLOYEE_TYPE"].ToString();
* // 看是否在这个角色里，若没有增加上去。
* userManager.AddToRole("PDA", userEntity.Id, roleName);
*
* // 添加用户密码表
* BaseUserLogOnEntity userLogOnEntity = userLogOnManager.GetObject(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.ChangePasswordDate = DateTime.Parse(dataReader["CHANGEPASSWORDDATE"].ToString());
* //}
* userLogOnManager.AddObject(userLogOnEntity);
* }
* else
* {
* userLogOnEntity.Id = userEntity.Id;
* userLogOnEntity.UserPassword = dataReader["BAR_PASSWORD"].ToString();
* //userLogOnEntity.Salt = dataReader["SALT"].ToString();
* //if (!string.IsNullOrEmpty(dataReader["CHANGEPASSWORDDATE"].ToString()))
* //{
* // userLogOnEntity.ChangePasswordDate = DateTime.Parse(dataReader["CHANGEPASSWORDDATE"].ToString());
* //}
* result = userLogOnManager.UpdateObject(userLogOnEntity);
* }
*/
return(result);
}
/// <summary>
/// 更新K8员工后，同步到中天baseuser表
/// 传入dbhelper 方法调用使用事务 避免部分同步成功
/// </summary>
/// <param name="entity"></param>
/// <param name="userCenterDbHelper"></param>
public void AfterUpdateEmployee(TAB_EMPLOYEEEntity entity, IDbHelper userCenterDbHelper)
{
int count = 0;
BaseUserEntity userEntity = new BaseUserEntity();
userEntity.Id = entity.ID.ToString();
userEntity.UserFrom = "PDA";
userEntity.UserPassword = entity.BAR_PASSWORD;
userEntity.Code = entity.EMPLOYEE_CODE;
userEntity.UserName = entity.EMPLOYEE_NAME;
userEntity.RealName = entity.EMPLOYEE_NAME;
userEntity.Description = entity.PHONE;
userEntity.CompanyName = entity.OWNER_SITE;
// 1、更新baseuser中的所属网点
if (string.IsNullOrEmpty(userEntity.CompanyId))
{
BaseOrganizeEntity organizeEntity = new BaseOrganizeManager(userCenterDbHelper).GetObjectByName(userEntity.CompanyName);
if (organizeEntity != null)
{
userEntity.CompanyId = organizeEntity.Id.ToString();
}
}
userEntity.DepartmentName = entity.DEPT_NAME;
userEntity.WorkgroupName = entity.GROUP_NAME;
userEntity.HomeAddress = entity.ADDRESS;
userEntity.IDCard = entity.ID_CARD;
// 2、员工操作类型，按签名处理
userEntity.Signature = entity.EMPLOYEE_TYPE;
userEntity.SortCode = int.Parse(entity.ID.ToString());
userEntity.ModifiedOn = entity.UPDATETIME;
BaseUserManager userManager = new BaseUserManager(userCenterDbHelper, Utilities.UserInfo);
// if (!userManager.Exists(userEntity.Id))
count = userManager.UpdateObject(userEntity);
if (count == 0)
{
userManager.AddObject(userEntity);
}
// 3、如果有电话，同步到baseusercontact中
BaseUserContactEntity userContactEntity = new BaseUserContactEntity();
userContactEntity.Id = entity.ID.ToString();
userContactEntity.Telephone = entity.PHONE;
BaseUserContactManager userContactManager = new DotNet.Business.BaseUserContactManager(userCenterDbHelper, Utilities.UserInfo);
count = userContactManager.UpdateObject(userContactEntity);
if (count == 0)
{
userContactManager.AddObject(userContactEntity);
}
// 4、新增员工时，同步baseuser员工的密码
BaseUserLogOnEntity userLogOnEntity = new BaseUserLogOnEntity();
userLogOnEntity.Id = entity.ID.ToString();
userLogOnEntity.UserPassword = entity.BAR_PASSWORD;
BaseUserLogOnManager userLogOnManager = new BaseUserLogOnManager(userCenterDbHelper, Utilities.UserInfo);
count = userLogOnManager.UpdateObject(userLogOnEntity);
if (count == 0)
{
userLogOnManager.AddObject(userLogOnEntity);
}
// 5、中转附加费和派件附加费，再确认
BaseUserExpressManager userExpressManager = new BaseUserExpressManager(userCenterDbHelper, Utilities.UserInfo);
BaseUserExpressEntity userExpressEntity = new BaseUserExpressEntity();
userExpressEntity.Id = entity.ID;
userExpressEntity.DISPATCH_ADD_FEE = entity.DISPATCH__ADD_FEE;
userExpressEntity.TRANSFER_ADD_FEE = entity.TRANSFER_ADD_FEE;
userExpressEntity.OWNER_RANGE = entity.OWNER_RANGE;
count = userExpressManager.UpdateObject(userExpressEntity);
if (count == 0)
{
userExpressManager.Add(userExpressEntity, false);
}
}
/// <summary>
/// 增加用户账号
/// 传入dbhelper 方法调用使用事务 避免部分同步成功
/// </summary>
/// <param name="userEntity"></param>
/// <param name="userContact"></param>
/// <param name="userCenterDbHelper"></param>
/// <param name="k8DbHelper"></param>
/// <returns></returns>
public bool AddUser(BaseUserEntity userEntity, BaseUserContactEntity userContact, IDbHelper userCenterDbHelper, IDbHelper k8DbHelper)
{
//1、先往中天里添加账号
BaseUserManager userManager = new BaseUserManager(userCenterDbHelper);
userEntity.UserFrom = "Security";
userEntity.CreateBy = Utilities.UserInfo.RealName;
userEntity.CreateUserId = Utilities.UserInfo.Id;
bool identity = false;
if (string.IsNullOrEmpty(userEntity.Id))
{
identity = true;
}
userEntity.Id = userManager.Add(userEntity, identity, true);
//添加用户密码表
BaseUserLogOnManager userLogOnManager = new BaseUserLogOnManager(userCenterDbHelper);
BaseUserLogOnEntity userLogOnEntity = userLogOnManager.GetObject(userEntity.Id);
userLogOnEntity = new BaseUserLogOnEntity();
userLogOnEntity.Id = userEntity.Id;
//是否验证邦定mac地址，默认绑定
userLogOnEntity.CheckIPAddress = 1;
//产生盐
var salt = BaseRandom.GetRandomString(20);
userLogOnEntity.Salt = salt;
userLogOnEntity.UserPassword = userManager.EncryptUserPassword(userEntity.UserPassword, salt);
//是否检查机器码MAC地址
userLogOnManager.AddObject(userLogOnEntity);
//添加用户的联系方式
BaseUserContactManager userContactManager = new BaseUserContactManager(userCenterDbHelper);
userContact.MobileValiated = 1;
userContactManager.AddObject(userContact);
//2、再往K8里加用户
TAB_USERManager tabUserManager = new TAB_USERManager(k8DbHelper);
TAB_USEREntity tabUserEntity = new TAB_USEREntity();
tabUserEntity.OWNER_SITE = userEntity.CompanyName;
tabUserEntity.DEPT_NAME = userEntity.DepartmentName;
tabUserEntity.USER_NAME = userEntity.UserName.ToLower();
tabUserEntity.EMPLOYEE_CODE = userEntity.Code;
tabUserEntity.EMPLOYEE_NAME = userEntity.RealName;
tabUserEntity.REAL_NAME = userEntity.RealName;
tabUserEntity.ONLY_USER_NAME = userEntity.NickName.ToLower();
tabUserEntity.ID_CARD = userEntity.IDCard;
tabUserEntity.MOBILE = userContact.Mobile;
tabUserEntity.CREATE_SITE = Utilities.UserInfo.CompanyName;
tabUserEntity.CREATE_USER = Utilities.UserInfo.RealName;
tabUserEntity.CREATE_DATE = DateTime.Now;
tabUserEntity.BL_LOCK_FLAG = 1;
tabUserEntity.BL_TYPE = 0;
tabUserEntity.BL_CHECK_COMPUTER = 1;
tabUserEntity.BL_CHECK_NAME = 1;
tabUserEntity.ID = decimal.Parse(userEntity.Id);
tabUserEntity.USER_DATE = DateTime.Now.AddYears(3);
tabUserManager.Add(tabUserEntity, false, true);
//更新密码和盐
var sql = string.Format(" UPDATE TAB_USER SET USER_PASSWORD=NULL,USER_PASSWD='{0}',SALT ='{1}', CHANGEPASSWORDDATE=to_date('{2}','yyyy-mm-dd-hh24:mi:ss') WHERE ID = '{3}'",
userEntity.UserPassword, salt, DateTime.Now, tabUserEntity.ID);
tabUserManager.ExecuteNonQuery(sql);
//3、新增账号的时候默认增加新员工的权限为网点员工
var roleMenus = GetMenusByUserCode(k8DbHelper, "网点员工", "", "上海");
TAB_USERPOPEDOMManager userMenuManager = new TAB_USERPOPEDOMManager(k8DbHelper);
foreach (var roleMenu in roleMenus)
{
TAB_USERPOPEDOMEntity userPOPEDOM = new TAB_USERPOPEDOMEntity();
userPOPEDOM.BL_INSERT = roleMenu.BL_INSERT;
userPOPEDOM.BL_UPDATE = roleMenu.BL_UPDATE;
userPOPEDOM.BL_DELETE = roleMenu.BL_DELETE;
userPOPEDOM.USER_NAME = tabUserEntity.USER_NAME;
userPOPEDOM.OWNER_SITE = tabUserEntity.OWNER_SITE;
userPOPEDOM.MENU_GUID = roleMenu.MENU_GUID;
userMenuManager.Add(userPOPEDOM);
}
return(true);
}
public BaseUserInfo ConvertToUserInfo(BaseUserInfo userInfo, BaseUserEntity userEntity, BaseUserLogOnEntity userLogOnEntity = null, bool validateUserOnly = false)
{
if (userEntity == null)
{
return(null);
}
userInfo.Id = userEntity.Id;
userInfo.IsAdministrator = userEntity.IsAdministrator;
userInfo.Code = userEntity.Code;
userInfo.UserName = userEntity.UserName;
userInfo.RealName = userEntity.RealName;
userInfo.NickName = userEntity.NickName;
if (userLogOnEntity != null)
{
userInfo.OpenId = userLogOnEntity.OpenId;
}
userInfo.CompanyId = userEntity.CompanyId;
userInfo.CompanyName = userEntity.CompanyName;
userInfo.DepartmentId = userEntity.DepartmentId;
userInfo.DepartmentName = userEntity.DepartmentName;
BaseOrganizeEntity organizeEntity = null;
BaseOrganizeManager organizeManager = null;
if (!string.IsNullOrEmpty(userInfo.CompanyId))
{
#if Redis
try
{
organizeEntity = BaseOrganizeManager.GetObjectByCache(userInfo.CompanyId);
}
catch (System.Exception ex)
{
string writeMessage = "BaseOrganizeManager.GetObjectByCache:发生时间:" + DateTime.Now
+ System.Environment.NewLine + "CompanyId 无法缓存获取:" + userInfo.CompanyId
+ System.Environment.NewLine + "Message:" + ex.Message
+ System.Environment.NewLine + "Source:" + ex.Source
+ System.Environment.NewLine + "StackTrace:" + ex.StackTrace
+ System.Environment.NewLine + "TargetSite:" + ex.TargetSite
+ System.Environment.NewLine;
FileUtil.WriteMessage(writeMessage, BaseSystemInfo.StartupPath + "//Exception//Exception" + DateTime.Now.ToString(BaseSystemInfo.DateFormat) + ".txt");
}
#endif
if (organizeEntity == null)
{
organizeManager = new BaseOrganizeManager();
organizeEntity = organizeManager.GetObject(userInfo.CompanyId);
// 2015-12-06 吉日嘎拉 进行记录日志功能改进
if (organizeEntity == null)
{
string writeMessage = "BaseOrganizeManager.GetObject:发生时间:" + DateTime.Now
+ System.Environment.NewLine + "CompanyId 无法缓存获取:" + userInfo.CompanyId
+ System.Environment.NewLine + "BaseUserInfo:" + userInfo.Serialize();
FileUtil.WriteMessage(writeMessage, BaseSystemInfo.StartupPath + "Log//Log" + DateTime.Now.ToString(BaseSystemInfo.DateFormat) + ".txt");
}
}
if (organizeEntity != null)
{
userInfo.CompanyCode = organizeEntity.Code;
}
}
/*
* 部门数据需要从部门表里读取
*
* if (!validateUserOnly && !string.IsNullOrEmpty(userInfo.DepartmentId))
* {
* organizeEntity = BaseOrganizeManager.GetObjectByCache(userInfo.DepartmentId);
* }
* else
* {
* if (organizeManager == null)
* {
* organizeManager = new Business.BaseOrganizeManager();
* }
* organizeEntity = organizeManager.GetObject(userInfo.DepartmentId);
* }
* if (organizeEntity != null)
* {
* userInfo.DepartmentCode = organizeEntity.Code;
* }
*/
return(userInfo);
}
public BaseUserInfo ConvertToUserInfo(BaseUserEntity userEntity, BaseUserLogOnEntity userLogOnEntity = null, bool validateUserOnly = false)
{
BaseUserInfo userInfo = new BaseUserInfo();
return(ConvertToUserInfo(userInfo, userEntity, userLogOnEntity, validateUserOnly));
}
/// <summary>
/// 更新访问当前访问状态
/// </summary>
/// <param name="userId">用户主键</param>
/// <param name="createOpenId">是否每次都产生新的OpenId</param>
/// <returns>OpenId</returns>
public string UpdateVisitDate(string userId, bool createOpenId = false)
{
BaseUserLogOnEntity userLogOnEntity = this.GetObject(userId);
return(UpdateVisitDate(userLogOnEntity, createOpenId));
}
// public async Task
public void UpdateVisitDateTask(BaseUserLogOnEntity userLogOnEntity, bool createOpenId, string openId)
{
int errorMark = 0;
string sqlQuery = string.Empty;
DateTime?openIdTimeout = DateTime.Now.AddHours(16);
try
{
using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType, BaseSystemInfo.UserCenterDbConnection))
{
// 是否更新访问日期信息
List <IDbDataParameter> dbParameters = null;
// 若有一周没登录了，需要重新进行手机验证
bool mobileNeedValiated = false;
if (userLogOnEntity.PreviousVisit.HasValue || userLogOnEntity.FirstVisit.HasValue)
{
TimeSpan ts = new System.TimeSpan();
if (userLogOnEntity.LastVisit.HasValue)
{
ts = DateTime.Now.Subtract((DateTime)userLogOnEntity.LastVisit);
mobileNeedValiated = (ts.TotalDays > 7);
}
else if (userLogOnEntity.FirstVisit.HasValue)
{
ts = DateTime.Now.Subtract((DateTime)userLogOnEntity.FirstVisit);
mobileNeedValiated = (ts.TotalDays > 7);
}
if (mobileNeedValiated)
{
sqlQuery = " UPDATE " + BaseUserContactEntity.TableName
+ " SET " + BaseUserContactEntity.FieldMobileValiated + " = 0 "
+ " WHERE " + BaseUserContactEntity.FieldId + " = " + DbHelper.GetParameter(BaseUserContactEntity.FieldId)
+ " AND " + BaseUserContactEntity.FieldMobileValiated + " = " + DbHelper.GetParameter(BaseUserContactEntity.FieldMobileValiated);
dbParameters = new List <IDbDataParameter>();
dbParameters.Add(DbHelper.MakeParameter(BaseUserContactEntity.FieldId, userLogOnEntity.Id));
dbParameters.Add(DbHelper.MakeParameter(BaseUserContactEntity.FieldMobileValiated, 1));
errorMark = 10;
dbHelper.ExecuteNonQuery(sqlQuery, dbParameters.ToArray());
}
}
if (BaseSystemInfo.UpdateVisit)
{
// 第一次登录时间
if (userLogOnEntity.FirstVisit == null)
{
sqlQuery = " UPDATE " + this.CurrentTableName
+ " SET " + BaseUserLogOnEntity.FieldPasswordErrorCount + " = 0 "
+ ", " + BaseUserLogOnEntity.FieldUserOnLine + " = 1 "
+ ", " + BaseUserLogOnEntity.FieldFirstVisit + " = " + dbHelper.GetDbNow()
+ ", " + BaseUserLogOnEntity.FieldLogOnCount + " = 1 "
+ ", " + BaseUserLogOnEntity.FieldSystemCode + " = " + dbHelper.GetParameter(BaseUserLogOnEntity.FieldSystemCode)
+ ", " + BaseUserLogOnEntity.FieldIPAddress + " = " + dbHelper.GetParameter(BaseUserLogOnEntity.FieldIPAddress)
+ ", " + BaseUserLogOnEntity.FieldIPAddressName + " = " + dbHelper.GetParameter(BaseUserLogOnEntity.FieldIPAddressName)
+ ", " + BaseUserLogOnEntity.FieldMACAddress + " = " + dbHelper.GetParameter(BaseUserLogOnEntity.FieldMACAddress)
+ ", " + BaseUserLogOnEntity.FieldComputerName + " = " + dbHelper.GetParameter(BaseUserLogOnEntity.FieldComputerName);
dbParameters = new List <IDbDataParameter>();
dbParameters.Add(dbHelper.MakeParameter(BaseUserLogOnEntity.FieldSystemCode, userLogOnEntity.SystemCode));
dbParameters.Add(dbHelper.MakeParameter(BaseUserLogOnEntity.FieldIPAddress, userLogOnEntity.IPAddress));
dbParameters.Add(dbHelper.MakeParameter(BaseUserLogOnEntity.FieldIPAddressName, userLogOnEntity.IPAddressName));
dbParameters.Add(dbHelper.MakeParameter(BaseUserLogOnEntity.FieldMACAddress, userLogOnEntity.MACAddress));
dbParameters.Add(dbHelper.MakeParameter(BaseUserLogOnEntity.FieldComputerName, userLogOnEntity.ComputerName));
if (createOpenId)
{
sqlQuery += ", " + BaseUserLogOnEntity.FieldOpenId + " = " + dbHelper.GetParameter(BaseUserLogOnEntity.FieldOpenId);
sqlQuery += ", " + BaseUserLogOnEntity.FieldOpenIdTimeout + " = " + dbHelper.GetParameter(BaseUserLogOnEntity.FieldOpenIdTimeout);
dbParameters.Add(dbHelper.MakeParameter(BaseUserLogOnEntity.FieldOpenId, openId));
dbParameters.Add(dbHelper.MakeParameter(BaseUserLogOnEntity.FieldOpenIdTimeout, openIdTimeout));
}
sqlQuery += " WHERE " + BaseUserLogOnEntity.FieldId + " = " + dbHelper.GetParameter(BaseUserLogOnEntity.FieldId)
+ " AND " + BaseUserLogOnEntity.FieldFirstVisit + " IS NULL";
dbParameters.Add(dbHelper.MakeParameter(BaseUserLogOnEntity.FieldId, userLogOnEntity.Id));
errorMark = 20;
dbHelper.ExecuteNonQuery(sqlQuery, dbParameters.ToArray());
}
else
{
// 最后一次登录时间
sqlQuery = " UPDATE " + this.CurrentTableName
+ " SET " + BaseUserLogOnEntity.FieldPasswordErrorCount + " = 0 "
+ ", " + BaseUserLogOnEntity.FieldPreviousVisit + " = " + BaseUserLogOnEntity.FieldLastVisit
+ ", " + BaseUserLogOnEntity.FieldUserOnLine + " = 1 "
+ ", " + BaseUserLogOnEntity.FieldLastVisit + " = " + dbHelper.GetDbNow()
+ ", " + BaseUserLogOnEntity.FieldLogOnCount + " = " + BaseUserLogOnEntity.FieldLogOnCount + " + 1 "
+ ", " + BaseUserLogOnEntity.FieldSystemCode + " = " + dbHelper.GetParameter(BaseUserLogOnEntity.FieldSystemCode)
+ ", " + BaseUserLogOnEntity.FieldIPAddress + " = " + dbHelper.GetParameter(BaseUserLogOnEntity.FieldIPAddress)
+ ", " + BaseUserLogOnEntity.FieldIPAddressName + " = " + dbHelper.GetParameter(BaseUserLogOnEntity.FieldIPAddressName)
+ ", " + BaseUserLogOnEntity.FieldMACAddress + " = " + dbHelper.GetParameter(BaseUserLogOnEntity.FieldMACAddress)
+ ", " + BaseUserLogOnEntity.FieldComputerName + " = " + dbHelper.GetParameter(BaseUserLogOnEntity.FieldComputerName);
dbParameters = new List <IDbDataParameter>();
dbParameters.Add(dbHelper.MakeParameter(BaseUserLogOnEntity.FieldSystemCode, userLogOnEntity.SystemCode));
dbParameters.Add(dbHelper.MakeParameter(BaseUserLogOnEntity.FieldIPAddress, userLogOnEntity.IPAddress));
dbParameters.Add(dbHelper.MakeParameter(BaseUserLogOnEntity.FieldIPAddressName, userLogOnEntity.IPAddressName));
dbParameters.Add(dbHelper.MakeParameter(BaseUserLogOnEntity.FieldMACAddress, userLogOnEntity.MACAddress));
dbParameters.Add(dbHelper.MakeParameter(BaseUserLogOnEntity.FieldComputerName, userLogOnEntity.ComputerName));
if (createOpenId)
{
sqlQuery += ", " + BaseUserLogOnEntity.FieldOpenId + " = " + dbHelper.GetParameter(BaseUserLogOnEntity.FieldOpenId);
sqlQuery += ", " + BaseUserLogOnEntity.FieldOpenIdTimeout + " = " + dbHelper.GetParameter(BaseUserLogOnEntity.FieldOpenIdTimeout);
dbParameters.Add(dbHelper.MakeParameter(BaseUserLogOnEntity.FieldOpenId, openId));
dbParameters.Add(dbHelper.MakeParameter(BaseUserLogOnEntity.FieldOpenIdTimeout, openIdTimeout));
}
sqlQuery += " WHERE " + BaseUserLogOnEntity.FieldId + " = " + dbHelper.GetParameter(BaseUserLogOnEntity.FieldId);
dbParameters.Add(dbHelper.MakeParameter(BaseUserLogOnEntity.FieldId, userLogOnEntity.Id));
errorMark = 30;
dbHelper.ExecuteNonQuery(sqlQuery, dbParameters.ToArray());
}
}
else
{
// 2015-12-08 吉日嘎拉，更新时参数化，提高效率 实现单点登录功能，每次都更换Guid
if (createOpenId)
{
sqlQuery = " UPDATE " + this.CurrentTableName
+ " SET " + BaseUserLogOnEntity.FieldPasswordErrorCount + " = " + dbHelper.GetParameter(BaseUserLogOnEntity.FieldPasswordErrorCount)
+ " , " + BaseUserLogOnEntity.FieldSystemCode + " = " + dbHelper.GetParameter(BaseUserLogOnEntity.FieldSystemCode)
+ " , " + BaseUserLogOnEntity.FieldOpenId + " = " + dbHelper.GetParameter(BaseUserLogOnEntity.FieldOpenId)
+ " , " + BaseUserLogOnEntity.FieldOpenIdTimeout + " = " + dbHelper.GetParameter(BaseUserLogOnEntity.FieldOpenIdTimeout)
+ " WHERE " + BaseUserLogOnEntity.FieldId + " = " + dbHelper.GetParameter(BaseUserLogOnEntity.FieldId);
// sqlQuery += " AND " + BaseUserEntity.FieldOpenId + " IS NULL ";
dbParameters = new List <IDbDataParameter>();
dbParameters.Add(dbHelper.MakeParameter(BaseUserLogOnEntity.FieldPasswordErrorCount, 0));
dbParameters.Add(dbHelper.MakeParameter(BaseUserLogOnEntity.FieldSystemCode, userLogOnEntity.SystemCode));
dbParameters.Add(dbHelper.MakeParameter(BaseUserLogOnEntity.FieldOpenId, openId));
dbParameters.Add(dbHelper.MakeParameter(BaseUserLogOnEntity.FieldOpenIdTimeout, openIdTimeout));
dbParameters.Add(dbHelper.MakeParameter(BaseUserLogOnEntity.FieldId, userLogOnEntity.Id));
errorMark = 40;
dbHelper.ExecuteNonQuery(sqlQuery, dbParameters.ToArray());
}
}
}
}
catch (System.Exception ex)
{
string writeMessage = "BaseUserLogOnManager.UpdateVisitDateTask:发生时间:" + DateTime.Now
+ System.Environment.NewLine + "errorMark = " + errorMark.ToString()
+ System.Environment.NewLine + "UserInfo:" + this.UserInfo.Serialize()
+ System.Environment.NewLine + "Message:" + ex.Message
+ System.Environment.NewLine + "Source:" + ex.Source
+ System.Environment.NewLine + "StackTrace:" + ex.StackTrace
+ System.Environment.NewLine + "TargetSite:" + ex.TargetSite
+ System.Environment.NewLine;
FileUtil.WriteMessage(writeMessage, BaseSystemInfo.StartupPath + "//Exception//Exception" + DateTime.Now.ToString(BaseSystemInfo.DateFormat) + ".txt");
}
}
/// <summary>
/// 添加实体
/// </summary>
/// <param name="entity">实体</param>
public string AddObject(BaseUserLogOnEntity entity)
{
string result = string.Empty;
if (string.IsNullOrEmpty(entity.Id))
{
BaseSequenceManager manager = new BaseSequenceManager(DbHelper, this.Identity);
result = manager.Increment(this.CurrentTableName);
entity.Id = result;
}
SQLBuilder sqlBuilder = new SQLBuilder(DbHelper, this.Identity, this.ReturnId);
sqlBuilder.BeginInsert(this.CurrentTableName, BaseUserLogOnEntity.FieldId);
if (!this.Identity)
{
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldId, entity.Id);
}
else
{
if (!this.ReturnId && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (DbHelper.CurrentDbType == CurrentDbType.Oracle)
{
sqlBuilder.SetFormula(BaseUserLogOnEntity.FieldId, "SEQ_" + this.CurrentTableName.ToUpper() + ".NEXTVAL ");
}
if (DbHelper.CurrentDbType == CurrentDbType.DB2)
{
sqlBuilder.SetFormula(BaseUserLogOnEntity.FieldId, "NEXT VALUE FOR SEQ_" + this.CurrentTableName.ToUpper());
}
}
else
{
if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
{
if (entity.Id == null)
{
if (string.IsNullOrEmpty(result))
{
BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper, this.Identity);
result = sequenceManager.Increment(this.CurrentTableName);
}
entity.Id = result;
}
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldId, entity.Id);
}
}
}
this.SetObject(sqlBuilder, entity);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldCreateUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldCreateBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseUserLogOnEntity.FieldCreateOn);
if (UserInfo != null)
{
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldModifiedUserId, UserInfo.Id);
sqlBuilder.SetValue(BaseUserLogOnEntity.FieldModifiedBy, UserInfo.RealName);
}
sqlBuilder.SetDBNow(BaseUserLogOnEntity.FieldModifiedOn);
if (DbHelper.CurrentDbType == CurrentDbType.SqlServer && this.Identity)
{
result = sqlBuilder.EndInsert().ToString();
}
else
{
sqlBuilder.EndInsert();
result = entity.Id;
}
return(result);
}
/// <summary>
/// 检查用户的 IPAddress 绑定是否正常
///
/// 防止重复多读数据？
/// 是否判断正确？
/// 可以按每个用户缓存？
/// 若没有就自动化增加？
/// IP 限制完善？
/// IP 限制缓存预热？
/// </summary>
/// <param name="userId">用户主键</param>
/// <param name="IPAddress">ip地址</param>
/// <param name="autoAdd">没有在列表的IP是否自动增加</param>
/// <returns>正确</returns>
public static bool CheckIPAddressByCache(BaseUserLogOnEntity userLogOnEntity, string ipAddress, bool autoAdd = false)
{
// 默认是不成功的，防止出错误
bool result = false;
if (userLogOnEntity == null)
{
return(result);
}
string userId = userLogOnEntity.Id;
// 检查参数的有效性
if (string.IsNullOrEmpty(userId))
{
return(result);
}
if (string.IsNullOrEmpty(ipAddress))
{
return(result);
}
// 若用户是不限制登录的、那就可以返回真的
if (!userLogOnEntity.CheckIPAddress.HasValue || userLogOnEntity.CheckIPAddress.Value == 0)
{
return(true);
}
// 提高效率，全小写转换
ipAddress = ipAddress.ToLower();
// 这里是处理，多个IP的问题
string[] ip = ipAddress.Split(';');
using (var redisClient = PooledRedisHelper.GetClient())
{
string key = "IP:" + userId;
// 若是缓存里过期了？
if (!redisClient.ContainsKey(key))
{
// 重新缓存用户的限制数据
if (CachePreheatingIPAddressByUser(redisClient, userId) == 0)
{
// 若没有设置IP限制，需要把限制都自动加上来。
// 没有加到数据的，就是表明是新增加的用户、第一次登录的用户
BaseParameterManager parameterManager = new BaseParameterManager();
for (int i = 0; i < ip.Length; i++)
{
if (!string.IsNullOrEmpty(ip[i]))
{
// 把收集过来的IP地址需要保存起来
BaseParameterEntity parameterEntity = new BaseParameterEntity();
parameterEntity.Id = Guid.NewGuid().ToString("N");
parameterEntity.CategoryCode = "IPAddress";
parameterEntity.ParameterCode = "Single";
parameterEntity.ParameterId = userId;
// 这里之际保存小写、就效率也高，省事了
parameterEntity.ParameterContent = ip[i].Trim();
parameterManager.Add(parameterEntity);
}
}
result = true;
}
}
// 若还是没有？表示是新增的
if (redisClient.ContainsKey(key))
{
// 若已经存在，就需要进行缓存里的判断？
// 这里要提高效率，不能反复打开缓存
for (int i = 0; i < ip.Length; i++)
{
// 这里对数据还不放心，进行优化处理
if (!string.IsNullOrEmpty(ip[i]))
{
ip[i] = ip[i].Trim();
result = redisClient.SetContainsItem(key, ip[i]);
if (result)
{
// 这里要提高判断的效率
break;
}
}
}
// 若没有验证成功、把当前的 IPAddress 保存起来, 方便后台管理的人加上去。
if (!result)
{
List <KeyValuePair <string, object> > parameters = new List <KeyValuePair <string, object> >();
parameters.Add(new KeyValuePair <string, object>(BaseUserLogOnEntity.FieldIPAddress, ipAddress));
BaseUserLogOnManager userLogOnManager = new BaseUserLogOnManager();
userLogOnManager.SetProperty(userId, parameters);
}
}
}
return(result);
}
/// <summary>
/// 添加
/// </summary>
/// <param name="entity">实体</param>
/// <returns>主键</returns>
public string Add(BaseUserLogOnEntity entity)
{
return(this.AddObject(entity));
}
/// <summary>
/// 添加
/// </summary>
/// <param name="entity">实体</param>
/// <param name="identity">自增量方式</param>
/// <param name="returnId">返回主鍵</param>
/// <returns>主键</returns>
public string Add(BaseUserLogOnEntity entity, bool identity, bool returnId)
{
this.Identity = identity;
this.ReturnId = returnId;
return(this.AddObject(entity));
}
