CE/HiTeachCE/Services/WeChatService.cs

using HiTeachCE.Extension;
using HiTeachCE.Helpers;
using HiTeachCE.Models;
using IdentityModel;
using Microsoft.Extensions.Configuration;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Security.Claims;
using System.Threading.Tasks;
using TEAMModelOS.SDK.Context.Configuration;
using TEAMModelOS.SDK.Extension.JwtAuth.Models;
using TEAMModelOS.SDK.Helper.Common.CollectionHelper;
using TEAMModelOS.SDK.Helper.Common.JsonHelper;
using TEAMModelOS.SDK.Helper.Network.HttpHelper;
using JwtSetting = HiTeachCE.Extension.JwtSetting;

namespace HiTeachCE.Services
{
    public class WeChatService : IBusinessService
    {
        public WeChatUserService weChatUserService;
        public WeChatService(WeChatUserService _weChatUserService) {
            weChatUserService = _weChatUserService;
        }

        public async Task<object> VerifyWeChat(Dictionary<string, object> dict)
        {
            if (dict.TryGetValue("code", out object code))
            {
                WeChatToken oauth2Token = await GetWeChatAccessToken(code != null ? code.ToString() : "");
                oauth2Token.id = oauth2Token.access_token;
             //   oauth2Token.PartitionKey = "WeChatOauth2Token";
              //  oauth2Token = await SaveOrUpdate<WeChatToken>(oauth2Token);


            }
            return null;
        }
        /// <summary>
        /// 获取微信AccessToken
        /// </summary>
        /// <param name="Code"></param>
        /// <returns></returns>
        private async Task<WeChatToken> GetWeChatAccessTokenClient()
        {

            string requestUrl = BaseConfigModel.Configuration["WeChat:WeChatAccessTokenUrlClient"] + "appid={{APPID}}&secret={{SECRET}}&code={{CODE}}&grant_type=client_credential";
            requestUrl = requestUrl.Replace("{{APPID}}", BaseConfigModel.Configuration["WeChat:WeChatAppID"]);
            requestUrl = requestUrl.Replace("{{SECRET}}", BaseConfigModel.Configuration["WeChat:WeChatAppSecret"]);
            string info = await HttpHelper.HttpGetAsync(requestUrl);
            return info.FromApiJson<WeChatToken>();
        }


        /// <summary>
        /// 获取微信AccessToken
        /// </summary>
        /// <param name="Code"></param>
        /// <returns></returns>
        private async Task<WeChatToken> GetWeChatAccessToken(string Code)
        {
            if (string.IsNullOrEmpty(Code))
            {
                return null;
            }
            string requestUrl = BaseConfigModel.Configuration["WeChat:WeChatAccessTokenUrlCode"] + "appid={{APPID}}&secret={{SECRET}}&code={{CODE}}&grant_type=authorization_code";
            requestUrl = requestUrl.Replace("{{APPID}}", BaseConfigModel.Configuration["WeChat:WeChatAppID"]);
            requestUrl = requestUrl.Replace("{{SECRET}}", BaseConfigModel.Configuration["WeChat:WeChatAppSecret"]);
            requestUrl = requestUrl.Replace("{{CODE}}", Code);
            string info = await HttpHelper.HttpGetAsync(requestUrl);
            return info.FromApiJson<WeChatToken>();
        }

        /// <summary>
        /// 获取微信登录跳转链接
        /// </summary>
        /// <param name="time">13位时间戳</param>
        /// <returns></returns>
        public Dictionary<string, object> GetWechatConfig(string Time)
        {
            Dictionary<string, object> config = new Dictionary<string, object>();
            config.Add("WeChatAuthorizeUrlCode", BaseConfigModel.Configuration["WeChat:WeChatAuthorizeUrlCode"] + "?appid=" + BaseConfigModel.Configuration["WeChat:WeChatAppID"] + "&redirect_uri={{redirect_uri}}&response_type=code&scope=snsapi_userinfo&state=" + Time + "#wechat_redirect");
            return config;
        }

        public async Task<MiniAPPLoginInfo> VerifyMiniAPP(Dictionary<string, object> dict)
        {
            MiniAPPLoginInfo loginInfo = null;
            if (dict.TryGetValue("js_code", out object js_code))
            {
                if (string.IsNullOrEmpty(js_code != null ? js_code.ToString() : ""))
                {
                    throw new Exception("Validation failure , js_code is null!");
                }
                string requestUrl = BaseConfigModel.Configuration["WeChat:MiniAPPAuthUrl"];
                requestUrl = requestUrl.Replace("{{APPID}}", BaseConfigModel.Configuration["WeChat:MiniAPPID"]);
                requestUrl = requestUrl.Replace("{{SECRET}}", BaseConfigModel.Configuration["WeChat:MiniAPPSECRET"]);
                requestUrl = requestUrl.Replace("{{JSCODE}}", js_code.ToString());
                string info = await HttpHelper.HttpGetAsync(requestUrl);
                loginInfo = info.FromApiJson<MiniAPPLoginInfo>();
                if (loginInfo != null)
                {
                    if (loginInfo.errcode != 0)
                    {
                        throw new Exception(loginInfo.errmsg);
                    }
                }
                else
                {
                    throw new Exception("Validation failure , loginInfo is null !");
                }
            }
            else
            {
                throw new Exception("js_code is null !");
            }
            return loginInfo;
        }

        /// <summary>
        /// 获取微信AccessToken
        /// </summary>
        /// <param name="Code"></param>
        /// <returns></returns>
        public async Task<MiniAPPToken> GetMiniAPPAccessToken()
        {
            string requestUrl = BaseConfigModel.Configuration["WeChat:MiniAPPAccessTokenUrl"];
            requestUrl = requestUrl.Replace("{{APPID}}", BaseConfigModel.Configuration["WeChat:MiniAPPID"]);
            requestUrl = requestUrl.Replace("{{SECRET}}", BaseConfigModel.Configuration["WeChat:MiniAPPSECRET"]);
            string info = await HttpHelper.HttpGetAsync(requestUrl);
            MiniAPPToken miniAPPToken = info.FromApiJson<MiniAPPToken>();
            if (miniAPPToken != null)
            {
                if (miniAPPToken.errcode != 0)
                {
                    throw new Exception(miniAPPToken.errmsg);
                }
            }
            else
            {
                throw new Exception("Validation failure,miniAPPToken is null!");
            }
            return miniAPPToken;
        }
        /// <summary>
        /// 获取用户登录信息
        /// </summary>
        /// <param name="unionid"></param>
        /// <param name="access_token"></param>
        /// <returns></returns>
        public   WeChatUser GetWeChatUserInfo(string session_key, Dictionary<string, object> dict)
        {
            string enData = "";
            if (dict.TryGetValue("encryptedData", out object encryptedData) && dict.TryGetValue("iv", out object iv))
            {
                if (encryptedData != null && iv != null)
                {
                    /**
                     *{"openId":"oLaYK45lBS8HWSAXJisDdIlEWj3A",
                     * "nickName":"菁華浮梦、℡",
                     * "gender":1,
                     * "language":"zh_CN",
                     * "city":"Chengdu",
                     * "province":"Sichuan",
                     * "country":"China",
                     * "avatarUrl":"https://wx.qlogo.cn/mmopen/vi_32/DYAIOgq83er98z4MsFd1xKML71TwQuR1Bxnt7ib3SGrNsKiaBCLYbLeS7KAT8h0ia8byiaVzurvEpVmmQpSzBQs5Nw/132",
                     * "unionId":"oqADO5qdTR6PItxhmDEPCsWU9PqI",
                     * "watermark":{"timestamp":1562224447,"appid":"wxf4905703824211aa"}}
                     **/
                    enData = WeChatCryptHelper.AESDecrypt(encryptedData.ToString(), session_key, iv.ToString());

                }
            }

            //string requestUrl = BaseConfigModel.Configuration["WeChat:UnionidUserinfo"];
            //requestUrl = requestUrl.Replace("{{openid}}", unionid);
            //WeChatToken weChatToken = await GetWeChatAccessTokenClient();
            //requestUrl = requestUrl.Replace("{{access_token}}", weChatToken.access_token);
            //string info = await HttpHelper.HttpGetAsync(requestUrl);
            MiniAPPUserInfo miniAPPUser = enData.FromApiJson<MiniAPPUserInfo>();
            if (miniAPPUser != null)
            {

                Expression<Func<WeChatUser, bool>> linq = null;
                linq = l => l.unionId == miniAPPUser.unionId;
                var weChatUsers = weChatUserService.GetList(linq);

                
                //   await SaveOrUpdate<WeChatUser>(weChatUser);
             
                if (weChatUsers.IsNotEmpty())
                {
                    var weChatUser = weChatUsers[0];
                    weChatUser.nickName = miniAPPUser.nickName;
                    weChatUser.gender = miniAPPUser.gender;
                    weChatUser.avatarUrl = miniAPPUser.avatarUrl;
                    weChatUser.country = miniAPPUser.country;
                    weChatUser.city = miniAPPUser.city;
                    weChatUser.province = miniAPPUser.province;
                    weChatUser.openId = miniAPPUser.openId;
                    weChatUser.unionId = miniAPPUser.unionId;
                    weChatUserService.Update(weChatUser);
                    return weChatUser;
                }
                else {
                    var   weChatUser = new WeChatUser();
                    weChatUser.id = Guid.NewGuid().ToString();
                    weChatUser.nickName = miniAPPUser.nickName;
                    weChatUser.gender = miniAPPUser.gender;
                    weChatUser.avatarUrl = miniAPPUser.avatarUrl;
                    weChatUser.country = miniAPPUser.country;
                    weChatUser.city = miniAPPUser.city;
                    weChatUser.province = miniAPPUser.province;
                    weChatUser.openId = miniAPPUser.openId;
                    weChatUser.unionId = miniAPPUser.unionId;
                    weChatUser.registerTime = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds();
                    weChatUserService.Insert(weChatUser);
                    return weChatUser;
                }
            }
            else
            {
                throw new Exception("Validation failure,miniAPPToken is null!");
            }
        }
        public async Task<JwtResponse> MiniAPPLogin(Dictionary<string, object> dict)
        {
            MiniAPPLoginInfo loginInfo = await VerifyMiniAPP(dict);
            WeChatUser weChatUser =   GetWeChatUserInfo(loginInfo.session_key, dict);
            JwtResponse jwt = CreateJwtToken(weChatUser, loginInfo.session_key);
            LoginInfo login = new LoginInfo();
            login.id = Guid.NewGuid().ToString();
          //  login.PartitionKey = weChatUser.PartitionKey;
            login.TeamModelId = weChatUser.unionId;
            login.Token = jwt.Access_token;
            login.Scope = jwt.Scope;
            return jwt;
        }
        public JwtResponse CreateJwtToken(WeChatUser user, string sessionKey)
        {
            ClaimModel model = new ClaimModel
            {
                Scope = "MiniAPP"
            };
            if (user != null)
            {
                model.Claims.Add(new Claim(JwtClaimTypes.SessionId, sessionKey));
                model.Claims.Add(new Claim(JwtClaimTypes.Name, user.nickName));
                model.Claims.Add(new Claim(JwtClaimTypes.Id, user.unionId));
                model.Claims.AddRange("learner".Split(',').Select(s => new Claim(JwtClaimTypes.Role, s)));
                model.Roles.Add("learner");
                JwtResponse jwtResponse = JwtHelper.IssueJWT(model);
                return jwtResponse;
            }
            else
            {
                throw new Exception("Validation failure,user is null !");
            }
        }
    }
}