MTP2.0_CSharp/Muchinfo.MTPClient/Fx4.0/Main/05.Services/Muchinfo.TASClient.Service/OrderService.cs

//----------------------------------------------------------------
//Module Name:  OrderService
//Purpose:      
//CopyRight:    Muchinfo
//History:
//----------------------------------------------------------------
//DateTime		Author		    Description
//----------------------------------------------------------------
//2014-03-22    deng.yinping       Create
//----------------------------------------------------------------
//#define test

using Muchinfo.MTPClient.Adapter.Abstract;
using Muchinfo.MTPClient.Data;
using Muchinfo.MTPClient.Data.Enums;
using Muchinfo.MTPClient.Data.Model;
using Muchinfo.MTPClient.Data.Model.Account;
using Muchinfo.MTPClient.Infrastructure.Cache;
using Muchinfo.MTPClient.Infrastructure.LinkProxy;
using Muchinfo.MTPClient.Infrastructure.Utilities;
using Muchinfo.MTPClient.IService;
using Muchinfo.MTPClient.NetworkCore;
using Muchinfo.MTPClient.Resources;
using Muchinfo.MTPClient.Service.Utilities;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;

namespace Muchinfo.MTPClient.Service
{
    public class OrderService : IOrderService
    {
        private OrderAdapter _orderAdapter;

        public OrderService()
        {
            _orderAdapter = LinkManager.Instance.TradeAdapterFactory.CreateOrderAdapter();
        }

        #region 委托下单

        /// <summary>
        /// OTC市场委托订单
        /// </summary>
        /// <param name="entrustOrder"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void MakeMarketEntrustOrder(Data.Model.NewEntrustOrder entrustOrder, Action<Data.Model.Account.OrderDetail> successAction, Action<Data.ErrorEntity> errorAction)
        {
            var userId = UserManager.CurrentTradeAccount.CustomerId;
            var reqeust = _orderAdapter.ToMakeMarketEntrustOrder(entrustOrder, userId);
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_OrderReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntrity = _orderAdapter.ToMakeLimitOrder(revPackgage.Content);
                if (responeEntrity.RetCode == 0)
                {
                    //todo:生成委托单
                    successAction(responeEntrity.Entity);
                }
                else
                {
                    if (errorAction != null)
                    {
                        //RequestFunc = 市场委托订单 
                        errorAction(new ErrorEntity() { ReturnCode = responeEntrity.RetCode, ReturnDesc = responeEntrity.RetMessage, RequestFunc = Client_Resource.Resources_Service_MakeMarketEntrustOrder });
                    }
                }
            }), new Action<int, string>((errorCode, errorDesc) =>
            {     ////通信错误
                if (errorAction != null)
                {
                    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = Client_Resource.Resources_Service_MakeMarketEntrustOrder });
                }
            }));
        }


        public void CancelOrder(NewEntrustOrder entrustOrder, Action successAction,
            Action<ErrorEntity> errorAction)
        {
            var userId = UserManager.CurrentTradeAccount.CustomerId;
            var reqeust = _orderAdapter.ToCancelOrder(entrustOrder, userId);
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_CancelOrderReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntrity = _orderAdapter.ToResponseCancelOrder(revPackgage.Content);
                if (responeEntrity.RetCode == 0)
                {
                    successAction();
                }
                else
                {
                    if (errorAction != null)
                    {
                        errorAction(new ErrorEntity() { ReturnCode = responeEntrity.RetCode, ReturnDesc = responeEntrity.RetMessage, RequestFunc = Client_Resource.Button_Cancellation });
                    }
                }
            }), new Action<int, string>((errorCode, errorDesc) =>
            {     ////通信错误
                if (errorAction != null)
                {
                    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = Client_Resource.Button_Cancellation });
                }
            }));
        }

        public void CancelOrderWithoutResult(NewEntrustOrder entrustOrder)
        {
            var userId = UserManager.CurrentTradeAccount.CustomerId;
            var reqeust = _orderAdapter.ToCancelOrder(entrustOrder, userId);
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_CancelOrderReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntrity = _orderAdapter.ToResponseCancelOrder(revPackgage.Content);
                //todo
            }), new Action<int, string>((errorCode, errorDesc) =>
            {
            }));
        }

        /// <summary>
        /// 竞价市场委托订单
        /// </summary>
        /// <param name="entrustOrder"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void BidMarketEntrustOrder(Data.Model.NewEntrustOrder entrustOrder, Action<Data.Model.Account.OrderDetail> successAction, Action<Data.ErrorEntity> errorAction)
        {
            //var reqeust = _orderAdapter.ToBidMarketEntrustOrder(entrustOrder);
            //var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_BMOrderReq };
            //LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            //{
            //    var responeEntrity = _orderAdapter.ToBidMarketLimitOrder(revPackgage.Content);
            //    if (responeEntrity.RetCode == 0)
            //    {
            //        //todo:生成委托单
            //        successAction(responeEntrity.Entity);
            //    }
            //    else
            //    {
            //        if (errorAction != null)
            //        {
            //            //RequestFunc = 竞价市场委托订单 M
            //            errorAction(new ErrorEntity() { ReturnCode = responeEntrity.RetCode, ReturnDesc = responeEntrity.RetMessage, RequestFunc = Client_Resource.Resources_Service_BidMarketEntrustOrder });
            //        }
            //    }
            //}), new Action<int, string>((errorCode, errorDesc) =>
            //{     ////通信错误
            //    if (errorAction != null)
            //    {
            //        errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = Client_Resource.Resources_Service_BidMarketEntrustOrder });
            //    }
            //}));
        }

        /// <summary>
        /// 混合市场委托订单
        /// </summary>
        /// <param name="entrustOrder"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void MixMarketEntrustOrder(Data.Model.NewEntrustOrder entrustOrder, Action<Data.Model.Account.OrderDetail> successAction, Action<Data.ErrorEntity> errorAction)
        {
            //var reqeust = _orderAdapter.ToMixMarketEntrustOrder(entrustOrder);
            //var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_XMOrderReq };
            //LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            //{
            //    var responeEntrity = _orderAdapter.ToMixMarketLimitOrder(revPackgage.Content);
            //    if (responeEntrity.RetCode == 0)
            //    {
            //        //todo:生成委托单
            //        successAction(responeEntrity.Entity);
            //    }
            //    else
            //    {
            //        if (errorAction != null)
            //        {
            //            //RequestFunc = 混合市场委托订单 
            //            errorAction(new ErrorEntity() { ReturnCode = responeEntrity.RetCode, ReturnDesc = responeEntrity.RetMessage, RequestFunc = Client_Resource.Resources_Service_MixMarketEntrustOrder });
            //        }
            //    }
            //}), new Action<int, string>((errorCode, errorDesc) =>
            //{     ////通信错误
            //    if (errorAction != null)
            //    {
            //        errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = Client_Resource.Resources_Service_MixMarketEntrustOrder });
            //    }
            //}));
        }


        public void MixModifyEntrustOrder(NewEntrustOrder entrustOrder, Action<OrderDetail> successAction, Action<ErrorEntity> errorAction)
        {
            return;
            //var reqeust = _orderAdapter.ToMixModifyEntrustOrder(entrustOrder);
            //var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_XMModifyOrderReq};
            //LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            //{
            //    var responeEntrity = _orderAdapter.ToMixModifyRsp(revPackgage.Content);
            //    if (responeEntrity.RetCode == 0)
            //    {
            //        //todo:生成委托单
            //        successAction(responeEntrity.Entity);
            //    }
            //    else
            //    {
            //        if (errorAction != null)
            //        {
            //            //RequestFunc = 混合市场委托订单 
            //            errorAction(new ErrorEntity() { ReturnCode = responeEntrity.RetCode, ReturnDesc = responeEntrity.RetMessage, RequestFunc = Client_Resource.Resources_Service_MixMarketEntrustOrder });
            //        }
            //    }
            //}), new Action<int, string>((errorCode, errorDesc) =>
            //{     ////通信错误
            //    if (errorAction != null)
            //    {
            //        errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = Client_Resource.Resources_Service_MixMarketEntrustOrder });
            //    }
            //}));
        }

        #endregion

        #region 单据查询
        /// <summary>
        /// 查询持仓单明细
        /// </summary>
        /// <param name="statement"></param>
        /// <param name="queryCommonParams"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryHoldingPosistion(string statement, List<QueryCommonParam> queryCommonParams,
            Action<List<HoldingSummary>> successAction, Action<ErrorEntity> errorAction)
        {
            QueryCommonHelper.QueryCommon(statement, queryCommonParams, new Action<List<HoldingSummary>>((holdDetails) =>
            {
                if (successAction != null)
                {
                    //更新缓存数据 - dyp
                    UserManager.UpdateCacheOrder(holdDetails);

                    //    HoldingSummary to Dictionary<ulong, List<TradePositionModel>> 生产List<TradePositionModel>，按照不同的资金账号存储
                    
                    CacheManager.HoldingSummaries.Clear();
                    foreach (HoldingSummary t in holdDetails)
                    {
                        // to TradePositionModel
                        bool isBuy = t.Direction == Direction.Bid;
                        TradePositionModel tradePosition = new TradePositionModel()// 初始化数据
                        {
                            AgreeUnit = (uint)t.AgreeUnit,
                            BuyCurHolderAmount = 0,
                            BuyCurPositionQty = 0,
                            BuyFrozenQty = 0,
                            BuyOtherFrozenQty = 0,
                            GoodsId = t.GoodsId,
                            SellCurHolderAmount = 0,
                            SellCurPositionQty = 0,
                            SellFrozenQty = 0,
                            SellOtherFrozenQty = 0
                        };
                        convertTo(isBuy, t, tradePosition);
                        // 不知道怎么通过资金账号分持仓单，就当做单资金账号先，后面再改
                        if (CacheManager.HoldingSummaries.ContainsKey(UserManager.CurrentTradeAccount.FundsAccountId))
                            // 如果已经有了，那就add进去
                        {
                            List<TradePositionModel> itemOrder =
                                CacheManager.HoldingSummaries[UserManager.CurrentTradeAccount.FundsAccountId];// 如果已经存在一个买卖方向的汇总，那就需要合并另一个方向的信息
                            TradePositionModel temp = itemOrder.Find(i => i.GoodsId == tradePosition.GoodsId);
                            if (temp == null)// 
                            {
                                CacheManager.HoldingSummaries[UserManager.CurrentTradeAccount.FundsAccountId].Add(tradePosition);
                            }
                            else// 这里，买卖需要合并，是不是很坑爹
                            {
                                convertTo(isBuy, t, temp);
                            }
                        }
                        else// 如果没有，就new List
                        {
                            List<TradePositionModel> temps = new List<TradePositionModel> {tradePosition};
                            CacheManager.HoldingSummaries.Add(UserManager.CurrentTradeAccount.FundsAccountId, temps);
                        }
                    }
                    successAction(holdDetails);
                }
            }), (error) =>
            {
                if (errorAction != null)
                {
                    //RequestFunc = 查询持仓单明细 
                    error.RequestFunc = Client_Resource.Resources_Service_QueryHoldingDetails;
                    errorAction(error);
                }
            });
        }

        /// <summary>
        /// 汇总的买卖方向部分信息，保存在一条单据里面。
        /// </summary>
        /// <param name="isBuy"></param>
        /// <param name="s"></param>
        /// <param name="t"></param>
        private void convertTo(bool isBuy, HoldingSummary s, TradePositionModel t)
        {
            /*{
                            AgreeUnit = (uint) t.AgreeUnit,
                            BuyCurHolderAmount = (double) (isBuy ? t.CurHolderAmount : 0),
                            BuyCurPositionQty = (uint) (isBuy ? t.AvailQty : 0),
                            BuyFrozenQty = (uint) (isBuy ? t.FrozenQty : 0),
                            BuyOtherFrozenQty = (uint) (isBuy ? t.OtherFrozenQty : 0),
                            GoodsId = t.GoodsId,
                            SellCurHolderAmount = (double) (!isBuy ? t.CurHolderAmount : 0),
                            SellCurPositionQty = (uint)(!isBuy ? t.AvailQty : 0),
                            SellFrozenQty = (uint) (!isBuy ? t.FrozenQty : 0),
                            SellOtherFrozenQty = (uint) (!isBuy ? t.OtherFrozenQty : 0)
                        };*/
            if (isBuy) // 买，
            {
                t.BuyCurHolderAmount = (double)s.CurHolderAmount;
                t.BuyCurPositionQty = (uint)s.AvailQty;
                t.BuyFrozenQty = (uint) s.FrozenQty;
                t.BuyOtherFrozenQty = (uint)s.OtherFrozenQty;
            }
            else // 卖
            {
                t.SellCurHolderAmount = (double)s.CurHolderAmount;
                t.SellCurPositionQty = (uint)s.AvailQty;
                t.SellFrozenQty = (uint)s.FrozenQty;
                t.SellOtherFrozenQty = (uint)s.OtherFrozenQty;
            }
        }


        /// <summary>
        /// 查询持仓汇总
        /// </summary>
        /// <param name="statement"></param>
        /// <param name="queryCommonParams"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryHoldingSummarys(string statement, List<QueryCommonParam> queryCommonParams,
            Action<List<HoldingSummary>> successAction, Action<ErrorEntity> errorAction)
        {
            QueryCommonHelper.QueryCommon(statement, queryCommonParams, new Action<List<HoldingSummary>>((holdSummarys) =>
            {
                if (successAction != null)
                {
                    //更新持仓缓存-dyp
                    UserManager.UpdateCacheOrder(holdSummarys);
                    successAction(holdSummarys);
                }
            }), (error) =>
            {
                if (errorAction != null)
                {
                    //RequestFunc = 查询持仓单明细 
                    error.RequestFunc = "查询持仓明细";
                    errorAction(error);
                }
            });
        }

        ///// <summary>
        ///// 生成头寸
        ///// </summary>
        ///// <param name="marketHoldDetails"></param>
        //private void CreatePosition(Dictionary<eTradeMode, List<HoldingOrder>> marketHoldDetails)
        //{
        //    var marketPosition = new Dictionary<eTradeMode, List<HoldingSummary>>();

        //    foreach (var keyValue in marketHoldDetails.Keys)
        //    {
        //        var dicPosition = new Dictionary<string, HoldingSummary>();
        //        foreach (var holdingOrder in marketHoldDetails[keyValue])
        //        {
        //            var goodsFlag = string.Format("{0}_{1}", holdingOrder.GoodsCode, holdingOrder.Direction);  ////头寸标识
        //            if (!dicPosition.ContainsKey(goodsFlag))
        //            {
        //                dicPosition[goodsFlag] = new HoldingSummary();
        //                dicPosition[goodsFlag].Holders = new List<HoldingOrder>();
        //                dicPosition[goodsFlag].GoodsName = holdingOrder.GoodsName;
        //                dicPosition[goodsFlag].GoodsCode = holdingOrder.GoodsCode;
        //                dicPosition[goodsFlag].GoodsId = holdingOrder.GoodsId;
        //                dicPosition[goodsFlag].Direction = holdingOrder.Direction;
        //                dicPosition[goodsFlag].QuoteGoods = holdingOrder.QuoteGoods;
        //                dicPosition[goodsFlag].DecimalPlace = holdingOrder.DecimalPlace;
        //                dicPosition[goodsFlag].TradeMode = holdingOrder.MarketType;
        //            }
        //            if (holdingOrder.PositionFzQty != 0)
        //                dicPosition[goodsFlag].PositionFzQty = holdingOrder.PositionFzQty;
        //            dicPosition[goodsFlag].TnFreezeqty = holdingOrder.tnFreezeqty;
        //            dicPosition[goodsFlag].currentAgreeunit = holdingOrder.currentAgreeunit;
        //            dicPosition[goodsFlag].MarketType = holdingOrder.MarketType;
        //            dicPosition[goodsFlag].HoldAmount += holdingOrder.HoldAmount;
        //            dicPosition[goodsFlag].OpenAmount += holdingOrder.OpenAmount;
        //            dicPosition[goodsFlag].TnAvailQty += holdingOrder.IsCanClose ? holdingOrder.Lot - holdingOrder.LockQty : 0;   ////达到T＋N的持仓数量
        //            dicPosition[goodsFlag].Lot += holdingOrder.Lot;
        //            dicPosition[goodsFlag].LockQty += holdingOrder.LockQty;
        //            dicPosition[goodsFlag].PLFloat += holdingOrder.PLFloat;
        //            dicPosition[goodsFlag].Holders.Add(holdingOrder);

        //        }
        //        //:todo:计算均价
        //        foreach (var key in dicPosition.Keys)
        //        {
        //            //var quoteGoods =
        //            //    CacheManager.CacheGoodsBaseInfos.FirstOrDefault(
        //            //        (goods) => goods.GoodsId == dicPosition[key].GoodsId);
        //            //if (quoteGoods != null && dicPosition[key].Lot != 0 && quoteGoods.GoodsParameters.AgreeUnit != 0)
        //            //{
        //            dicPosition[key].HoldingAVGPrice = dicPosition[key].HoldAmount / dicPosition[key].Lot /
        //                                              dicPosition[key].currentAgreeunit;
        //            //}
        //        }
        //        marketPosition[keyValue] = dicPosition.Values.ToList();
        //    }
        //    UserManager.UpdateMarketHoldOrders(marketPosition);

        //}

        ///// <summary>
        ///// 生成头寸
        ///// </summary>
        //private void CreatePosition(List<HoldingOrder> holdingOrders)
        //{
        //    var dicPosition = new Dictionary<string, HoldingSummary>();
        //    foreach (var holdingOrder in holdingOrders)
        //    {
        //        var goodsFlag = string.Format("{0}_{1}", holdingOrder.GoodsCode, holdingOrder.Direction);  ////头寸标识
        //        if (!dicPosition.ContainsKey(goodsFlag))
        //        {
        //            dicPosition[goodsFlag] = new HoldingSummary();
        //            dicPosition[goodsFlag].GoodsName = holdingOrder.GoodsName;
        //            dicPosition[goodsFlag].GoodsCode = holdingOrder.GoodsCode;
        //            dicPosition[goodsFlag].GoodsId = holdingOrder.GoodsId;
        //            dicPosition[goodsFlag].Direction = holdingOrder.Direction;
        //            dicPosition[goodsFlag].QuoteGoods = holdingOrder.QuoteGoods;
        //        }
        //        dicPosition[goodsFlag].HoldAmount += holdingOrder.HoldAmount;
        //        dicPosition[goodsFlag].OpenAmount += holdingOrder.OpenAmount;
        //        dicPosition[goodsFlag].Lot += holdingOrder.Lot;
        //        dicPosition[goodsFlag].PLFloat += holdingOrder.PLFloat;
        //    }
        //    //:todo:计算均价
        //    foreach (var key in dicPosition.Keys)
        //    {
        //        var quoteGoods =
        //            CacheManager.CacheGoodsBaseInfos.FirstOrDefault(
        //                (goods) => goods.GoodsId == dicPosition[key].GoodsId);
        //        if (quoteGoods != null && dicPosition[key].Lot != 0 && quoteGoods.GoodsParameters.AgreeUnit != 0)
        //        {
        //            dicPosition[key].HoldingAVGPrice = dicPosition[key].HoldAmount / dicPosition[key].Lot /
        //                                           quoteGoods.GoodsParameters.AgreeUnit;
        //        }
        //    }
        //    UserManager.UpdateCacheOrder(dicPosition.Values.ToList());
        //}

        /// <summary>
        /// 查询委托单
        /// </summary>
        /// <param name="statement"></param>
        /// <param name="queryCommonParams"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryEntrustOrder(string statement, List<QueryCommonParam> queryCommonParams, Action<List<OrderDetail>> successAction, Action<ErrorEntity> errorAction)
        {
            QueryCommonHelper.QueryCommon(statement, queryCommonParams, new Action<List<OrderDetail>>((orderDetails) =>
            {
                orderDetails = orderDetails.OrderByDescending((order) => order.EntrustTime).ToList();
                UserManager.UpdateCacheOrder(orderDetails);

                if (successAction != null)
                {
                    successAction(orderDetails);
                }
            }), (error) =>
            {
                if (errorAction != null)
                {
                    //RequestFunc = 查询委托单 
                    error.RequestFunc = Client_Resource.Resources_Service_QueryEntrustOrder;
                    errorAction(error);
                }
            });
        }

        /// <summary>
        /// 根据持仓汇总查询持仓明细
        /// </summary>
        /// <param name="statement"></param>
        /// <param name="queryCommonParams"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryHoldLstBySummary(string statement, List<QueryCommonParam> queryCommonParams, Action<List<HoldingOrder20>> successAction, Action<ErrorEntity> errorAction)
        {
            QueryCommonHelper.QueryCommon(statement, queryCommonParams, new Action<List<HoldingOrder20>>((holderDetails) =>
            {
                holderDetails = holderDetails.OrderByDescending((order) => order.TradeTime).ToList();

                if (successAction != null)
                {
                    successAction(holderDetails);
                }
            }), (error) =>
            {
                if (errorAction != null)
                {
                    error.RequestFunc = Client_Resource.Resources_Service_QueryHoldingDetails;
                    errorAction(error);
                }
            });
        }

        /// <summary>
        /// 查询成交单
        /// </summary>
        /// <param name="statement"></param>
        /// <param name="queryCommonParams"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryComplateOrders(string statement, List<QueryCommonParam> queryCommonParams, Action<List<CompleteOrder>> successAction, Action<ErrorEntity> errorAction)
        {
            QueryCommonHelper.QueryCommon(statement, queryCommonParams, new Action<List<CompleteOrder>>((ComplateOrders) =>
            {
                ComplateOrders = ComplateOrders.OrderByDescending((order) => order.CompleteDate).ToList();
                UserManager.UpdateCacheOrder(ComplateOrders);
                if (successAction != null)
                {
                    successAction(ComplateOrders);
                }
            }), (error) =>
            {
                if (errorAction != null)
                {
                    //RequestFunc = 查询成交单 
                    error.RequestFunc = Client_Resource.Resources_Service_QueryComplateOrders;
                    errorAction(error);
                }
            });
        }
        #endregion

        /// <summary>
        /// 查询用户日志
        /// </summary>
        /// <param name="statement"></param>
        /// <param name="queryCommonParams"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryUserLogs(string statement, List<QueryCommonParam> queryCommonParams, Action<List<UserLog>> successAction, Action<ErrorEntity> errorAction)
        {
            QueryCommonHelper.QueryCommon(statement, queryCommonParams, new Action<List<UserLog>>((userLogs) =>
            {
                if (successAction != null)
                {
                    successAction(userLogs);
                }
            }), (error) =>
            {
                if (errorAction != null)
                {
                    //RequestFunc = 查询用户日志 
                    error.RequestFunc = Client_Resource.Resources_Service_QueryUserLogs;
                    errorAction(error);
                }
            });
        }


        /// <summary>
        /// 查询平仓单查询
        /// </summary>
        /// <param name="statement"></param>
        /// <param name="queryCommonParams"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryCloseOrders(string statement, List<QueryCommonParam> queryCommonParams, Action<List<CloseOrder>> successAction, Action<ErrorEntity> errorAction)
        {
            QueryCommonHelper.QueryCommon(statement, queryCommonParams, new Action<List<CloseOrder>>((CloseOrders) =>
            {
                CloseOrders = CloseOrders.OrderByDescending((order) => order.CloseDate).ToList();
                UserManager.UpdateCacheOrder(CloseOrders);
                if (successAction != null)
                {
                    successAction(CloseOrders);
                }
            }), (error) =>
            {
                if (errorAction != null)
                {
                    //RequestFunc = 查询平仓单查询 
                    error.RequestFunc = Client_Resource.Resources_Service_QueryCloseOrders;
                    errorAction(error);
                }
            });
        }

        /// <summary>
        /// 查询平仓明细-》查询成交单明细【不区分市场和方向】
        /// </summary>
        /// <param name="marketType"></param>
        /// <param name="queryCommonParams"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryMarketCloseOrders(eTradeMode marketType, List<QueryCommonParam> queryCommonParams, Action<eTradeMode, List<CloseOrder>> successAction, Action<ErrorEntity> errorAction)
        {
            var searchId = QueryStatement.SearchAllTransactionDetailOrder;//查询成交单明细【不区分市场和方向】
            //switch (marketType)
            //{
            //    case eTradeMode.TRADEMODE_MARKETMAKE:
            //        searchId = QueryStatement.SearchOTCCloseOrder;
            //        break;
            //    case eTradeMode.TRADEMODE_BIDDING:
            //        searchId = QueryStatement.QueryAllBidCloseOrder;
            //        break;

            //    #region 保证金和全额合并
            //    //case eTradeMode.TRADEMODE_FullPay:
            //    //    searchId = QueryStatement.SearchBidSumCloseOrder;
            //    //    break; 
            //    #endregion

            //    case eTradeMode.TRADEMODE_SALE:
            //        searchId = QueryStatement.SearchSaleCloseOrder;
            //        break;
            //    case eTradeMode.TRADEMODE_BIDDINGMARKETMAKE:
            //        searchId = QueryStatement.SearchOTCBidCloseOrder;
            //        break;
            //}
            //by zp
            //searchId = QueryStatement.ClientInforInnerTradeDetail;
            QueryCommonHelper.QueryCommon(searchId, queryCommonParams, new Action<List<CloseOrder>>((CloseOrders) =>
            {
                CloseOrders = CloseOrders.OrderByDescending((order) => order.CloseDate).ToList();
                //  UserManager.UpdateCacheOrder(CloseOrders);
                UserManager.UpdateMarketOrders<CloseOrder>(marketType, CloseOrders);
                if (successAction != null)
                {
                    successAction(marketType, CloseOrders);
                }
            }), (error) =>
            {
                if (errorAction != null)
                {
                    //RequestFunc = 查询平仓明细 
                    error.RequestFunc = Client_Resource.Resources_Service_QueryMarketCloseOrders;
                    errorAction(error);
                }
            });
        }
        /// <summary>
        /// 查询建仓明细
        /// </summary>
        /// <param name="marketType"></param>
        /// <param name="queryCommonParams"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryMarketOpenOrders(eTradeMode marketType, List<QueryCommonParam> queryCommonParams, Action<eTradeMode, List<CompleteOrder>> successAction, Action<ErrorEntity> errorAction)
        {

            var searchId = string.Empty;
            switch (marketType)
            {
                case eTradeMode.TRADEMODE_MARKETMAKE:
                    searchId = QueryStatement.SearchOTCOpenOrder;
                    break;
                case eTradeMode.TRADEMODE_BIDDING:
                    searchId = QueryStatement.QueryAllBidOpenOrder;
                    break;
                #region 保证金和全额合并
                //case eTradeMode.TRADEMODE_FullPay:
                //    searchId = QueryStatement.SearchBidSumOpenOrder;
                //    break; 
                #endregion
                case eTradeMode.TRADEMODE_SALE:
                    searchId = QueryStatement.SearchSaleOpenOrder;
                    break;
                case eTradeMode.TRADEMODE_BIDDINGMARKETMAKE:
                    searchId = QueryStatement.SearchOTCBidOpenOrder;
                    break;
            }
            QueryCommonHelper.QueryCommon(searchId, queryCommonParams, new Action<List<CompleteOrder>>((ComplateOrders) =>
            {
                ComplateOrders = ComplateOrders.OrderByDescending((order) => order.CompleteDate).ToList();

                UserManager.UpdateMarketOrders<CompleteOrder>(marketType, ComplateOrders);

                if (successAction != null)
                {
                    successAction(marketType, ComplateOrders);
                }
            }), (error) =>
            {
                if (errorAction != null)
                {
                    //RequestFunc = 查询建仓明细 
                    error.RequestFunc = Client_Resource.Resources_Service_QueryMarketOpenOrders;
                    errorAction(error);
                }
            });
        }

        /// <summary>
        /// 按市场类型查询预埋单
        /// </summary>
        /// <param name="marketType"></param>
        /// <param name="queryCommonParams"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryPrePostOrders(eTradeMode marketType, List<QueryCommonParam> queryCommonParams, Action<eTradeMode, List<PrePostDetail>> successAction, Action<ErrorEntity> errorAction)
        {
            var searchId = QueryStatement.SearchAllPrePostDetail;//查询所有预埋单-不区分市场
            //switch (marketType)
            //{
            //    case eTradeMode.TRADEMODE_MARKETMAKE:
            //        searchId = QueryStatement.QueryMarketPrePostDetail;
            //        break;
            //    //竞价
            //    case eTradeMode.TRADEMODE_BIDDING:
            //        searchId = QueryStatement.SearchBidPrePostOrder;
            //        break;
            //    //case eTradeMode.TRADEMODE_SALE:
            //    //    searchId = QueryStatement.SearchSaleOrderDetail;
            //    //    break;
            //    //混合
            //    case eTradeMode.TRADEMODE_BIDDINGMARKETMAKE:
            //        searchId = QueryStatement.SearchPrePostOrder;
            //        break;
            //}
            QueryCommonHelper.QueryCommon(searchId, queryCommonParams, new Action<List<PrePostDetail>>((PrePostOrders) =>
            {
                PrePostOrders = PrePostOrders.OrderByDescending((order) => order.ClientOrderTime).ToList();

                UserManager.UpdateMarketOrders<PrePostDetail>(marketType, PrePostOrders);

                if (successAction != null)
                {
                    successAction(marketType, PrePostOrders);
                }
            }), (error) =>
            {
                if (errorAction != null)
                {
                    //RequestFunc = 查询预埋单 
                    error.RequestFunc = Client_Resource.Resources_Service_QueryPrePostOrders;
                    errorAction(error);
                }
            });
        }
        /// <summary>
        /// 查询委托单
        /// </summary>
        /// <param name="marketType"></param>
        /// <param name="queryCommonParams"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryMarketOrderDetails(eTradeMode marketType, List<QueryCommonParam> queryCommonParams, Action<eTradeMode, List<OrderDetail>> successAction, Action<ErrorEntity> errorAction)
        {
            var searchId = QueryStatement.QueryAllMarketOrderDetail;//查询委托单[不区分市场]
            //switch (marketType)
            //{
            //    case eTradeMode.TRADEMODE_MARKETMAKE:
            //        searchId = QueryStatement.SearchOTCOrderDetail;
            //        break;
            //    case eTradeMode.TRADEMODE_BIDDING:
            //        searchId = QueryStatement.QueryAllBidOrderDetail;
            //        break;
            //    //竞价保证金与全额合并
            //    //case eTradeMode.TRADEMODE_FullPay:
            //    //    searchId = QueryStatement.SearchBidSumOrderDetail;
            //    //    break;
            //    case eTradeMode.TRADEMODE_SALE:
            //        searchId = QueryStatement.SearchSaleOrderDetail;
            //        break;
            //    case eTradeMode.TRADEMODE_BIDDINGMARKETMAKE:
            //        searchId = QueryStatement.SearchOTCBidOrderDetail;
            //        break;
            //}
            QueryCommonHelper.QueryCommon(searchId, queryCommonParams, new Action<List<OrderDetail>>((orderDetails) =>
            {
                orderDetails = orderDetails.OrderByDescending((order) => order.EntrustTime).ToList();

                UserManager.UpdateMarketOrders<OrderDetail>(marketType, orderDetails);
                if (successAction != null)
                {
                    successAction(marketType, orderDetails);
                }
            }), (error) =>
            {
                if (errorAction != null)
                {
                    //RequestFunc = 查询委托单 
                    error.RequestFunc = Client_Resource.Resources_Service_QueryMarketOrderDetails;
                    errorAction(error);
                }
            });
        }

        /// <summary>
        /// 查询单据数量
        /// </summary>
        /// <param name="searchId"></param>
        /// <param name="queryCommonParams"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryMarketOrderCount(string searchId, List<QueryCommonParam> queryCommonParams, Action<List<MarketOrderCount>> successAction, Action<ErrorEntity> errorAction)
        {
            QueryCommonHelper.QueryCommon(searchId, queryCommonParams, new Action<List<MarketOrderCount>>((orderDetails) =>
            {
                if (successAction != null)
                {
                    successAction(orderDetails);
                }
            }), (error) =>
            {
                if (errorAction != null)
                {
                    //RequestFunc = 查询单据数量({0}) 
                    error.RequestFunc = string.Format(Client_Resource.Resources_Service_QueryMarketOrderCount, searchId);
                    errorAction(error);
                }
            });
        }

        /// <summary>
        /// 查询会员监控数据
        /// </summary>
        /// <param name="accountId"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryMemberMonitor(uint accountId, Action<List<MemberAccountInfo>> successAction, Action<ErrorEntity> errorAction)
        {
            return;
            //var request = _orderAdapter.ToRequestTaRiskRate(accountId);
            //var packgage = new TCPPackage() { Content = request, FunCode = FuncCode.FID_QueryMemberMonitorReq };
            //LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            //{
            //    var responeEntity = _orderAdapter.ToLocalTaRiskRateInfo(revPackgage.Content);
            //    ////更新GoodsName
            //    UpdateGoodsName(responeEntity.Entity);
            //    if (responeEntity.RetCode == 0)
            //    {
            //        successAction(responeEntity.Entity);
            //    }
            //    else
            //    {
            //        if (errorAction != null)
            //        {
            //            errorAction(new ErrorEntity()
            //            {
            //                RequestFunc = Client_Resource.Resources_Service_QueryMemberMonitor,
            //                ReturnCode = responeEntity.RetCode,
            //                ReturnDesc = responeEntity.RetMessage
            //            });
            //        }
            //    }
            //}), new Action<int, string>((errorCode, errorDesc) =>
            //{
            //    ////通信错误
            //    if (errorAction != null)
            //    {
            //        //RequestFunc = 查询会员监控数据 
            //        errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = Client_Resource.Resources_Service_QueryMemberMonitor });
            //    }
            //}));
        }

        /// <summary>
        /// 更新GoodsName
        /// </summary>
        /// <param name="infos"></param>
        private void UpdateGoodsName(List<MemberAccountInfo> infos)
        {
            if (infos == null || !infos.Any()) return;
            foreach (var info in infos)
            {
                if (info == null || info.MemberPositions == null || !info.MemberPositions.Any()) continue;
                foreach (var memberPosition in info.MemberPositions)
                {
                    if (memberPosition == null) continue;
                    var goods = CacheManager.CacheGoodsBaseInfos.FirstOrDefault(z => z.GoodsId == memberPosition.GoodsId);
                    if (goods == null) continue;
                    memberPosition.GoodsName = goods.Name;
                }
            }
        }


        public void QueryTaAmountLog(bool isHistory,List < QueryCommonParam> queryCommonParams, Action<List<AccountAmountLog>> successAction, Action<ErrorEntity> errorAction)
        {
            string statement = isHistory ? QueryStatement.QueryHisClientAmountLog : QueryStatement.QueryClientAmountLog;
            
            QueryCommonHelper.QueryCommon(statement, queryCommonParams, new Action<List<AccountAmountLog>>((amountLogs) =>
            {
                if (successAction != null)
                {
                    successAction(amountLogs);
                }
            }), (error) =>
            {
                if (errorAction != null)
                {
                    //RequestFunc = 查询单据数量({0}) 
                    error.RequestFunc = Client_Resource.Content_AmountLog;
                    errorAction(error);
                }
            });
        }


        public void QueryDealCloseSetting(ulong accountId, Action<List<DealCloseModel>> successAction, Action<ErrorEntity> errorAction)
        {
            var queryCommonParams = new List<QueryCommonParam>();
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "accountId", ParamValue = accountId + string.Empty });
            QueryCommonHelper.QueryCommon(QueryStatement.QueryDealCloseSetting, queryCommonParams, new Action<List<DealCloseModel>>((dealCloseModels) =>
         {
             if (successAction != null)
             {
                 successAction(dealCloseModels);
             }
         }), (error) =>
         {
             if (errorAction != null)
             {
                    //RequestFunc = 查询单据数量({0}) 
                    error.RequestFunc = Client_Resource.Content_QueryDealClosed;
                 errorAction(error);
             }
         });
        }


        public void DealCloseComfirm(DealCloseOrder dealClose, Action<DealCloseOrder> successAction, Action<ErrorEntity> errorAction)
        {
            return;
            //var reqeust = _orderAdapter.ToRequestDealClose(dealClose);
            //var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_DealCloseSettingReq };
            //LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            //{
            //    var responeEntrity = _orderAdapter.ToLocalDealCloseInfo(revPackgage.Content);
            //    if (responeEntrity.RetCode == 0)
            //    {
            //        //todo:生成委托单
            //        successAction(responeEntrity.Entity);
            //    }
            //    else
            //    {
            //        if (errorAction != null)
            //        {
            //            //RequestFunc = 查询单据数量({0}) 
            //            var error = new ErrorEntity() { ReturnCode = responeEntrity.RetCode, ReturnDesc = responeEntrity.RetMessage };
            //            error.RequestFunc = Client_Resource.Content_DealClosedComfrim;
            //            errorAction(error);
            //        }
            //    }
            //}),(errorCode,errorDesc) =>
            //{
            //    if (errorAction != null)
            //    {
            //        //RequestFunc = 查询单据数量({0}) 
            //        var error= new ErrorEntity(){ReturnCode = errorCode,ReturnDesc = errorDesc};
            //        error.RequestFunc = Client_Resource.Content_DealClosedComfrim;
            //        errorAction(error);
            //    }
            //});
        }



        public void QueryMarketTypeStatus(Action<List<MarketTypeProperty>> successAction, Action<ErrorEntity> errorAction)
        {
            List<QueryCommonParam> queryCommonParams = new List<QueryCommonParam>();
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "0000", ParamValue = "0000" });
            QueryCommonHelper.QueryCommon(QueryStatement.SearchClientMarketTypeStatus, queryCommonParams, new Action<List<MarketTypeProperty>>((MarketType) =>
            {
                if (successAction != null)
                {
                    successAction(MarketType);
                }
            }), (error) =>
            {
                if (errorAction != null)
                {
                    //RequestFunc = 查询单据数量({0}) 
                    // error.RequestFunc = Client_Resource.Content_AmountLog;
                    errorAction(error);
                }
            });
        }

        /// <summary>
        ///  查询历史持仓单
        /// </summary>
        //  public const string QueryHistoryHolding = "QueryHistoryHolding";


        /// <summary>
        ///  查询历史委托单
        /// </summary>
        //   public const string QueryHistoryEntrustOrder = "QueryHistoryEntrustOrder";


        /// <summary>
        ///  查询历史成交明细
        /// </summary>
        ///   public const string QueryHistoryComplete = "QueryHistoryComplete";


        /// <summary>
        ///  查询历史交割单
        /// </summary>
        /// public const string QueryHistoryDeliveryOrder = "QueryHistoryDeliveryOrder";


        public void QueryHistoryOrderBase(ulong accountId, HistoryOrder history, DateTime strarTime, DateTime endTime, Action<List<OrderBase>> successAction, Action<ErrorEntity> errorAction)
        {

            var queryCommonParams = new List<QueryCommonParam>();
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "accountId", ParamValue = accountId + "" });
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "startDate", ParamValue = strarTime.ToString("yyyy-MM-dd") });
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "endDate", ParamValue = endTime.Date.ToString("yyyy-MM-dd HH:mm:ss") });
            string format = QueryStatement.QueryHistoryEntrustOrder;


            switch (history)
            {
                ////委托单
                case HistoryOrder.EntrsuctOrder:
                    format = QueryStatement.QueryHistoryEntrustOrder;
                    QueryCommonHelper.QueryCommon(format, queryCommonParams, new Action<List<OrderDetail>>((orders) =>
                    {
                        var orderList = new List<OrderBase>();
                        if (orders.Any())
                        {
                            foreach (var order in orders)
                            {
                                orderList.Add(order);
                            }
                        }
                        if (successAction != null)
                        {
                            successAction(orderList);
                        }
                    }), errorAction);
                    break;
                case HistoryOrder.HoldingOrder:    ///持仓单
                    format = QueryStatement.QueryHistoryHolding;

                    QueryCommonHelper.QueryCommon(format, queryCommonParams, new Action<List<HoldingOrder>>((holds) =>
                    {
                        var orderList = new List<OrderBase>();
                        if (holds.Any())
                        {
                            foreach (var holdingOrder in holds)
                            {
                                orderList.Add(holdingOrder);
                            }
                        }
                        if (successAction != null)
                        {
                            successAction(orderList);
                        }
                    }), errorAction);
                    break;
                case HistoryOrder.CompleteOrder:   ////成交明细
                    format = QueryStatement.QueryHistoryComplete;

                    QueryCommonHelper.QueryCommon(format, queryCommonParams, new Action<List<CloseOrder>>((closes) =>
                    {
                        var orderList = new List<OrderBase>();
                        if (closes.Any())
                        {
                            foreach (var close in closes)
                            {
                                orderList.Add(close);
                            }
                        }
                        if (successAction != null)
                        {
                            successAction(orderList);
                        }
                    }), errorAction);
                    break;
                case HistoryOrder.DeliveryOrder:   ////交割明细
                    format = QueryStatement.QueryHistoryDeliveryOrder;

                    QueryCommonHelper.QueryCommon(format, queryCommonParams, new Action<List<DeliveryComplete>>((deliveries) =>
                    {
                        var orderList = new List<OrderBase>();
                        if (deliveries.Any())
                        {
                            foreach (var delivery in deliveries)
                            {
                                orderList.Add(delivery);
                            }
                        }
                        if (successAction != null)
                        {
                            successAction(orderList);
                        }
                    }), errorAction);
                    break;
                default:
                    break;
            }

        }


        public void QueryAccountArea(uint AreaId, Action<List<AreaModel>> successAction, Action<ErrorEntity> errorAction)
        {
            var queryCommonParams = new List<QueryCommonParam>();
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "areaId", ParamValue = AreaId + string.Empty });
            QueryCommonHelper.QueryCommon(QueryStatement.SearchAccountAreaInfo, queryCommonParams, new Action<List<AreaModel>>((areaModels) =>
            {
                if (successAction != null)
                {
                    successAction(areaModels);
                }
            }), (error) =>
            {
                if (errorAction != null)
                {
                    //RequestFunc = 查询单据数量({0}) 
                    // error.RequestFunc = Client_Resource.Content_AmountLog;
                    errorAction(error);
                }
            });
        }

        /// <summary>
        /// 资管下单委托
        /// </summary>
        /// <param name="entrustOrder">委托内容</param>
        /// <param name="successAction">成功回应</param>
        /// <param name="errorAction">失败回应</param>
        public void ChannelEntrustOrder(NewEntrustOrder entrustOrder, Action<OrderDetail> successAction, Action<ErrorEntity> errorAction)
        {
            var userId = UserManager.CurrentTradeAccount.CustomerId;

            var clientId = UserManager.CurrentTradeAccount.ClientId; 

            var reqeust = _orderAdapter.ToChannnelEntrustOrder(entrustOrder, userId, clientId);
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_ChannelOrderReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntrity = _orderAdapter.ToMakeLimitOrder(revPackgage.Content);
                if (responeEntrity.RetCode == 0)
                {
                    //todo:生成委托单
                    successAction(responeEntrity.Entity);
                }
                else
                {
                    if (errorAction != null)
                    {
                        //RequestFunc = 市场委托订单 
                        errorAction(new ErrorEntity() { ReturnCode = responeEntrity.RetCode, ReturnDesc = responeEntrity.RetMessage, RequestFunc = Client_Resource.Resources_Service_MakeMarketEntrustOrder });
                    }
                }
            }), new Action<int, string>((errorCode, errorDesc) =>
            {     ////通信错误
                if (errorAction != null)
                {
                    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = Client_Resource.Resources_Service_MakeMarketEntrustOrder });
                }
            }));
        }


        /// <summary>
        /// 资管止盈止损下单
        /// </summary>
        /// <param name="entrustOrder">The entrust order.</param>
        /// <param name="successAction">The success action.</param>
        /// <param name="errorAction">The error action.</param>
        /// <exception cref="System.NotImplementedException"></exception>
        public void ChannelSPSLOrder(NewEntrustOrder entrustOrder, Action<OrderDetail> successAction, Action<ErrorEntity> errorAction)
        {
            var userId = UserManager.CurrentTradeAccount.CustomerId;
            var reqeust = _orderAdapter.ToChannnelSPSLOrderReq(entrustOrder, userId);
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_ChannelSPSLOrderReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntrity = _orderAdapter.ToLocalChannnelSPSLRsp(revPackgage.Content);
                if (responeEntrity.RetCode == 0)
                {
                    //todo:生成委托单
                    successAction(responeEntrity.Entity);
                }
                else
                {
                    if (errorAction != null)
                    {
                        //RequestFunc = 市场委托订单 
                        errorAction(new ErrorEntity() { ReturnCode = responeEntrity.RetCode, ReturnDesc = responeEntrity.RetMessage, RequestFunc = Client_Resource.Resources_Service_MakeMarketEntrustOrder });
                    }
                }
            }), new Action<int, string>((errorCode, errorDesc) =>
            {     ////通信错误
                if (errorAction != null)
                {
                    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = Client_Resource.Resources_Service_MakeMarketEntrustOrder });
                }
            }));
        }
    }
}