qlhb/Ropin.Inspection.Api/Controllers/Base/WxController.cs

using Autofac.Core;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Options;
using Newtonsoft.Json;
using NPOI.SS.Formula.Functions;
using Ropin.Core.Extensions;
using Ropin.Inspection.Api.Common;
using Ropin.Inspection.Api.Common.Options;
using Ropin.Inspection.Api.Common.Token;
using Ropin.Inspection.Api.Filters;
using Ropin.Inspection.Api.Wx;
using Ropin.Inspection.Common.Helper;
using Ropin.Inspection.Model.Entities;
using Ropin.Inspection.Model.ViewModel;
using Ropin.Inspection.Service.Interface;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Security.Claims;
using System.Threading.Tasks;
using System.Xml;

namespace Ropin.Inspection.Api.Controllers
{
    public class WxController : BaseController
    {
        private readonly IOptionsMonitor<WXOptions> _options;
        private readonly IHttpClientFactory _httpClientFactory;
        private readonly IMemoryCache _memoryCache;
        private readonly ITsysUserService _userService;
        private readonly ITokenHelper _tokenHelper;

        public WxController(IOptionsMonitor<WXOptions> options, IHttpClientFactory httpClientFactory, IMemoryCache memoryCache, ITsysUserService userService, ITokenHelper tokenHelper)
        {
            _options = options;
            _httpClientFactory = httpClientFactory;
            _memoryCache = memoryCache;
            _userService = userService;
            _tokenHelper = tokenHelper;
        }
        // GET: api/<controller>
        [HttpGet]
        public ActionResult Get(SignatureModel signatureModel)
        {
            signatureModel.Token = _options.Get("WXOptions").Token;
            string rtnStr;
            if (SignatureHelper.Check(signatureModel))
            {
                rtnStr = signatureModel.Echostr;
            }
            else
            {
                rtnStr = signatureModel.Signature + signatureModel.Timestamp + signatureModel.Nonce + signatureModel.Echostr;
            }
            return Content(rtnStr);
        }
        /// <summary>
        /// 获取ai公众号的openID
        /// </summary>
        /// <returns></returns>
        [HttpGet("GetOpenId")]
        [AllowAnonymous]
        public async Task<ApiResult> GetOpenId(string jsCode)
        {
            var openid = await (new WeChatHelper(_httpClientFactory)).GetOpenIdByCodeAsync(jsCode);
            return new ApiResult<string>(openid, ReturnCode.Success);
        }


        /// <summary>
        /// 获取ai公众号的openID
        /// </summary>
        /// <returns></returns>
        [HttpGet("GetQRCode")]
        [AllowAnonymous]
        public async Task<ApiResult> GetQRCode()
        {
            var openid = await (new WeChatHelper(_httpClientFactory)).GetQRCode();
            return new ApiResult<WeChatQrCodeModel>(openid, ReturnCode.Success);
        }

        /// <summary>
        /// 服务器配置认证
        /// </summary>
        /// <param name="signature"></param>
        /// <param name="timestamp"></param>
        /// <param name="nonce"></param>
        /// <param name="echostr"></param>
        /// <returns></returns>
        [HttpGet("event")]
        [AllowAnonymous]
        public async Task<IActionResult> Verify(
            [FromQuery] string signature,
            [FromQuery] string timestamp,
            [FromQuery] string nonce,
            [FromQuery] string echostr)
        {
            try
            {
                using var reader = new StreamReader(Request.Body);
                var xmlContent = await reader.ReadToEndAsync();
            }
            catch (Exception ex)
            {
                // 记录日志
                return StatusCode(500);
            }
            // 验证逻辑可在此添加
            return Content(echostr);
        }

        /// <summary>
        /// 服务器事件推送
        /// </summary>
        /// <returns></returns>
        [HttpPost("event")]
        [AllowAnonymous]
        public async Task<IActionResult> HandleEvent()
        {
            try
            {
                using var reader = new StreamReader(Request.Body);
                var xmlContent = await reader.ReadToEndAsync();
                var xmlDoc = new XmlDocument();
                xmlDoc.LoadXml(xmlContent);

                var message = new Dictionary<string, string>();
                foreach (XmlNode node in xmlDoc.DocumentElement.ChildNodes)
                {
                    message[node.Name] = node.InnerText;
                }
                var json = JsonConvert.SerializeObject(message);
                var callBack = JsonConvert.DeserializeObject<WeChatCallBack>(json);

                //扫码把openid存缓存
                _memoryCache.Set(callBack.Ticket, callBack.FromUserName, TimeSpan.FromMinutes(5));
                //if (_memoryCache.TryGetValue(callBack.Ticket, out string scan))
                //{
                //    _memoryCache.Set(callBack.Ticket, callBack.FromUserName, TimeSpan.FromMinutes(5));
                //}
                //else
                //{
                //    _memoryCache.Set(callBack.Ticket, callBack.FromUserName, TimeSpan.FromMinutes(5));
                //}
                return Ok();
            }
            catch (Exception ex)
            {
                // 记录日志
                return StatusCode(500);
            }
        }

        /// <summary>
        /// 扫码登录
        /// </summary>
        /// <returns></returns>
        [HttpPost("ScanLogin")]
        [AllowAnonymous]
        public async Task<ApiResult> ScanLogin(WeChatQrCodeModel weChatQrCodeModel)
        {
            //扫码把openid存缓存
            if (!_memoryCache.TryGetValue(weChatQrCodeModel.ticket, out string openid))
            {
                return new ApiResult<ComplexToken>(null, ReturnCode.Success,"未收到推送");
            }
            var u = await _userService.GetUserByOpenidAsync(openid);
            if (u is null)
            {
                return new ApiResult(ReturnCode.LoginError, "账户不存在");
            }
            var user = await _userService.GetUserDetailByAsync(new Model.SearchModel.LoginModel { Mobile=u.C_Mobile,Password=u.C_Password,PrivModule= "SYS_PRIV_MODULE_001" });
            
            if (user.RoleTypePrivS == null || user.RoleTypePrivS.Count() == 0)
            {
                return new ApiResult(ReturnCode.LoginPriv, "没有权限");
            }

            var token = _tokenHelper.CreateToken(user);
            return new ApiResult<ComplexToken>(token, ReturnCode.Success);
        }
    }

    public class WeChatCallBack
    {
        public string ToUserName { get; set; }
        public string FromUserName { get; set; }
        public string CreateTime { get; set; }
        public string MsgType { get; set; }
        public string Event { get; set; }
        public string EventKey { get; set; }
        public string Ticket { get; set; }
    }
}