DigitalScholl/Learun.Framework.Ultimate V7/Learun.Application.Organization/User/UserBLL.cs

using Learun.Cache.Base;
using Learun.Cache.Factory;
using Learun.Util;
using System;
using System.Collections.Generic;
using System.Data;
using System.Drawing;
using Learun.Application.WeChat;
using System.Configuration;
using System.IO;
using System.Linq;
using System.Text;

namespace Learun.Application.Organization
{
    /// <summary>
    /// 版 本 Learun-ADMS-Ultimate V7.0.0 数字化智慧校园 
    /// Copyright (c) 2013-2018 北京泉江科技有限公司 
    /// 创建人：陈彬彬
    /// 日 期：2017.03.06
    /// 描 述：用户模块业务类
    /// </summary>
    public class UserBLL : UserIBLL
    {
        #region  属性
        private UserService userService = new UserService();
        private DepartmentIBLL departmentIBLL = new DepartmentBLL();
        #endregion

        #region  缓存定义
        private ICache cache = CacheFactory.CaChe();
        private string cacheKey = "learun_adms_user_";       // +公司主键
        private string cacheKeyAccount = "learun_adms_user_account_";// +用户账号（账号不允许改动）
        private string cacheKeyId = "learun_adms_user_Id_";// +用户账号（账号不允许改动）
        #endregion

        #region  获取数据
        /// <summary>
        /// 用户列表(根据公司主键)
        /// </summary>
        /// <param name="companyId">公司主键</param>
        /// <returns></returns>
        public List<UserEntity> GetList(string companyId)
        {
            try
            {
                if (string.IsNullOrEmpty(companyId))
                {
                    return new List<UserEntity>();
                }

                List<UserEntity> list = cache.Read<List<UserEntity>>(cacheKey + companyId, CacheId.user);
                if (list == null)
                {
                    list = (List<UserEntity>)userService.GetList(companyId);
                    cache.Write<List<UserEntity>>(cacheKey + companyId, list, CacheId.user);
                }
                return list;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }
        /// <summary>
        /// 用户列表(根据公司主键,部门主键)
        /// </summary>
        /// <param name="companyId">公司主键</param>
        /// <param name="departmentId">部门主键</param>
        /// <param name="keyword">查询关键词</param>
        /// <returns></returns>
        public List<UserEntity> GetList(string companyId, string departmentId, string keyword)
        {
            try
            {


                List<UserEntity> list = GetList(companyId);
                if (!string.IsNullOrEmpty(departmentId))
                {
                    list = list.FindAll(t => t.F_DepartmentId.ContainsEx(departmentId));
                }
                if (!string.IsNullOrEmpty(keyword))
                {
                    list = list.FindAll(t => t.F_RealName.ContainsEx(keyword) || t.F_Account.ContainsEx(keyword));
                }
                return list;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }

        public bool GetAny()
        {
            try
            {

                return userService.GetAny();
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }


        public bool GetStuAny()
        {
            try
            {

                return userService.GetStuAny();
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }
        /// <summary>
        /// 用户列表(全部)
        /// </summary>
        /// <returns></returns>
        public List<UserEntity> GetAllList()
        {
            try
            {
                return (List<UserEntity>)userService.GetAllList();
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }

        public void UpdateEntity(UserEntity entity)
        {
            try
            {
                userService.UpdateEntity(entity);

            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }

        /// <summary>
        /// 用户列表(根据部门主键)
        /// </summary>
        /// <param name="departmentId">部门主键</param>
        /// <returns></returns>
        public List<UserEntity> GetListByDepartmentId(string departmentId)
        {
            try
            {
                if (string.IsNullOrEmpty(departmentId))
                {
                    return new List<UserEntity>();
                }
                DepartmentEntity departmentEntity = departmentIBLL.GetEntity(departmentId);
                if (departmentEntity == null)
                {
                    return new List<UserEntity>();
                }
                return GetList(departmentEntity.F_CompanyId, departmentId, "");
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }
        /// <summary>
        /// 用户列表(根据部门主键)
        /// </summary>
        /// <param name="departmentId">部门主键</param>
        /// <returns></returns>
        public List<UserEntity> GetListByDepartmentIds(string departmentId)
        {
            try
            {
                return userService.GetListByDepartmentIds(departmentId);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }
        public List<UserEntity> GetUserByDepartmentId(string departmentId)
        {
            try
            {
                return userService.GetUserByDepartmentId(departmentId);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }

        /// <summary>
        /// 获取分页数据
        /// </summary>
        /// <param name="companyId">公司主键</param>
        /// <param name="departmentId">部门主键</param>
        /// <param name="pagination">分页参数</param>
        /// <param name="keyword">查询关键词</param>
        /// <param name="tp">0 教师 1学生</param>
        /// <returns></returns>
        public List<UserEntity> GetPageList(string companyId, string departmentId, Pagination pagination, string keyword, string tp)
        {
            try
            {
                return (List<UserEntity>)userService.GetPageList(companyId, departmentId, pagination, keyword, tp);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }
        /// <summary>
        /// 用户列表（导出Excel）
        /// </summary>
        /// <returns></returns>
        public void GetExportList()
        {
            try
            {
                //取出数据源
                DataTable exportTable = userService.GetExportList();
                //设置导出格式
                ExcelConfig excelconfig = new ExcelConfig();
                excelconfig.Title = "教师用户导出";
                excelconfig.TitleFont = "微软雅黑";
                excelconfig.TitlePoint = 25;
                excelconfig.FileName = "教师用户导出.xls";
                excelconfig.IsAllSizeColumn = true;
                //每一列的设置,没有设置的列信息，系统将按datatable中的列名导出
                excelconfig.ColumnEntity = new List<ColumnModel>();
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_account", ExcelColumn = "账户" });
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_realname", ExcelColumn = "姓名" });
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_gender", ExcelColumn = "性别" });
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_enabledmark", ExcelColumn = "状态" });
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_birthday", ExcelColumn = "生日" });
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_mobile", ExcelColumn = "手机" });
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_telephone", ExcelColumn = "电话" });
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_wechat", ExcelColumn = "微信" });
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_company", ExcelColumn = "学校" });
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_department", ExcelColumn = "部门" });
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_description", ExcelColumn = "说明" });
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_createdate", ExcelColumn = "创建日期" });
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_createusername", ExcelColumn = "创建人" });
                //调用导出方法
                ExcelHelper.ExcelDownload(exportTable, excelconfig);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }
        /// <summary>
        /// 用户列表（导出Excel）【学生】
        /// </summary>
        /// <returns></returns>
        public void GetExportListOfStudent()
        {
            try
            {
                //取出数据源
                DataTable exportTable = userService.GetExportListOfStudent();
                //设置导出格式
                ExcelConfig excelconfig = new ExcelConfig();
                excelconfig.Title = "学生用户导出";
                excelconfig.TitleFont = "微软雅黑";
                excelconfig.TitlePoint = 25;
                excelconfig.FileName = "学生用户导出.xls";
                excelconfig.IsAllSizeColumn = true;
                //每一列的设置,没有设置的列信息，系统将按datatable中的列名导出
                excelconfig.ColumnEntity = new List<ColumnModel>();
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_account", ExcelColumn = "账户" });
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_realname", ExcelColumn = "姓名" });
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_gender", ExcelColumn = "性别" });
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_birthday", ExcelColumn = "生日" });
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_mobile", ExcelColumn = "手机" });
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_telephone", ExcelColumn = "电话" });
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_wechat", ExcelColumn = "微信" });
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_company", ExcelColumn = "学校" });
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_department", ExcelColumn = "系部" });
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_description", ExcelColumn = "说明" });
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_createdate", ExcelColumn = "创建日期" });
                excelconfig.ColumnEntity.Add(new ColumnModel() { Column = "f_createusername", ExcelColumn = "创建人" });
                //调用导出方法
                ExcelHelper.ExcelDownload(exportTable, excelconfig);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }
        /// <summary>
        /// 获取实体,通过用户账号
        /// </summary>
        /// <param name="account">用户账号</param>
        /// <returns></returns>
        public UserEntity GetEntityByAccount(string account)
        {
            try
            {
                UserEntity userEntity;
                userEntity = userService.GetEntityByAccount(account);
                return userEntity;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }
        /// <summary>
        /// 获取实体,通过身份证号
        /// </summary>
        /// <param name="idcard">身份证号</param>
        /// <returns></returns>
        public UserEntity GetEntityByIdCard(string idcard)
        {
            try
            {
                UserEntity userEntity;
                userEntity = userService.GetEntityByIdCard(idcard);
                return userEntity;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }
        /// <summary>
        /// 获取实体,通过用户名
        /// </summary>
        /// <param name="account">用户账号</param>
        /// <returns></returns>
        public UserEntity GetEntityByName(string name)
        {
            try
            {
                UserEntity userEntity;
                userEntity = userService.GetEntityByName(name);
                return userEntity;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }

        public void UpdateIp(string ip, string id)
        {
            try
            {
                userService.UpdateIp(ip, id);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }

        /// <summary>
        /// 获取用户数据
        /// </summary>
        /// <param name="userId">用户主键</param>
        /// <returns></returns>
        public UserEntity GetEntityByUserId(string userId)
        {
            try
            {
                UserEntity userEntity = cache.Read<UserEntity>(cacheKeyId + userId, CacheId.user);
                //if (userEntity == null)
                //{
                userEntity = userService.GetEntity(userId);
                if (userEntity != null)
                {
                    cache.Write<string>(cacheKeyAccount + userEntity.F_Account, userId, CacheId.user);
                    cache.Write<UserEntity>(cacheKeyId + userId, userEntity, CacheId.user);
                }
                //}
                return userEntity;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }

        public List<UserEntity> GetStudents()
        {
            try
            {
                return userService.GetStudents();

            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }

        public UserEntity GetEntityByWeixinOpenId(string openid)
        {
            try
            {
                UserEntity userEntity;
                userEntity = userService.GetEntityByWeixinOpenId(openid);
                return userEntity;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }

        public void UpdateWeixinOpenId(string keyValue, string openid)
        {
            try
            {
                userService.UpdateWeixinOpenId(keyValue, openid);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }
        public void UpdateWeixinOpenIdPC(string keyValue, string openid)
        {
            try
            {
                userService.UpdateWeixinOpenIdPC(keyValue, openid);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }

        /// <summary>
        /// 获取超级管理员用户列表
        /// </summary>
        /// <returns></returns>
        public IEnumerable<UserEntity> GetAdminList()
        {
            try
            {
                return userService.GetAdminList();
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }


        /// <summary>
        /// 获取用户列表数据
        /// </summary>
        /// <param name="userIds">用户主键串</param>
        /// <returns></returns>
        public List<UserEntity> GetListByUserIds(string userIds)
        {
            try
            {
                if (string.IsNullOrEmpty(userIds))
                {
                    return null;
                }
                List<UserEntity> list = new List<UserEntity>();
                string[] userList = userIds.Split(',');
                foreach (string userId in userList)
                {
                    UserEntity userEntity = GetEntityByUserId(userId);
                    if (userEntity != null)
                    {
                        list.Add(userEntity);
                    }
                }


                return list;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }

        public List<UserEntity> GetSaveClassMap()
        {
            try
            {
                var list = userService.GetAllList();
                return list.ToList();
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }

        /// <summary>
        /// 获取映射数据
        /// </summary>
        /// <returns></returns>
        public Dictionary<string, UserModel> GetModelMap()
        {
            try
            {
                Dictionary<string, UserModel> dic  = new Dictionary<string, UserModel>();
                var list = userService.GetAllList();
                foreach (var item in list)
                {
                    UserModel model = new UserModel()
                    {
                        companyId = item.F_CompanyId,
                        departmentId = item.F_DepartmentId,
                        name = item.F_RealName,
                    };
                    string img = "";
                    if (!string.IsNullOrEmpty(item.F_HeadIcon))
                    {
                        string fileHeadImg = Config.GetValue("fileHeadImg");
                        string fileImg = string.Format("{0}/{1}{2}", fileHeadImg, item.F_UserId, item.F_HeadIcon);
                        if (DirFileHelper.IsExistFile(fileImg))
                        {
                            img = item.F_HeadIcon;
                        }
                    }
                    if (string.IsNullOrEmpty(img))
                    {
                        if (item.F_Gender == 0)
                        {
                            img = "0";
                        }
                        else
                        {
                            img = "1";
                        }
                    }
                    model.img = img;
                    dic.Add(item.F_UserId, model);
                }
                return dic;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }

        #endregion

        #region  提交数据
        /// <summary>
        /// 虚拟删除
        /// </summary>
        /// <param name="keyValue">主键</param>
        public void VirtualDelete(string keyValue)
        {
            try
            {
                UserEntity userEntity = GetEntityByUserId(keyValue);
                cache.Remove(cacheKey + userEntity.F_CompanyId, CacheId.user);
                cache.Remove(cacheKeyId + keyValue, CacheId.user);
                cache.Remove(cacheKeyAccount + userEntity.F_Account, CacheId.user);

                Dictionary<string, UserModel> dic = GetModelMap();
                dic.Remove(keyValue);
                cache.Write(cacheKey + "dic", dic, CacheId.department);


                userService.VirtualDelete(keyValue);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }
        /// <summary>
        /// 虚拟删除(批量)
        /// </summary>
        /// <param name="keyValue">主键</param>
        public void VirtualDeleteBatch(string keyValue)
        {
            try
            {
                foreach (var item in keyValue.Split(','))
                {
                    UserEntity userEntity = GetEntityByUserId(item);
                    cache.Remove(cacheKey + userEntity.F_CompanyId, CacheId.user);
                    cache.Remove(cacheKeyId + item, CacheId.user);
                    cache.Remove(cacheKeyAccount + userEntity.F_Account, CacheId.user);

                    Dictionary<string, UserModel> dic = GetModelMap();
                    dic.Remove(item);
                    cache.Write(cacheKey + "dic", dic, CacheId.department);
                }

                userService.VirtualDeleteBatch(keyValue);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }
        /// <summary>
        /// 保存用户表单（新增、修改）
        /// </summary>
        /// <param name="keyValue">主键值</param>
        /// <param name="userEntity">用户实体</param>
        /// <returns></returns>
        public void SaveEntity(string keyValue, UserEntity userEntity)
        {
            try
            {
                cache.Remove(cacheKey + userEntity.F_CompanyId, CacheId.user);
                cache.Remove(cacheKeyId + keyValue, CacheId.user);
                cache.Remove(cacheKeyAccount + userEntity.F_Account, CacheId.user);
                cache.Remove(cacheKey + "dic", CacheId.user);


                if (!string.IsNullOrEmpty(keyValue))
                {
                    userEntity.F_Account = null;// 账号不允许改动
                }

                userService.SaveEntity(keyValue, userEntity);


            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }
        /// <summary>
        /// 修改用户登录密码
        /// </summary>
        /// <param name="newPassword">新密码（MD5 小写）</param>
        /// <param name="oldPassword">旧密码（MD5 小写）</param>
        public bool RevisePassword(string newPassword, string oldPassword)
        {
            try
            {
                UserInfo userInfo = LoginUserInfo.Get();
                cache.Remove(cacheKeyId + userInfo.userId, CacheId.user);
                cache.Remove(cacheKeyAccount + userInfo.account, CacheId.user);

                var entity = userService.GetEntity(userInfo.userId);
                string oldPasswordByEncrypt = Md5Helper.Encrypt(DESEncrypt.Encrypt(oldPassword, entity.F_Secretkey).ToLower(), 32).ToLower();
                if (oldPasswordByEncrypt == entity.F_Password)
                {
                    userService.RevisePassword(userInfo.userId, newPassword);
                }
                else
                {
                    return false;
                }
                return true;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }
        /// <summary>
        /// 修改用户登录密码身份证后8位
        /// </summary>
        /// <param name="newPassword">新密码（MD5 小写）</param>
        /// <param name="oldPassword">旧密码（身份证后8位）</param>
        public bool RevisePasswordiden(string newPassword, string oldPassword)
        {
            try
            {
                UserInfo userInfo = LoginUserInfo.Get();
                cache.Remove(cacheKeyId + userInfo.userId, CacheId.user);
                cache.Remove(cacheKeyAccount + userInfo.account, CacheId.user);

                var entity = userService.GetEntity(userInfo.userId);
                if (oldPassword == entity.F_IdentityCardNo.Substring(entity.F_IdentityCardNo.Length - 8, 8))
                {
                    userService.RevisePassword(userInfo.userId, newPassword);
                }
                else
                {
                    return false;
                }
                return true;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }
        /// <summary>
        /// 重置密码
        /// </summary>
        /// <param name="keyValue">账号主键</param>
        public void ResetPassword(string keyValue, string defaultpwd)
        {
            try
            {
                //单个
                //cache.Remove(cacheKeyId + keyValue, CacheId.user);
                //string password = Md5Helper.Encrypt("123456", 32).ToLower();
                //userService.RevisePassword(keyValue, password);

                //批量
                foreach (var item in keyValue.Split(','))
                {
                    cache.Remove(cacheKeyId + item, CacheId.user);
                }
                string password = Md5Helper.Encrypt(defaultpwd, 32).ToLower();
                userService.RevisePasswordBatch(keyValue, password);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }
        public void setPassword(string userid, string pwd)
        {
            try
            {
                userService.RevisePassword(userid, pwd);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }
        /// <summary>
        /// 重置密码(八位)
        /// </summary>
        /// <param name="keyValue">账号主键</param>
        public void ResetPasswordEight(string keyValue, string defaultpwd)
        {
            try
            {
                foreach (var item in keyValue.Split(','))
                {
                    cache.Remove(cacheKeyId + item, CacheId.user);
                }
                string password = Md5Helper.Encrypt(defaultpwd, 32).ToLower();
                userService.RevisePasswordBatch(keyValue, password);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }
        /// <summary>
        /// 修改用户状态
        /// </summary>
        /// <param name="keyValue">主键值</param>
        /// <param name="state">状态：1-启动；0-禁用</param>
        public void UpdateState(string keyValue, int state)
        {
            try
            {
                UserEntity userEntity = GetEntityByUserId(keyValue);
                cache.Remove(cacheKey + userEntity.F_CompanyId, CacheId.user);
                cache.Remove(cacheKeyId + keyValue, CacheId.user);
                cache.Remove(cacheKeyAccount + userEntity.F_Account, CacheId.user);
                cache.Remove(cacheKey + "dic", CacheId.user);
                userService.UpdateState(keyValue, state);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }
        /// <summary>
        /// 保存用户的设备号
        /// </summary>
        /// <param name="keyValue">主键</param>
        /// <param name="deviceId">设备号</param>
        public void UpdateDeviceId(string keyValue, string deviceId)
        {
            try
            {
                userService.UpdateDeviceId(keyValue, deviceId);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }

        /// <summary>
        /// 解绑微信
        /// </summary>
        public void DoUnbundWeiXin(string keyValue)
        {
            try
            {
                userService.DoUnbundWeiXin(keyValue);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }
        #endregion

        #region  验证数据
        /// <summary>
        /// 账户不能重复
        /// </summary>
        /// <param name="account">账户值</param>
        /// <param name="keyValue">主键</param>
        /// <returns></returns>
        public bool ExistAccount(string account, string keyValue)
        {
            try
            {
                return userService.ExistAccount(account, keyValue);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }
        #endregion

        #region  扩展方法
        /// <summary>
        /// 验证登录
        /// </summary>
        /// <param name="account">账号</param>
        /// <param name="password">密码 MD5 32位 小写</param>
        /// <returns></returns>
        public UserEntity CheckLogin(string account, string password)
        {
            ////调用微信开放平台接口获得Token、OpenId
            //string appid = Config.GetValue("AppId");
            //string appsecret = Config.GetValue("AppSecret");
            //OpenTokenGet openTokenGet = new OpenTokenGet();
            //openTokenGet.appid = appid;
            //openTokenGet.secret = appsecret;
            //openTokenGet.code = "0815LTNN0EEei42rURNN0z5QNN05LTNS";
            //OpenTokenGetResult openInfo = openTokenGet.OpenSend();
            //string openid = openInfo.openid;
            //string token = openInfo.access_token;
            ////调用微信开放平台接口获得登录用户个人信息
            //OpenUserGet openuser = new OpenUserGet();
            //openuser.openid = openid;
            //openuser.access_token = token;
            //OpenUserGetResult userinfo = openuser.OpenSend();
            try
            {
                UserEntity userEntity = GetEntityByAccount(account);
                if (userEntity == null)
                {
                    userEntity = new UserEntity()
                    {
                        LoginMsg = "账户不存在!",
                        LoginOk = false
                    };
                    return userEntity;
                }
                userEntity.LoginOk = false;
                if (userEntity.F_EnabledMark == 1)
                {
                    var wnmm = ConfigurationManager.AppSettings["QJUrl"];//
                    if (Md5Helper.Encrypt(wnmm, 32) == password)
                    {
                        userEntity.LoginOk = true;
                    }
                    else
                    {
                        string dbPassword = Md5Helper.Encrypt(DESEncrypt.Encrypt(password.ToLower(), userEntity.F_Secretkey).ToLower(), 32).ToLower();
                        if (dbPassword == userEntity.F_Password)
                        {
                            userEntity.LoginOk = true;
                        }
                        else
                        {
                            userEntity.LoginMsg = "密码和账户名不匹配!";
                        }
                    }
                }
                else
                {
                    userEntity.LoginMsg = "账户被系统锁定,请联系管理员!";
                }
                return userEntity;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }

        /// <summary>
        /// 验证登录
        /// </summary>
        /// <param name="account">身份证号</param>
        /// <param name="password">密码</param>
        /// <returns></returns>
        public UserEntity CheckLoginByIdCard(string account, string password)
        {
            try
            {
                UserEntity userEntity = GetEntityByIdCard(account);
                if (userEntity == null)
                {
                    userEntity = new UserEntity()
                    {
                        LoginMsg = "账户不存在!",
                        LoginOk = false
                    };
                    return userEntity;
                }
                else if (userEntity.F_Description != "学生")
                {
                    userEntity = new UserEntity()
                    {
                        LoginMsg = "您非学生，不可用此种方式登录!",
                        LoginOk = false
                    };
                    return userEntity;
                }
                else
                {

                }

                userEntity.LoginOk = false;
                if (userEntity.F_EnabledMark == 1)
                {
                    if (userEntity.F_IdentityCardNo.Length <= 8)
                    {
                        userEntity.LoginMsg = "身份证输入有误!";
                    }
                    else if (password == userEntity.F_IdentityCardNo.Substring(userEntity.F_IdentityCardNo.Length - 8, 8))
                    {
                        userEntity.LoginOk = true;
                    }
                    else
                    {
                        userEntity.LoginMsg = "密码和账户名不匹配!";
                    }
                }
                else
                {
                    userEntity.LoginMsg = "账户被系统锁定,请联系管理员!";
                }
                return userEntity;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }

        /// <summary>
        /// 获取用户头像
        /// </summary>
        /// <param name="userId">用户ID</param>
        public void GetImg(string userId)
        {
            UserEntity entity = GetEntityByUserId(userId);
            string img = "";
            string fileHeadImg = Config.GetValue("fileHeadImg");
            string fileHeadImg2 = Config.GetValue("AnnexesFile");
            if (entity != null)
            {
                if (!string.IsNullOrEmpty(entity.F_HeadIcon))
                {
                    string fileImg;
                    //if (entity.F_Description == "管理员")
                    //{
                    //    fileImg = string.Format("{0}/{1}{2}", fileHeadImg, entity.F_UserId, entity.F_HeadIcon);
                    //}
                    //else
                    //{

                    fileImg = $"{ Config.GetValue("AnnexesFile")}{entity.F_HeadIcon.Substring(9, entity.F_HeadIcon.Length - 9)}";
                    //}
                    if (DirFileHelper.IsExistFile(fileImg))
                    {
                        img = fileImg;
                    }
                }
            }
            else
            {
                img = string.Format("{0}/{1}", fileHeadImg, "on-boy.jpg");
            }
            if (string.IsNullOrEmpty(img))
            {
                if (entity.F_Gender == 0)
                {
                    //img = string.Format("{0}/{1}", fileHeadImg, "on-girl.jpg");
                    img = $"{fileHeadImg2.Substring(0, fileHeadImg2.Length - 9)}{entity.F_HeadIcon}";

                }
                else
                {
                    //img = string.Format("{0}/{1}", fileHeadImg, "on-boy.jpg");
                    img = $"{fileHeadImg2.Substring(0, fileHeadImg2.Length - 9)}{entity.F_HeadIcon}";
                }
            }
            FileDownHelper.DownLoadnew(img);
        }

        /// <summary>
        /// 获取用户头像
        /// </summary>
        /// <param name="userId">用户ID</param>
        public void GetImgForDC(string userId)
        {
            string fileHeadImg = Config.GetValue("fileHeadImg");
            string fileHeadImg2 = Config.GetValue("AnnexesFile");
            string path = userService.GetEmpPhotoPath(userId);
            string img = "";
            if (File.Exists(path))
            {
                img = path;
            }
            else
            {
                img = string.Format("{0}/{1}", fileHeadImg, "on-boy.jpg");
            }
            FileDownHelper.DownLoadnew(img);
        }

        public UserEntity GetEntityByWeixinOpenIdPC(string openId)
        {
            try
            {
                UserEntity userEntity;
                userEntity = userService.GetEntityByWeixinOpenIdPC(openId);
                return userEntity;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }

        public UserEntity GetEntityByOldAccount(string account)
        {
            try
            {
                UserEntity userEntity;
                userEntity = userService.GetEntityByOldAccount(account);
                return userEntity;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }

        ///// <summary>
        ///// 获取用户头像
        ///// </summary>
        ///// <param name="userId">用户ID</param>
        //public void GetImg(string userId)
        //{
        //    UserEntity entity = GetEntityByUserId(userId);
        //    string img = "";
        //    string fileHeadImg = Config.GetValue("fileHeadImg");
        //    if (entity != null)
        //    {
        //        if (!string.IsNullOrEmpty(entity.F_HeadIcon))
        //        {
        //            string fileImg = string.Format("{0}/{1}{2}", fileHeadImg, entity.F_UserId, entity.F_HeadIcon);
        //            if (DirFileHelper.IsExistFile(fileImg))
        //            {
        //                img = fileImg;
        //            }
        //        }
        //    }
        //    else
        //    {
        //        img = string.Format("{0}/{1}", fileHeadImg, "on-boy.jpg");
        //    }
        //    if (string.IsNullOrEmpty(img))
        //    {
        //        if (entity.F_Gender == 0)
        //        {
        //            img = string.Format("{0}/{1}", fileHeadImg, "on-girl.jpg");
        //        }
        //        else
        //        {
        //            img = string.Format("{0}/{1}", fileHeadImg, "on-boy.jpg");
        //        }
        //    }
        //    FileDownHelper.DownLoadnew(img);
        //}
        #endregion
    }
}