using POSV.Card;
using POSV.Entity;
using POSV.Helper;
using POSV.HttpApi;
using POSV.HttpResponse;
using POSV.MessageEvent;
using POSV.MsgCenter;
using POSV.Proxy.Base;
using POSV.ServiceCenter;
using POSV.ShoppingCart;
using POSV.ThirdPartyOrderData;
using POSV.Utils;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace POSV.Proxy.ThirdPartyOrder
{
    public class JuWeiAppOrderProxy : ProxyBase
    {

        public JuWeiAppOrderProxy()
        {
            if (LOGGET == null)
            {
                LOGGET = NLog.LogManager.GetLogger(GetType().FullName);
            }
        }
        #region API


        /// <summary>
        /// 加载小程序门店商品信息
        /// zhangy 2020-03-03 Add 
        /// </summary>
        /// <param name="programId"></param>
        /// <param name="storeId"></param>
        public Tuple<bool, string, EntityResponse<ProgramProductObject>> GetProduct(string programId, string storeId)
        {
            Tuple<bool, string, EntityResponse<ProgramProductObject>> result = null;

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

                parameters.Add("method", "program.product");
                parameters.Add("programId", programId);
                parameters.Add("storeId", storeId);
                var ignoreParameters = new List<string>();
                ignoreParameters.Add("programId");
                ignoreParameters.Add("storeId");
                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));

                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);
                LOGGET.Info("小程序门店商品资料:" + response);

                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<EntityResponse<ProgramProductObject>>(response);

                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, EntityResponse<ProgramProductObject>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, EntityResponse<ProgramProductObject>>(false, data.ErrMessage, null);
                    }
                }
                else
                {
                    var _errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, EntityResponse<ProgramProductObject>>(false, _errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                LOGGET.Error(ex, "小程序门店商品资料异常");

                result = new Tuple<bool, string, EntityResponse<ProgramProductObject>>(false, ex.Message, null);
            }

            return result;
        }

        /// <summary>
        /// 小程序商品开卖
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public Tuple<bool, string, EntityResponse<string>> ProductSalein(ProgramProductSaleinRequest request)
        {
            Tuple<bool, string, EntityResponse<string>> result = null;

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

                parameters.Add("method", "program.product.salein");
                parameters.Add("storeId", request.StoreId);
                parameters.Add("productTypeIds", request.ProductTypeIds);
                parameters.Add("specIds", request.SpecIds);
                var ignoreParameters = new List<string>();
                ignoreParameters.Add("productTypeIds");
                ignoreParameters.Add("specIds");

                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<EntityResponse<string>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, EntityResponse<string>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, EntityResponse<string>>(false, data.ErrMessage, null);
                    }
                }
                else
                {
                    var errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, EntityResponse<string>>(false, errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                LOGGET.Error(ex, "小程序商品开卖异常");

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

            return result;
        }

        /// <summary>
        /// 小程序商品停售
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public Tuple<bool, string, EntityResponse<string>> ProductSaleout(ProgramProductSaleoutRequest request)
        {
            Tuple<bool, string, EntityResponse<string>> result = null;

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

                parameters.Add("method", "program.product.saleout");
                parameters.Add("storeId", request.StoreId);
                parameters.Add("productTypeIds", request.ProductTypeIds);
                parameters.Add("specIds", request.SpecIds);
                var ignoreParameters = new List<string>();
                ignoreParameters.Add("productTypeIds");
                ignoreParameters.Add("specIds");

                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<EntityResponse<string>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, EntityResponse<string>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, EntityResponse<string>>(false, data.ErrMessage, null);
                    }
                }
                else
                {
                    var errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, EntityResponse<string>>(false, errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                LOGGET.Error(ex, "小程序商品开卖异常");

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

            return result;
        }

        /// <summary>
        /// 门店信息
        /// </summary> 
        private Tuple<bool, string, StockEntityResponse<ProgramStoreDetailData>> Program_Store_Detail(string request)
        {
            Tuple<bool, string, StockEntityResponse<ProgramStoreDetailData>> result = null;

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

                parameters.Add("method", "program.store.detail");
                parameters.Add("storeId", request);
                var ignoreParameters = new List<string>();

                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));

                LOGGET.Info("小程序点餐_门店信息请求:" + JsonUtils.Serialize(parameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);
                //LOGGET.Info("小程序点餐_门店信息接收:" + response);
                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<StockEntityResponse<ProgramStoreDetailData>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, StockEntityResponse<ProgramStoreDetailData>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, StockEntityResponse<ProgramStoreDetailData>>(false, data.ErrMessage, data);
                    }
                }
                else
                {
                    var _errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, StockEntityResponse<ProgramStoreDetailData>>(false, _errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                LOGGET.Error(ex, "小程序点餐_门店信息");

                result = new Tuple<bool, string, StockEntityResponse<ProgramStoreDetailData>>(false, "小程序点餐_门店信息,请检测网络连接", null);
            }
            return result;
        }

        /// <summary>
        /// 门店停业 \ 开业
        /// </summary> 
        /// 
        private Tuple<bool, string, StockEntityResponse<ProgramStoreStopData>> Program_Store_Stop_Open(bool _isopen, string request)
        {
            Tuple<bool, string, StockEntityResponse<ProgramStoreStopData>> result = null;

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

                if (_isopen)
                {
                    parameters.Add("method", "program.store.open");
                }
                else
                {
                    parameters.Add("method", "program.store.stop");
                }

                parameters.Add("storeId", request);

                var ignoreParameters = new List<string>();
                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));
                //LOGGET.Info("小程序点餐_门店开停业_请求:" + _isopen + JsonUtils.Serialize(parameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);
                //LOGGET.Info("小程序点餐_门店开停业_接收:" + _isopen + response);
                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<StockEntityResponse<ProgramStoreStopData>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, StockEntityResponse<ProgramStoreStopData>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, StockEntityResponse<ProgramStoreStopData>>(false, data.ErrMessage, data);
                    }
                }
                else
                {
                    var _errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, StockEntityResponse<ProgramStoreStopData>>(false, _errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                LOGGET.Error(ex, "小程序点餐_门店开停业");

                result = new Tuple<bool, string, StockEntityResponse<ProgramStoreStopData>>(false, "小程序点餐_门店开停业,请检测网络连接", null);
            }
            return result;
        }

        /// <summary>
        /// 门店开业
        /// </summary> 
        [Obsolete("冗余接口")]
        private Tuple<bool, string, StockEntityResponse<ProgramStoreStopData>> Program_Store_Open(string request)
        {
            Tuple<bool, string, StockEntityResponse<ProgramStoreStopData>> result = null;

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

                parameters.Add("method", "program.store.open");
                parameters.Add("storeId", request);

                var ignoreParameters = new List<string>();
                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));
                LOGGET.Info("小程序点餐_门店开业_请求:" + JsonUtils.Serialize(parameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);
                //LOGGET.Info("小程序点餐_门店开业_接收:" + response);
                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<StockEntityResponse<ProgramStoreStopData>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, StockEntityResponse<ProgramStoreStopData>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, StockEntityResponse<ProgramStoreStopData>>(false, data.ErrMessage, data);
                    }
                }
                else
                {
                    var _errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, StockEntityResponse<ProgramStoreStopData>>(false, _errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                LOGGET.Error(ex, "小程序点餐_门店开业");

                result = new Tuple<bool, string, StockEntityResponse<ProgramStoreStopData>>(false, "小程序点餐_门店开业,请检测网络连接", null);
            }
            return result;
        }


        /// <summary>
        /// 配送同步信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public Tuple<bool, string, EntityResponse<string>> Program_Order_Dispatch_Sync(string storeId, string busNo)
        {
            Tuple<bool, string, EntityResponse<string>> result = null;

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

                parameters.Add("method", "program.order.dispatch.sync");
                parameters.Add("storeId", storeId);
                parameters.Add("busNo", busNo);
                var ignoreParameters = new List<string>();

                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<EntityResponse<string>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, EntityResponse<string>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, EntityResponse<string>>(false, string.IsNullOrEmpty(data.ErrMessage) ? data.Message : data.ErrMessage, null);
                    }
                }
                else
                {
                    var errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, EntityResponse<string>>(false, errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                LOGGET.Error(ex, "物流同步订单异常");

                result = new Tuple<bool, string, EntityResponse<string>>(false, "物流同步订单异常,本次操作无效", null);
            }

            return result;
        }

        /// <summary>
        /// 配送信息
        /// </summary> 
        public Tuple<bool, string, StockEntityResponse<ProgramOrderDeliveryQueryData>> Program_Order_Delivery_Query(string storeId, string busNo)
        {
            Tuple<bool, string, StockEntityResponse<ProgramOrderDeliveryQueryData>> result = null;

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

                parameters.Add("method", "program.order.delivery.query");
                parameters.Add("storeId", storeId);
                parameters.Add("busNo", busNo);
                var ignoreParameters = new List<string>();

                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));

                LOGGET.Info("小程序点餐_配送信息请求:" + JsonUtils.Serialize(parameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);
                //LOGGET.Info("小程序点餐_配送信息接收:" + response);
                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<StockEntityResponse<ProgramOrderDeliveryQueryData>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, StockEntityResponse<ProgramOrderDeliveryQueryData>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, StockEntityResponse<ProgramOrderDeliveryQueryData>>(false, data.ErrMessage, null);
                    }
                }
                else
                {
                    var _errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, StockEntityResponse<ProgramOrderDeliveryQueryData>>(false, _errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                LOGGET.Error(ex, "小程序点餐_配送信息");

                result = new Tuple<bool, string, StockEntityResponse<ProgramOrderDeliveryQueryData>>(false, ",请检测门店网络连接", null);
            }
            return result;
        }


        /// <summary>
        /// 订单详情
        /// </summary> 
        private Tuple<bool, string, StockEntityResponse<ProgramOrderQueryBybusnoData>> Program_Order_Query_Bybusno(string storeId, string busNo)
        {
            Tuple<bool, string, StockEntityResponse<ProgramOrderQueryBybusnoData>> result = null;

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

                parameters.Add("method", "program.order.query.bybusno");
                parameters.Add("storeId", storeId);
                parameters.Add("busNo", busNo);

                var ignoreParameters = new List<string>();
                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));
                LOGGET.Info("小程序点餐_请求内容:" + JsonUtils.Serialize(parameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);
                //LOGGET.Info("小程序点餐_订单内容:" + response);
                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<StockEntityResponse<ProgramOrderQueryBybusnoData>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, StockEntityResponse<ProgramOrderQueryBybusnoData>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, StockEntityResponse<ProgramOrderQueryBybusnoData>>(false, data.ErrMessage, null);

                        //zhangy 2020-03-01 Edit 注释以下代码
                        //result = new Tuple<bool, string, StockEntityResponse<ProgramOrderQueryBybusnoData>>(false, data.ErrMessage, data);
                    }
                }
                else
                {
                    var _errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, StockEntityResponse<ProgramOrderQueryBybusnoData>>(false, _errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                LOGGET.Error(ex, "小程序点餐_订单详情_异常");

                result = new Tuple<bool, string, StockEntityResponse<ProgramOrderQueryBybusnoData>>(false, "小程序点餐_订单详情,请检测网络连接", null);
            }
            return result;
        }

        /// <summary>
        /// 订单接单\拒单\同意退款\拒绝退款
        /// </summary>  
        private Tuple<bool, string, StockEntityResponse<ProgramOrderConfirmData>> Program_Order_Confirm(ProgramOrderOperationType orderOperationType, string storeId, string busNo)
        {
            Tuple<bool, string, StockEntityResponse<ProgramOrderConfirmData>> result = null;

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

                switch (orderOperationType)
                {
                    case ProgramOrderOperationType.Confirm:
                        parameters.Add("method", "program.order.confirm");
                        break;
                    case ProgramOrderOperationType.Refuse:
                        parameters.Add("method", "program.order.cancel");
                        break;
                    case ProgramOrderOperationType.Refund:
                        parameters.Add("method", "program.order.refundagree");
                        break;
                    case ProgramOrderOperationType.NotRefund:
                        parameters.Add("method", "program.order.refundreject");
                        break;
                    default:
                        parameters.Add("method", "program.order.confirm");
                        break;
                }


                parameters.Add("storeId", storeId);
                parameters.Add("busNo", busNo);

                var ignoreParameters = new List<string>();
                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));
                LOGGET.Info("小程序点餐_订单" + orderOperationType + "_请求:" + JsonUtils.Serialize(parameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);
                //LOGGET.Info("小程序点餐_订单" + orderOperationType + "_接收:" + response);
                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<StockEntityResponse<ProgramOrderConfirmData>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, StockEntityResponse<ProgramOrderConfirmData>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, StockEntityResponse<ProgramOrderConfirmData>>(false, data.Message, null);
                    }
                }
                else
                {
                    var _errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, StockEntityResponse<ProgramOrderConfirmData>>(false, _errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                LOGGET.Error(ex, "小程序点餐_订单接单");

                result = new Tuple<bool, string, StockEntityResponse<ProgramOrderConfirmData>>(false, "小程序点餐_订单接单,请检测网络连接", null);
            }
            return result;
        }

        /// <summary>
        /// 订单列表
        /// </summary> 
        private Tuple<bool, string, StockPagerResponse<ProgramHandleOrderData>> Program_Handle_Order(bool _isHandle, ProgramHandleOrderRequestData request)
        {
            Tuple<bool, string, StockPagerResponse<ProgramHandleOrderData>> result = null;

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

                if (_isHandle)
                {
                    parameters.Add("method", "program.handle.order");
                    parameters.Add("storeId", request.Storeid);
                    var ignoreParameters = new List<string>();
                    parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));
                }
                else
                {
                    parameters.Add("method", "program.list.order");
                    parameters.Add("storeId", request.Storeid);
                    var ignoreParameters = new List<string>();
                    parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));
                    parameters.Add("status", request.Status.ToString());
                    parameters.Add("startTime", request.Starttime);
                    parameters.Add("endTime", request.Endtime);
                    parameters.Add("pageNumber", request.Pagenumber.ToString());
                    parameters.Add("pageSize", request.Pagesize.ToString());
                }

                LOGGET.Info("小程序点餐_订单列表 是否待处理" + _isHandle + "请求:" + JsonUtils.Serialize(parameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);
                //LOGGET.Info("小程序点餐_订单列表 是否待处理" + _isHandle + "接收:" + response);

                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<StockPagerResponse<ProgramHandleOrderData>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, StockPagerResponse<ProgramHandleOrderData>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, StockPagerResponse<ProgramHandleOrderData>>(false, data.ErrMessage, null);
                    }
                }
                else
                {
                    var _errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, StockPagerResponse<ProgramHandleOrderData>>(false, _errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                LOGGET.Error(ex, "小程序点餐_订单列表");

                result = new Tuple<bool, string, StockPagerResponse<ProgramHandleOrderData>>(false, "小程序点餐_订单列表 , 请检测网络连接", null);
            }
            return result;
        }

        #endregion

        /// <summary>
        /// 门店信息
        /// </summary> 
        public Tuple<bool, string, ProgramStoreDetailData> GetShopInfo()
        {
            Tuple<bool, string, ProgramStoreDetailData> tuple = new Tuple<bool, string, ProgramStoreDetailData>(false, "", null);

            try
            {
                var _data = this.Program_Store_Detail(Global.Instance.Authc.StoreId);
                if (_data != null && _data.Item1)
                {
                    return new Tuple<bool, string, ProgramStoreDetailData>(_data.Item1, _data.Item2, _data.Item3.Data);
                }
                else
                {
                    return new Tuple<bool, string, ProgramStoreDetailData>(false, _data.Item2, null);
                }

            }
            catch (Exception ex)
            {
                LOGGET.Error(ex, "获取小程序门店信息异常");

                return new Tuple<bool, string, ProgramStoreDetailData>(false, ex.Message, null);
            }
        }

        /// <summary>
        /// 开业\歇业
        /// </summary>
        /// <param name="_open">是否开业</param>
        /// <returns></returns>
        public Tuple<bool, string, ProgramStoreStopData> SetStoreStopAndOpen(bool _open)
        {
            try
            {
                var _data = this.Program_Store_Stop_Open(_open, Global.Instance.Authc.StoreId);
                if (_data != null && _data.Item1)
                {
                    return new Tuple<bool, string, ProgramStoreStopData>(_data.Item1, _data.Item2, _data.Item3.Data);
                }
                else
                {
                    return new Tuple<bool, string, ProgramStoreStopData>(_data.Item1, _data.Item2, null);
                }

            }
            catch (Exception ex)
            {

                LOGGET.Error(ex, "小程序门店开业歇业状态异常");

                return new Tuple<bool, string, ProgramStoreStopData>(false, ex.Message, null);
            }
        }

        /// <summary>
        /// 根据单号查询订单
        /// </summary>
        /// <param name="busNo">订单号</param>
        /// <returns></returns>
        public Tuple<bool, string, ProgramOrderQueryBybusnoData> GetOrder(string busNo)
        {
            try
            {
                var _data = this.Program_Order_Query_Bybusno(Global.Instance.Authc.StoreId, busNo);

                if (_data != null && _data.Item1 == false)
                {
                    if (_data.Item2.Equals("小程序点餐_订单详情,请检测网络连接"))
                    {
                        LOGGET.Info($"第二次小程序订单查询<{busNo}>");
                        _data = this.Program_Order_Query_Bybusno(Global.Instance.Authc.StoreId, busNo);

                        if (_data != null && _data.Item1 == false)
                        {
                            if (_data.Item2.Equals("小程序点餐_订单详情,请检测网络连接"))
                            {
                                LOGGET.Info($"第三次小程序订单查询<{busNo}>");
                                _data = this.Program_Order_Query_Bybusno(Global.Instance.Authc.StoreId, busNo);
                            }
                        }
                    }
                }

                if (_data != null && _data.Item1)
                {
                    return new Tuple<bool, string, ProgramOrderQueryBybusnoData>(_data.Item1, _data.Item2, _data.Item3.Data);
                }
                else
                {
                    return new Tuple<bool, string, ProgramOrderQueryBybusnoData>(_data.Item1, _data.Item2, null);
                }

            }
            catch (Exception ex)
            {
                LOGGET.Error(ex, "小程序订单查询异常");

                return new Tuple<bool, string, ProgramOrderQueryBybusnoData>(false, "小程序订单查询出错", null);
            }
        }

        /// <summary>
        /// 查询订单
        /// </summary>
        /// <param name="_isHandle">是否待处理状态订单</param> 
        public Tuple<bool, string, StockPagerResponse<ProgramHandleOrderData>> GetOrders(bool _isHandle, ProgramHandleOrderRequestData requestData = null)
        {
            try
            {
                if (requestData == null)
                {
                    requestData = new ProgramHandleOrderRequestData();
                    requestData.Storeid = Global.Instance.Authc.StoreId;
                }
                var _data = this.Program_Handle_Order(_isHandle, requestData);

                return new Tuple<bool, string, StockPagerResponse<ProgramHandleOrderData>>(_data.Item1, _data.Item2, _data.Item3);

            }
            catch (Exception ex)
            {

                LOGGET.Error(ex, "查询小程序订单异常");

                return new Tuple<bool, string, StockPagerResponse<ProgramHandleOrderData>>(false, ex.Message, null);
            }
        }

        /// <summary>
        /// 修改订单状态
        /// </summary> 
        public Tuple<bool, string, ProgramOrderConfirmData> SetOrderStatus(ProgramOrderOperationType orderOperationType, string busNo)
        {
            try
            {
                LOGGET.Info("开始修改订单状态:<{0},{1}>", busNo, orderOperationType.ToString());
                var _data = this.Program_Order_Confirm(orderOperationType, Global.Instance.Authc.StoreId, busNo);
                LOGGET.Info("订单状态结果:<{0},{1}>", (_data != null && _data.Item1), _data.Item3 != null && _data.Item3.Data != null);

                if (_data != null && _data.Item1 == false)
                {
                    if (_data.Item2.Equals("小程序点餐_订单接单,请检测网络连接"))
                    {
                        LOGGET.Info("第二次修改订单状态:<{0},{1}>", busNo, orderOperationType.ToString());
                        _data = this.Program_Order_Confirm(orderOperationType, Global.Instance.Authc.StoreId, busNo);

                        if (_data != null && _data.Item1 == false)
                        {
                            if (_data.Item2.Equals("小程序点餐_订单接单,请检测网络连接"))
                            {
                                LOGGET.Info("第三次修改订单状态:<{0},{1}>", busNo, orderOperationType.ToString());
                                _data = this.Program_Order_Confirm(orderOperationType, Global.Instance.Authc.StoreId, busNo);
                            }
                        }
                    }
                }

                if (_data != null && _data.Item1)
                {
                    return new Tuple<bool, string, ProgramOrderConfirmData>(_data.Item1, _data.Item2, _data.Item3.Data);
                }
                else
                {
                    return new Tuple<bool, string, ProgramOrderConfirmData>(_data.Item1, _data.Item2, null);
                }



            }
            catch (Exception ex)
            {
                LOGGET.Info(ex, "修改订单状态异常");

                return new Tuple<bool, string, ProgramOrderConfirmData>(false, ex.Message, null);
            }
        }

        /// <summary>
        /// 补单
        /// </summary> 
        public Tuple<bool, string, string> ReplacementOrder(List<ProgramHandleOrderData> program)
        {
            //zhangy 2020-02-18 Add 订单保存数据库后，要修改isHaveUpLoadTicket=true     
            bool isException = false;

            try
            {
                if (program == null)
                {
                    return new Tuple<bool, string, string>(false, "补单传入的对象未空", "已成功补入 0 单");
                }

                string _mess = @"已成功补入 {0} 单";
                int count = 0;


                foreach (var item in program)
                {
                    //判断完全订单进行补录
                    if (item.Status == 1 || item.Status == 2 || item.Status == 4)
                    {
                        using (var _db = Global.Instance.OpenDataBase)
                        {
                            var _sql = string.Format("select * from pos_order where orderNo = '{0}'", item.Seqno);

                            var _data = _db.FirstOrDefault<OrderObject>(_sql);

                            if (_data == null)
                            {
                                var _JuWeiOrder = this.GetOrder(item.No);
                                if (_JuWeiOrder.Item1)
                                {
                                    var _order = getOrderLocalJuWeiOrder(_JuWeiOrder.Item3);

                                    if (_order != null)
                                    {
                                        using (var _tran = _db.GetTransaction())
                                        {
                                            _db.Insert(_order);

                                            if (_order.Items != null)
                                                foreach (var Orderitem in _order.Items)
                                                {
                                                    _db.Insert(Orderitem);

                                                    foreach (var _Flavor in Orderitem.Flavors)
                                                    {
                                                        _db.Insert(_Flavor);
                                                    }
                                                    if (Orderitem.Promotions != null)
                                                        foreach (var Promotions in Orderitem.Promotions)
                                                        {
                                                            _db.Insert(Promotions);
                                                        }

                                                }
                                            if (_order.Pays != null)
                                                foreach (var orderPay in _order.Pays)
                                                {
                                                    orderPay.FinishDate = _order.FinishDate;

                                                    #region subin 20231003 注释修改
                                                    //注释
                                                    //zhangy 2020-02-18 Add 档口结算信息赋默认值
                                                    //orderPay.Ext1 = "0";
                                                    //orderPay.Ext2 = "0"; 

                                                    //修改
                                                    orderPay.Ext1 = string.IsNullOrEmpty(orderPay.Ext1) ? "0" : orderPay.Ext1;
                                                    orderPay.Ext2 = string.IsNullOrEmpty(orderPay.Ext2) ? "0" : orderPay.Ext2;
                                                    #endregion

                                                    //zhangy 2020-02-18 Add 添加结算参数计算
                                                    var payMode = OrderUtils.GetPayMode(orderPay.No);
                                                    if (payMode == null)
                                                    {
                                                        orderPay.IncomeFlag = 1;
                                                        orderPay.OtherRateType = 0;
                                                        orderPay.OtherRateValue = 0.00M;
                                                    }
                                                    else
                                                    {
                                                        orderPay.IncomeFlag = payMode.IncomeFlag;
                                                        orderPay.OtherRateType = payMode.OtherRateType;
                                                        orderPay.OtherRateValue = payMode.OtherRateValue;


                                                        OrderUtils.SetPayModeDiscount(orderPay, payMode);
                                                    }

                                                    _db.Insert(orderPay);
                                                }
                                            if (_order.Promotions != null)
                                                _db.Insert(_order.Promotions);
                                            if (_order.Delivery != null)
                                                _db.Insert(_order.Delivery);
                                            _tran.Complete();
                                            count++;


                                            #region subin 20230916 小程序分账.补单的同时将分账信息保存
                                            LOGGET.Info("补单，小程序分账。");
                                            //DoSplitOrderBefore(_order);
                                            //Task.Factory.StartNew(() =>
                                            //{
                                            //    SplitPayUtils.Instance.SaveSplitPayInfo(_order);
                                            //});
                                            #endregion
                                        }
                                    }
                                }

                            }
                        }
                    }
                }

                return new Tuple<bool, string, string>(true, " ", string.Format(_mess, count));
            }
            catch (Exception ex)
            {
                //有异常发生
                isException = true;

                LOGGET.Info(ex);
                return new Tuple<bool, string, string>(false, ex.Message, "已成功补入 0 单");
            }
            finally
            {
                //没有异常发生
                if (!isException)
                {
                    //更新是否有订单需要上传的状态
                    Global.isHaveUpLoadTicket = true;
                    Global.isHaveBurdenTicket = true;
                    Global.isHaveCenterTicket = true;
                }
            }

        }


        public Tuple<bool, string, string> InsertOrder(OrderObject orderObject)
        {
            //zhangy 2020-02-18 Add 订单保存数据库后，要修改isHaveUpLoadTicket=true     
            bool isException = false;

            try
            {
                if (orderObject == null)
                {
                    LOGGET.Error("补单传入的对象未空.....");

                    return new Tuple<bool, string, string>(false, "补单传入的对象未空", "已成功补入 0 单");
                }

                //subin 20230717 start add lock
                lock (Global.Instance.SyncLock)
                {
                    using (var _db = Global.Instance.OpenDataBase)
                    {
                        var _sql = string.Format("select * from pos_order where tradeNo = '{0}'", orderObject.TradeNo);

                        var _data = _db.FirstOrDefault<OrderObject>(_sql);

                        //订单本地不存在
                        if (_data == null)
                        {
                            LOGGET.Info("================================巨为小程序订单插入数据库================================");
                            var _JuWeiOrder = this.GetOrder(orderObject.TradeNo);
                            if (_JuWeiOrder.Item1)
                            {
                                var _order = getOrderLocalJuWeiOrder(_JuWeiOrder.Item3);

                                if (_order != null)
                                {
                                    using (var _tran = _db.GetTransaction())
                                    {
                                        _db.Insert(_order);

                                        if (_order.Items != null)
                                            foreach (var Orderitem in _order.Items)
                                            {
                                                _db.Insert(Orderitem);

                                                foreach (var _Flavor in Orderitem.Flavors)
                                                {
                                                    _db.Insert(_Flavor);
                                                }
                                                if (Orderitem.Promotions != null)

                                                    foreach (var Promotions in Orderitem.Promotions)
                                                    {
                                                        _db.Insert(Promotions);
                                                    }
                                            }
                                        if (_order.Pays != null)
                                            foreach (var orderPay in _order.Pays)
                                            {
                                                orderPay.FinishDate = _order.FinishDate;

                                                #region subin 20230916 新增，用于本地小程序订单退款。
                                                orderPay.OpenId = _order.OpenId;
                                                #endregion

                                                #region subin 20231003 注释修改
                                                //注释
                                                //zhangy 2020-02-18 Add 档口结算信息赋默认值
                                                //orderPay.Ext1 = "0";
                                                //orderPay.Ext2 = "0"; 

                                                //修改
                                                orderPay.Ext1 = string.IsNullOrEmpty(orderPay.Ext1) ? "0" : orderPay.Ext1;
                                                orderPay.Ext2 = string.IsNullOrEmpty(orderPay.Ext2) ? "0" : orderPay.Ext2;
                                                #endregion


                                                //zhangy 2020-02-18 Add 添加结算参数计算
                                                var payMode = OrderUtils.GetPayMode(orderPay.No);
                                                if (payMode == null)
                                                {
                                                    orderPay.IncomeFlag = 1;
                                                    orderPay.OtherRateType = 0;
                                                    orderPay.OtherRateValue = 0.00M;
                                                }
                                                else
                                                {
                                                    orderPay.IncomeFlag = payMode.IncomeFlag;
                                                    orderPay.OtherRateType = payMode.OtherRateType;
                                                    orderPay.OtherRateValue = payMode.OtherRateValue;


                                                    OrderUtils.SetPayModeDiscount(orderPay, payMode);
                                                }

                                                _db.Insert(orderPay);
                                            }
                                        if (_order.Promotions != null)
                                            _db.Insert(_order.Promotions);
                                        if (_order.Delivery != null)
                                            _db.Insert(_order.Delivery);
                                        _tran.Complete();
                                    }
                                    LOGGET.Info("================================" + orderObject.TradeNo + "插入成功！================================");

                                    //subin 20231025 注释，分账由实时改为交班时分账
                                    //Task.Factory.StartNew(() =>
                                    //{
                                    //    SplitPayUtils.Instance.SaveSplitPayInfo(_order);
                                    //});
                                    //subin 20231025 注释 end

                                    return new Tuple<bool, string, string>(true, "订单保存成功", "");
                                }
                                else
                                {
                                    return new Tuple<bool, string, string>(false, "本地转单发生错误", "已成功补入 0 单");
                                }
                            }
                            else
                            {
                                return new Tuple<bool, string, string>(false, _JuWeiOrder.Item2, "已成功补入 0 单");
                            }
                        }
                        else
                        {
                            //LOGGET.Error("订单保存或者补单操作失败，原因:本地单号<" + orderObject.TradeNo + ">重复!,订单内容:" + JsonUtils.Serialize(orderObject));
                            LOGGET.Error("订单保存或者补单操作失败，原因:本地单号<" + orderObject.TradeNo + ">重复!");

                            return new Tuple<bool, string, string>(false, "订单保存失败", "已成功补入 0 单");
                        }


                    }
                }
                //subin 20230717 end
            }
            catch (Exception ex)
            {
                //有异常发生
                isException = true;

                LOGGET.Error(ex, "巨为小程序订单插入数据库异常");

                return new Tuple<bool, string, string>(false, ex.Message, "已成功补入 0 单");

            }
            finally
            {
                //没有异常发生
                if (!isException)
                {
                    //更新是否有订单需要上传的状态
                    Global.isHaveUpLoadTicket = true;
                    Global.isHaveBurdenTicket = true;
                    Global.isHaveCenterTicket = true;
                }
            }
        }

        /// <summary>
        /// 数据转换
        /// </summary>
        public static OrderObject getOrderLocalJuWeiOrder(ProgramOrderQueryBybusnoData response)
        {
            try
            {
                //当前订单对象
                OrderObject _orderObject = new OrderObject();

                #region subin 20230916 新增，用于本地小程序订单退款。
                _orderObject.OpenId = response.Openid;
                #endregion


                _orderObject.Id = IdWorkerUtils.Instance.NextId();
                _orderObject.AddPoint = 0.00M;//本地积分

                _orderObject.CardPayResult = null;//会员卡支付清单
                _orderObject.ChangeAmount = 0.00M;//找零金额
                _orderObject.CreateDate = response.Saledate;//创建时间
                _orderObject.CreateUser = "program";//创建人
                _orderObject.DeviceName = DeviceUtils.Instance.ComputerName;//设备名称

                _orderObject.FinishDate = response.Saledate;//完成时间

                _orderObject.InvoicedAmount = 0.00M;
                _orderObject.IpAddress = DeviceUtils.Instance.IPAddress;//本地IP地址

                _orderObject.BoxFee = response.Packagefee;//餐盒费
                _orderObject.DeliverFee = response.Deliverfee;//配送费
                _orderObject.Amount = response.Amount + _orderObject.BoxFee + _orderObject.DeliverFee;//消费金额(订单应付金额+餐盒费 + 配送费)
                _orderObject.DiscountAmount = response.Discounttotal;//优惠总额(活动总额)
                _orderObject.PaidAmount = response.Receivable + _orderObject.BoxFee + _orderObject.DeliverFee;//实收金额


                //MAC地址,zhangy 2020-02-19 Edit
                string macAddress = DeviceUtils.Instance.MacAddress;
                _orderObject.MacAddress = (!string.IsNullOrEmpty(macAddress) && macAddress.Length < 32) ? macAddress : macAddress.Substring(0, 25);

                _orderObject.MalingAmount = 0.00M;
                _orderObject.ReserveTime = response.Reservetime;//到店、预约、取餐时间
                _orderObject.People = 1;//人数
                _orderObject.PosNo = Global.Instance.Authc.PosNo;//POS号
                _orderObject.PrintStatus = OrderPrintStatus.打印完成;//打印状态
                _orderObject.PrintTimes = 1; //打印时间
                _orderObject.SaleDate = response.Saledate;//销售时间
                _orderObject.SalesCode = Global.Instance.Worker.No;//营业员编码
                _orderObject.SalesName = Global.Instance.Worker.Name;//营业员名称
                _orderObject.ShiftName = Global.Instance.BusinessPlanLog.Name;//班次编号
                _orderObject.ShiftNo = Global.Instance.BusinessPlanLog.No;//班次名称
                _orderObject.StoreId = Global.Instance.Authc.StoreId; //门店ID
                _orderObject.StoreName = Global.Instance.Worker.StoreInfo.Name;//门店名称
                _orderObject.StoreNo = Global.Instance.Authc.StoreNo;//门店编号
                _orderObject.WorkerName = Global.Instance.Worker.Name;//员工姓名
                _orderObject.WorkerNo = Global.Instance.Worker.No;//员工工号 
                _orderObject.SyncStatus = 0;//同步状态
                _orderObject.TableNo = response.Tableno;//桌号
                _orderObject.TableName = response.Tablename;//餐桌名称
                _orderObject.TenantId = Global.Instance.Authc.TenantId;//租户ID
                _orderObject.TradeNo = response.No;
                _orderObject.Weather = string.Empty;
                _orderObject.Weeker = response.Weeker;

                _orderObject.Ext1 = response.Ext2;//单注

                //zhangy 2020-05-09 Add 堂食和外卖订单厨打支持打印手机号和订餐人
                string memberName = string.IsNullOrEmpty(response.Membername) ? "" : response.Membername;
                string memberMobile = string.IsNullOrEmpty(response.Mobile) ? "" : response.Mobile;
                _orderObject.Ext2 = string.Format("{0} {1}", memberName, memberMobile);

                _orderObject.Phone = memberMobile;
                _orderObject.Recipients = memberName;

                _orderObject.OrderCount = response.OrderProduct.Count;
                _orderObject.TicketId = response.Id;
                _orderObject.ObjectId = ObjectId.GenerateNewStringId();//订单ID
                _orderObject.OrderNo = string.Format("{0}", response.Seqno);


                switch (response.Status)//(-1待支付0待接单1已确认2已配送3已取消4已完成)
                {
                    case -1:
                        _orderObject.OrderStatus = OrderStatus.等待付款;//订单状态
                        break;
                    case 0:
                        _orderObject.OrderStatus = OrderStatus.已支付;//订单状态
                        break;
                    case 1:
                        _orderObject.OrderStatus = OrderStatus.已完成;//订单状态
                        break;
                    case 2:
                        _orderObject.OrderStatus = OrderStatus.已完成;//订单状态
                        break;
                    case 3:
                        _orderObject.OrderStatus = OrderStatus.已取消;//订单状态
                        break;
                    case 4:
                        _orderObject.OrderStatus = OrderStatus.已完成;//订单状态
                        break;
                    default:
                        break;
                }

                switch (response.Busmode)
                {
                    case 0:
                        _orderObject.BusMode = "堂食";
                        break;
                    case 1:
                        _orderObject.BusMode = "外带";
                        break;
                    case 2:
                        _orderObject.BusMode = "预定";
                        break;
                    case 3:
                        _orderObject.BusMode = "外卖";
                        break;
                    default:
                        break;
                }

                _orderObject.OrderType = OrderType.微信点餐;

                _orderObject.PaymentStatus = OrderPaymentStatus.已付款;//支付装

                //订单明细
                _orderObject.Items = new List<OrderItem>();


                var map = new ObservableCollection<OrderItem>();
                var i = 0;

                #region 商品明细
                foreach (var _ordertime in response.OrderProduct)
                {
                    OrderItem order = new OrderItem();
                    order.Id = IdWorkerUtils.Instance.NextId();
                    order.clientId = _ordertime.Clientid;

                    #region ItemInfo
                    using (var db = Global.Instance.OpenDataBase)
                    {
                        string template1 = SqlConstant.ProductExt + " where  p.id = '{0}' and s.id = '{1}'";
                        string sql1 = string.Format(template1, _ordertime.Productid, _ordertime.Specid);
                        List<ProductExt> productList = db.Fetch<ProductExt>(sql1);


                        ProductExt product = new ProductExt();
                        //商品资料
                        if (productList == null || productList.Count == 0)
                        {
                            product = new ProductExt();
                            product.Chuda = "";//厨打ID
                            product.ChudaFlag = "1";//是否厨打
                            product.Chupin = "";//出品ID
                            product.ChuDaLabel = string.Empty;//厨打标签ID
                            product.ChuDaLabelFlag = "1";//是否厨打标签
                            product.ChupinFlag = "1";//是否出品
                            product.Chuxian = "";//厨显ID
                            product.ChuxianFlag = "1";//是否厨显
                            product.ChuxianTime = 0;//厨显超时时间
                            product.CurrentFlag = 0;//是否可以议价
                            product.DiscountFlag = 0;//是否可折扣
                            product.GiveFlag = 0;//允许赠送
                            product.KdsChupin = "";//厨显出品ID
                            product.KdsChupinFlag = "0";//厨显是否出品
                            product.KdsChupinTime = 0;//厨显出品超时时间
                            product.LabelPrintFlag = 1;//标签打印
                            product.MebDiscountFlag = 0;//会员折上折
                            product.MinPrice = 0.00M;//最低售价
                            product.Name = _ordertime.Productname;//商品名称
                            product.Id = _ordertime.Productid;//商品ID
                            product.No = _ordertime.Productno;//商品编号
                            product.UnitId = _ordertime.Productunitid;//商品单位ID
                            product.UnitName = _ordertime.Productunitname;//商品单位名称
                            product.PromotionFlag = 0;//是否允许促销
                            product.ShortName = _ordertime.Productname;//简称
                            product.SpecId = _ordertime.Specid;//规格ID
                            product.SpecName = _ordertime.Specname;//规格名称
                            product.StockFlag = 0;//是否管理库存
                            product.TapleFlag = 0;//是否主食
                            product.TypeId = _ordertime.Typeid;//商品类别ID
                            product.TypeName = _ordertime.Typename;//商品类别名称
                            product.WeighFlag = 0;//是否称重

                        }
                        else
                        {
                            product = productList[0];
                        }

                        //销售商品明细
                        order.Price = _ordertime.Price;//单价
                        order.Quantity = _ordertime.Count;//数量
                        order.Amount = _ordertime.Amount; //单品金额 = 数量*单价

                        order.Discount = _ordertime.Discounttotal;//折扣金额
                        order.DiscountFlag = product.DiscountFlag;//是否可折扣
                        order.DiscountPrice = _ordertime.Discountprice;//折后单价

                        order.Chuda = product.Chuda;//厨打ID
                        order.ChudaFlag = product.ChudaFlag;//是否厨打
                        order.ChudaQty = 0;//厨打次数
                        order.Chupin = product.Chupin;//出品ID
                        order.ChupinFlag = product.ChupinFlag;//是否出品
                        order.ChupinQty = 0;//出品次数
                        order.ChuDaLabel = product.ChuDaLabel;//厨打标签
                        order.ChuDaLabelFlag = product.ChuDaLabelFlag;//是否厨打标签
                        order.ChuDaLabelQty = 0;//厨打标签数量
                        order.Chuxian = product.Chuxian;//厨显ID
                        order.ChuxianFlag = product.ChuxianFlag;//是否厨显
                        order.ChuxianQty = 0;//厨显次数
                        order.ChuxianTime = product.ChuxianTime;//厨显超时时间
                        order.CreateDate = response.Saledate;//创建时间
                        order.CreateUser = Constant.DEFAULT_SYNC_USER;//创建人
                        order.CurrentFlag = product.CurrentFlag;//是否可以议价

                        order.DispatchPrice = product.DispatchPrice;//批发价
                        order.Flavor = response.MakeInfo.Count > 0 ? 1 : 0;//是否包含做法

                        #region 单品优惠
                        var _product = response.OrderProductInfo.Where(f => f.Orderitemid == _ordertime.Clientid);
                        if (_product != null && _product.Count() > 0)
                        {
                            //var _itemid = 0;
                            foreach (var _prductitem in _product)
                            {
                                PromotionItem orderInfo = new PromotionItem();
                                orderInfo.Id = IdWorkerUtils.Instance.NextId();
                                orderInfo.ItemId = order.Id;
                                orderInfo.Amount = _ordertime.Amount;
                                orderInfo.CreateDate = response.Saledate;//创建时间
                                orderInfo.CreateUser = "JuWeiWeiXin";//创建人
                                orderInfo.DiscountAmount = _prductitem.Discountmoney;
                                orderInfo.OrderId = _orderObject.Id;//订单ID
                                orderInfo.CouponId = string.Empty;
                                orderInfo.Enabled = true;
                                orderInfo.PromotionType = (PromotionType)_prductitem.Type;
                                orderInfo.TenantId = Global.Instance.Authc.TenantId;//租户ID
                                orderInfo.TradeNo = _orderObject.TradeNo;
                                orderInfo.ReceivableAmount = orderInfo.Amount - orderInfo.DiscountAmount;
                                orderInfo.DiscountRate = orderInfo.Amount <= 0 ? 0 : OrderUtils.ToRound(orderInfo.DiscountAmount / orderInfo.Amount);
                                orderInfo.FinishDate = _orderObject.FinishDate;
                                if (order.Promotions == null)
                                {
                                    order.Promotions = new List<PromotionItem>();
                                }
                                order.Discount = _ordertime.Discount;
                                order.Promotions.Add(orderInfo);
                            }

                        }
                        order.DiscountPrice = _ordertime.Discountprice;//折后价

                        #endregion

                        ///zhangy 2020-03-11 Edit 整单优惠暂时不处理
                        //var _ticketInfo = response.TicketInfo;
                        //if (_ticketInfo != null && _ticketInfo.Count() > 0)
                        //{
                        //    if (_orderObject.Promotions == null)
                        //    {
                        //        _orderObject.Promotions = new List<PromotionOrder>();
                        //    }

                        //    //var _itemid = 0;
                        //    decimal _total = 0.0M;
                        //    foreach (var _ticket in _ticketInfo)
                        //    {

                        //        PromotionOrder orderInfo = new PromotionOrder();
                        //        orderInfo.Id = IdWorkerUtils.Instance.NextId();
                        //        orderInfo.ItemId = _ticket.Id;

                        //        orderInfo.Amount = _orderObject.Amount - _total;
                        //        orderInfo.DiscountAmount = _ticket.Discountmoney;
                        //        orderInfo.ReceivableAmount = orderInfo.Amount - orderInfo.DiscountAmount;
                        //        orderInfo.DiscountRate = OrderUtils.ToRound(orderInfo.DiscountAmount / orderInfo.Amount);

                        //        orderInfo.CreateDate = response.Saledate;//创建时间
                        //        orderInfo.CreateUser = "JuWeiWeiXin";//创建人

                        //        orderInfo.OrderId = _orderObject.Id;//订单ID
                        //        orderInfo.CouponId = _ticket.Ticketid;
                        //        orderInfo.Enabled = true;
                        //        orderInfo.PromotionType = (PromotionType)_ticket.Type;
                        //        orderInfo.TenantId = Global.Instance.Authc.TenantId;//租户ID
                        //        orderInfo.TradeNo = _orderObject.TradeNo;

                        //        orderInfo.Ext1 = _ticket.Info;
                        //        orderInfo.FinishDate = _orderObject.FinishDate;

                        //        _total += _ticket.Discountmoney;

                        //        _orderObject.Promotions.Add(orderInfo);
                        //    }

                        //    _orderObject.PromotionCount = _ticketInfo.Count();

                        //}


                        #region 做法
                        var _Flavor = response.MakeInfo.Where(f => f.Orderitemid == _ordertime.Clientid).ToList();
                        if (_Flavor != null)
                        {
                            order.FlavorAmount = (decimal)_Flavor.Sum(f => f.Addtotal);//加价金额
                            order.FlavorCount = _Flavor.Count;//(int)_Flavor.Sum(f => f.Addprice);
                            order.FlavorDiscountAmount = _Flavor.Sum(f => f.Discountaddtotal);//做法优惠金额
                            order.FlavorReceivableAmount = _Flavor.Sum(f => f.Discountaddtotal);//餐盒应收金额
                            List<FlavorItem> flavors = new List<FlavorItem>();

                            foreach (var item in _Flavor)
                            {
                                FlavorItem flavor = new FlavorItem();

                                flavor.Quantity = item.Count;
                                flavor.Price = item.Addprice;
                                flavor.Amount = item.Addtotal;

                                flavor.BaseQuantity = flavor.Quantity;

                                flavor.Code = "000";
                                flavor.CreateDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:dd");
                                flavor.CreateUser = Global.Instance.Worker.StoreInfo.CreateUser;
                                flavor.Description = "";
                                flavor.DiscountAmount = item.Addtotal - item.Discountaddtotal;
                                flavor.DiscountPrice = item.Addprice - item.Discountprice;
                                flavor.FinishDate = _orderObject.FinishDate;
                                flavor.Group = "";
                                flavor.Color = "黄色";
                                flavor.Hand = 0;
                                flavor.Id = IdWorkerUtils.Instance.NextId();
                                flavor.ItemId = order.Id;
                                flavor.MakeId = item.Makeid;
                                flavor.Name = item.Makename;
                                flavor.OrderId = _orderObject.Id;
                                flavor.OrderItemQuantity = _ordertime.Count;
                                flavor.TenantId = _orderObject.TenantId;
                                flavor.TradeNo = _orderObject.TradeNo;
                                flavor.Type = 1;

                                flavor.RefundQuantity = item.Rcount;

                                flavors.Add(flavor);
                            }

                            order.Flavors = flavors;
                        }
                        #endregion

                        #region 餐盒费 
                        if (_ordertime.Packagefee > 0 && _ordertime.Issuit != 2)
                        {
                            if (_ordertime != null)
                            {
                                if (order.Flavors == null || order.Flavors.Count == 0)
                                {
                                    order.Flavors = new List<FlavorItem>();
                                }

                                FlavorItem flavorItem = new FlavorItem();

                                //zhangy 2020-02-18 Edit,修复餐盒费作为做法情况的计算错误
                                flavorItem.Quantity = _ordertime.Count;
                                flavorItem.Price = DecimalUtils.ToRound(_ordertime.Packagefee / (_ordertime.Count <= 0 ? 1 : _ordertime.Count), 2);

                                flavorItem.BaseQuantity = 1;

                                flavorItem.Code = "000";
                                flavorItem.CreateDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:dd");
                                flavorItem.CreateUser = Global.Instance.Worker.StoreInfo.CreateUser;
                                flavorItem.Description = "";
                                flavorItem.DiscountAmount = 0;
                                flavorItem.DiscountPrice = 0;
                                flavorItem.FinishDate = _orderObject.FinishDate;
                                flavorItem.Group = "";
                                flavorItem.Color = "黄色";
                                flavorItem.Hand = 0;
                                flavorItem.Id = IdWorkerUtils.Instance.NextId();
                                flavorItem.ItemId = order.Id;
                                flavorItem.MakeId = "0";
                                flavorItem.Name = "餐盒费";
                                flavorItem.OrderId = _orderObject.Id;
                                flavorItem.OrderItemQuantity = _ordertime.Count;
                                flavorItem.TenantId = _orderObject.TenantId;
                                flavorItem.TradeNo = _orderObject.TradeNo;
                                flavorItem.Type = 0;
                                order.Flavors.Add(flavorItem);
                            }
                        }
                        #endregion

                        order.GiveFlag = product.GiveFlag;//允许赠送
                        order.Group = "";//分组
                        order.KdsChupin = product.KdsChupin;//厨显出品ID
                        order.KdsChupinFlag = product.KdsChupinFlag;//厨显是否出品
                        order.KdsChupinQty = 0;
                        order.KdsChupinTime = product.KdsChupinTime;//厨显出品超时时间
                        order.LabelPrintFlag = product.LabelPrintFlag;//标签打印
                        order.MebDiscountFlag = product.MebDiscountFlag;//会员折上折
                        order.MemberPrice = _ordertime.Price;//会员价
                        order.MinPrice = product.MinPrice;//最低售价
                        order.Name = product.Name;//商品名称
                        order.OrderId = _orderObject.Id;//订单ID
                        order.OrderNo = i++;
                        order.OtherPrice = _ordertime.Price;//第三方价
                        order.Price = _ordertime.Price;//售价
                        order.ProductExt = product;//商品信息
                        order.ProductId = product.Id;//商品ID
                        order.ProductNo = product.No;//商品编号
                        order.ProductUnitId = product.UnitId;//商品单位ID
                        order.ProductUnitName = product.UnitName;//商品单位名称
                        order.PromotionFlag = product.PromotionFlag;//是否允许促销
                        order.Quantity = _ordertime.Count;//商品数量
                        order.RefundQuantity = _ordertime.Rcount;//退菜数量
                        order.Remark = "小程序单品";
                        //是否套菜(1普通菜 2 主菜 3 明细菜)
                        switch (_ordertime.Issuit)
                        {
                            case 1:
                                order.RowState = OrderRowState.普通;
                                break;
                            case 2:
                                order.RowState = OrderRowState.套餐主;
                                break;
                            case 3:
                                order.RowState = OrderRowState.套餐明;
                                break;
                            default:
                                break;
                        }

                        order.SuitId = _ordertime.Suitid;
                        order.ParentId = _ordertime.Parentid;
                        order.SuitQuantity = 1;
                        order.SaleDate = _ordertime.Saledate;//创建时间
                        order.SalePrice = _ordertime.Price;//售价
                        order.ShortName = product.ShortName;//简称
                        order.SpecId = product.SpecId;//规格ID
                        order.SpecName = product.SpecName;//规格名称
                        order.StockFlag = product.StockFlag;//是否管理库存
                        order.TapleFlag = product.TapleFlag;//是否主食
                        order.TenantId = Global.Instance.Authc.TenantId;//租户ID
                        order.TotalAmonut = _ordertime.Receivable;//总计金额
                        order.TradeNo = _orderObject.TradeNo;//订单编号
                        order.TypeId = product.TypeId;//商品类别ID
                        order.TypeName = product.TypeName;//商品类别名称
                        order.WeighFlag = product.WeighFlag;//是否称重
                        order.OtherWaimaiPrintMake = "";
                        order.SaleDate = _orderObject.SaleDate;
                        //order.OtherWaimaiPrintName = item.Name;
                        //order.Promotions = promotionsList;


                        map.Add(order);
                        _orderObject.Items.Add(order);

                    }
                    #endregion

                    _orderObject.Maps = map; //商品Map明细 
                }
                #endregion

                foreach (OrderItem order in _orderObject.Items)
                {

                    if (order.RowState == OrderRowState.套餐主)
                    {
                        List<OrderItem> itemDetail = _orderObject.Items.FindAll(x => x.RowState == OrderRowState.套餐明 && x.ParentId == order.ParentId);
                        foreach (OrderItem item in itemDetail)
                        {
                            order.FlavorAmount += item.Flavors.Sum(f => f.Amount);
                            order.FlavorReceivableAmount += item.Flavors.Sum(f => f.ReceivableAmount);
                            order.FlavorDiscountAmount += item.Flavors.Sum(f => f.DiscountAmount);
                        }
                    }
                }

                #region PatInfo
                _orderObject.Pays = new List<PayItem>();
                foreach (var _pay in response.PayInfo)
                {
                    PayItem _payitem = new PayItem();
                    _payitem.TenantId = Global.Instance.Worker.TenantId;
                    _payitem.Amount = _pay.Money - response.Deliverfee;
                    _payitem.CardAftAmount = 0.00M;
                    _payitem.CardBeforeBalance = 0.00M;
                    _payitem.CardBeforePoint = 0.00M;
                    _payitem.CardFaceNo = "";
                    _payitem.CardNo = _pay.Cardno;
                    _payitem.ChangeAmount = 0.00M;
                    _payitem.CreateDate = _pay.Paydate;
                    _payitem.CreateUser = "";
                    _payitem.FinishDate = _pay.Paydate;
                    _payitem.Id = IdWorkerUtils.Instance.NextId();
                    _payitem.IncomeFlag = 1;
                    _payitem.MemberMobileNo = "";
                    _payitem.Memo = _payitem.Memo;
                    _payitem.Name = _pay.Paytype;
                    _payitem.No = _pay.Paytypeno;
                    _payitem.Order = 1;
                    _payitem.OrderId = _orderObject.Id;
                    _payitem.TradeNo = _orderObject.TradeNo;
                    _payitem.OutTradeNo = _pay.Voucherno;
                    _payitem.PaidAmount = _pay.Money - response.Deliverfee;
                    _payitem.PayNo = _pay.Payno;
                    _payitem.PayTime = _pay.Paydate;
                    _payitem.ShiftName = Global.Instance.BusinessPlanLog.Name;
                    _payitem.ShiftNo = Global.Instance.BusinessPlanLog.No;
                    _payitem.Ext2 = _pay.ChargeBack.ToString();
                    _orderObject.Pays.Add(_payitem);
                }

                #endregion

                #region 外送信息

                foreach (var ticket in response.TicketDeliver)
                {
                    _orderObject.Address = ticket.Address;
                    _orderObject.Recipients = ticket.Name;
                    _orderObject.Phone = ticket.Ordertel;
                }

                //if (_orderObject.OrderType == OrderType.微信_外送)
                //{

                //    foreach (var item in response.TicketDeliver)
                //    {
                //        OrderDelivery delivery = new OrderDelivery();
                //    }
                //}

                #endregion

                return _orderObject;
            }
            catch (Exception ex)
            {
                LOGGET.Error(ex, "巨为小程序订单本地转单异常");

                return null;
            }

        }

        /// <summary>
        /// 小票打印
        /// </summary> 
        public static Tuple<bool, string, string> PrintOrder(OrderObject _orderdata, bool isRprint = false)
        {
            try
            {
                if (isRprint)
                {
                    _orderdata.RPrint = true;
                }

                //20240330 subin 收银小票，打印外带和自提的小票，不打印堂食票
                if (_orderdata.BusMode == "堂食" || _orderdata.OrderType == OrderType.堂食)
                {
                    LOGGET.Info($"订单类型<{_orderdata.OrderType}>,不打印收银小票");
                    //return new Tuple<bool, string, string>(true, "", "堂食不打印收银小票");
                }
                else
                {
                    LOGGET.Info("开始打印小程序订单.....<{0}>", _orderdata.TradeNo);
                    //打印入库
                    //构建收银小票模版参数打印
                    var vars = WaiMaiHelper.BuilderWeiXinVariable(_orderdata, isRprint);

                    //自动切纸
                    bool cutPager = Global.Instance.GlobalConfigBoolValue(ConfigConstant.PERIPHERAL_CASHIER_ALLOW_CUT_PAGER, false);
                    //是否允许打开钱箱 补打单、退单不开钱箱
                    bool openCashbox = false;
                    //票头空白行
                    int headerLine = Global.Instance.GlobalConfigIntValue(ConfigConstant.PERIPHERAL_CASHIER_HEADER_EMPTY, 0);
                    //票尾空白行
                    int footerLine = Global.Instance.GlobalConfigIntValue(ConfigConstant.PERIPHERAL_CASHIER_FOOTER_EMPTY, 0);
                    //打印机
                    var pobject = WaiMaiHelper.GetTicketPrinterObject("收银台打印机", cutPager, false);

                    var printResult = WaiMaiHelper.PrinterTicket(pobject, "巨为小程序", vars, cutPager, openCashbox, headerLine, footerLine);

                    LOGGET.Info("小程序订单打印结果.....<{0}>", printResult.Item2);


                    //打印标签
                    LabelPrintHelper.PrintOrderLabel(_orderdata);
                    //执行厨打
                    ChuDaHelper.KitchenPrinter(_orderdata);
                    //执行厨打标签
                    ChuDaHelper.KitchenLabelPrinter(_orderdata);
                    //执行出品
                    ChuDaHelper.MadePrinter(_orderdata);
                }
                //通知厨显
                UploadSCNewOrder.UploadNewOrder2SC4KDS(_orderdata);
            }
            catch (Exception ex)
            {
                LOGGET.Info(ex, "巨为小程序订单打印异常");
            }

            return new Tuple<bool, string, string>(true, "", "");
        }

        /// <summary>
        /// 巨为微信小程序接单
        /// </summary>
        public static void sendJwWeixinMessage(string message)
        {
            if (LOGGET == null)
            {
                LOGGET = NLog.LogManager.GetLogger("JuWeiAppOrderProxy");
            }
            try
            {
                LOGGET.Info("巨为微信小程序接单开始");
                //微信小程序订单是否开启自动接单
                bool openConfirm = Global.Instance.GlobalConfigBoolValue(ConfigConstant.WEIXIN_CONFIRM_PARAMETER, false);

                var _data = JsonUtils.Deserialize<Dictionary<string, string>>(message);

                if (_data == null)
                {
                    LOGGET.Info("订单推送数据解析可能出现问题");
                    return;
                }
                JuWeiAppOrderProxy _juWeiAppOrderProxy = new JuWeiAppOrderProxy();
                if (_data.ContainsKey("program") && _data.ContainsKey("date") && !"".Equals(_data["program"]))
                {
                    //如果发送的时间和本机相差15分钟,证明是无效消息
                    if (DateTimeUtils.ExecDateDiff(DateTime.Now, DateTime.Parse(_data["date"])) < 15)
                    {
                        string[] orderIds = _data["program"].Split(',');

                        //有美团外卖订单
                        MsgEvent.Send(Constant.MSGCENTER_NOTIFY, new MsgEntity()
                        {
                            Subject = Constant.MENU_TITLE_CHANGED_NOTIFY,
                            SubSubject = ModuleKeyCode.微信订单.ToString(),
                            Operate = MsgEntityOperate.发布,
                            Data = new Tuple<ModuleKeyCode, MenuTileNotifyType, string>(ModuleKeyCode.微信订单, MenuTileNotifyType.数量, string.Format("{0}", orderIds.Length))
                        });

                        //手动接单，发送界面更新通知
                        if (!openConfirm)
                        {
                            // 播放声音
                            SoundUtils.PlaySound("weixin");
                            LOGGET.Info("巨为小程序订单播放声音，通知手动接单");

                            MsgEvent.Send(Constant.JW_WEIXIN_UI_UPDATA, null);
                            return;
                        }

                        LOGGET.Info("巨为小程序订单进入自动接单.....");

                        //自动接单处理
                        if (orderIds.Length > 0)
                        {
                            LOGGET.Info("巨为小程序订单Length>0");
                        }
                        //20240129 subin 改为只处理服务端返回为一条订单的小程序订单
                        if (orderIds.Length == 1)
                        {
                            LOGGET.Info($"巨为小程序订单Length={orderIds.Length}");
                            var _len = orderIds.Length;
                            foreach (var item in orderIds)
                            {
                                LOGGET.Info($"巨为小程序订单进入自动接单<{item}>开始");
                                if (string.IsNullOrEmpty(item))
                                {
                                    LOGGET.Info("订单编号为空,忽略");
                                    continue;
                                }

                                // 播放声音
                                #region 播放声音
                                //SoundUtils.PlaySound("weixin");
                                //LOGGET.Info($"巨为小程序订单<{item}>播放声音，通知自动接单");

                                //20240129 subin 改为异步播放
                                Task.Factory.StartNew(() =>
                                {
                                    SoundUtils.PlaySound("weixin");
                                    LOGGET.Info($"巨为小程序订单<{item}>播放声音，通知自动接单");
                                });
                                #endregion

                                //请求接口查询订单
                                LOGGET.Info($"巨为小程序请求接口查询订单<{item}>");
                                var _order = _juWeiAppOrderProxy.GetOrder(item);
                                LOGGET.Info($"巨为小程序请求接口查询订单<{item}>,返回结果：{JsonUtils.Serialize(_order)}");
                                if (_order == null)
                                {
                                    LOGGET.Info("推送的巨为小程序订单号<{0}>在服务器中查询不到！", item);
                                    //return;

                                    continue;
                                }


                                //zhangy 2020-03-01 Add 添加以下代码，替换原来的处理方式
                                if (_order.Item1)
                                {
                                    LOGGET.Info("获取到服务端小程序订单ID:{0},检测本地是否存在订单:{1}", _order.Item3.Id, _order.Item3.No);

                                    bool isExists = false;
                                    using (var _db = Global.Instance.OpenDataBase)
                                    {
                                        var _sql = string.Format("select * from pos_order where tradeNo = '{0}'", _order.Item3.No);

                                        var _oo = _db.Query<OrderObject>(_sql);

                                        if (_oo != null && _oo.Count() > 0)
                                        {
                                            isExists = true;
                                        }
                                    }

                                    if (isExists)
                                    {
                                        LOGGET.Info("本地已经存在订单:{0}", _order.Item3.No);
                                        //return;
                                        continue;
                                    }

                                    //zhangy 2020-02-19 Add 
                                    //订单已确认后申请退款，刷新订单显示在待处理订单中
                                    if (_order.Item3.Status == 1 && _order.Item3.Refundstatus == 1)
                                    {
                                        MsgEvent.Send(Constant.JW_WEIXIN_UI_UPDATA, null);
                                    }

                                    //非待接单
                                    if (_order.Item3.Status != 0)
                                    {
                                        //return;
                                        continue;
                                    }


                                    //请求接口修改订单状态
                                    var _status = _juWeiAppOrderProxy.SetOrderStatus(ProgramOrderOperationType.Confirm, item);
                                    _len--;
                                    //接单成功刷新页面
                                    MsgEvent.Send(Constant.MSGCENTER_NOTIFY, new MsgEntity()
                                    {
                                        Subject = Constant.MENU_TITLE_CHANGED_NOTIFY,
                                        SubSubject = ModuleKeyCode.微信订单.ToString(),
                                        Operate = MsgEntityOperate.发布,
                                        Data = new Tuple<ModuleKeyCode, MenuTileNotifyType, string>(ModuleKeyCode.微信订单, MenuTileNotifyType.数量, string.Format("{0}", _len))
                                    });

                                    if (!_status.Item1)
                                    {
                                        LOGGET.Info("巨为小程序自动接单失败,订单号:<{0}>", item);
                                        //return;
                                        continue;
                                    }

                                    LOGGET.Info("巨为小程序自动接单,开始组装数据.....");
                                    var _orderdata = getOrderLocalJuWeiOrder(_order.Item3);
                                    LOGGET.Info($"巨为小程序自动接单,开始组装数据<{item}>,返回结果：{JsonUtils.Serialize(_orderdata)}");
                                    if (_orderdata != null)
                                    {
                                        LOGGET.Info("巨为小程序自动接单,开始保存数据....");
                                        var _intder = _juWeiAppOrderProxy.InsertOrder(_orderdata);
                                        if (_intder.Item1)
                                        {
                                            #region 打印小票
                                            LOGGET.Info($"巨为小程序自动接单<{item}>,数据保存成功,开始打印小票....");
                                            //JuWeiAppOrderProxy.PrintOrder(_orderdata);


                                            //20240129 subin 改为异步打印
                                            Task.Factory.StartNew(() =>
                                            {
                                                JuWeiAppOrderProxy.PrintOrder(_orderdata);
                                            });
                                            #endregion

                                            #region subin 20230916 订单保存成功后处理分账明细

                                            //LOGGET.Info("巨为小程序自动接单,数据保存成功,开始保存分账明细....");
                                            //JuWeiAppOrderProxy.DoSplitOrder(_orderdata);
                                            //Task.Factory.StartNew(() =>
                                            //{
                                            //    SplitPayUtils.Instance.SaveSplitPayInfo(_orderdata);
                                            //});
                                            #endregion


                                            #region subin 20240322 沽清
                                            //处理参与沽清的业务
                                            var rows = _orderdata.Items;
                                            if (rows.Count > 0)
                                            {
                                                foreach (var row in rows)
                                                {
                                                    //套餐明细不处理沽清业务
                                                    if (row.RowState == OrderRowState.套餐明)
                                                    {
                                                        continue;
                                                    }

                                                    //添加沽清业务规则
                                                    SaleClear saleClear = null;
                                                    if (SaleClearUtils.Instance.Maps.ContainsKey(row.ProductId))
                                                    {
                                                        saleClear = SaleClearUtils.Instance.Maps[row.ProductId];
                                                    }
                                                    //是否参与沽清
                                                    bool isSaleClear = SaleClearUtils.Instance.CheckSaleClear(saleClear);

                                                    if (isSaleClear && saleClear.Quantity > 0)
                                                    {
                                                        saleClear.SaleQuantity += row.Quantity;

                                                        SaleClearUtils.Instance.Maps[row.ProductId] = saleClear;

                                                        LOGGET.Info($"小程序沽清：{JsonUtils.Serialize(saleClear)}");
                                                    }
                                                    //参与沽清，已经售完
                                                    else if (isSaleClear && saleClear.Quantity <= 0)
                                                    {
                                                        LOGGET.Info($"小程序沽清,沽清售完了：{JsonUtils.Serialize(saleClear)}");
                                                    }
                                                }
                                            }
                                            else
                                            {
                                                LOGGET.Info("小程序沽清：没有明细");
                                            }
                                            #endregion
                                        }
                                        else
                                        {
                                            LOGGET.Error("巨为小程序自动接单,数据保存失败，订单号:<{0}>", item);
                                        }
                                    }
                                    else
                                    {
                                        LOGGET.Info("巨为小程序自动接单,数据转单失败....");
                                    }
                                }
                                else
                                {
                                    LOGGET.Error("获取订单操作失败:[" + _order.Item2 + "]");
                                }


                                Thread.Sleep(100);
                                LOGGET.Info($"巨为小程序订单进入自动接单<{item}>结束");
                            }
                        }
                    }
                    else
                    {
                        LOGGET.Error("巨为小程序订单已经超过15分钟，视为无效！推送信息:" + message);
                    }
                }
            }
            catch (Exception ex)
            {
                LOGGET.Error(ex, "巨为小程序自动接单发生异常");
            }

            LOGGET.Info("巨为微信小程序接单结束");
        }

        public static Tuple<bool, string> DoRefund(string tradeNo)
        {
            try
            {
                OrderObject _OrderObject = OrderUtils.getOrderObjectByTranNo(tradeNo);
                if (_OrderObject != null)
                {
                    if (_OrderObject.OrgTradeNo != null && !"".Equals(_OrderObject.OrgTradeNo))
                    {
                        return new Tuple<bool, string>(false, "订单已完全退单");
                    }
                    //生成新单
                    OrderObject _BackOrderObject = ObjectUtils.Copy(_OrderObject);
                    string finishDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                    //=========更新原单内容
                    //录入原单号
                    _BackOrderObject.Id = IdWorkerUtils.Instance.NextId();
                    //操作员工号
                    _BackOrderObject.WorkerNo = Global.Instance.Worker.No;
                    //操作员名称
                    _BackOrderObject.WorkerName = Global.Instance.Worker.Name;
                    _BackOrderObject.SaleDate = finishDate;
                    //班次名称
                    _BackOrderObject.ShiftName = Global.Instance.BusinessPlanLog.Name;
                    //班次编号
                    _BackOrderObject.ShiftNo = Global.Instance.BusinessPlanLog.No;
                    //订单标识为 新建状态
                    _BackOrderObject.OrderStatus = OrderStatus.已退单;
                    //订单创建时间
                    _BackOrderObject.CreateDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                    //订单创建人
                    _BackOrderObject.CreateUser = Global.Instance.Worker.Name;
                    string[] day = new string[] { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
                    string weeker = day[Convert.ToInt32(DateTime.Now.DayOfWeek.ToString("d"))].ToString();
                    //星期
                    _BackOrderObject.Weeker = weeker;
                    //天气
                    _BackOrderObject.Weather = string.Empty;
                    _BackOrderObject.ObjectId = ObjectId.GenerateNewStringId();
                    _BackOrderObject.TradeNo = OrderUtils.Instance.GenerateTicketNo();
                    _BackOrderObject.FinishDate = finishDate;
                    _BackOrderObject.Amount = 0 - _OrderObject.Amount;
                    _BackOrderObject.DiscountAmount = 0 - _OrderObject.DiscountAmount;
                    _BackOrderObject.ReceivableAmount = 0 - _OrderObject.ReceivableAmount;
                    _BackOrderObject.PaidAmount = 0 - _OrderObject.PaidAmount;
                    _BackOrderObject.ReceivedAmount = 0 - _OrderObject.ReceivedAmount;
                    _BackOrderObject.MalingAmount = 0 - _OrderObject.MalingAmount;
                    _BackOrderObject.ChangeAmount = 0 - _OrderObject.ChangeAmount;
                    _BackOrderObject.InvoicedAmount = 0 - _OrderObject.InvoicedAmount;
                    _BackOrderObject.SyncStatus = 0;
                    _BackOrderObject.PrintStatus = 0;
                    _BackOrderObject.AddPoint = 0 - _OrderObject.AddPoint;
                    _BackOrderObject.UploadStatus = 0;
                    _BackOrderObject.UploadMessage = "";
                    _BackOrderObject.TicketId = "";
                    _BackOrderObject.OrgTradeNo = _OrderObject.TradeNo;
                    _BackOrderObject.RefundCause = "用户申请退款";
                    //整单优惠
                    foreach (PromotionOrder promotion in _BackOrderObject.Promotions)
                    {
                        promotion.Id = IdWorkerUtils.Instance.NextId();
                        promotion.OrderId = _BackOrderObject.Id;
                        promotion.TradeNo = _BackOrderObject.TradeNo;
                        promotion.Amount = 0 - promotion.Amount;
                        promotion.DiscountAmount = 0 - promotion.DiscountAmount;
                        promotion.ReceivableAmount = 0 - promotion.ReceivableAmount;
                        promotion.FinishDate = finishDate;
                    }
                    //====== 更新明细内容
                    foreach (OrderItem item in _BackOrderObject.Items)
                    {
                        item.Id = IdWorkerUtils.Instance.NextId();
                        item.OrderId = _BackOrderObject.Id;
                        item.TradeNo = _BackOrderObject.TradeNo;
                        //单品优惠
                        foreach (PromotionItem promotion in item.Promotions)
                        {
                            promotion.Id = IdWorkerUtils.Instance.NextId();
                            promotion.OrderId = _BackOrderObject.Id;
                            promotion.ItemId = item.Id;
                            promotion.TradeNo = _BackOrderObject.TradeNo;
                            promotion.Amount = 0 - promotion.Amount;
                            promotion.DiscountAmount = 0 - promotion.DiscountAmount;
                            promotion.ReceivableAmount = 0 - promotion.ReceivableAmount;
                            promotion.FinishDate = finishDate;
                        }
                        //做法信息
                        foreach (FlavorItem flavor in item.Flavors)
                        {
                            flavor.Id = IdWorkerUtils.Instance.NextId();
                            flavor.OrderId = _BackOrderObject.Id;
                            flavor.ItemId = item.Id;
                            flavor.TradeNo = _BackOrderObject.TradeNo;
                            flavor.RefundQuantity = flavor.Quantity;
                            flavor.Amount = 0 - flavor.Amount;
                            flavor.Quantity = 0;
                            flavor.DiscountAmount = 0 - flavor.DiscountAmount;
                            flavor.FinishDate = finishDate;
                            flavor.isBackTicket = true;
                        }
                        item.RefundQuantity = item.Quantity;
                        item.Quantity = 0;
                        item.Amount = 0 - item.Amount;
                        item.FlavorAmount = 0 - item.FlavorAmount;
                        item.FlavorDiscountAmount = 0 - item.FlavorDiscountAmount;
                        item.FlavorReceivableAmount = 0 - item.FlavorReceivableAmount;
                        item.TotalAmonut = 0 - item.TotalAmonut;
                        item.SuitAddPrice = 0 - item.SuitAddPrice;
                        item.SuitAmount = 0 - item.SuitAmount;
                        item.SaleDate = finishDate;
                        item.ChudaQty = 0;
                        item.ChupinQty = 0;
                        item.ChuxianQty = 0;
                        item.KdsChupinQty = 0;
                        item.FinishDate = finishDate;

                    }
                    //支付方式遍历
                    foreach (PayItem pay in _BackOrderObject.Pays)
                    {
                        pay.Id = IdWorkerUtils.Instance.NextId();
                        pay.TradeNo = _BackOrderObject.TradeNo;
                        pay.PayNo = OrderUtils.Instance.GeneratePayNo();
                        pay.OrderId = _BackOrderObject.Id;
                        pay.Amount = 0 - pay.Amount;
                        pay.PaidAmount = 0 - pay.PaidAmount;
                        pay.ChangeAmount = 0 - pay.ChangeAmount;
                        pay.PayTime = finishDate;
                        pay.FinishDate = finishDate;
                        pay.OverAmount = 0 - pay.OverAmount;
                        pay.ShiftName = _BackOrderObject.ShiftName;
                        pay.ShiftNo = _BackOrderObject.ShiftNo;

                        #region subin 20231003 注释修改
                        //注释
                        //zhangy 2020-02-18 Add 档口结算信息赋默认值
                        //pay.Ext1 = "0";
                        //pay.Ext2 = "0"; 

                        //修改
                        pay.Ext1 = string.IsNullOrEmpty(pay.Ext1) ? "0" : pay.Ext1;
                        pay.Ext2 = string.IsNullOrEmpty(pay.Ext2) ? "0" : pay.Ext2;
                        #endregion

                        var payMode = OrderUtils.GetPayMode(pay.No);
                        if (payMode == null)
                        {
                            pay.IncomeFlag = 1;
                            pay.OtherRateType = 0;
                            pay.OtherRateValue = 0.00M;
                        }
                        else
                        {
                            pay.IncomeFlag = payMode.IncomeFlag;
                            pay.OtherRateType = payMode.OtherRateType;
                            pay.OtherRateValue = 0 - payMode.OtherRateValue;

                            //zhangy 2020-02-20 Add,退单，扣率金额也退
                            pay.Ext2 = string.IsNullOrEmpty(pay.Ext2) ? "0" : ("-" + pay.Ext2);
                        }

                    }

                    var isException = OrderUtils.Instance.SaveOrderObject(_BackOrderObject);
                    if (!isException)
                    {
                        _OrderObject.OrgTradeNo = _BackOrderObject.TradeNo;
                        using (var db = Global.Instance.OpenDataBase)
                        {
                            using (var trans = db.GetTransaction())
                            {
                                db.Update(_OrderObject);
                                WxWaimaiOrder wxWaimaiOrder = db.FirstOrDefault<WxWaimaiOrder>("where ticketNo =@0;", tradeNo);
                                //如果是外卖模式
                                //如果是外卖订单,存储配送信息
                                if (wxWaimaiOrder != null)
                                {
                                    WxWaimaiOrder wxBackWaimaiOrder = new WxWaimaiOrder();
                                    wxWaimaiOrder.Id = IdWorkerUtils.Instance.NextId();
                                    wxWaimaiOrder.TenantId = wxWaimaiOrder.TenantId;
                                    wxWaimaiOrder.TicketNo = _OrderObject.TradeNo;
                                    wxWaimaiOrder.StoreId = _OrderObject.StoreId;
                                    wxWaimaiOrder.StoreNo = _OrderObject.StoreNo;
                                    wxWaimaiOrder.StoreName = _OrderObject.StoreName;
                                    wxWaimaiOrder.WorkerNo = _OrderObject.WorkerNo;
                                    wxWaimaiOrder.ShiftId = Global.Instance.BusinessPlanLog.PlanId;
                                    wxWaimaiOrder.ShiftNo = Global.Instance.BusinessPlanLog.No;
                                    wxWaimaiOrder.ReceiveName = wxWaimaiOrder.ReceiveName;
                                    wxWaimaiOrder.ReceiveMobile = wxWaimaiOrder.ReceiveMobile;
                                    wxWaimaiOrder.ReceiveAddress = wxWaimaiOrder.ReceiveAddress;
                                    wxWaimaiOrder.DistributionFee = wxWaimaiOrder.DistributionFee;
                                    wxWaimaiOrder.Type = 1;
                                    wxWaimaiOrder.IsIncome = 1;
                                    wxWaimaiOrder.Status = 1;
                                    wxWaimaiOrder.CreateDate = _OrderObject.FinishDate;
                                    wxWaimaiOrder.CreateUser = _OrderObject.CreateUser;
                                    db.Insert<WxWaimaiOrder>(wxWaimaiOrder);
                                }
                                trans.Complete();
                            }
                        }
                        return new Tuple<bool, string>(true, "退单完成");
                    }
                    else
                    {
                        return new Tuple<bool, string>(false, "退单保存失败！");
                    }
                }
                else
                {
                    return new Tuple<bool, string>(false, "获取订单信息异常");
                }
            }
            catch (Exception ex)
            {
                LOGGET.Error(ex, "退单发生异常");
                return new Tuple<bool, string>(false, "退单发生异常");
            }
        }

        #region subin 20230916 新增小程序订单保存分账明细

        public static Tuple<bool, string> DoSplitOrderBefore(OrderObject _orderdata)
        {
            using (var db = Global.Instance.OpenDataBase)
            {
                try
                {
                    var splitPayLst = db.Query<SplitStorePay>($"where busNo='{_orderdata.TradeNo}'");
                    if (splitPayLst.Count() > 0)
                    {
                        LOGGET.Info("分账信息已存在，不需要分账");
                    }
                    else
                    {
                        return DoSplitOrder(_orderdata);
                    }
                }
                catch (Exception ex)
                {
                    new Tuple<bool, string>(false, $"订单补打保存分账明细错误：{ex.Message}");
                }
            }

            return new Tuple<bool, string>(true, "");
        }



        public static Tuple<bool, string> DoSplitOrder(OrderObject _orderdata)
        {
            LOGGET.Info("开始保存订单的分账信息");
            var productIds = "";
            var splitStorePayLst = new List<SplitStorePay>();
            using (var db = Global.Instance.OpenDataBase)
            {
                var _orderObject = OrderUtils.getOrderObjectByTranNo(_orderdata.TradeNo);
                if (_orderObject != null)
                {
                    try
                    {
                        var splitShopList = db.Fetch<SplitShopAccount>();
                        var splitFoodList = new List<SplitFoodAccount>();

                        var productIdList = _orderObject.Items.Select(item => item.ProductId.Trim()).Distinct();
                        if (productIdList != null && productIdList.Count() > 0)
                        {
                            productIds = string.Join(",", productIdList);

                            splitFoodList = db.Query<SplitFoodAccount>($"where goodId in ('{productIds.Replace(",", "','")}');").ToList();
                        }

                        int i = 0;
                        foreach (var pay in _orderObject.Pays)
                        {
                            foreach (var item in _orderObject.Items)
                            {

                                var s = splitFoodList.FirstOrDefault(m => m.ProductId == item.ProductId);
                                if (s != null)
                                {
                                    var _fromBizUser = splitShopList.FirstOrDefault(m => m.Id == s.ShopId.Trim());
                                    var _fromBizUserId = _fromBizUser != null ? _fromBizUser.BizUserId : "";

                                    var ssp = new SplitStorePay
                                    {
                                        Id = IdWorkerUtils.Instance.NextId(),
                                        ClientId = "",
                                        ProgramId = "",
                                        TenantId = item.TenantId,
                                        StoreId = _orderObject.StoreId,
                                        SplitStoreId = s.ShopId,
                                        StoreNo = _orderObject.StoreNo,
                                        PayNo = pay.PayNo,
                                        TicketId = "",
                                        BusNo = pay.TradeNo,
                                        PayTypeNo = pay.No,
                                        PayType = pay.Name,
                                        Paid = item.TotalReceivableAmount,
                                        Rchange = 0,
                                        Money = item.TotalReceivableAmount,
                                        OverAmount = 0,
                                        VoucherNo = pay.TradeVoucherNo,
                                        PayDate = pay.PayTime,
                                        CardNo = pay.CardNo,
                                        IncomeFlag = pay.IncomeFlag,
                                        OtherRateType = pay.OtherRateType,
                                        OtherRateValue = pay.OtherRateValue,
                                        OtherRate = pay.OtherRate,
                                        PayClientType = -1,
                                        PayChannel = (int)pay.PayChannel,
                                        DeductionRate = 0,
                                        ChargeBack = 0,
                                        Memo = _orderObject.Ext1,
                                        IsInvalid = "0",
                                        OrderId = _orderObject.Id,
                                        PayId = pay.Id,
                                        SyncStatus = 0,
                                        UploadErrors = 0,
                                        UploadStatus = 0,
                                        UploadMessage = "",
                                        ProductId = item.ProductId,
                                        OrderItemId = item.Id,
                                        PayItemId = "",
                                        RefundAmount = 0,
                                        //FromBizUserld = JsonUtils.Deserialize<StoreAllinParams>(Global.Instance.Worker.StoreInfo.Ext1).BizUserId,
                                        FromBizUserld = _fromBizUserId,
                                        OrderType = (int)_orderObject.OrderType,
                                        IsRefund = 0,
                                        RefundQuantity = 0,
                                        fee = 0
                                    };
                                    if (i == 0)
                                    {
                                        ssp.fee = string.IsNullOrEmpty(pay.Ext2) ? 0 : Convert.ToDecimal(pay.Ext2);
                                    }
                                    splitStorePayLst.Add(ssp);
                                }
                                i++;
                            }
                        }


                        if (splitStorePayLst.Count() > 0)
                        {
                            db.InsertBatch<SplitStorePay>(splitStorePayLst);
                            //LOGGET.Info($"保存订单的分账信息:{JsonUtils.Serialize(splitStorePayLst)}");
                            LOGGET.Info("有需要上传的营业分账数据,isHaveUpLoadSplitPay = true");
                            Global.isHaveUpLoadSplitPay = true;
                        }
                        else
                        {
                            LOGGET.Info($"订单[{_orderObject.TradeNo}]，没有要分账的菜品信息，将不保存分账信息。");
                        }
                    }
                    catch (Exception ex)
                    {
                        LOGGET.Error(ex, $"保存订单的分账信息异常，单号ID：{_orderObject.Id}");
                        return new Tuple<bool, string>(false, "退单保存失败！");
                    }
                }
                else
                {
                    return new Tuple<bool, string>(false, "未查询到订单信息");
                }
            }

            LOGGET.Info("结束保存订单的分账信息");

            return new Tuple<bool, string>(true, "");
        }
        #endregion
    }
    public enum ProgramOrderOperationType
    {
        /// <summary>
        /// 接单
        /// </summary>
        Confirm = 0,
        /// <summary>
        /// 拒单
        /// </summary>
        Refuse = 1,
        /// <summary>
        /// 同意退款
        /// </summary>
        Refund = 2,
        /// <summary>
        /// 拒绝退款
        /// </summary>
        NotRefund = 3
    }
}