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;

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="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);
                }
            }
        }

        /// <summary>
        /// 获取实体,通过手机号
        /// </summary>
        /// <param name="mobile">手机号</param>
        /// <returns></returns>
        public UserEntity GetEntityByMobile(string mobile)
        {
            try
            {
                return userService.GetEntityByMobile(mobile);

            }
            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 = cache.Read<Dictionary<string, UserModel>>(cacheKey + "dic", CacheId.user);
                if (dic == null)
                {
                    dic = new Dictionary<string, UserModel>();
                    var list = userService.GetAllListForMap();
                    string fileHeadImg = Config.GetValue("fileHeadImg");
                    foreach (var item in list)
                    {
                        UserModel model = new UserModel()
                        {
                            companyId = item.F_CompanyId,
                            departmentId = item.F_DepartmentId,
                            name = item.F_RealName,
                            mobile = item.F_Mobile ?? ""
                        };
                        string img = "";
                        if (!string.IsNullOrEmpty(item.F_HeadIcon))
                        {
                            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);
                        cache.Write(cacheKey + "dic", dic, CacheId.user);
                    }
                }
                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>
        /// 重置密码
        /// </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 = userService.GetEntityByIdCard(account);
                if (userEntity == null)
                {
                    userEntity = userService.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();
                        //string phone = Md5Helper.Encrypt(userEntity.F_Mobile, 32).ToLower();
                        if (dbPassword == userEntity.F_Password)
                        {
                            userEntity.LoginOk = true;
                        }
                        //else if (phone == 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="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);
                }
            }
        }


        /// <summary>
        /// 修改用户的允许登录结束时间
        /// </summary>
        /// <param name="keyValue">主键值</param>
        /// <param name="state">状态：1-赋值；0-重置</param>
        public void UpdateAllowEndTime(string keyValue, int state)
        {
            try
            {
                userService.UpdateAllowEndTime(keyValue, state);
            }
            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);
        //}


        /// <summary>
        /// 获取实体,账号身份证
        /// </summary>
        /// <param name="account">账号身份证</param>
        /// <returns></returns>
        public UserEntity GetEntityByIdCard(string account)
        {
            try
            {
                UserEntity userEntity;
                userEntity = userService.GetEntityByIdCard(account);
                return userEntity;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowBusinessException(ex);
                }
            }
        }
        #endregion
    }
}