/// <summary>
        /// 将用户从某些角色中移除
        /// </summary>
        /// <param name="userInfo">用户</param>
        /// <param name="userId">用户主键</param>
        /// <param name="removeRoleIds">角色主键数组</param>
        /// <returns>影响行数</returns>
        public int RemoveUserFromRole(BaseUserInfo userInfo, string userId, string[] removeRoleIds)
        {
            // 写入调试信息
            #if (DEBUG)
            int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
            #endif

            // 加强安全验证防止未授权匿名调用
            #if (!DEBUG)
            LogOnService.UserIsLogOn(userInfo);
            #endif

            int returnValue = 0;
            using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
            {
                try
                {
                    dbHelper.Open(UserCenterDbConnection);
                    BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
                    if (removeRoleIds != null)
                    {
                        returnValue += userManager.RemoveFormRole(userId, removeRoleIds);
                    }
                    BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, MethodBase.GetCurrentMethod());
                }
                catch (Exception ex)
                {
                    BaseExceptionManager.LogException(dbHelper, userInfo, ex);
                    throw ex;
                }
                finally
                {
                    dbHelper.Close();
                }
            }

            // 写入调试信息
            #if (DEBUG)
            BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
            #endif

            return(returnValue);
        }
Exemple #2
0
        /// <summary>
        /// 撤销用户权限
        /// </summary>
        /// <param name="userInfo">用户</param>
        /// <param name="userName">用户名</param>
        /// <param name="permissionCode">权限编号</param>
        /// <returns>主键</returns>
        public int RevokeUserPermission(BaseUserInfo userInfo, string userName, string permissionCode)
        {
            int result = 0;

            var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());

            ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
            {
                var userManager = new BaseUserManager(dbHelper, userInfo);
                string userId   = userManager.GetId(new KeyValuePair <string, object>(BaseUserEntity.FieldUserName, userName));
                if (!String.IsNullOrEmpty(userId))
                {
                    var userPermissionManager = new BaseUserPermissionManager(dbHelper, userInfo);
                    result = userPermissionManager.RevokeByPermissionCode(userInfo.SystemCode, userId, permissionCode);
                }
            });

            return(result);
        }
        /// <summary>
        /// 用户退出
        /// </summary>
        /// <param name="openId">信令</param>
        /// <param name="systemCode">系统编码</param>
        /// <param name="ipAddress">IP地址</param>
        /// <param name="macAddress">MAC地址</param>
        /// <returns>影响行数</returns>
        public bool SignOut(string openId, string systemCode = "Base", string ipAddress = null, string macAddress = null)
        {
            var result = 0;

            // 应该进行一次日志记录
            // 从缓存读取、效率高
            if (!string.IsNullOrWhiteSpace(openId))
            {
                var userEntity = BaseUserManager.GetEntityByOpenIdByCache(openId);
                if (userEntity != null && userEntity.Id > 0)
                {
                    var ipAddressName = string.Empty;
                    if (!string.IsNullOrEmpty(ipAddress))
                    {
                        ipAddressName = IpUtil.GetInstance().FindName(ipAddress);
                    }

                    BaseLogonLogManager.AddLog(systemCode, userEntity, ipAddress, ipAddressName, macAddress, Status.SignOut.ToDescription(), 0, 1);

                    // 是否更新访问日期信息
                    if (!BaseSystemInfo.UpdateVisit)
                    {
                        return(result > 0);
                    }
                    // 最后一次登录时间
                    var sql = "UPDATE " + BaseUserLogonEntity.CurrentTableName + " SET " + BaseUserLogonEntity.FieldPreviousVisitTime + " = " + BaseUserLogonEntity.FieldLastVisitTime;
                    //Troy.Cui 2020-02-29用户退出时也强制OpenId重新生成,和登录时一样强制生成OpenId
                    sql += " , " + BaseUserLogonEntity.FieldOpenId + " = '" + Guid.NewGuid().ToString("N") + "'";
                    sql += ", " + BaseUserLogonEntity.FieldOpenIdTimeoutTime + " = " + DbHelper.GetDbNow();
                    sql += " , " + BaseUserLogonEntity.FieldUserOnline + " = 0 "
                           + " , " + BaseUserLogonEntity.FieldLastVisitTime + " = " + DbHelper.GetDbNow();
                    sql += "  WHERE " + BaseUserLogonEntity.FieldUserId + " = " + DbHelper.GetParameter(BaseUserEntity.FieldId);

                    var dbParameters = new List <IDbDataParameter>
                    {
                        DbHelper.MakeParameter(BaseUserEntity.FieldId, userEntity.Id)
                    };
                    result = ExecuteNonQuery(sql, dbParameters.ToArray());
                }
            }

            return(result > 0);
        }
        public string GetAllRolesId()
        {
            string[] roleIds       = new BaseUserManager().GetAllRoleIds(this.UserInfo.Id);
            string   roleIdsString = null;

            if (roleIds.Length > 0)
            {
                foreach (var roleId in roleIds)
                {
                    roleIdsString += roleId + ",";
                }
                if (!string.IsNullOrEmpty(roleIdsString))
                {
                    // 去掉末尾的","
                    roleIdsString = roleIdsString.TrimEnd(',');
                }
            }
            return(roleIdsString);
        }
Exemple #5
0
        /// <summary>
        /// 批量删除
        /// </summary>
        /// <param name="userInfo">用户</param>
        /// <param name="ids">主键数组</param>
        /// <returns>影响行数</returns>
        public int BatchDelete(BaseUserInfo userInfo, string[] ids)
        {
            // 写入调试信息
            #if (DEBUG)
            int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
            #endif

            // 加强安全验证防止未授权匿名调用
            #if (!DEBUG)
            LogOnService.UserIsLogOn(userInfo);
            #endif

            int returnValue = 0;
            using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
            {
                try
                {
                    dbHelper.Open(UserCenterDbConnection);
                    BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
                    returnValue = userManager.Delete(ids);
                    // 用户已经被删除的员工的UserId设置为Null,说白了,是需要整理数据
                    userManager.CheckUserStaff();
                    BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, MethodBase.GetCurrentMethod());
                }
                catch (Exception ex)
                {
                    BaseExceptionManager.LogException(dbHelper, userInfo, ex);
                    throw ex;
                }
                finally
                {
                    dbHelper.Close();
                }
            }

            // 写入调试信息
            #if (DEBUG)
            BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
            #endif

            return(returnValue);
        }
Exemple #6
0
        /// <summary>
        /// 更新用户
        /// </summary>
        /// <param name="userInfo">用户信息</param>
        /// <param name="userEntity">用户实体</param>
        /// <param name="statusCode">状态码</param>
        /// <param name="statusMessage">状态信息</param>
        /// <returns>影响行数</returns>
        public int UpdateUser(BaseUserInfo userInfo, BaseUserEntity userEntity, out string statusCode, out string statusMessage)
        {
            // 写入调试信息
            #if (DEBUG)
            int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
            #endif

            // 加强安全验证防止未授权匿名调用
            #if (!DEBUG)
            LogOnService.UserIsLogOn(userInfo);
            #endif

            int returnValue = 0;
            using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
            {
                try
                {
                    dbHelper.Open(UserCenterDbConnection);
                    BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
                    // 调用方法,并且返回运行结果
                    returnValue   = userManager.Update(userEntity, out statusCode);
                    statusMessage = userManager.GetStateMessage(statusCode);
                    BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.UserService_UpdateUser, MethodBase.GetCurrentMethod());
                }
                catch (Exception ex)
                {
                    BaseExceptionManager.LogException(dbHelper, userInfo, ex);
                    throw ex;
                }
                finally
                {
                    dbHelper.Close();
                }
            }

            // 写入调试信息
            #if (DEBUG)
            BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
            #endif

            return(returnValue);
        }
Exemple #7
0
        /// <summary>
        /// 添加用户
        /// </summary>
        /// <param name="dbHelper">数据库连接</param>
        /// <param name="userInfo">用户信息</param>
        /// <param name="userEntity">用户实体</param>
        /// <param name="statusCode">状态码</param>
        /// <param name="statusMessage">状态信息</param>
        /// <returns>主键</returns>
        public string AddUser(IDbHelper dbHelper, BaseUserInfo userInfo, BaseUserEntity userEntity, out string statusCode, out string statusMessage)
        {
            // 加强安全验证防止未授权匿名调用
            #if (!DEBUG)
            BaseSystemInfo.IsAuthorized(userInfo);
            #endif

            string          returnValue = string.Empty;
            BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
            // 若是系统需要用加密的密码,这里需要加密密码。
            if (BaseSystemInfo.ServerEncryptPassword)
            {
                userEntity.UserPassword = userManager.EncryptUserPassword(userEntity.UserPassword);
                // 安全通讯密码、交易密码也生成好
                userEntity.CommunicationPassword = userManager.EncryptUserPassword(userEntity.CommunicationPassword);
            }
            returnValue   = userManager.Add(userEntity, out statusCode);
            statusMessage = userManager.GetStateMessage(statusCode);
            // 自己不用给自己发提示信息,这个提示信息是为了提高工作效率的,还是需要审核通过的,否则垃圾信息太多了
            if (userEntity.Enabled == 0 && statusCode.Equals(StatusCode.OKAdd.ToString()))
            {
                // 不是系统管理员添加
                if (!userInfo.IsAdministrator)
                {
                    // 给超级管理员群组发信息
                    BaseRoleManager roleManager = new BaseRoleManager(dbHelper, userInfo);
                    string[]        roleIds     = roleManager.GetIds(new KeyValuePair <string, object>(BaseRoleEntity.FieldCode, "Administrators"));
                    string[]        userIds     = userManager.GetIds(new KeyValuePair <string, object>(BaseUserEntity.FieldCode, "Administrator"));
                    // 发送请求审核的信息
                    BaseMessageEntity messageEntity = new BaseMessageEntity();
                    messageEntity.FunctionCode = MessageFunction.WaitForAudit.ToString();

                    // Pcsky 2012.05.04 显示申请的用户名
                    messageEntity.Contents = userInfo.RealName + "(" + userInfo.IPAddress + ")" + AppMessage.UserService_Application + userEntity.UserName + AppMessage.UserService_Check;
                    //messageEntity.Contents = userInfo.RealName + "(" + userInfo.IPAddress + ")" + AppMessage.UserService_Application + userEntity.RealName + AppMessage.UserService_Check;

                    BaseMessageManager messageManager = new BaseMessageManager(dbHelper, userInfo);
                    messageManager.BatchSend(userIds, null, roleIds, messageEntity, false);
                }
            }
            return(returnValue);
        }
        /// <summary>
        /// 按角色获取用户列表
        /// </summary>
        /// <param name="userInfo">用户</param>
        /// <param name="roleId">角色主键</param>
        /// <returns>数据表</returns>
        public string[] GetUserByRole(BaseUserInfo userInfo, string roleId)
        {
            string[] result = null;

            var dt = new DataTable(BaseUserEntity.TableName);

            var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());

            ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
            {
                var userManager = new BaseUserManager(dbHelper, userInfo);
                string sqlQuery = "SELECT " + BaseUserEntity.FieldId + "," + BaseUserEntity.FieldRealName
                                  + " FROM " + BaseUserEntity.TableName;
                sqlQuery += " WHERE (" + BaseUserEntity.TableName + "." + BaseUserEntity.FieldDeletionStateCode + " = 0 "
                            + " AND " + BaseUserEntity.TableName + "." + BaseUserEntity.FieldEnabled + " = 1  "
                            + " AND " + BaseUserEntity.TableName + "." + BaseUserEntity.FieldIsVisible + " = 1 ) ";

                if (!String.IsNullOrEmpty(roleId))
                {
                    // 从用户读取用户
                    sqlQuery += " AND " + BaseUserEntity.FieldId + " IN ("
                                + "SELECT " + BaseUserRoleEntity.FieldUserId
                                + "   FROM " + BaseUserRoleEntity.TableName
                                + "  WHERE " + BaseUserRoleEntity.TableName + "." + BaseUserRoleEntity.FieldDeletionStateCode + " = 0  "
                                + "       AND " + BaseUserRoleEntity.TableName + "." + BaseUserRoleEntity.FieldEnabled + " = 1  "
                                + "       AND " + BaseUserRoleEntity.TableName + "." + BaseUserRoleEntity.FieldRoleId + " = '" + roleId + "') ";
                }
                sqlQuery += " ORDER BY " + BaseUserEntity.TableName + "." + BaseUserEntity.FieldSortCode;

                dt           = userManager.Fill(sqlQuery);
                dt.TableName = BaseUserEntity.TableName;

                List <string> list = new List <string>();
                foreach (DataRow dr in dt.Rows)
                {
                    list.Add(dr[BaseUserEntity.FieldId].ToString() + "=" + dr[BaseUserEntity.FieldRealName].ToString());
                }
                result = list.ToArray();
            });

            return(result);
        }
        /// <summary>
        /// 按角色获取用户列表
        /// </summary>
        /// <param name="userInfo">用户</param>
        /// <returns>数据权限</returns>
        public DataTable GetDataTableByRole(BaseUserInfo userInfo, string roleId)
        {
            // 写入调试信息
            #if (DEBUG)
            int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
            #endif

            // 加强安全验证防止未授权匿名调用
            #if (!DEBUG)
            LogOnService.UserIsLogOn(userInfo);
            #endif

            DataTable dataTable = new DataTable(BaseStaffEntity.TableName);
            using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
            {
                try
                {
                    dbHelper.Open(UserCenterDbConnection);
                    BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
                    // 获取允许登录列表
                    dataTable           = userManager.GetDataTableByRole(roleId);
                    dataTable.TableName = BaseUserEntity.TableName;
                    BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.UserService_GetDataTableByRole, MethodBase.GetCurrentMethod());
                }
                catch (Exception ex)
                {
                    BaseExceptionManager.LogException(dbHelper, userInfo, ex);
                    throw ex;
                }
                finally
                {
                    dbHelper.Close();
                }
            }

            // 写入调试信息
            #if (DEBUG)
            BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
            #endif

            return(dataTable);
        }
        /// <summary>
        /// 获取用户角色数据列表
        /// </summary>
        /// <param name="userInfo">用户</param>
        /// <param name="targetUserId">目标角色</param>
        /// <returns>数据表</returns>
        public DataTable GetDataTableByUser(BaseUserInfo userInfo, string targetUserId)
        {
            DataTable result = null;

            var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());

            ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
            {
                var tableName = userInfo.SystemCode + "UserRole";
                var manager   = new BaseUserManager(dbHelper, userInfo, tableName);
                var roleIds   = manager.GetRoleIds(userInfo.SystemCode, targetUserId);

                tableName        = userInfo.SystemCode + "Role";
                var roleManager  = new BaseRoleManager(dbHelper, userInfo, tableName);
                result           = roleManager.GetDataTable(BaseRoleEntity.FieldId, roleIds, BaseRoleEntity.FieldSortCode);
                result.TableName = BaseRoleEntity.CurrentTableName;
            });

            return(result);
        }
        /// <summary>
        /// 给用户权限
        /// </summary>
        /// <param name="userInfo">用户</param>
        /// <param name="userName">用户名</param>
        /// <param name="permissionCode">权限编号</param>
        /// <returns>主键</returns>
        public string GrantUserPermission(BaseUserInfo userInfo, string userName, string permissionCode)
        {
            var result = string.Empty;

            var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());

            ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (ServiceUtil.ProcessFun)((dbHelper) =>
            {
                var userManager = new BaseUserManager(dbHelper, userInfo);
                var userId      = userManager.GetId(new KeyValuePair <string, object>(BaseUserEntity.FieldUserName, userName));

                if (ValidateUtil.IsInt(userId))
                {
                    var userPermissionManager = new BasePermissionManager((IDbHelper)dbHelper, (BaseUserInfo)userInfo);
                    result = userPermissionManager.GrantByPermissionCode(userInfo.SystemCode, userId, permissionCode);
                }
            }));

            return(result);
        }
        /// <summary>
        /// 登录
        /// </summary>
        /// <param name="taskId">任务标识</param>
        /// <param name="userInfo">用户</param>
        /// <param name="nickName">昵称</param>
        /// <param name="password">密码</param>
        /// <param name="openId">单点登录标识</param>
        /// <returns>登录实体类</returns>
        public UserLogonResult LogonByNickName(string taskId, BaseUserInfo userInfo, string nickName, string password, string openId)
        {
            var result = new UserLogonResult();

            var parameter = ServiceInfo.Create(taskId, userInfo, MethodBase.GetCurrentMethod());

            ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
            {
                // 先侦测是否在线
                // userLogonManager.CheckOnline();
                // 再进行登录
                var userManager = new BaseUserManager(userInfo)
                {
                    CheckIsAdministrator = true
                };
                result = userManager.LogonByNickName(nickName, password, openId, userInfo.SystemCode);
            });

            return(result);
        }
Exemple #13
0
        /// <summary>
        /// 清除角色权限
        ///
        /// 1.清除角色的用户归属。
        /// 2.清除角色的模块权限。
        /// 3.清除角色的操作权限。
        /// </summary>
        /// <param name="userInfo">用户</param>
        /// <param name="id">主键</param>
        /// <returns>数据表</returns>
        public int ClearRolePermission(BaseUserInfo userInfo, string id)
        {
            var result = 0;

            var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());

            ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (dbHelper) =>
            {
                var userManager = new BaseUserManager(dbHelper, userInfo);
                result         += userManager.ClearUser(userInfo.SystemCode, id);

                var rolePermissionManager = new BasePermissionManager(dbHelper, userInfo);
                result += rolePermissionManager.RevokeRoleAll(userInfo.SystemCode, id);

                var roleScopeManager = new BaseRoleScopeManager(dbHelper, userInfo);
                result += roleScopeManager.RevokeAll(userInfo.SystemCode, id);
            });

            return(result);
        }
Exemple #14
0
        /// <summary>
        /// 缓存预热,强制重新缓存
        /// </summary>
        /// <returns>影响行数</returns>
        public static int CachePreheating()
        {
            int result = 0;

            // 把所有的数据都缓存起来的代码
            BaseUserManager manager = new BaseUserManager();

            using (IDataReader dataReader = manager.ExecuteReader(0, BaseUserEntity.FieldId))
            {
                while (dataReader.Read())
                {
                    BaseUserEntity entity = BaseEntity.Create <BaseUserEntity>(dataReader, false);
                    BaseUserManager.SetCache(entity);
                    result++;
                }
                dataReader.Close();
            }

            return(result);
        }
Exemple #15
0
        /// <summary>
        /// 激活帐户
        /// </summary>
        /// <param name="openId">唯一识别码</param>
        /// <param name="statusCode">返回状态码</param>
        /// <returns>用户实体</returns>
        public BaseUserInfo AccountActivation(string openId, out string statusCode)
        {
            // 1.用户是否存在?
            BaseUserInfo userInfo = null;

            // 用户没有找到状态
            statusCode = StatusCode.UserNotFound.ToString();
            // 检查是否有效的合法的参数
            if (!String.IsNullOrEmpty(openId))
            {
                BaseUserManager userManager = new BaseUserManager(DbHelper);
                List <KeyValuePair <string, object> > parameters = new List <KeyValuePair <string, object> >();
                parameters.Add(new KeyValuePair <string, object>(BaseUserEntity.FieldOpenId, openId));
                parameters.Add(new KeyValuePair <string, object>(BaseUserEntity.FieldDeletionStateCode, 0));
                DataTable dataTable = userManager.GetDataTable(parameters);
                if (dataTable.Rows.Count == 1)
                {
                    BaseUserEntity userEntity = new BaseUserEntity(dataTable);
                    // 3.用户是否被锁定?
                    if (userEntity.Enabled == 0)
                    {
                        statusCode = StatusCode.UserLocked.ToString();
                        return(userInfo);
                    }
                    if (userEntity.Enabled == 1)
                    {
                        // 2.用户是否已经被激活?
                        statusCode = StatusCode.UserIsActivate.ToString();
                        return(userInfo);
                    }
                    if (userEntity.Enabled == -1)
                    {
                        // 4.成功激活用户
                        statusCode = StatusCode.OK.ToString();
                        userManager.SetProperty(new KeyValuePair <string, object>(BaseUserEntity.FieldId, userEntity.Id), new KeyValuePair <string, object>(BaseUserEntity.FieldEnabled, 1));
                        return(userInfo);
                    }
                }
            }
            return(userInfo);
        }
Exemple #16
0
        /// <summary>
        /// 验证用户数字签名密码
        /// </summary>
        /// <param name="userInfo">用户</param>
        /// <param name="signedPassword">验证数字签名密码</param>
        /// <param name="ipAddress">IP地址</param>
        /// <param name="statusCode">返回状态码</param>
        /// <param name="statusMessage">返回状消息</param>
        /// <returns>是否正确</returns>
        public bool SignedPassword(BaseUserInfo userInfo, string signedPassword)
        {
            // 写入调试信息
            #if (DEBUG)
            int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
            #endif

            // 加强安全验证防止未授权匿名调用
            #if (!DEBUG)
            LogOnService.UserIsLogOn(userInfo);
            #endif

            bool returnValue = false;

            using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
            {
                try
                {
                    dbHelper.Open(UserCenterDbConnection);
                    BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
                    returnValue = userManager.SignedPassword(signedPassword);
                    BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.LogOnService_SignedPassword, MethodBase.GetCurrentMethod());
                }
                catch (Exception ex)
                {
                    BaseExceptionManager.LogException(dbHelper, userInfo, ex);
                    throw ex;
                }
                finally
                {
                    dbHelper.Close();
                }
            }

            // 写入调试信息
            #if (DEBUG)
            BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
            #endif

            return(returnValue);
        }
Exemple #17
0
        /// <summary>
        /// 激活帐户
        /// </summary>
        /// <param name="openId">唯一识别码</param>
        /// <returns>用户实体</returns>
        public BaseUserInfo AccountActivation(string openId)
        {
            // 1.用户是否存在?
            BaseUserInfo userInfo = null;

            // 用户没有找到状态
            this.StatusCode = Status.UserNotFound.ToString();
            // 检查是否有效的合法的参数
            if (!String.IsNullOrEmpty(openId))
            {
                BaseUserManager manager = new BaseUserManager(DbHelper);
                List <KeyValuePair <string, object> > parameters = new List <KeyValuePair <string, object> >();
                // parameters.Add(new KeyValuePair<string, object>(BaseUserEntity.FieldOpenId, openId));
                parameters.Add(new KeyValuePair <string, object>(BaseUserEntity.FieldDeletionStateCode, 0));
                var dt = manager.GetDataTable(parameters);
                if (dt.Rows.Count == 1)
                {
                    BaseUserEntity entity = BaseEntity.Create <BaseUserEntity>(dt);
                    // 3.用户是否被锁定?
                    if (entity.Enabled == 0)
                    {
                        this.StatusCode = Status.UserLocked.ToString();
                        return(userInfo);
                    }
                    if (entity.Enabled == 1)
                    {
                        // 2.用户是否已经被激活?
                        this.StatusCode = Status.UserIsActivate.ToString();
                        return(userInfo);
                    }
                    if (entity.Enabled == -1)
                    {
                        // 4.成功激活用户
                        this.StatusCode = Status.OK.ToString();
                        manager.SetProperty(new KeyValuePair <string, object>(BaseUserEntity.FieldId, entity.Id), new KeyValuePair <string, object>(BaseUserEntity.FieldEnabled, 1));
                        return(userInfo);
                    }
                }
            }
            return(userInfo);
        }
        /// <summary>
        /// 检查在线状态
        /// </summary>
        /// <param name="userInfo">用户</param>
        /// <param name="onLineState">用户在线状态</param>
        /// <returns>离线人数</returns>
        public int CheckOnLine(BaseUserInfo userInfo, int onLineState)
        {
            // 写入调试信息
            #if (DEBUG)
            // int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
            #endif

            // 加强安全验证防止未授权匿名调用
            #if (!DEBUG)
            LogOnService.UserIsLogOn(userInfo);
            #endif

            int returnValue = 0;
            using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
            {
                try
                {
                    dbHelper.Open(UserCenterDbConnection);
                    BaseUserManager userManager = new BaseUserManager(dbHelper);
                    // 设置为在线状态
                    userManager.OnLine(userInfo.Id, onLineState);
                    returnValue = userManager.CheckOnLine();
                }
                catch (Exception ex)
                {
                    LogUtil.WriteException(ex);
                    throw ex;
                }
                finally
                {
                    dbHelper.Close();
                }
            }

            // 写入调试信息
            #if (DEBUG)
            // BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
            #endif

            return(returnValue);
        }
        /// <summary>
        /// 批量设置默认角色
        /// </summary>
        /// <param name="userInfo"></param>
        /// <param name="userIds"></param>
        /// <param name="roleId"></param>
        /// <returns>影响行数</returns>
        public int BatchSetDefaultRole(BaseUserInfo userInfo, string[] userIds, string roleId)
        {
            // 写入调试信息
            #if (DEBUG)
            int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
            #endif

            // 加强安全验证防止未授权匿名调用
            #if (!DEBUG)
            LogOnService.UserIsLogOn(userInfo);
            #endif

            int returnValue = 0;
            using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
            {
                try
                {
                    dbHelper.Open(UserCenterDbConnection);
                    BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
                    returnValue = userManager.SetProperty(userIds, new KeyValuePair <string, object>(BaseUserEntity.FieldRoleId, roleId));

                    BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, MethodBase.GetCurrentMethod());
                }
                catch (Exception ex)
                {
                    BaseExceptionManager.LogException(dbHelper, userInfo, ex);
                    throw ex;
                }
                finally
                {
                    dbHelper.Close();
                }
            }

            // 写入调试信息
            #if (DEBUG)
            BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
            #endif

            return(returnValue);
        }
Exemple #20
0
        //////////////////////////////////////////////////////////////////////////////////////////////////////
        /// 用户权限判断相关(需要实现对外调用)
        //////////////////////////////////////////////////////////////////////////////////////////////////////

        #region public bool IsInRole(BaseUserInfo userInfo, string userId, string roleName)
        /// <summary>
        /// 用户是否在指定的角色里
        /// </summary>
        /// <param name="userInfo">用户</param>
        /// <param name="UserId">用户主键</param>
        /// <param name="roleName">角色名称</param>
        /// <returns>在角色里</returns>
        public bool IsInRole(BaseUserInfo userInfo, string userId, string roleName)
        {
            bool result = false;

            var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());

            ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
            {
                // 先获得角色主键
                string tableName = userInfo.SystemCode + "Role";
                var roleManager  = new BaseRoleManager(dbHelper, userInfo, tableName);
                string roleCode  = roleManager.GetProperty(new KeyValuePair <string, object>(BaseRoleEntity.FieldRealName, roleName), BaseRoleEntity.FieldCode);
                // 判断用户的默认角色
                if (!string.IsNullOrEmpty(roleCode))
                {
                    var userManager = new BaseUserManager(dbHelper, userInfo);
                    result          = userManager.IsInRoleByCode(userId, roleCode);
                }
            });
            return(result);
        }
Exemple #21
0
        public static BaseUserEntity GetObjectByNickNameByCache(BaseUserInfo userInfo, string nickName)
        {
            BaseUserEntity result = null;

            if (string.IsNullOrEmpty(nickName))
            {
                return(result);
            }

            string key = "User:ByNickName:" + nickName.ToLower();

            result = BaseUserManager.GetObjectByNickNameByCache(key);

            // 远程通过接口获取数据
            if (result == null)
            {
                result = GetObjectByNickName(userInfo, nickName);
            }

            return(result);
        }
Exemple #22
0
        /// <summary>
        /// 获取待审批
        /// </summary>
        /// <param name="userInfo">用户信息</param>
        /// <param name="userId">用户主键</param>
        /// <param name="categoryCode">分类代码</param>
        /// <param name="categorybillFullName">单据分类名称</param>
        /// <param name="searchValue">查询字符串</param>
        /// <returns></returns>
        public DataTable GetWaitForAudit(BaseUserInfo userInfo, string userId = null, string categoryCode = null, string categorybillFullName = null, string searchValue = null)
        {
            DataTable dt = null;

            var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());

            ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
            {
                //BaseUserManager userManager = new BaseUserManager(dbHelper);
                var userManager  = new BaseUserManager(dbHelper, userInfo);
                string[] roleIds = userManager.GetRoleIds(userInfo.Id);
                dbHelper.Close();
                // 这里是获取待审核信息
                dbHelper.Open(WorkFlowDbConnection);
                var workFlowCurrentManager = new BaseWorkFlowCurrentManager(dbHelper, userInfo);
                dt           = workFlowCurrentManager.GetWaitForAudit(userId, categoryCode, categorybillFullName, searchValue);
                dt.TableName = BaseWorkFlowCurrentEntity.TableName;
            });

            return(dt);
        }
        /// <summary>
        /// 获取参数列表
        /// </summary>
        /// <param name="userInfo">用户</param>
        /// <param name="categoryCode">分类编号</param>
        /// <param name="parameterId">参数主键</param>
        /// <returns>数据表</returns>
        public DataTable GetDataTableByParameter(BaseUserInfo userInfo, string categoryCode, string parameterId)
        {
            var result = new DataTable(BaseParameterEntity.CurrentTableName);

            var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());

            ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
            {
                var manager      = new BaseParameterManager(dbHelper, userInfo);
                result           = manager.GetDataTableByParameter(categoryCode, parameterId);
                result.TableName = BaseParameterEntity.CurrentTableName;

                // 2015-12-21 吉日嘎拉,这里重新设置mac缓存,删除掉缓存。
                if (categoryCode.Equals("MacAddress"))
                {
                    BaseUserManager.ResetMacAddressByCache(parameterId);
                }
            });

            return(result);
        }
Exemple #24
0
        /// <summary>
        /// 获取用户实体
        /// </summary>
        /// <param name="userInfo">用户</param>
        /// <param name="id">主键</param>
        /// <returns>实体</returns>
        public BaseUserEntity GetEntity(BaseUserInfo userInfo, string id)
        {
            // 写入调试信息
            #if (DEBUG)
            int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
            #endif

            // 加强安全验证防止未授权匿名调用
            #if (!DEBUG)
            LogOnService.UserIsLogOn(userInfo);
            #endif

            BaseUserEntity userEntity = null;
            using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
            {
                try
                {
                    dbHelper.Open(UserCenterDbConnection);
                    BaseUserManager userManager = new BaseUserManager(dbHelper, userInfo);
                    userEntity = userManager.GetEntity(id);
                    BaseLogManager.Instance.Add(dbHelper, userInfo, this.serviceName, AppMessage.UserService_GetEntity, MethodBase.GetCurrentMethod());
                }
                catch (Exception ex)
                {
                    BaseExceptionManager.LogException(dbHelper, userInfo, ex);
                    throw ex;
                }
                finally
                {
                    dbHelper.Close();
                }
            }

            // 写入调试信息
            #if (DEBUG)
            BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
            #endif

            return(userEntity);
        }
Exemple #25
0
        /// <summary>
        /// 获得用户列表
        /// </summary>
        /// <param name="taskId">任务标识</param>
        /// <param name="userInfo">用户</param>
        /// <returns>数据表</returns>
        public DataTable GetUserDT(string taskId, BaseUserInfo userInfo)
        {
            var result = new DataTable(BaseUserEntity.TableName);

            var parameter = ServiceInfo.Create(taskId, userInfo, MethodBase.GetCurrentMethod());

            ServiceUtil.ProcessUserCenterReadDb(userInfo, parameter, (dbHelper) =>
            {
                // 检查用户在线状态(服务器专用)
                BaseUserLogOnManager userLogOnManager = new BaseUserLogOnManager();
                userLogOnManager.CheckOnLine();
                var userManager = new BaseUserManager(dbHelper, userInfo);
                // 获取允许登录列表
                List <KeyValuePair <string, object> > parameters = new List <KeyValuePair <string, object> >();
                parameters.Add(new KeyValuePair <string, object>(BaseUserEntity.FieldEnabled, 1));
                parameters.Add(new KeyValuePair <string, object>(BaseUserEntity.FieldDeletionStateCode, 0));
                result           = userManager.GetDataTable(parameters, BaseUserEntity.FieldSortCode);
                result.TableName = BaseUserEntity.TableName;
            });

            return(result);
        }
Exemple #26
0
        /// <summary>
        /// 用户名是否重复
        /// </summary>
        /// <param name="userInfo">用户</param>
        /// <param name="parameters">字段名,字段值</param>
        /// <returns>已存在</returns>
        public bool Exists(BaseUserInfo userInfo, List <KeyValuePair <string, object> > parameters)
        {
            // 写入调试信息
            #if (DEBUG)
            int milliStart = BaseBusinessLogic.StartDebug(userInfo, MethodBase.GetCurrentMethod());
            #endif

            // 加强安全验证防止未授权匿名调用
            #if (!DEBUG)
            LogOnService.UserIsLogOn(userInfo);
            #endif

            bool returnValue = false;
            using (IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType))
            {
                try
                {
                    dbHelper.Open(UserCenterDbConnection);
                    BaseUserManager userManager = new BaseUserManager(dbHelper);
                    returnValue = userManager.Exists(parameters);
                }
                catch (Exception ex)
                {
                    BaseExceptionManager.LogException(dbHelper, userInfo, ex);
                    throw ex;
                }
                finally
                {
                    dbHelper.Close();
                }
            }

            // 写入调试信息
            #if (DEBUG)
            BaseBusinessLogic.EndDebug(MethodBase.GetCurrentMethod(), milliStart);
            #endif

            return(returnValue);
        }
        /// <summary>
        /// 清除用户权限
        ///
        /// 1.清除用户的角色归属。
        /// 2.清除用户的模块权限。
        /// 3.清除用户的操作权限。
        /// </summary>
        /// <param name="userInfo">用户</param>
        /// <param name="userId">用户主键</param>
        /// <returns>数据表</returns>
        public int ClearUserPermission(BaseUserInfo userInfo, string userId)
        {
            var result = 0;

            var parameter = ServiceInfo.Create(userInfo, MethodBase.GetCurrentMethod());

            ServiceUtil.ProcessUserCenterWriteDb(userInfo, parameter, (ServiceUtil.ProcessFun)((dbHelper) =>
            {
                var systemCode = userInfo.SystemCode;

                var userManager = new BaseUserManager(dbHelper, userInfo);
                result         += userManager.ClearRole(systemCode, userId);

                var userPermissionManager = new BasePermissionManager((IDbHelper)dbHelper, (BaseUserInfo)userInfo);
                result += userPermissionManager.RevokeUserAll(systemCode, userId);

                var userPermissionScopeManager = new BaseUserScopeManager(dbHelper, userInfo);
                result += userPermissionScopeManager.RevokeAll(systemCode, userId);
            }));

            return(result);
        }
Exemple #28
0
        /// <summary>
        /// 缓存预热,强制重新缓存
        /// </summary>
        /// <returns>影响行数</returns>
        public static int CachePreheating()
        {
            var result = 0;

            // 把所有的数据都缓存起来的代码
            var manager    = new BaseUserManager();
            var dataReader = manager.ExecuteReader(0, BaseUserEntity.FieldId);

            if (dataReader != null && !dataReader.IsClosed)
            {
                while (dataReader.Read())
                {
                    var entity = BaseEntity.Create <BaseUserEntity>(dataReader, false);
                    SetCache(entity);
                    result++;
                }

                dataReader.Close();
            }

            return(result);
        }
Exemple #29
0
        /// <summary>
        /// 为了提高授权的运行速度
        /// </summary>
        /// <param name="systemCode">系统编号</param>
        /// <param name="userId">用户主键</param>
        /// <param name="roleId">角色主键</param>
        /// <param name="enabled">有效状态</param>
        /// <returns>主键</returns>
        public string AddToRoleById(string systemCode, string userId, string roleId, bool enabled = true)
        {
            string result = string.Empty;

            if (string.IsNullOrEmpty(systemCode))
            {
                systemCode = "Base";
            }
            string tableName = string.Empty;

            if (!string.IsNullOrEmpty(userId) && !string.IsNullOrEmpty(roleId))
            {
                BaseUserRoleEntity entity = new BaseUserRoleEntity();
                entity.UserId            = userId;
                entity.RoleId            = roleId;
                entity.Enabled           = enabled ? 1 : 0;
                entity.DeletionStateCode = 0;
                // 2016-03-02 吉日嘎拉 增加按公司可以区别数据的功能。
                if (this.DbHelper.CurrentDbType == CurrentDbType.MySql)
                {
                    entity.CompanyId = BaseUserManager.GetCompanyIdByCache(userId);
                }
                // 2015-12-05 吉日嘎拉 把修改人记录起来,若是新增加的
                if (this.UserInfo != null)
                {
                    entity.CreateUserId   = this.UserInfo.Id;
                    entity.CreateBy       = this.UserInfo.RealName;
                    entity.CreateOn       = System.DateTime.Now;
                    entity.ModifiedUserId = this.UserInfo.Id;
                    entity.ModifiedBy     = this.UserInfo.RealName;
                    entity.ModifiedOn     = System.DateTime.Now;
                }
                tableName = systemCode + "UserRole";
                BaseUserRoleManager manager = new BaseUserRoleManager(this.DbHelper, this.UserInfo, tableName);
                result = manager.Add(entity);
            }

            return(result);
        }
 public string[] GetUserIds(string[] organizeIds, string[] roleIds)
 {
     // 要注意不能重复发信息,只能发一次。
     string[] companyUsers    = null; // 按公司查找用户
     string[] departmentUsers = null; // 按部门查找用户
     string[] workgroupUsers  = null; // 按工作组查找用户
     if (organizeIds != null)
     {
         // 这里获得的是用户主键,不是员工主键
         companyUsers    = this.GetProperties(BaseUserEntity.FieldCompanyId, organizeIds, BaseUserEntity.FieldId);
         departmentUsers = this.GetProperties(BaseUserEntity.FieldDepartmentId, organizeIds, BaseUserEntity.FieldId);
         workgroupUsers  = this.GetProperties(BaseUserEntity.FieldWorkgroupId, organizeIds, BaseUserEntity.FieldId);
     }
     string[] roleUsers = null;
     if (roleIds != null)
     {
         BaseUserManager userManager = new BaseUserManager(DbHelper);
         roleUsers = userManager.GetUserIds(roleIds);
     }
     string[] userIds = StringUtil.Concat(companyUsers, departmentUsers, workgroupUsers, roleUsers);
     return(userIds);
 }