hn_zw_back_main/Service/System/LoginService.cs

using Autofac;
using Common.Const;
using Common.Enum;
using Common.Util;
using Entity.Dto.Resp;
using HybirdFrameworkCore.Attribute;
using HybirdFrameworkCore.Autofac;
using HybirdFrameworkCore.Autofac.Attribute;
using HybirdFrameworkCore.Configuration;
using HybirdFrameworkCore.Redis;
using Repository.System;
using Service.Mgr;
using System.ComponentModel.DataAnnotations;
using System.Reflection;
using Entity.DbModel.System;

namespace Service.System
{
    public class LoginResult
    {
        public int code { get; set; }
        public string message { get; set; }
        public DataInfo data { get; set; }

    }

    public class UserInfo
    {
        public string name { get; set; }
    }

    public class DataInfo
    {
        public string permissions { get; set; }
        public List<RoleInfo> roles { get; set; }
        public string menus { get; set; }

        public UserInfo user { get; set; }
        public string token { get; set; }
        public long expireAt { get; set; }
    }

    public class MenuInfo
    {
        public string router;

        public List<Children> children = new List<Children>();
    }
    public class Children
    {
        public string router;

        public List<string> children = new List<string>();
    }

    public class RoleInfo
    {
        public string id { get; set; }

        public List<string> operation = new List<string>();
    }

    [Scope("SingleInstance")]
    public class LoginService
    {
        private readonly UserManager _userManager = new UserManager();
        private readonly SysUserRepository _sysUserRepository;
        private readonly SysMenuRepository _sysMenuRepository;
        private readonly SysMenuMgr _sysMenuMgr;
        private readonly SysRoleRepository _sysRoleRepository;
        private readonly SysUserRoleRepository _sysUserRoleRepository;
        private readonly SysRoleMenuRepository _sysRoleMenuRepository;


        public LoginService(
            SysUserRepository sysUserRepository,
            SysMenuRepository sysMenuRepository,
            SysMenuMgr sysMenuMgr,
            SysRoleRepository sysRoleRepository,
            SysUserRoleRepository sysUserRoleRepository,
            SysRoleMenuRepository sysRoleMenuRepository

            )
        {
            _sysMenuRepository = sysMenuRepository;
            _sysUserRepository = sysUserRepository;
            _sysMenuMgr = sysMenuMgr;
            _sysRoleRepository = sysRoleRepository;
            _sysUserRoleRepository = sysUserRoleRepository;
            _sysRoleMenuRepository = sysRoleMenuRepository;
        }

        RedisHelper redisHelper = AppInfo.Container.Resolve<RedisHelper>();
        public object Login(string username, string password)
        {
            // 判断密码错误次数（默认5次）
            var keyErrorPasswordCount = $"{RedisConstMgr.KeyErrorPasswordCount}{username}";
            int errorPasswordCount = Convert.ToInt32(redisHelper.GetStrValue(keyErrorPasswordCount));
            if (errorPasswordCount >= 5)
            {
                throw new ArgumentException($"密码错误次数过多，账号已锁定，请半小时后重试！");
            }
            SysUser user = _sysUserRepository.QueryByClause(u => u.Account == username);
            if (user == null)
            {
                return new { code = -1, message = "用户名不存在" };
            }
            if (user.Status == StatusEnum.Disable)
            {
                return new { code = -1, message = "当前账户处于禁用状态" };
            }
            // 国密SM2解密（前端密码传输SM2加密后的）
            password = CryptogramUtil.SM2Decrypt(password);

            string verifyPassword = VerifyPassword(password, keyErrorPasswordCount, errorPasswordCount, user);
            if (verifyPassword == "密码不正确")
            {
                throw new ArgumentException($"密码不正确");
            }

            _userManager.SetManagerContent(user);

            return CreateResult(user.Id, username, JwtUtil.BuildToken(username));
        }
        /// <summary>
        /// 验证用户密码
        /// </summary>
        /// <param name="inputReq"></param>
        /// <param name="keyErrorPasswordCount"></param>
        /// <param name="errorPasswordCount">登录次数</param>
        /// <param name="user">用戶</param>
        private string VerifyPassword(string inputReq, string keyErrorPasswordCount, int errorPasswordCount, SysUser user)
        {
            string result = "";
            if (CryptogramUtil.CryptoType == CryptogramEnum.MD5.ToString())
            {
                if (!user.Password.Equals(MD5Util.MD5Encrypt32(inputReq)))
                {
                    errorPasswordCount++;
                    redisHelper.SetKeyValueStr(keyErrorPasswordCount, errorPasswordCount.ToString());
                    result = "密码不正确";
                }
            }
            else
            {
                if (!CryptogramUtil.Decrypt(user.Password).Equals(inputReq))
                {
                    errorPasswordCount++;
                    redisHelper.SetKeyValueStr(keyErrorPasswordCount, errorPasswordCount.ToString());
                    result = "密码不正确";
                }
            }
            return result;
        }
        public LoginResult CreateResult(long userId, string username, string token)
        {
            var loginResult = new LoginResult();

            var dataInfo = new DataInfo();

            var userInfo = new UserInfo();

            userInfo.name = username;
            dataInfo.token = token;
            dataInfo.expireAt = getTimeStamp();
            dataInfo.user = userInfo;

            var roles = new List<RoleInfo>();
            var permissions = new List<RoleInfo>();
            var menus = new List<MenuInfo>();
            var parentList = new List<SysMenu>();
            var childList = new List<SysMenu>();
            var menuList = new List<SysMenu>();
            List<MenuInfo> menuInfoList = new List<MenuInfo>();
            MenuInfo menuInfo = new MenuInfo();
            Children childrenInfo = new Children();
            Children childrenIndexInfo = new Children();

            SysUser adminUser = _sysUserRepository.QueryByClause(u => u.Account == username);
            if (adminUser != null)
            {
                SysUserRole adminRole = _sysUserRoleRepository.QueryByClause(u => u.UserId == adminUser.Id);
                if (adminRole != null)
                {
                    SysRole adminRoleInfo = _sysRoleRepository.QueryByClause(u => u.Id == adminRole.RoleId);

                    if (adminRoleInfo != null)
                    {
                        if (adminRoleInfo.Code.ToLower() == "sys_admin")
                        {
                            parentList = _sysMenuRepository.QueryByClauseToList(u => u.Pid == 0, u => u.Type == MenuTypeEnum.Menu, u => u.OrderNo);

                            menuInfo.router = "root";

                            foreach (var parents in parentList)
                            {
                                // childrenInfo.router = parents.Href;
                                //TODO::
                                childrenInfo.router = parents.Path;

                                childList = _sysMenuRepository.QueryByClauseToList(u => u.Pid == parents.Id);

                                foreach (var childs in childList)
                                {
                                    childrenInfo.children.Add(childs.Path);
                                }
                                menuInfo.children.Add(childrenInfo);
                                childrenInfo = new Children();
                            }
                            menuInfoList.Add(menuInfo);

                            string result = JsonUtil.ObjToJson(menuInfoList);

                            RoleInfo roleInfo = new RoleInfo();
                            menuList = _sysMenuRepository.QueryByClauseToList(u => u.Type == MenuTypeEnum.Menu, u => u.OrderNo);

                            if (menuList != null)
                            {
                                foreach (var menu in menuList)
                                {
                                    roleInfo.id = menu.Path;

                                    var buttonList = _sysMenuRepository.QueryByClauseToList(u => u.Pid == menu.Id, u => u.Type == MenuTypeEnum.Btn);
                                    if (buttonList != null)
                                    {
                                        foreach (var button in buttonList)
                                        {
                                            roleInfo.operation.Add(button.Name);
                                        }
                                    }
                                    permissions.Add(roleInfo);
                                    roleInfo = new RoleInfo();
                                }
                            }
                            string resultPermissions = JsonUtil.ObjToJson(permissions);


                            dataInfo.permissions = resultPermissions;
                            dataInfo.roles = roles;
                            dataInfo.menus = result;
                            loginResult.data = dataInfo;
                            loginResult.code = 200;
                            loginResult.message = "登录成功";
                        }
                        else
                        {
                            SysUser user = _sysUserRepository.QueryByClause(u => u.Account == username);
                            if (user != null)
                            {
                                SysUserRole role = _sysUserRoleRepository.QueryByClause(u => u.UserId == user.Id);
                                if (role != null)
                                {
                                    List<SysRoleMenu> authList = _sysRoleMenuRepository.QueryByClauseToList(u => u.RoleId == role.RoleId, u => u.MenuId);

                                    foreach (var auth in authList)
                                    {
                                        SysMenu parent = _sysMenuRepository.QueryByClause(u => u.Pid == 0 && u.Type == MenuTypeEnum.Menu && u.Id == auth.MenuId);
                                        if (parent != null)
                                        {
                                            parentList.Add(parent);
                                        }

                                        SysMenu permission = _sysMenuRepository.QueryByClause(u => u.Type == MenuTypeEnum.Menu && u.Id == auth.MenuId);
                                        if (permission != null)
                                        {
                                            menuList.Add(permission);
                                        }
                                    }

                                    menuInfo.router = "root";

                                    parentList = parentList.OrderBy(p => p.OrderNo).ToList();
                                    foreach (var parents in parentList)
                                    {
                                        childrenInfo.router = parents.Path;

                                        foreach (var auth in authList)
                                        {
                                            SysMenu child = _sysMenuRepository.QueryByClause(u => u.Pid == parents.Id && u.Id == auth.MenuId);
                                            if (child != null)
                                            {
                                                childList.Add(child);
                                            }
                                        }

                                        foreach (var childs in childList)
                                        {
                                            childrenInfo.children.Add(childs.Path);
                                        }
                                        menuInfo.children.Add(childrenInfo);
                                        childrenInfo = new Children();
                                        childList.Clear();
                                    }
                                }
                            }




                            menuInfoList.Add(menuInfo);

                            string result = JsonUtil.ObjToJson(menuInfoList);

                            RoleInfo roleInfo = new RoleInfo();

                            if (menuList != null)
                            {
                                foreach (var menu in menuList)
                                {
                                    roleInfo.id = menu.Path;

                                    var buttonList = _sysMenuRepository.QueryByClauseToList(u => u.Pid == menu.Id, u => u.Type == MenuTypeEnum.Btn).ToList();
                                    if (buttonList != null)
                                    {
                                        foreach (var button in buttonList)
                                        {
                                            roleInfo.operation.Add(button.Name);
                                        }
                                    }
                                    permissions.Add(roleInfo);
                                    roleInfo = new RoleInfo();
                                }
                            }
                            string resultPermissions = JsonUtil.ObjToJson(permissions);


                            dataInfo.permissions = resultPermissions;
                            dataInfo.roles = roles;
                            dataInfo.menus = result;
                            loginResult.data = dataInfo;
                            loginResult.code = 200;
                            loginResult.message = "登录成功";
                            Console.WriteLine("login success");
                        }
                    }
                }
            }


            return loginResult;
        }

        public static long getTimeStamp()
        {
            TimeSpan ts = DateTime.Now.AddMonths(12) - new DateTime(1970, 1, 1, 0, 0, 0, 0);
            return Convert.ToInt64(ts.TotalSeconds) * 1000;
        }

        /// <summary>
        /// 获取登录账号 🔖
        /// </summary>
        /// <returns></returns>
        public virtual async Task<LoginUserResp?> GetUserInfo()
        {
            var user = await _sysUserRepository.QueryByClauseAsync(u => u.Id == UserManager.UserId);
            if (user == null)
                return default;
            // 获取拥有按钮权限集合
            var buttons = await _sysMenuMgr.GetOwnBtnPermList();
            // 获取权限集合
            var roleIds = await _sysUserRoleRepository.QueryByClauseAsync(u => u.UserId == user.Id, u => u.RoleId);

            return new LoginUserResp
            {
                Id = user.Id,
                Account = user.Account,
                RealName = user.RealName,
                Phone = user.Phone,
                IdCardNum = user.IdCardNum,
                Email = user.Email,
                AccountType = user.AccountType,
                Avatar = user.Avatar,
                Address = user.Address,
                Signature = user.Signature,
                Buttons = buttons,
                RoleIds = roleIds
            };
        }

        /// <summary>
        /// Const list
        /// </summary>
        /// <returns></returns>
        public async Task<List<ConstResp>> GetList()
        {
            return await GetConstList();
        }
        /// <summary>
        /// 获取所有常量列表 🔖
        /// </summary>
        /// <returns></returns>
        public async Task<List<ConstResp>> GetConstList()
        {

            var key = $"{RedisConstMgr.KeyConst}list";
            List<string> constList = redisHelper.GetStrListValue(key);
            List<ConstResp> constlist = new List<ConstResp>();
            foreach (var item in constList)
            {
                constlist.Add(JsonUtil.ParseFormByJson<ConstResp>(item));
            }
            if (constlist == null)
            {
                var typeList = GetConstAttributeList();
                constlist = typeList.Select(u => new ConstResp
                {
                    Name = u.CustomAttributes.ToList().FirstOrDefault()?.ConstructorArguments.ToList().FirstOrDefault().Value?.ToString() ?? u.Name,
                    Code = u.Name,
                    Data = GetData(Convert.ToString(u.Name))
                }).ToList();
                List<string> setConstList = new List<string>();
                foreach (var item in constlist)
                {
                    setConstList.Add(JsonUtil.GetJSON<string>(item));
                }
                redisHelper.SetListInRedis(key, setConstList);
            }
            return await Task.FromResult(constlist);
        }
        /// <summary>
        /// 获取常量特性类型列表
        /// </summary>
        /// <returns></returns>
        private List<Type> GetConstAttributeList()
        {
            return AppDomain.CurrentDomain.GetAssemblies().SelectMany(u => u.GetTypes())
                .Where(u => u.CustomAttributes.Any(c => c.AttributeType == typeof(ConstAttribute))).ToList();
        }

        /// <summary>
        /// 根据类名获取常量数据 🔖
        /// </summary>
        /// <param name="typeName"></param>
        /// <returns></returns>
        public async Task<List<ConstResp>> GetData([Required] string typeName)
        {
            var key = $"{RedisConstMgr.KeyConst}list";
            List<string> constList = redisHelper.GetStrListValue(key);
            List<ConstResp> constlist = new List<ConstResp>();
            foreach (var item in constList)
            {
                constlist.Add(JsonUtil.ParseFormByJson<ConstResp>(item));
            }
            if (constlist == null)
            {
                var typeList = GetConstAttributeList();
                var type = typeList.FirstOrDefault(u => u.Name == typeName);

                var isEnum = type.BaseType.Name == "Utils";
                constlist = type.GetFields()?
                    .Where(isEnum, u => u.FieldType.Name == typeName)
                    .Select(u => new ConstResp
                    {
                        Name = u.Name,
                        Code = isEnum ? (int)u.GetValue(BindingFlags.Instance) : u.GetValue(BindingFlags.Instance)
                    }).ToList();
                List<string> setConstList = new List<string>();
                foreach (var item in constlist)
                {
                    setConstList.Add(JsonUtil.GetJSON<string>(item));
                }
                redisHelper.SetListInRedis(key, setConstList);
            }
            return await Task.FromResult(constlist);
        }

    }
}