YD_XinWei.Api/Server/YD_XinWei/Services/Impl/UserService.cs

using Microsoft.EntityFrameworkCore;
using YD_XinWei.Commons;
using YD_XinWei.Api.Utilities;
using YD_XinWei.Commons.Exceptions;
using Microsoft.AspNetCore.Mvc;
using TGJ.NetworkFreight.SeckillAggregateServices.Pos.UserService;
using YD_XinWei.Api.Entitys;
using YD_XinWei.Commons.Users;
using System.Linq.Expressions;
using YD_XinWei.Api.WeChat.Lib;
using YD_XinWei.Api.Context;
using YD_XinWei.Api.Services.Interface;
using YD_XinWei.Api.WeChat;

namespace YD_XinWei.Api.Services.Impl
{
    public class UserService : IUserService
    {
        public UserContext _userContext;
        public SmartSportsContext _smartSportsContext;

        public UserService(UserContext userContext, SmartSportsContext smartSportsContext)
        {
            _userContext = userContext;
            _smartSportsContext = smartSportsContext;
        }
        public async Task<UserInfoDto> Login(LoginInfo paramDto)
        {
            User userModel = null;

            switch (paramDto.RoleId)
            {
                case 2: // 教师登录
                    userModel = await QueryUserByRole(
                        x => x.PhoneNo == paramDto.Key && x.UserPwd == paramDto.Password,
                        () => GetTeacherUser(paramDto)
                    );
                    break;

                case 3: // 家长登录
                    userModel = await QueryUserByRole(
                        x => x.UserName == paramDto.Key && x.UserPwd == paramDto.Password,
                        () => GetParentUser(paramDto)
                    );
                    break;

                default:
                    throw new BizException("无效的角色ID");
            }

            if (userModel == null || userModel.User_Id <= 0)
                throw new BizException("用户新增失败");

            return GenerateUserInfoDto(userModel);
        }

        private async Task<User> QueryUserByRole(Expression<Func<User, bool>> queryCondition, Func<Task<UserModelDataDto>> createUser)
        {
            var userModel = await _userContext.Users.FirstOrDefaultAsync(queryCondition);

            if (userModel == null)
            {
                var userData = await createUser();
                if (userData == null)
                    throw new BizException("账号或密码错误");

                userModel = CreateUserModel(userData);

                // 保存新用户信息
                await _userContext.Users.AddAsync(userModel);
                await _userContext.SaveChangesAsync();
            }

            return userModel;
        }

        private async Task<UserModelDataDto> GetTeacherUser(LoginInfo paramDto)
        {
            var teacherUser = await _smartSportsContext.Teacher
                .FirstOrDefaultAsync(x => x.TeacherPhoneNo == paramDto.Key && x.AppletPwd == paramDto.Password && x.TeacherStatus == 1);

            if (teacherUser == null)
                return null;

            return new UserModelDataDto
            {
                PhoneNo = teacherUser.TeacherPhoneNo,
                UserPwd = teacherUser.AppletPwd,
                UserName = teacherUser.TeacherPhoneNo,
                Gender = teacherUser.Sex,
                HeadImageUrl = teacherUser.TeacherPhoto,
                SchoolCode = teacherUser.SchoolCode,
                RoleName = "老师",
                RoleId = 2,
                RelevanceId = paramDto.RelevanceId ?? Guid.NewGuid()
            };
        }

        private async Task<UserModelDataDto> GetParentUser(LoginInfo paramDto)
        {
            var parentUser = await _smartSportsContext.Student
                .FirstOrDefaultAsync(x => x.StudentName == paramDto.Key && x.StudentNo == paramDto.Password && x.StudentStatus == 1);

            if (parentUser == null)
                return null;

            return new UserModelDataDto
            {
                PhoneNo = parentUser.ParentPhoneNo,
                UserPwd = parentUser.StudentNo,
                UserName = parentUser.StudentName,
                Gender = parentUser.Sex,
                HeadImageUrl = parentUser.Photo,
                Address = parentUser.HomeAddress,
                SchoolCode = parentUser.SchoolCode,
                RoleName = "家长",
                RoleId = 3,
                RelevanceId = paramDto.RelevanceId ?? Guid.NewGuid()
            };
        }

        private User CreateUserModel(UserModelDataDto userData)
        {
            return new User()
            {
                ModifyDate = DateTime.Now,
                CreateDate = DateTime.Now,
                Enable = true,
                RoleName = userData.RoleName,
                Role_Id = userData.RoleId,
                HeadImageUrl = userData.HeadImageUrl,
                Address = userData.Address,
                Gender = userData.Gender,
                Email = userData.Email,
                PhoneNo = userData.PhoneNo,
                SchoolCode = userData.SchoolCode,
                UserName = userData.UserName,
                UserPwd = userData.UserPwd,
                RelevanceId = Guid.NewGuid()
            };
        }

        private UserInfoDto GenerateUserInfoDto(User userModel)
        {
            string token = JwtHelper.IssueJwt(new UserInfoDto()
            {
                User_Id = userModel.User_Id,
                UserName = userModel.UserName,
                Role_Id = userModel.Role_Id,
                PhoneNo = userModel.PhoneNo ?? "",
                SchoolCode = userModel.SchoolCode,
                UserTrueName = userModel.UserName
            });

            return new UserInfoDto()
            {
                SchoolCode = userModel.SchoolCode,
                Enable = userModel.Enable,
                PhoneNo = userModel.PhoneNo,
                RoleName = userModel.RoleName,
                Role_Id = userModel.Role_Id,
                UserName = userModel.UserName,
                UserTrueName = userModel.UserName,
                User_Id = userModel.User_Id,
                RelevanceId = userModel.RelevanceId,
                Token = token
            };
        }


        public async Task<UserInfoDto> WxLogin(WXLoginPo loginPo)
        {
            var wli = new WechatLoginInfo();
            wli.code = loginPo.code;
            wli.encryptedData = loginPo.encryptedData;
            wli.iv = loginPo.iv;
            wli.rawData = loginPo.rawData;
            wli.signature = loginPo.signature;

            wli.appid = AppSettings.WeChat.Appid;
            wli.secret = AppSettings.WeChat.Appid;

            WechatUserInfo wechatResult = new WeChatAppDecrypt().Decrypt(wli);

            if (wechatResult == null || string.IsNullOrWhiteSpace(wechatResult.phoneNumber))
            {
                throw new BizException("手机号获取失败");
            }

            var userInfo = await _userContext.Users.FirstOrDefaultAsync(x => x.wx_OpenID == wechatResult.openId);

            if (null == userInfo || userInfo.User_Id == 0)
            {
                var model = new User()
                {
                    ModifyDate = DateTime.Now,
                    CreateDate = DateTime.Now,
                    PhoneNo = wechatResult.phoneNumber,
                    wx_HeadImgUrl = wechatResult.avatarUrl,
                    wx_NickName = wechatResult.nickName,
                    UserTrueName = wechatResult.nickName,
                    wx_OpenID = wechatResult.openId,
                    wx_UnionID = wechatResult.unionId,
                    Enable = true,
                    RoleName = "用户",
                    Role_Id = 1,
                    RelevanceId = loginPo.RelevanceId ?? Guid.NewGuid()
                };

                await _userContext.Users.AddAsync(model);
                await _userContext.SaveChangesAsync();

                if (model == null || model.User_Id <= 0)
                {
                    throw new BizException("用户新增失败");
                }
            }
            else
            {
                userInfo.wx_HeadImgUrl = wechatResult.avatarUrl;
                userInfo.wx_NickName = wechatResult.nickName;
                userInfo.wx_UnionID = wechatResult.unionId;
                userInfo.ModifyDate = DateTime.Now;

                _userContext.Users.Update(userInfo);
                await _userContext.SaveChangesAsync();
            }

            string token = JwtHelper.IssueJwt(new UserInfoDto()
            {
                User_Id = userInfo.User_Id,
                UserName = userInfo.UserName,
                Role_Id = userInfo.Role_Id
            });

            return new UserInfoDto()
            {
                Enable = userInfo.Enable,
                PhoneNo = userInfo.PhoneNo,
                RoleName = userInfo.RoleName,
                Role_Id = userInfo.Role_Id,
                UserName = userInfo.UserName,
                UserTrueName = userInfo.UserName,
                User_Id = userInfo.User_Id,
                RelevanceId = userInfo.RelevanceId,
                Token = token
            };
        }

        public async Task<List<RelatedAccountsDto>> RelatedAccounts(Guid relevanceId)
        {
            var roleId = UserLoginContext.Current.RoleId;

            var res = await _userContext.Users.Where(x => x.RelevanceId == relevanceId).Select(s => new RelatedAccountsDto()
            {
                RoleId = s.Role_Id,
                IsCurrentLogin = s.Role_Id == roleId,
                Key = s.UserName ?? "",
                UserPwd = s.UserPwd ?? "",
                OpenId = s.wx_OpenID ?? ""

            }).ToListAsync();

            return res;
        }
    }
}