using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using POSV.HttpApi;
using POSV.Utils;
using POSV.Stock;
using POSV.WeiXin;
using POSV.Entity.WeiXinDc;

namespace POSV.Card
{
    public class WeiXinOrderUtils
    {
        private static NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();

        protected static Dictionary<string , string> _errorDesc = new Dictionary<string , string>();

        static WeiXinOrderUtils()
        {
            //------------------------------------------------------
            //系统没有定义的错误代码
            _errorDesc.Add("9999" , "应答的报文解析异常");
        }

        /// <summary>
        /// 微信点餐商品停售
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public static Tuple<bool, string, WeiXinEntityResponse<string>> WxdcGoodsSellOut(WxdcGoodsSellOutRequest request)
        {
            Tuple<bool, string, WeiXinEntityResponse<string>> result = null;

            try
            {
                OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
                SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);

                parameters.Add("method", "wxdc.goods.sellout");
                parameters.Add("storeId", request.StoreId);
                parameters.Add("productIds", request.ProductIds);
                var ignoreParameters = new List<string>();
                ignoreParameters.Add("productIds");
                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);

                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<WeiXinEntityResponse<string>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, WeiXinEntityResponse<string>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, WeiXinEntityResponse<string>>(false, data.ErrMessage, data);
                    }
                }
                else
                {
                    string errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, WeiXinEntityResponse<string>>(false, errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "商品停售异常");

                result = new Tuple<bool, string, WeiXinEntityResponse<string>>(false, "商品停售异常,本次操作无效", null);
            }

            return result;
        }

        /// <summary>
        /// 微信点餐商品开卖
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public static Tuple<bool, string, WeiXinEntityResponse<string>> WxdcGoodsSellin(WxdcGoodsSellinRequest request)
        {
            Tuple<bool, string, WeiXinEntityResponse<string>> result = null;

            try
            {
                OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
                SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);

                parameters.Add("method", "wxdc.goods.sellin");
                parameters.Add("storeId", request.StoreId);
                parameters.Add("productIds", request.ProductIds);
                var ignoreParameters = new List<string>();
                ignoreParameters.Add("productIds");
                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);

                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<WeiXinEntityResponse<string>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, WeiXinEntityResponse<string>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, WeiXinEntityResponse<string>>(false, data.ErrMessage, data);
                    }
                }
                else
                {
                    string errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, WeiXinEntityResponse<string>>(false, errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "点餐商品开卖异常");

                result = new Tuple<bool, string, WeiXinEntityResponse<string>>(false, "点餐商品开卖异常,本次操作无效", null);
            }

            return result;
        }

        /// <summary>
        /// 商品分类列表
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public static Tuple<bool, string, WeiXinListResponse<WxdcGoodsCategoryEntity>> WxdcGoodsCategory(WxdcGoodsCategoryListRequest request)
        {
            Tuple<bool, string, WeiXinListResponse<WxdcGoodsCategoryEntity>> result = null;

            try
            {
                OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
                SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);
                parameters.Add("method", "wxdc.goods.category");
                parameters.Add("storeId", request.StoreId);
                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);

                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<WeiXinListResponse<WxdcGoodsCategoryEntity>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, WeiXinListResponse<WxdcGoodsCategoryEntity>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, WeiXinListResponse<WxdcGoodsCategoryEntity>>(false, data.ErrMessage, data);
                    }
                }
                else
                {
                    string errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, WeiXinListResponse<WxdcGoodsCategoryEntity>>(false, errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "微信商品分类查询异常");

                result = new Tuple<bool, string, WeiXinListResponse<WxdcGoodsCategoryEntity>>(false, "微信商品分类查询异常,本次操作无效", null);
            }

            return result;
        }

        /// <summary>
        /// 商品信息列表
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public static Tuple<bool, string, WeiXinPagerResponse<WxdcGoodsEntity>> WxdcGoods(WxdcGoodsListRequest request)
        {
            Tuple<bool, string, WeiXinPagerResponse<WxdcGoodsEntity>> result = null;

            try
            {
                OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
                SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);

                parameters.Add("method", "wxdc.goods.list");

                parameters.Add("storeId", request.StoreId);
                parameters.Add("categoryId", request.CategoryId);
                parameters.Add("property", request.Property);
                parameters.Add("keyword", request.Keyword);
                parameters.Add("pageNumber", string.Format("{0}", request.PageNumber));
                parameters.Add("pageSize", string.Format("{0}", request.PageSize));
                var ignoreParameters = new List<string>();
                ignoreParameters.Add("categoryId");
                ignoreParameters.Add("property");
                ignoreParameters.Add("keyword");
                ignoreParameters.Add("pageNumber");
                ignoreParameters.Add("pageSize");
                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);

                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<WeiXinPagerResponse<WxdcGoodsEntity>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, WeiXinPagerResponse<WxdcGoodsEntity>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, WeiXinPagerResponse<WxdcGoodsEntity>>(false, data.ErrMessage, data);
                    }
                }
                else
                {
                    string errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, WeiXinPagerResponse<WxdcGoodsEntity>>(false, errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "微信商品信息查询异常");

                result = new Tuple<bool, string, WeiXinPagerResponse<WxdcGoodsEntity>>(false, "微信商品信息查询异常,本次操作无效", null);
            }

            return result;
        }

        /// <summary>
        /// 门店拒绝退款
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public static Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderRefundRefuseResponse>> WeiXinOrderRefundRefuse(WeiXinOrderRefundRefuseRequest request)
        {
            Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderRefundRefuseResponse>> result = null;

            try
            {
                OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
                SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);

                parameters.Add("method", "wxdc.order.refund.store.refuse");
                parameters.Add("erpStoreId", request.StoreId);
                parameters.Add("ticketId", request.TicketId);
                parameters.Add("refuseReason", request.RefuseReason);
                var ignoreParameters = new List<string>();
                ignoreParameters.Add("refuseReason");
                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);

                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<WeiXinEntityResponse<WeiXinOrderRefundRefuseResponse>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderRefundRefuseResponse>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderRefundRefuseResponse>>(false, data.ErrMessage, data);
                    }
                }
                else
                {
                    string errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderRefundRefuseResponse>>(false, errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "门店拒绝退款失败");

                result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderRefundRefuseResponse>>(false, "门店拒绝退款失败,本次操作无效", null);
            }

            return result;
        }

        /// <summary>
        /// 门店同意退款
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public static Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderRefundAgreeResponse>> WeiXinOrderRefundAgree(WeiXinOrderRefundAgreeRequest request)
        {
            Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderRefundAgreeResponse>> result = null;

            try
            {
                OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
                SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);

                parameters.Add("method", "wxdc.order.refund.store.agree");
                parameters.Add("erpStoreId", request.StoreId);
                parameters.Add("ticketId", request.TicketId);

                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);

                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<WeiXinEntityResponse<WeiXinOrderRefundAgreeResponse>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderRefundAgreeResponse>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderRefundAgreeResponse>>(false, data.ErrMessage, data);
                    }
                }
                else
                {
                    string errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderRefundAgreeResponse>>(false, errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "门店同意退款失败");

                result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderRefundAgreeResponse>>(false, "门店同意退款失败,本次操作无效", null);
            }

            return result;
        }

        /// <summary>
        /// 门店营业状态修改
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public static Tuple<bool, string, WeiXinEntityResponse<WeiXinShopOpenResponse>> WeiXinShopOpen(WeiXinShopOpenRequest request)
        {
            Tuple<bool, string, WeiXinEntityResponse<WeiXinShopOpenResponse>> result = null;

            try
            {
                OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
                SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);

                parameters.Add("method", "wxdc.store.open.status.update");
                parameters.Add("erpStoreId", request.StoreId);
                parameters.Add("openStatus", string.Format("{0}", request.OpenStatus));

                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);

                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<WeiXinEntityResponse<WeiXinShopOpenResponse>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinShopOpenResponse>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinShopOpenResponse>>(false, data.ErrMessage, data);
                    }
                }
                else
                {
                    string errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinShopOpenResponse>>(false, errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "门店营业状态变更异常");

                result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinShopOpenResponse>>(false, "门店营业状态变更异常,本次操作无效", null);
            }

            return result;
        }

        /// <summary>
        /// 门店信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public static Tuple<bool, string, WeiXinEntityResponse<WeiXinShopInfoResponse>> WeiXinShopInfo(WeiXinShopInfoRequest request)
        {
            Tuple<bool, string, WeiXinEntityResponse<WeiXinShopInfoResponse>> result = null;

            try
            {
                OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
                SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);

                parameters.Add("method", "wxdc.store.info");
                parameters.Add("erpStoreId", request.StoreId);

                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);

                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<WeiXinEntityResponse<WeiXinShopInfoResponse>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinShopInfoResponse>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinShopInfoResponse>>(false, data.ErrMessage, data);
                    }
                }
                else
                {
                    string errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinShopInfoResponse>>(false, errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "门店信息获取异常");

                result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinShopInfoResponse>>(false, "门店信息获取异常,本次操作无效", null);
            }

            return result;
        }

        /// <summary>
        /// 微信订单拒单
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public static Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderCancelResponse>> WeiXinOrderCancel(WeiXinOrderCancelRequest request)
        {
            Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderCancelResponse>> result = null;

            try
            {
                OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
                SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);

                parameters.Add("method", "wxdc.store.order.cancel");
                parameters.Add("erpStoreId", request.StoreId);
                parameters.Add("ticketId", request.TicketId);
                parameters.Add("cancelReason", request.CancelReason);

                var ignoreParameters = new List<string>();
                ignoreParameters.Add("cancelReason");
                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);

                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<WeiXinEntityResponse<WeiXinOrderCancelResponse>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderCancelResponse>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderCancelResponse>>(false, data.ErrMessage, data);
                    }
                }
                else
                {
                    string errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderCancelResponse>>(false, errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "微信订单取消异常");

                result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderCancelResponse>>(false, "微信订单取消异常,本次操作无效", null);
            }

            return result;
        }

        /// <summary>
        /// 微信订单接单
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public static Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderConfirmResponse>> WeiXinOrderConfirm(WeiXinOrderConfirmRequest request)
        {
            Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderConfirmResponse>> result = null;

            try
            {
                OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
                SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);

                parameters.Add("method", "wxdc.store.order.confirm");
                parameters.Add("erpStoreId", request.StoreId);
                parameters.Add("ticketId", request.TicketId);

                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);

                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<WeiXinEntityResponse<WeiXinOrderConfirmResponse>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderConfirmResponse>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderConfirmResponse>>(false, data.ErrMessage, data);
                    }
                }
                else
                {
                    string errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderConfirmResponse>>(false, errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "微信订单接单异常");

                result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderConfirmResponse>>(false, "微信订单接单异常,本次操作无效", null);
            }

            return result;
        }

        /// <summary>
        /// 微信订单信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public static Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderResponse>> WeiXinOrder(WeiXinOrderRequest request)
        {
            Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderResponse>> result = null;

            try
            {
                OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
                SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);

                parameters.Add("method", "wxdc.sales.order.info");
                parameters.Add("erpStoreId", request.StoreId);
                parameters.Add("ticketId", request.TicketId);
                parameters.Add("memberId", request.MemberId);

                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);

                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<WeiXinEntityResponse<WeiXinOrderResponse>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderResponse>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderResponse>>(false, data.ErrMessage, data);
                    }
                }
                else
                {
                    string errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderResponse>>(false, errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "微信订单查询异常");

                result = new Tuple<bool, string, WeiXinEntityResponse<WeiXinOrderResponse>>(false, "微信订单询异常,本次操作无效", null);
            }

            return result;
        }

        /// <summary>
        /// 微信历史列表查询
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public static Tuple<bool, string, WeiXinPagerResponse<WeiXinOrderListResponse>> QueryWeiXinOrder(WeiXinOrderListRequest request)
        {
            Tuple<bool, string, WeiXinPagerResponse<WeiXinOrderListResponse>> result = null;

            try
            {
                OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
                SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);

                parameters.Add("method", "wxdc.store.order.list");

                parameters.Add("erpStoreId", request.StoreId);
                if (request.Status!=-1) {
                    parameters.Add("status", string.Format("{0}", request.Status));
                }
                parameters.Add("startDate", request.StartDate);
                parameters.Add("endDate", request.EndDate);
                parameters.Add("orderField", request.OrderField);
                parameters.Add("orderType", request.OrderType);
                parameters.Add("pageNumber", string.Format("{0}", request.PageNumber));
                parameters.Add("pageSize", string.Format("{0}", request.PageSize));
               

                var ignoreParameters = new List<string>();
                ignoreParameters.Add("pageNumber");
                ignoreParameters.Add("pageSize");
                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);

                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<WeiXinPagerResponse<WeiXinOrderListResponse>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, WeiXinPagerResponse<WeiXinOrderListResponse>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, WeiXinPagerResponse<WeiXinOrderListResponse>>(false, data.ErrMessage, data);
                    }
                }
                else
                {
                    string errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, WeiXinPagerResponse<WeiXinOrderListResponse>>(false, errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "微信订单查询异常");

                result = new Tuple<bool, string, WeiXinPagerResponse<WeiXinOrderListResponse>>(false, "微信订单询异常,本次操作无效", null);
            }

            return result;
        }

        protected static string PaserErrors(string response)
        {
            string result = string.Empty;
            try
            {
                logger.Error(response);

                Errors mainError = JsonUtils.Deserialize<Errors>(response);
                if (_errorDesc.ContainsKey(mainError.Code))
                {
                    result = _errorDesc[mainError.Code];
                }
                else
                {
                    result = mainError.Message;
                }

                List<SubErrors> subError = mainError.SubErrors;
                if (subError != null && subError.Count > 0)
                {
                    SubErrors error = subError[0];
                    if (_errorDesc.ContainsKey(error.Code))
                    {
                        result = _errorDesc[error.Code];
                    }
                    else
                    {
                        result = error.Message;
                    }
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex , "非法的错误信息格式");

                result = _errorDesc["9999"];
            }

            return result;
        }
    }
}