WEBUI/WMS.BZServices/UserCenterManager/AclUserInfoService.cs

using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WMS.BZModels.Dto.UserCenterManager.UserRoleDtos;
using WMS.BZModels;
using WMS.BZModels.Models.UserCenterManager;
using WMS.Info;
using WMS.BZSqlSugar;
using WMS.BZModels.Dto.UserCenterManager.UserInfoDtos;
using Mapster;
using WMS.Util;
using System.Reflection;
using NPOI.OpenXmlFormats.Spreadsheet;
using static Microsoft.Extensions.Logging.EventSource.LoggingEventSource;

namespace WMS.BZServices.UserCenterManager
{
    public class AclUserInfoService
    {
        private readonly Repository<AclUserInfo> _acluserInfoRepository;

        public AclUserInfoService(Repository<AclUserInfo> acluserInfoRepository)
        {
            _acluserInfoRepository = acluserInfoRepository;
        }

        /// <summary>
        /// 获取列表数据
        /// <summary>
        /// <returns></returns>
        public IList<AclUserinfoListDto> GetList(string keyword)
        {
            var predicate = Expressionable.Create<AclUserInfo>();
            predicate = predicate.AndIF(!string.IsNullOrEmpty(keyword), m => m.Code.Contains(keyword) || m.Name.Contains(keyword));
            var list = _acluserInfoRepository.Queryable().Where(predicate.ToExpression()).ToList();
            return list.Adapt<List<AclUserinfoListDto>>();
        }

        public IEnumerable<AclUserinfoListDto> GetListForDeptNo(long DeptNo)
        {
            var predicate = Expressionable.Create<AclUserInfo>();
            predicate = predicate.And(m => m.IsStop == 0);
            predicate = predicate.AndIF(DeptNo > 0, m => m.DeptId.Equals(DeptNo));
            var list = _acluserInfoRepository.Queryable().Where(predicate.ToExpression()).ToList();
            return list.Adapt<List<AclUserinfoListDto>>();
        }

        public PagedInfo<AclUserinfoListDto> GetPageList(Pagination pagination, AclUserinfoQueryDto billDocsinfoQueryDto)
        {
            var predicate = Expressionable.Create<AclUserInfo>();
            predicate = predicate.AndIF(billDocsinfoQueryDto != null && !string.IsNullOrEmpty(billDocsinfoQueryDto?.KeyWord), m => m.Code.Contains(billDocsinfoQueryDto.KeyWord) || m.Name.Contains(billDocsinfoQueryDto.KeyWord));
            predicate = predicate.AndIF(billDocsinfoQueryDto != null && !string.IsNullOrEmpty(billDocsinfoQueryDto?.DeptId), m => m.DeptId.Equals(billDocsinfoQueryDto.DeptId));

            var list = _acluserInfoRepository.Queryable().Where(predicate.ToExpression())
                 .ToPage<AclUserInfo, AclUserinfoListDto>(pagination);

            return list;
        }

        public Dictionary<string, AclUserinfoDto> GetMap()
        {
            try
            {
                Dictionary<string, AclUserinfoDto> dics = new Dictionary<string, AclUserinfoDto>();
                _acluserInfoRepository.Queryable().ToList().ForEach(it => dics.Add(it.Id.ToString(), it.Adapt<AclUserinfoDto>()));
                return dics;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 获取实体数据
        /// <param name="keyValue">主键</param>
        /// <summary>
        /// <returns></returns>
        public AclUserinfoListDto GetEntityById(long keyValue)
        {
            var user = _acluserInfoRepository.Queryable().Single(it => it.Id == keyValue);
            return user.Adapt<AclUserinfoListDto>();
        }

        /// <summary>
        /// 获取实体数据
        /// <param name="keyValue">主键</param>
        /// <summary>
        /// <returns></returns>
        public AclUserinfoListDto GetEntityByCode(string keyValue)
        {
            var user = _acluserInfoRepository.Queryable().Where(it => it.Code == keyValue).ToList();
            return user.First().Adapt<AclUserinfoListDto>();
        }

        public dynamic GetUserByUserNo(LoginUserInfo LoginUser)
        {

            try
            {
                var user = _acluserInfoRepository.Queryable().First(it => it.Code == LoginUser.UserNo);
                //ACL_USERITEM user = SysDbCore.GetDbCtx().Queryable<ACL_USERITEM>().Where(it => it.F_NO == LoginUser.UserNo).First();
                LoginUser.EncryptTokenNo = "";
                //UserInfo userInfo = null;
                //if (user != null)
                //{
                //    user.Adapt<AclUserinfoListDto>();
                //    user.F_DATA = "";
                //    user.Pwd = "";
                //    userInfo = user.F_DATA.ToObject<UserInfo>();
                //}
                return new
                {
                    USERITEM = user.Adapt<AclUserinfoListDto>(),
                    USERINFO = "",
                    LOGINUSER = LoginUser
                };

            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public   void ValidationOldPassword(string UserNo, string OldPassword)
        {
            try
            {
                var user = _acluserInfoRepository.Queryable().First(it => it.Code == UserNo);
                if (user == null)
                {
                    throw BZSysExCore.ThrowFailException("用户不存在。");
                }
                if (string.IsNullOrWhiteSpace(OldPassword))
                {
                    throw BZSysExCore.ThrowFailException("请输入旧密码。");
                }
                string EOldPassword = SysSecurityHelp.Aes256Encrypt(OldPassword, user.Secretkey);

                if ( EOldPassword != user.Pwd)
                {
                    throw BZSysExCore.ThrowFailException("原密码错误，请重新输入。");
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// 获取用户类型
        /// </summary>
        public EUserType GetUserType(string UserNo)
        {
            EUserType UserType = EUserType.User;
            try
            {
                if (UserNo.ToUpper() == EUserType.Super.ToString().ToUpper())
                {
                    UserType = EUserType.Super;
                }
                else if (UserNo.ToUpper() == EUserType.System.ToString().ToUpper())
                {
                    UserType = EUserType.System;
                }
                else if (UserNo.ToUpper() == EUserType.SuperAdmin.ToString().ToUpper())
                {
                    UserType = EUserType.SuperAdmin;
                }
                else
                {
                    UserType = EUserType.User;
                }
                //权限管理员
            }
            catch
            {

            }
            return UserType;
        }
        public void Save(LoginUserInfo loginUser, string keyValue, AclUserInfo entity)
        {
            try
            {
                if (entity == null)
                {
                    throw new ArgumentException("用户保存数据为空。");
                }
                if (string.IsNullOrWhiteSpace(entity.Code))
                {
                    throw new ArgumentException("用户编号为空。");
                }
                if (string.IsNullOrWhiteSpace(entity.Name))
                {
                    throw new ArgumentException("用户名称为空。");
                }

                if (keyValue.IsEmpty() || keyValue == "undefined")
                {
                    EUserType ut = GetUserType(keyValue);
                    if (ut != EUserType.User)
                    {
                        throw new ArgumentException("用户名非法。");
                    }

                    var mat = _acluserInfoRepository.GetSingle(p => p.Code == entity.Code);
                    if (mat != null)
                    {
                        throw new ArgumentException("用户编码已存在");
                    }
                    entity.Id = IdFactory.NewId();
                    entity.AddTime = DateTime.Now;
                    entity.AddWho = loginUser.UserNo;
                    entity.EditTime = DateTime.Now;
                    entity.EditWho = loginUser.UserNo;
                    entity.Secretkey = SysSecurityHelp.Encrypt(CommonUtil.CreateNo(), 16).ToLower();
                    entity.Pwd = SysSecurityHelp.Aes256Encrypt("000000", entity.Secretkey);
                    _acluserInfoRepository.Insert(entity);
                }
                else
                {
                    entity.Id = Convert.ToInt64(keyValue);
                    _acluserInfoRepository.UpdateModelColumns(p => new AclUserInfo
                    {
                        EditWho = loginUser.UserNo,
                        EditTime = DateTime.Now,
                        DeptId = entity.DeptId,
                        Memo = entity.Memo,
                        IsStop = entity.IsStop,
                        Name = entity.Name,
                        SexNum = entity.SexNum,
                        Birthday = entity.Birthday,
                        Mobile = entity.Mobile,
                        Telephone = entity.Telephone,
                        Email = entity.Email,
                        WarehouseNo=entity.WarehouseNo,
                    },
                    it => it.Id == entity.Id);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 重置密码
        /// </summary>
        public void ResetPassword(LoginUserInfo LoginUser, string EditUserNo)
        {
            try
            {
                EUserType editEuser = GetUserType(EditUserNo);
                if (LoginUser.UserType == EUserType.System)
                {
                    if (editEuser == EUserType.Super)
                    {
                        throw new ArgumentException("无法重置超级管理员账号密码!!!");
                    }
                }
                else if (LoginUser.UserType == EUserType.SuperAdmin)
                {
                    if (editEuser == EUserType.Super || editEuser == EUserType.System)
                    {
                        throw new ArgumentException("无法重置系统管理员账号密码!!!");
                    }
                }
                else
                {
                    if (editEuser == EUserType.Super || editEuser == EUserType.System || editEuser == EUserType.SuperAdmin)
                    {
                        throw new ArgumentException("无法重置管理员账号密码!!!");
                    }
                }

                var secretkey = SysSecurityHelp.Encrypt(CommonUtil.CreateNo(), 16).ToLower();
                var i = _acluserInfoRepository.AsUpdateable().SetColumns(it => new AclUserInfo
                {
                    EditWho = LoginUser.UserNo,
                    EditTime = DateTime.Now,
                    PwdErrQty = 0,
                    Secretkey = secretkey,
                    Pwd = SysSecurityHelp.Aes256Encrypt("000000", secretkey),
                }).Where(it => it.Code.ToUpper() == EditUserNo.ToUpper()).ExecuteCommand();

                if (i <= 0)
                {
                    throw new ArgumentException("修改密码失败!!!");
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 是否是管理员
        /// </summary>
        public bool CheckAdmin(string UserNo)
        {
            bool IsAdmin = false;
            EUserType UserType = GetUserType(UserNo);
            if (UserType == EUserType.SuperAdmin || UserType == EUserType.Super || UserType == EUserType.System)
            {
                IsAdmin = true;
            }
            return IsAdmin;
        }

        public void Delete(string Id)
        {
            try
            {


                if (string.IsNullOrWhiteSpace(Id) || long.TryParse(Id, out var result))
                {
                    throw new ArgumentException("用户Id错误");
                }

                var entity = GetEntityById(result);
                if (entity != null)
                {
                    if (CheckAdmin(entity.Code))
                    {
                        throw new ArgumentException("系统内置账号，无法进行删除。");
                    }
                    _acluserInfoRepository.Delete(entity);
                    //_acluserInfoRepository.Deleteable<ACL_USERRELATION>().Where(it => it.F_USERNO == keyValue).ExecuteCommand();
                    //_acluserInfoRepository.Deleteable<ACL_AUTHORIZE>().Where(it => it.F_OBJTYPENUM == (int)EACLObjType.UserItem && it.F_OBJNO == keyValue).ExecuteCommand();

                }

            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
    }
}