BarbecueApi/Central.Control.WebApi/Service/OrderService.cs

using Ant.Core.Utils;
using Ant.Core.WebApi.Enum;
using Ant.Core.WebApi.Model;
using Aop.Api.Util;
using Central.Control.WebApi.Config;
using Central.Control.WebApi.DbEntity;
using Central.Control.WebApi.EFDbContext;
using Central.Control.WebApi.Enum;
using Central.Control.WebApi.Log4net;
using Central.Control.WebApi.Models.Request;
using Central.Control.WebApi.Models.Response;
using Central.Control.WebApi.Service.Interface;
using Com.Alipay;
using Com.Alipay.Business;
using Com.Alipay.Domain;
using Com.Alipay.Model;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Configuration;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;

namespace Central.Control.WebApi.Service
{
    /// <summary>
    /// 
    /// </summary>
    public class OrderService: IOrderService
    {
        IAlipayTradeService serviceClient = F2FBiz.CreateClientInstance(AliPayConfig.serverUrl, AliPayConfig.appId, AliPayConfig.merchant_private_key, AliPayConfig.version,
                           AliPayConfig.sign_type, AliPayConfig.alipay_public_key, AliPayConfig.charset);

        /// <summary>
        /// 支付宝回写地址
        /// </summary>
        public readonly static string aliNotifyUrl = ConfigurationManager.AppSettings["aliNotifyUrl"].ToString();
        /// <summary>
        /// 支付中间页地址
        /// </summary>
        public readonly static string payRedirectUrl = ConfigurationManager.AppSettings["payredirecturl"].ToString();

        private readonly IDbContext _dbContent;
        private readonly IUserService _userService;
        private readonly ILog4NetHelper _log4NetHelper;
        private readonly IYWLogService _ywLogService;

        /// <summary>
        /// 
        /// </summary>
        /// <param name="dbContent"></param>
        /// <param name="userService"></param>
        /// <param name="log4NetHelper"></param>
        /// <param name="ywLogService"></param>
        public OrderService(
            IDbContext dbContent,
            IUserService userService,
            ILog4NetHelper log4NetHelper,
            IYWLogService ywLogService)
        {
            _dbContent = dbContent;
            _userService = userService;
            _log4NetHelper = log4NetHelper;
            _ywLogService = ywLogService;
        }

        /// <summary>
        /// 下单
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        public ApiResult<OrderResponseDto> Order(OrderRequestDto req)
        {
            #region 1、验证参数
            if (req == null
                || req.OrderInfo == null
                || req.OrderInfo.Count() == 0)
            {
                return new ApiResult<OrderResponseDto>(ApiStatusCode.InvalidParameter, "请求参数不正确");
            }
            #endregion

            #region 2、验证相应数据和库存
            var productIds = req.OrderInfo.Select(p => p.ProductId).ToList();
            var products = _dbContent.Set<YW_Product>().Where(p => p.IsDelete == 0 && p.Sale == Enum.SaleEnum.On && productIds.Contains(p.Id)).ToList();
            if (products.Count() <= 0)
            {
                return new ApiResult<OrderResponseDto>(ApiStatusCode.RecordNotFound, "未找到下单的商品");
            }
            #endregion

            #region 3、包装盒库存验证

            var session = _userService.GetLoginSession();
            // 修改
            var devicePackings = _dbContent.Set<YW_DevicePacking>().Where(p => p.IsDelete == 0 && p.DeviceId == session.UserId).ToList();
            if (devicePackings == null || devicePackings.Count() == 0)
            {
                return new ApiResult<OrderResponseDto>(ApiStatusCode.Forbidden, "包装盒库存不足，请联系工作人员添加包装盒");
            }
            int orderCount = req.OrderInfo.Sum(p => p.Count);
            int packingCount = devicePackings.Sum(p => p.Stock * p.Capacity);
            if (packingCount < orderCount)
            {
                return new ApiResult<OrderResponseDto>(ApiStatusCode.Forbidden, "包装盒库存不足，请联系工作人员添加包装盒");
            }

            // 计算使用的包装盒数量（减包装盒库存）
            var orderCountIndex = orderCount;
            foreach (var devicePacking in devicePackings)
            {
                if (orderCountIndex <= 0)
                {
                    break;// 数量为0了，则直接跳出循环
                }
                int currentPackingStock = devicePacking.Stock;
                for (int i = 0; i < currentPackingStock; i++)
                {
                    // 循环库存
                    if (orderCountIndex <= 0)
                    {
                        break;// 数量为0了，则直接跳出循环
                    }
                    orderCountIndex = orderCountIndex - devicePacking.Capacity;
                    devicePacking.Stock--;// 减库存
                }
            }

            #endregion

            #region 4、商品库存验证
            var orderId = IdGenerator.NewId();
            List<YW_OrderDetails> orderDetailAdds = new List<YW_OrderDetails>();
            List<YW_OrderProcess> orderProcessAdds = new List<YW_OrderProcess>();
            StringBuilder orderName = new StringBuilder();
            foreach (var o in req.OrderInfo)
            {
                var currentProduct = products.FirstOrDefault(p => p.Id == o.ProductId);
                if (currentProduct == null)
                {
                    return new ApiResult<OrderResponseDto>(ApiStatusCode.RecordNotFound, $"{o.ProductId}商品不存在");
                }
                if (currentProduct.Stock < o.Count)
                {
                    return new ApiResult<OrderResponseDto>(ApiStatusCode.Forbidden, $"{currentProduct.Name}商品库存不足，请修改后重新下单");
                }
                // 扣库存
                currentProduct.Stock = currentProduct.Stock - o.Count;

                // orderDetails
                orderDetailAdds.Add(new YW_OrderDetails()
                {
                    Id = IdGenerator.NewId(),
                    OrderId = orderId,
                    ProductId = currentProduct.Id,
                    Name = currentProduct.Name,
                    Code = currentProduct.Code,
                    Img = currentProduct.Img,
                    Info = currentProduct.Info,
                    Price = currentProduct.Price,
                    BuyingPrice = currentProduct.BuyingPrice,
                    Count = o.Count,
                    CreateBY = session.UserId
                });
                if (orderName.Length < 40)
                {
                    orderName.Append($"{currentProduct.Name},");
                }
            }
            #endregion

            #region 5、下单
            YW_Order order = new YW_Order()
            {
                Id = orderId,
                Name = orderName.ToString().TrimEnd(','),
                DeviceId = session.UserId,
                Price = orderDetailAdds.Sum(p => p.Price * p.Count),
                PayStatus = PayStatusEnum.UnPay,
                OrderStatus = OrderStatusEnum.UnPay,
                // PaySerialId = Snowflake.Instance().GetId().ToString(), // 支付流水号，支付完成会回写
                CreateBY = session.UserId
            };
            YW_OrderProcess orderProcess = new YW_OrderProcess()
            {
                Id = IdGenerator.NewId(),
                OrderId = order.Id,
                DeviceId = session.UserId,
                CurrentOrderStatus = OrderStatusEnum.UnPay,
                Message = "下单成功",
                CreateBY = session.UserId
            };
            #endregion

            #region 6、存库
            _dbContent.Set<YW_Order>().Add(order);
            _dbContent.Set<YW_OrderProcess>().Add(orderProcess);
            _dbContent.Set<YW_OrderDetails>().AddRange(orderDetailAdds);

            // 数据库执行 库存已经改过了，会自动保存
            _dbContent.SaveChanges();
            #endregion

            // 写入订单日志
            _ywLogService.WriteOrderLog(order.Id, "下单", "下单成功", session.UserId);

            return new ApiResult<OrderResponseDto>(new OrderResponseDto()
            {
                OrderId = order.Id,
                Price = order.Price,
                QrCode = string.Format(payRedirectUrl, order.Id)
            });
        }

        /// <summary>
        /// 获取待烧烤的商品列表
        /// <summary>
        /// <returns></returns>
        public ApiResult<List<QueueOrderResponseDto>> GetQueueOrders()
        {
            var orders = _dbContent.Set<YW_Order>()
                                    .Where(p => p.IsDelete == 0
                                                && p.PayStatus == PayStatusEnum.Paid
                                                && p.OrderStatus == OrderStatusEnum.Paid)
                                    .OrderBy(p => p.CreateDT).ToList();
            var orderIds = orders.Select(p => p.Id).ToList();

            var orderDetails = _dbContent.Set<YW_OrderDetails>().Where(p => p.IsDelete == 0 && orderIds.Contains(p.OrderId)).ToList();



            List<QueueOrderResponseDto> result = new List<QueueOrderResponseDto>();
            orders.ForEach(item => {
                QueueOrderResponseDto resultItem = new QueueOrderResponseDto()
                {
                    OrderId = item.Id,
                    Price = item.Price,
                    OrderDetails = orderDetails
                                     .Where(p => p.OrderId == item.Id)
                                     .Select(p => SafeClone<YW_OrderDetails, QueueOrderDetailsDto>.Trans(p))
                                     .ToList()
                };
                resultItem.OrderDetails?.ForEach(p => p.Img = $"{ProductService.ImagePrefix}{p.Img}");

                result.Add(resultItem);
            });
            return new ApiResult<List<QueueOrderResponseDto>>(result);
        }

        /// <summary>
        /// 回写流程状态
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        public ApiResult OrderProcess(OrderProcessRequestDto req)
        {
            if (req == null)
            {
                return new ApiResult(ApiStatusCode.InvalidParameter, "请求参数不正确");
            }
            var order = _dbContent.Set<YW_Order>().FirstOrDefault(p => p.Id == req.OrderId);
            if (order == null)
            {
                return new ApiResult(ApiStatusCode.InvalidParameter, "未找到相应订单");
            }
            if (order.PayStatus != PayStatusEnum.Paid)
            {
                return new ApiResult(ApiStatusCode.InvalidParameter, "未支付订单不能回写流程");
            }
            if (order.OrderStatus == OrderStatusEnum.UnPay
                || order.OrderStatus == OrderStatusEnum.Cancel)
            {
                return new ApiResult(ApiStatusCode.InvalidParameter, "未支付或已取消订单不能回写流程");
            }
            var session = _userService.GetLoginSession();
            // 修改订单状态
            order.OrderStatus = req.OrderStatus;
            // 记录订单流程
            YW_OrderProcess orderProcess = new YW_OrderProcess()
            {
                Id = IdGenerator.NewId(),
                OrderId = req.OrderId,
                DeviceId = session.UserId,
                CurrentOrderStatus = req.OrderStatus,
                Message = req.Message,
                CreateBY = session.UserId
            };
            _dbContent.Set<YW_OrderProcess>().Add(orderProcess);
            _dbContent.SaveChanges();

            // 写入订单日志
            _ywLogService.WriteOrderLog(order.Id, "流程回写", $"回写流程状态{req.OrderStatus.ToString()}", session.UserId);

            return new ApiResult();
        }

        /// <summary>
        /// 获取支付宝支付链接
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public string AliPayProcess(string id)
        {
            // 1、先查询订单是否存在
            var order = _dbContent.Set<YW_Order>().FirstOrDefault(p => p.IsDelete == 0 && p.Id == id);
            if (order == null)
            {
                return "http://api.rgtech.ltd/html/ordernotexist.html";
            }
            string result = "http://api.rgtech.ltd/html/error.html";
            // 查询订单详情
            var orderDetails = _dbContent.Set<YW_OrderDetails>().Where(p => p.IsDelete == 0 && p.OrderId == order.Id).ToList();

            #region 拼写支付宝支付参数

            AlipayTradePrecreateContentBuilder builder = new AlipayTradePrecreateContentBuilder();
            //收款账号
            builder.seller_id = AliPayConfig.pid;
            //订单编号
            builder.out_trade_no = order.Id;
            //订单总金额
            builder.total_amount = order.Price.ToString();
            //参与优惠计算的金额
            //builder.discountable_amount = "";
            //不参与优惠计算的金额
            //builder.undiscountable_amount = "";
            //订单名称
            builder.subject = order.Name;
            //自定义超时时间
            builder.timeout_express = "10m";
            //订单描述
            builder.body = "";
            //门店编号，很重要的参数，可以用作之后的营销
            builder.store_id = order.DeviceId;
            //操作员编号，很重要的参数，可以用作之后的营销
            //builder.operator_id = "test";

            //传入商品信息详情
            List<GoodsInfo> gList = orderDetails?.Select(od => new GoodsInfo()
            {
                goods_id = od.Id,
                goods_name = od.Name,
                price = od.Price.ToString(),
                quantity = od.Count.ToString()
            }).ToList() ?? new List<GoodsInfo>();
            builder.goods_detail = gList;

            //系统商接入可以填此参数用作返佣
            //ExtendParams exParam = new ExtendParams();
            //exParam.sysServiceProviderId = "20880000000000";
            //builder.extendParams = exParam;

            #endregion

            //如果需要接收扫码支付异步通知，那么请把下面两行注释代替本行。
            //推荐使用轮询撤销机制，不推荐使用异步通知,避免单边账问题发生。
            AlipayF2FPrecreateResult precreateResult = serviceClient.tradePrecreate(builder, aliNotifyUrl);//商户接收异步通知的地址，采用异步回写通知

            switch (precreateResult.Status)
            {
                case ResultEnum.SUCCESS:
                    result = precreateResult.response.QrCode;
                    break;
                case ResultEnum.FAILED:
                case ResultEnum.UNKNOWN:
                default:
                    // 请求失败，记录日志
                    _log4NetHelper.Error($"[AliPayProcess]-tradePrecreate失败:{JsonConvert.SerializeObject(precreateResult)}");
                    break;
            }
            return result;
        }

        /// <summary>
        /// 支付宝支付回写（已测试好，勿动）
        /// </summary>
        /// <returns></returns>
        public string AliPayNotify()
        {
            _log4NetHelper.Info("[AliPayNotify]-start");
            SortedDictionary<string, string> sPara = GetRequestPost();
            _log4NetHelper.Info("[AliPayNotify]-[原始请求参数]-" + JsonConvert.SerializeObject(sPara));
            
            Notify aliNotify = new Notify(AliPayConfig.charset, AliPayConfig.sign_type, AliPayConfig.pid, AliPayConfig.mapiUrl, AliPayConfig.alipay_public_key);

            string notifyId = HttpContext.Current.Request.Form["notify_id"];
            string sign = HttpContext.Current.Request.Form["sign"];
            _log4NetHelper.Info($"[AliPayNotify]-[基础参数]-notify_id:{notifyId};sign{sign}");

            //对异步通知进行验签
            bool verifyResult = aliNotify.Verify(sPara, notifyId, sign);
            if (verifyResult && CheckParams()) //验签成功 && 关键业务参数校验成功
            {
                _log4NetHelper.Info("[AliPayNotify]-验签成功");

                string paySerialId = HttpContext.Current.Request.Form["trade_no"] ?? string.Empty;
                string outTradeNo = HttpContext.Current.Request.Form["out_trade_no"] ?? string.Empty;
                string payResponse = JsonConvert.SerializeObject(sPara);

                // 写入支付日志-里面有trycatch
                _ywLogService.WritePayCallLog(paySerialId, outTradeNo, PayWayEnum.AliPay, payResponse);

                PayStatusEnum payStatus = PayStatusEnum.Fail;
                if (HttpContext.Current.Request.Form["trade_status"] == "TRADE_SUCCESS")
                {
                    payStatus = PayStatusEnum.Paid;
                }

                PayWriteBackRequestDto payWriteBack = new PayWriteBackRequestDto()
                {
                    PaySerialId = paySerialId,
                    OrderId = outTradeNo,
                    PayStatus = payStatus,
                    PayWay = PayWayEnum.AliPay,
                    BuyerId = HttpContext.Current.Request.Form["buyer_id"] ?? string.Empty,
                    BuyAccount = HttpContext.Current.Request.Form["buyer_logon_id"] ?? string.Empty,
                    SellerId = HttpContext.Current.Request.Form["seller_id"] ?? string.Empty,
                    SellAccount = HttpContext.Current.Request.Form["seller_email"] ?? string.Empty,
                    TotalAmount = ConvertHelper.ToDecimal(HttpContext.Current.Request.Form["total_amount"]),
                    PayAmount = ConvertHelper.ToDecimal(HttpContext.Current.Request.Form["buyer_pay_amount"]),
                    PayTime = ConvertHelper.ToDateTime(HttpContext.Current.Request.Form["gmt_payment"]),
                    PayResponse = payResponse
                };
                // 回写到实际表中
                var result = PayWriteBack(payWriteBack);
                if (!result.IsSuccess)
                {
                    // 失败了
                    _log4NetHelper.Info($"[AliPayNotify]-[支付回写验证失败]-{result.Message}");
                    return "false";
                }
                return "sucess";
            }
            else
            {
                _log4NetHelper.Info("[AliPayNotify]-验签失败！！！");
                return "false";
            }
        }

        /// <summary>
        /// 支付回写（雏形，需要根据实际需要接入支付宝或微信）
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        private ApiResult PayWriteBack(PayWriteBackRequestDto req)
        {
            if (req == null
                || string.IsNullOrWhiteSpace(req.PaySerialId))
            {
                return new ApiResult(ApiStatusCode.InvalidParameter, "请求参数不正确");
            }
            var order = _dbContent.Set<YW_Order>().FirstOrDefault(p => p.Id == req.OrderId);
            if (order == null)
            {
                return new ApiResult(ApiStatusCode.InvalidParameter, "未找到相应订单");
            }
            if (order.Price != req.TotalAmount)
            {
                // 写入订单日志
                string msg = $"回写总金额与订单金额不匹配，订单号{order.Id};订单价格{order.Price};支付流水号{req.PaySerialId};支付订单总金额{req.TotalAmount}";
                _ywLogService.WriteOrderLog(order.Id, "支付回写", msg, req.PayWay.ToString());
                return new ApiResult(ApiStatusCode.InvalidParameter, msg);
            }
            if (order.Price != req.PayAmount)
            {
                // 写入订单日志
                string msg = $"回写支付金额与订单金额不匹配，订单号{order.Id};订单价格{order.Price};支付流水号{req.PaySerialId};支付订单已付金额{req.PayAmount}";
                _ywLogService.WriteOrderLog(order.Id, "支付回写", msg, req.PayWay.ToString());
                return new ApiResult(ApiStatusCode.InvalidParameter, msg);
            }
            var status = GetStatusByPayWriteBack(req.PayStatus);
            // 修改订单状态
            order.PayStatus = status.Item1;
            order.OrderStatus = status.Item2;
            order.PaySerialId = req.PaySerialId;
            // 记录订单流程
            YW_PayCall payCall = new YW_PayCall()
            {
                Id = IdGenerator.NewId(),
                OrderId = req.OrderId,
                PayStatus = status.Item1,
                PaySerialId = req.PaySerialId,
                PayWay = req.PayWay,
                BuyerId = req.BuyerId,
                BuyAccount = req.BuyAccount,
                SellerId = req.SellerId,
                SellAccount = req.SellAccount,
                PayAmount = req.PayAmount,
                PayTime = req.PayTime,
                PayResponse = req.PayResponse,
                CreateBY = req.BuyAccount
            };
            _dbContent.Set<YW_PayCall>().Add(payCall);
            _dbContent.SaveChanges();

            // 记录订单日志
            _ywLogService.WriteOrderLog(order.Id, "支付回写", "回写成功", req.PayWay.ToString());

            return new ApiResult();
        }

        /// <summary>
        /// 支付测试
        /// </summary>
        /// <returns></returns>
        public ApiResult<AlipayF2FPrecreateResult> PayTest()
        {

            AlipayTradePrecreateContentBuilder builder = BuildPrecreateContent();
            string out_trade_no = builder.out_trade_no;

            //如果需要接收扫码支付异步通知，那么请把下面两行注释代替本行。
            //推荐使用轮询撤销机制，不推荐使用异步通知,避免单边账问题发生。
            // AlipayF2FPrecreateResult precreateResult = serviceClient.tradePrecreate(builder);
            string notify_url = aliNotifyUrl;  //商户接收异步通知的地址
            AlipayF2FPrecreateResult precreateResult = serviceClient.tradePrecreate(builder, notify_url);

            //以下返回结果的处理供参考。
            //payResponse.QrCode即二维码对于的链接
            //将链接用二维码工具生成二维码打印出来，顾客可以用支付宝钱包扫码支付。
            string result = "";


            return new ApiResult<AlipayF2FPrecreateResult>(precreateResult);
            //switch (precreateResult.Status)
            //{
            //    case ResultEnum.SUCCESS:
            //        DoWaitProcess(precreateResult);
            //        txtRCCode.Text = precreateResult.response.QrCode;
            //        break;
            //    case ResultEnum.FAILED:
            //        result = precreateResult.response.Body;
            //        Response.Redirect("result.aspx?Text=" + result);
            //        break;

            //    case ResultEnum.UNKNOWN:
            //        if (precreateResult.response == null)
            //        {
            //            result = "配置或网络异常，请检查后重试";
            //        }
            //        else
            //        {
            //            result = "系统异常，请更新外部订单后重新发起请求";
            //        }
            //        Response.Redirect("result.aspx?Text=" + result);
            //        break;
            //}


        }

        /// <summary>
        /// 构造支付请求数据
        /// </summary>
        /// <returns>请求数据集</returns>
        private AlipayTradePrecreateContentBuilder BuildPrecreateContent()
        {
            AlipayTradePrecreateContentBuilder builder = new AlipayTradePrecreateContentBuilder();
            //收款账号
            builder.seller_id = AliPayConfig.pid;
            //订单编号-----------------------
            builder.out_trade_no = DateTime.Now.ToString("yyyyMMddHHmmss") + "0000" + (new Random()).Next(1, 10000).ToString();
            //订单总金额-----------------------------
            builder.total_amount = "0.02";
            //参与优惠计算的金额
            //builder.discountable_amount = "";
            //不参与优惠计算的金额
            //builder.undiscountable_amount = "";
            //订单名称-------------------------------
            builder.subject = "smj_webapi测试订单";
            //自定义超时时间
            builder.timeout_express = "5m";
            //订单描述
            builder.body = "";
            //门店编号，很重要的参数，可以用作之后的营销--------------------
            builder.store_id = "test store id";
            //操作员编号，很重要的参数，可以用作之后的营销---------------------
            builder.operator_id = "test";

            //传入商品信息详情
            List<GoodsInfo> gList = new List<GoodsInfo>();
            GoodsInfo goods = new GoodsInfo();
            goods.goods_id = "goods id";
            goods.goods_name = "goods name";
            goods.price = "0.02";
            goods.quantity = "1";
            gList.Add(goods);
            builder.goods_detail = gList;

            //系统商接入可以填此参数用作返佣
            //ExtendParams exParam = new ExtendParams();
            //exParam.sysServiceProviderId = "20880000000000";
            //builder.extendParams = exParam;

            return builder;

        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="payStatus"></param>
        /// <returns></returns>
        private Tuple<PayStatusEnum, OrderStatusEnum> GetStatusByPayWriteBack(PayStatusEnum payStatus)
        {
            // 临时：payStatus 0失败，1成功
            OrderStatusEnum orderStatus = OrderStatusEnum.UnPay;
            switch (payStatus)
            {
                case  PayStatusEnum.Paid:// 成功
                    orderStatus = OrderStatusEnum.Paid;
                    break;
                default:// 失败
                    break;
            }

            return new Tuple<PayStatusEnum, OrderStatusEnum>(payStatus, orderStatus);
        }

        /// <summary>
        /// 获取支付宝POST过来通知消息，并以“参数名=参数值”的形式组成数组
        /// </summary>
        /// <returns>request回来的信息组成的数组</returns>
        private SortedDictionary<string, string> GetRequestPost()
        {
            int i = 0;
            SortedDictionary<string, string> sArray = new SortedDictionary<string, string>();
            NameValueCollection coll;
            //Load Form variables into NameValueCollection variable.
            coll = HttpContext.Current.Request.Form;

            // Get names of all forms into a string array.
            String[] requestItem = coll.AllKeys;

            for (i = 0; i < requestItem.Length; i++)
            {
                sArray.Add(requestItem[i], HttpContext.Current.Request.Form[requestItem[i]]);
            }

            return sArray;
        }

        /// <summary>
        /// 对支付宝异步通知的关键参数进行校验
        /// </summary>
        /// <returns></returns>
        private bool CheckParams()
        {
            bool ret = true;

            //获得调用方的appid；
            //如果是非授权模式，appid是商户的appid；如果是授权模式（token调用），appid是系统商的appid
            string app_id = HttpContext.Current.Request.Form["app_id"];
            if (app_id != AliPayConfig.appId)
            {
                ret = false;
                _log4NetHelper.Info($"[支付回写][appid认证失败]：request_appid:{app_id};sys_appid:{AliPayConfig.appId}");
            }
            return ret;
        }

    }
}