smartfuel_Lite/FuelCloud/src/Fuel.Payment.Service/WeChatPaymentProcessor/Wechat/WechatPaymentProcessor.cs

using Aop.Api.Domain;
using DFS.Core.Abstractions.View;
using Fuel.Core.Models;
using Fuel.Payment.Core;
using Fuel.Payment.Core.Enum;
using Fuel.Payment.Core.Models;
using Fuel.Payment.Service.Factory;
using Newtonsoft.Json;
using Org.BouncyCastle.Asn1.X509;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Reflection.PortableExecutable;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;
using Wechat.PayAPI;



namespace Fuel.Payment.Service.WeChatPaymentProcessor.Wechat
{
    public class WechatPaymentProcessor : AsyncPaymentProcessor
    {
        private NLog.Logger logger = NLog.LogManager.GetLogger("Main");
        public override async Task<GenericProcessResponse> Cancel(ElectronicOrderModel order)
        {
            Log.Info("MicroPay", "Micropay failure, reverse order " + order.BillNumber);

            order.TradeStatus = TradeStatus.CANCELLING;

            var result = await MicroPay.Cancel(order.BillNumber, (WayneCloud.Models.Models.WxPayConfig)order.Config, (X509Certificate2)order.Certification);

            if (result)
            {
                Log.Info("MicroPay", "Micropay Cancel Order successed, order " + order.BillNumber + " has been closed.");
                order.TradeStatus = TradeStatus.CLOSED;
            }
            return new GenericProcessResponse();
        }

        public override async Task<GenericProcessResponse> Process(ElectronicOrderModel order)
        {
            order.Config = Initialize(order).Result?.electronicOrderModel?.Config;
            order.Certification = Initialize(order).Result?.electronicOrderModel?.Certification;
            TradeStatus tradeStatus = TradeStatus.PAYERROR;
            var response = new GenericProcessResponse()
            {
                WeChatResponse = new WxPayData()
            };
            if (order.Optional.ContainsKey("preCreatedBillNumber"))
            {
                response = await Query(order, 40, 2000);
                if (response.WeChatResponse.IsSet("trade_state") &&
                    response.WeChatResponse.GetValue("trade_state") as string == "SUCCESS")
                {
                    tradeStatus = TradeStatus.SUCCESS;
                    logger.Info("MicroPay TradeStatus.SUCCESS", $"The final MicroPay response is: {response.WeChatResponse.GetValue("trade_state")}");
                }
                else
                {
                    if (response.WeChatResponse.IsSet("trade_state"))
                    {
                        logger.Info("MicroPay", $"The final MicroPay response is: {response.WeChatResponse.GetValue("trade_state")}");
                    }
                    else
                    {
                        logger.Info("MicroPay", $"The final MicroPay response is: {response.WeChatResponse.GetValue("trade_state")}");
                    }
                }
            }
            else
            {
                response.WeChatResponse = await MicroPay.Run(ModelMapper.ConvertToWayneCloudModel(order));
            }

            logger.Info("MicroPay", "The final MicroPay response is: \r\n" + response.WeChatResponse.ToXml());
            return response;
        }

        public override async Task<GenericProcessResponse> Query(ElectronicOrderModel order)
        {
            return await Query(order, 1, 2000);
        }

        public override async Task<GenericProcessResponse> Query(ElectronicOrderModel order, int count, int interval)
        {
            order.TradeStatus = TradeStatus.PAYERROR;
            try
            {
                Log.Info("MicroPay", "Wechat OrderQuery is processing order: " + order.BillNumber);
                var result = await MicroPay.RunQuery(ModelMapper.ConvertToWayneCloudModel(order), count, interval);

                Log.Info("MicroPay", "Wechat OrderQuery process complete, result : \r\n" + result.ToXml());
                order.TradeStatus = TradeStatus.SUCCESS;
                return new GenericProcessResponse()
                {
                    WeChatResponse = result
                };
            }
            catch (Exception e)
            {
                return new GenericProcessResponse()
                {
                };
            }
          
        }

        public override async Task<GenericProcessResponse> Return(ElectronicOrderModel order)
        {
            Log.Info("MicroPay", "MicroPay is processing refund, BillNumber = " + order.BillNumber);
            order.Config = Initialize(order).Result?.electronicOrderModel?.Config;
            order.Certification = Initialize(order).Result?.electronicOrderModel?.Certification;
            TradeStatus tradeStatus;
            //var result = Refund.Run("", order.BillNumber, 
            //    order.TotalAmount.ToString(), order.NetAmount.ToString(), out tradeStatus);
            var result = await Refund.Run("", ModelMapper.ConvertToWayneCloudModel(order));

            Log.Info("MicroPay", "The final MicroPay response is: \r\n" + result.ToXml());
            var Generic = new GenericProcessResponse()
            {
                WeChatResponse = result
            };
            var ProcessResults = await ReturnResult(Generic, order);
            Generic.ProcessResults = ProcessResults.ProcessResults;
            return Generic;
        }

        public override async Task<GenericProcessResponse> UnifiedOrder(ElectronicOrderModel order)
        {
            try
            {
                order.Config = Initialize(order).Result?.electronicOrderModel?.Config;
                order.Certification = Initialize(order).Result?.electronicOrderModel?.Certification;
                Log.Info("UnifiedOrder", "UnifiedOrder is processing order " + order.BillNumber);
                var result = await MicroPay.UnifiedOrder(ModelMapper.ConvertToWayneCloudModel(order));

                Log.Info("UnifiedOrder", "The final MicroPay UnifiedOrder is: \r\n" + result.ToXml());
                var Generic = new GenericProcessResponse()
                {
                    WeChatResponse = result
                };
                var ProcessResults = await UnifiedOrderResult(Generic, order);
                Generic.UnifiedOrderResult = ProcessResults;
                return Generic;
            }
            catch (Exception ex)
            {
                Log.Info("UnifiedOrder", "WechatPaymentProcessor :" + ex.Message);
                return new GenericProcessResponse()
                {

                };
            }
        }

        protected override async Task<GenericProcessResponse> Initialize(ElectronicOrderModel order)
        {
            try
            {
                string sourceFilePath = @"C:\cw\Code\smartfuel_lite\FuelCloud\src\Fuel.Payment.Server\File\Certificate\12345678-9abc-def0-1234-56789abcdef0\apiclient_cert.p12";
                //string sourceFilePath = @"D:/fuelcloud/fabu/File/Certificate/12345678-9abc-def0-1234-56789abcdef0/apiclient_cert.p12";
                string config = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<WxPayConfig>  \r\n  <APPID>wxb198dafff060e651</APPID>  \r\n  <SUBAPPID></SUBAPPID>\r\n  <MINI_PROGRAM_APPID>wxb198dafff060e651</MINI_PROGRAM_APPID>\r\n  <MCHID>1617253894</MCHID>\r\n  <SUBMCHID></SUBMCHID>\r\n  <KEY>Kguangzhouhengshangongsi20250211</KEY>\r\n  <APPSECRET>2e6ee037b95c8fb90eb415bb559f8259</APPSECRET>\r\n  <SSLCERT>apiclient_cert.p12</SSLCERT>\r\n  <SSLCERT_PASSWORD>1617253894</SSLCERT_PASSWORD>\r\n  <NOTIFY_URL>http://paysdk.weixin.qq.com/example/ResultNotifyPage.aspx</NOTIFY_URL>\r\n  <IP>8.8.8.8</IP>\r\n  <PROXY_URL>http://10.152.18.220:8080</PROXY_URL>\r\n  <REPORT_LEVENL>1</REPORT_LEVENL>\r\n</WxPayConfig>";
                FileHandler fileHandler = new FileHandler();
                byte[] fileBytes = fileHandler.ReadFileToByteArray(sourceFilePath);
                order.Certification = fileHandler.GetWxPayCertificationInfo(fileBytes, "1617253894").Result.Certification;
                WayneCloud.Models.Models.WxPayConfig wxPayConfig = WayneCloud.Models.Models.WxPayConfig.DeserializeFromXmlString(config);
                order.Config = wxPayConfig;
                return new GenericProcessResponse()
                {
                    electronicOrderModel = order
                };
            }
            catch(Exception ex)
            {
                Log.Info("UnifiedOrder", "Initialize :" + ex.Message);
                return new GenericProcessResponse()
                {

                };
            }

        }

        protected override async Task<ElectronicOrderModel> PaymentResult(GenericProcessResponse order, ElectronicOrderModel electronicOrderModel)
        {
            throw new NotImplementedException();
        }


        /// <summary>
        /// 统一下单结果
        /// </summary>
        /// <param name="processResponse"></param>
        /// <param name="eOrder"></param>
        /// <returns></returns>

        protected override async Task<object> UnifiedOrderResult(GenericProcessResponse order, ElectronicOrderModel electronicOrderModel)
        {
            var returnCode = ReturnCode.PAY_ERROR;
            object response = null;
            var wechatResponse = order.WeChatResponse;
            if (electronicOrderModel.TradeStatus == TradeStatus.SUCCESS && wechatResponse.IsSet("prepay_id"))
            {
                var prepayId = wechatResponse.GetValue("prepay_id");
                var payInfo = new PayInfo();

                var config = electronicOrderModel.Config as WayneCloud.Models.Models.WxPayConfig;
                payInfo.appId = config.MINI_PROGRAM_APPID;
                payInfo.package = "prepay_id=" + prepayId;
                payInfo.signType = "MD5";
                payInfo.timeStamp = WayneCloud.Models.Models.SignUtility.GetSecondsSince1970();
                payInfo.nonceStr = WayneCloud.Models.Models.SignUtility.GenerateRondomString(new Random(), 32);
                payInfo.paySign = WayneCloud.Models.Models.SignUtility.GenerateSignature(WayneCloud.Models.Models.SignUtility.BuildSignData(payInfo), config.KEY);
                payInfo.billNumber = electronicOrderModel.BillNumber;
                response = payInfo;
            }
            electronicOrderModel.UnifiedOrderResult = response;
            return electronicOrderModel;
        }

        protected override async Task<ElectronicOrderModel> ReturnResult(GenericProcessResponse processResponse, ElectronicOrderModel eOrder)
        {
            var returnCode = ReturnCode.PAY_ERROR;
            var wechatResponse = processResponse.WeChatResponse;
            if (eOrder.TradeStatus == TradeStatus.SUCCESS)
            {
                returnCode = ReturnCode.OK;
            }
            else
            {
                returnCode = ReturnCode.PAY_ERROR;

                if (!eOrder.IsRefund)
                {
                    //cancelOrder = true;

                }
            }
            List<ElectronicOrderProcessResultModel> electronicOrderProcessResultModels = new List<ElectronicOrderProcessResultModel>();
            electronicOrderProcessResultModels.Add(new ElectronicOrderProcessResultModel()
            {
                BillNumber = eOrder.BillNumber,
                ResultCode = ((int)returnCode).ToString(CultureInfo.InvariantCulture),
                ResultMessage = returnCode.ToString(),
                ErrorDetail = wechatResponse.IsSet("err_code") ? wechatResponse.GetValue("err_code").ToString() : "",
                RawResult = wechatResponse.ToXml()
            });
            eOrder.ProcessResults = electronicOrderProcessResultModels;
            return eOrder;
        }

    }
}