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

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

namespace Muchinfo.MTPClient.Service
{
    /// <summary>
    /// 交收功能服务接口实现
    /// </summary>
    public class DeliveryService : IDeliveryService
    {
        private DeliveryAdapter _deliveryAdapter;
        public DeliveryService()
        {
            _deliveryAdapter = LinkManager.Instance.TradeAdapterFactory.CreateDeliveryAdapter();
        }
      


        /// <summary>
        ///  下交割申报
        /// </summary>
        /// <param name="entrustOrder">交割内容</param>
        /// <param name="successAction">成功回应</param>
        /// <param name="errorAction">失败回应</param>
        public void DeliveryApplyOrder(DeliveryOrderReqModel deliveryOrder, Action<DeliveryOrderRspModel> successAction,
            Action<ErrorEntity> errorAction)
        {
            var reqeust = _deliveryAdapter.ToDeliveryApplyReqOrder(deliveryOrder);
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_DeliveryOrderReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntrity = _deliveryAdapter.ToDeliveryApplyRspOrder(revPackgage.Content);
                //if (responeEntrity.RetCode == 0)
                //{
                //    if (successAction != null)
                //    {
                //        //todo:生成委托单
                //        successAction(responeEntrity.Entity);
                //    }
                //}
                //else
                //{
                //    if (errorAction != null)
                //    {
                //        //RequestFunc = 交割申报 
                //        errorAction(new ErrorEntity() { ReturnCode = responeEntrity.RetCode, ReturnDesc = responeEntrity.RetMessage, RequestFunc = Client_Resource.Resources_Service_DeliveryApply });
                //    }
                //}
            }), new Action<int, string>((errorCode, errorDesc) =>
            {     ////通信错误
                //if (errorAction != null)
                //{
                //    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = Client_Resource.Resources_Service_DeliveryApply });
                //}
            }));
        }


        /// <summary>
        /// 查询交收单详情
        /// </summary>
        /// <param name="DeliveryId">交割单</param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryDeliveryHoldersMoreDetail(uint DeliveryId, Action<List<DeliveryDetailWR>> successAction, Action<ErrorEntity> errorAction)
        {
            var queryCommonParams = new List<QueryCommonParam>();
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "deliveryid", ParamValue = DeliveryId + string.Empty });
            QueryCommonHelper.QueryCommon(QueryStatement.QueryDeliveryHolderDetail, queryCommonParams,
                new Action<List<DeliveryDetailWR>>((orderDetails) =>
                {
                    if (successAction != null)
                    {
                        successAction(orderDetails);
                    }
                }), (error) =>
                {
                    if (errorAction != null)
                    {
                        //RequestFunc = 查询交收单详情 
                        error.RequestFunc = Client_Resource.Resources_Service_QueryDeliveryHoldersMoreDetail;
                        errorAction(error);
                    }
                });
        }

        /// <summary>
        /// 查询提货详情
        /// </summary>
        /// <param name="WRID">仓单ID</param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryTakeGoodsMoreDetail(long STOREOUTID, Action<List<WarehouseRecieptModel>> successAction, Action<ErrorEntity> errorAction)
        {
            var queryCommonParams = new List<QueryCommonParam>();
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "STOREOUTID", ParamValue = STOREOUTID + string.Empty });
            QueryCommonHelper.QueryCommon(QueryStatement.QueryTakeGoodsMoreDetail, queryCommonParams,
                new Action<List<WarehouseRecieptModel>>((orderDetails) =>
                {
                    if (successAction != null)
                    {
                        successAction(orderDetails);
                    }
                }), (error) =>
                {
                    if (errorAction != null)
                    {
                        //RequestFunc = 查询提货详情 
                        error.RequestFunc = Client_Resource.Resources_Service_QueryTakeGoodsMoreDetail;
                        errorAction(error);
                    }
                });
        }

        /// <summary>
        /// 查询交割单
        /// </summary>
        /// <param name="AccountId"></param>
        /// <param name="strarTime"></param>
        /// <param name="endTime"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryDeliveryHolders(ulong AccountId, DateTime strarTime, DateTime endTime,
            Action<List<DryHoldDetail>> successAction, Action<ErrorEntity> errorAction)
        {
            var queryCommonParams = new List<QueryCommonParam>();
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "accountid", ParamValue = AccountId + string.Empty });
            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") });
            QueryCommonHelper.QueryCommon(QueryStatement.QueryDeliveryHolder, queryCommonParams,
                new Action<List<DryHoldDetail>>((orderDetails) =>
                {
                    //UserManager.UpdateCacheOrder(orderDetails);
                    if (successAction != null)
                    {
                        successAction(orderDetails);
                    }
                }), (error) =>
                {
                    if (errorAction != null)
                    {
                        //RequestFunc = 查询交割单 
                        error.RequestFunc = Client_Resource.Resources_Service_QueryDeliveryHolders;
                        errorAction(error);
                    }
                });
        }
        /// <summary>
        /// 查询申报单
        /// </summary>
        /// <param name="AccountId"></param>
        /// <param name="strarTime"></param>
        /// <param name="endTime"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryDeliveryEntrustOrders(ulong AccountId, DateTime strarTime, DateTime endTime, Action<List<DeliveryEntrustOrder>> successAction, Action<ErrorEntity> errorAction)
        {
            var queryCommonParams = new List<QueryCommonParam>();
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "accointId", ParamValue = AccountId + string.Empty });
            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") });
            QueryCommonHelper.QueryCommon(QueryStatement.QueryDeliverEntrustOrder, queryCommonParams,
                new Action<List<DeliveryEntrustOrder>>((orderDetails) =>
                {
                    //UserManager.UpdateCacheOrder(orderDetails);
                    if (successAction != null)
                    {
                        successAction(orderDetails);
                    }
                }), (error) =>
                {
                    if (errorAction != null)
                    {
                        //RequestFunc = 查询申报单 
                        error.RequestFunc = Client_Resource.Resources_Service_QueryDeliveryEntrustOrders;
                        errorAction(error);
                    }
                });
        }


        /// <summary>
        /// 仓单查询
        /// </summary>
        /// <param name="accountId"></param>
        /// <param name="strarTime"></param>
        /// <param name="endTime"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryDeliveryWarehouseOrders(SearchWarehouseOrdersType warehouseType,string WRCode, ulong accountId, DateTime strarTime, DateTime endTime,
            Action<List<DeliveryWarehouse>> successAction,
            Action<ErrorEntity> errorAction)
        {
            var queryCommonParams = new List<QueryCommonParam>();
            if (warehouseType == SearchWarehouseOrdersType.AccountId)
            {
                queryCommonParams.Add(new QueryCommonParam() { ParamKey = "accountId", ParamValue = accountId + string.Empty });
                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") });
            }
            else
            {
                queryCommonParams.Add(new QueryCommonParam() { ParamKey = "WRCode", ParamValue = WRCode + string.Empty });
            }
            QueryCommonHelper.QueryCommon(QueryStatement.SearchDeliveryWarehouseOrder, queryCommonParams,
                new Action<List<DeliveryWarehouse>>((orderDetails) =>
                {
                    UserManager.UpdateCacheOrder(orderDetails);
                    if (successAction != null)
                    {
                        successAction(orderDetails);
                    }
                }), (error) =>
                {
                    if (errorAction != null)
                    {
                        //RequestFunc = 仓单查询 
                        error.RequestFunc = Client_Resource.Resources_Service_QueryDeliveryWarehouseOrders;
                        errorAction(error);
                    }
                });
        }


        /// <summary>
        /// 仓单配对查询
        /// </summary>
        /// <param name="DeliveryGoodsId"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryDeliveryMatchOrders(uint DeliveryGoodsId, Action<List<DeliveryMatchModel>> successAction, Action<ErrorEntity> errorAction)
        {
            var queryCommonParams = new List<QueryCommonParam>();
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "DeliveryGoodsId", ParamValue = DeliveryGoodsId + string.Empty });
            QueryCommonHelper.QueryCommon(QueryStatement.SearchDeliveryMatchOrder, queryCommonParams,
                new Action<List<DeliveryMatchModel>>((orderDetails) =>
                {
                    UserManager.UpdateCacheOrder(orderDetails);
                    if (successAction != null)
                    {
                        successAction(orderDetails);
                    }
                }), (error) =>
                {
                    if (errorAction != null)
                    {
                        //RequestFunc = 仓单配对查询 
                        error.RequestFunc = Client_Resource.Resources_Service_QueryDeliveryMatchOrders;
                        errorAction(error);
                    }
                });
        }

        /// <summary>
        ///  提交仓单配对
        /// </summary>
        /// <param name="entrustOrder">配对仓单内容</param>
        /// <param name="successAction">成功回应</param>
        /// <param name="errorAction">失败回应</param>
        public void SubmitDeliveryMatchOrder(DeliveryOrderMatchReqModel deliveryMatchOrder, Action<DeliveryOrderMatchRspModel> successAction,
              Action<ErrorEntity> errorAction)
        {
            return;

            //var reqeust = _deliveryAdapter.ToDeliveryMatchReqOrder(deliveryMatchOrder);
            //var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_DeliveryOrderMatchReq };
            //LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            //{
            //    var responeEntrity = _deliveryAdapter.ToDeliveryMatchRspOrder(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_SubmitDeliveryMatchOrder });
            //        }
            //    }
            //}), new Action<int, string>((errorCode, errorDesc) =>
            //{     ////通信错误
            //    if (errorAction != null)
            //    {
            //        errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = Client_Resource.Resources_Service_SubmitDeliveryMatchOrder });
            //    }
            //}));
        }


        /// <summary>
        /// 查询提货仓单
        /// </summary>
        /// <param name="AccountId">账号</param>
        /// <param name="strarTime">开始时间</param>
        /// <param name="endTime">结束时间</param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryTakaDeliveryGoodsOrders(ulong AccountId, DateTime strarTime, DateTime endTime,
             Action<List<TakaDeliveryGoodsQueryModel>> successAction,
             Action<ErrorEntity> errorAction)
        {
            var queryCommonParams = new List<QueryCommonParam>();
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "accountId", ParamValue = AccountId + string.Empty });
            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") });
            QueryCommonHelper.QueryCommon(QueryStatement.SearchTakaDeliveryGoodsQuery, queryCommonParams,
                new Action<List<TakaDeliveryGoodsQueryModel>>((orderDetails) =>
                {
                    UserManager.UpdateCacheOrder(orderDetails);
                    if (successAction != null)
                    {
                        successAction(orderDetails);
                    }
                }), (error) =>
                {
                    if (errorAction != null)
                    {
                        //RequestFunc = 查询提货仓单 
                        error.RequestFunc = Client_Resource.Resources_Service_QueryTakaDeliveryGoodsOrders;
                        errorAction(error);
                    }
                });
        }


        /// <summary>
        /// 提货申请-查询
        /// </summary>
        /// <param name="accountId"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryTakaDeliveryGoodsOrdersAppy(ulong accountId, Action<List<TakaDeliveryGoodsApplyModel>> successAction, Action<ErrorEntity> errorAction)
        {
            var queryCommonParams = new List<QueryCommonParam>();
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "accountId", ParamValue = accountId + string.Empty });
            QueryCommonHelper.QueryCommon(QueryStatement.SearchTakaDeliveryGoodsApply, queryCommonParams,
                new Action<List<TakaDeliveryGoodsApplyModel>>((orderDetails) =>
                {
                    UserManager.UpdateCacheOrder(orderDetails);
                    if (successAction != null)
                    {
                        successAction(orderDetails);
                    }
                }), (error) =>
                {
                    if (errorAction != null)
                    {
                        //RequestFunc = 提货申请查询 
                        error.RequestFunc = Client_Resource.Resources_Service_QueryTakaDeliveryGoodsOrdersAppy;
                        errorAction(error);
                    }
                });
        }


        /// <summary>
        /// 交易商品-交割关系表-配置信息
        /// </summary>
        /// <param name="goodId"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryDeliveryGoodsRelationConfig(uint goodsId, Action<List<DeliveryConfig>> successAction, Action<ErrorEntity> errorAction)
        {
            var queryCommonParams = new List<QueryCommonParam>();
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "goodsId", ParamValue = goodsId + string.Empty });
            QueryCommonHelper.QueryCommon(QueryStatement.SearchDeliveryGoodsRelationConfig, queryCommonParams,
                new Action<List<DeliveryConfig>>((configDetails) =>
                {
                    UserManager.UpdateCacheOrder(configDetails);
                    if (successAction != null)
                    {
                        successAction(configDetails);
                    }
                }), (error) =>
                {
                    if (errorAction != null)
                    {
                        //RequestFunc = 交易商品配置信息
                        error.RequestFunc = Client_Resource.Resources_Service_Complete;
                        errorAction(error);
                    }
                });
        }

        /// <summary>
        /// 交易商品-交割规则查询
        /// </summary>
        /// <param name="deliveryGoodsId"></param>
        ///  <param name="ruleId"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryDeliveryRule(uint deliveryGoodsId,uint ruleId, Action<List<DeliveryRuleModel>> successAction, Action<ErrorEntity> errorAction)
        {
            var queryCommonParams = new List<QueryCommonParam>();
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "deliverygoodsid", ParamValue = deliveryGoodsId + string.Empty });
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "ruleid", ParamValue = ruleId + string.Empty });
            QueryCommonHelper.QueryCommon(QueryStatement.queryDeliveryRuleVal, queryCommonParams,
                new Action<List<DeliveryRuleModel>>((ruleDetails) =>
                {
                    UserManager.UpdateCacheOrder(ruleDetails);
                    if (successAction != null)
                    {
                        successAction(ruleDetails);
                    }
                }), (error) =>
                {
                    if (errorAction != null)
                    {
                        //RequestFunc = 交割规则查询
                        error.RequestFunc = Client_Resource.Resources_Service_QueryDeliveryRule;
                        errorAction(error);
                    }
                });

        }

        /// <summary>
        ///  提交-提货申请/撤销：OperateType操作类型：1=>申请，2=>撤销
        /// </summary>
        /// <param name="OutStoreReqModel">提货申请内容</param>
        /// <param name="successAction">成功回应</param>
        /// <param name="errorAction">失败回应</param>
        public void SubmitOutStoreReq(OutStoreReqModel reqModel, Action<OutStoreRspModel> successAction,
             Action<ErrorEntity> errorAction)
        {
            return;

            //var reqeust = _deliveryAdapter.ToOutStoreReq(reqModel);
            //var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_OutStoreReq };
            //LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            //{
            //    var responeEntrity = _deliveryAdapter.ToOutStoreRsp(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_SubmitOutStoreReq });
            //        }
            //    }
            //}), new Action<int, string>((errorCode, errorDesc) =>
            //{     ////通信错误
            //    if (errorAction != null)
            //    {
            //        errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = Client_Resource.Resources_Service_SubmitOutStoreReq });
            //    }
            //}));
        }
        /// <summary>
        /// 确认-交收现货付款请求
        /// </summary>
        /// <param name="ReceiveConfirmReqModel"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void SubmitReceiveConfirmReq(ReceiveConfirmReqModel reqModel, Action<ReceiveConfirmRspModel> successAction,
             Action<ErrorEntity> errorAction)
        {
            var reqeust = _deliveryAdapter.ToReceiveConfirmReq(reqModel);
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_ReceiveConfirmReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntrity = _deliveryAdapter.ToReceiveConfirmRsp(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_ReceiveConfirmReq });
                    }
                }
            }), new Action<int, string>((errorCode, errorDesc) =>
            {     ////通信错误
                if (errorAction != null)
                {
                    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = Client_Resource.Resources_Service_ReceiveConfirmReq });
                }
            }));
        }


        /// <summary>
        ///  查询配对仓单请求
        /// </summary>
        /// <param name="ReceiveConfirmReqModel">查询配对仓单内容</param>
        /// <param name="successAction">成功回应</param>
        /// <param name="errorAction">失败回应</param>
        public void SearchMatchWarehouseReq(WrPairReqModel reqModel, Action<WrPairRspModel> successAction,
            Action<ErrorEntity> errorAction)
        {
            return;
            //var reqeust = _deliveryAdapter.ToWrPairReq(reqModel);
            //var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_WrPairReq };
            //LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            //{
            //    var responeEntrity = _deliveryAdapter.ToWrPairRsp(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_SearchMatchWarehouseReq });
            //        }
            //    }
            //}), new Action<int, string>((errorCode, errorDesc) =>
            //{     ////通信错误
            //    if (errorAction != null)
            //    {
            //        errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = Client_Resource.Resources_Service_SearchMatchWarehouseReq });
            //    }
            //}));
        }


        /// <summary>
        /// 查询交割关系表LIST
        /// </summary>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryGoodsDeliveryRelationList(Action<List<GoodsDeliveryRelationModel>> successAction, Action<ErrorEntity> errorAction)
        {
            var queryCommonParams = new List<QueryCommonParam>();
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "deliverygoodsid", ParamValue = string.Empty });
            QueryCommonHelper.QueryCommon(QueryStatement.SearchGoodsDeliveryRelationList, queryCommonParams,
                new Action<List<GoodsDeliveryRelationModel>>((itemDetails) =>
                {
                    if (successAction != null)
                    {
                        successAction(itemDetails);
                    }
                }), (error) =>
                {
                    if (errorAction != null)
                    {
                        //RequestFunc = 查询交割关系表
                        error.RequestFunc = Client_Resource.Resources_Service_QueryGoodsDeliveryRelationList;
                        errorAction(error);
                    }
                });
        }

        /// <summary>
        /// 查询P+X交割商品信息
        /// </summary>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryRelationPAndXGoodsInfoList(Action<List<RelationPAndXGoodsInfoModel>> successAction, Action<ErrorEntity> errorAction)
        {
            var queryCommonParams = new List<QueryCommonParam>();
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "deliverygoodsid", ParamValue = string.Empty });
            QueryCommonHelper.QueryCommon(QueryStatement.SearchRelationPAndXGoodsInfo, queryCommonParams,
                new Action<List<RelationPAndXGoodsInfoModel>>((itemDetails) =>
                {
                    if (successAction != null)
                    {
                        successAction(itemDetails);
                    }
                }), (error) =>
                {
                    if (errorAction != null)
                    {
                        //RequestFunc = 查询P+X交割商品信息
                        error.RequestFunc = Client_Resource.Resources_Service_QueryRelationPAndXGoodsInfoList;
                        errorAction(error);
                    }
                });
        }


        /// <summary>
        /// 交割成交单查询
        /// </summary>
        /// <param name="AccountId"></param>
        /// <param name="strarTime"></param>
        /// <param name="endTime"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryDeliveryComplete(ulong AccountId, DateTime strarTime, DateTime endTime, Action<List<DeliveryCompleteModel>> successAction, Action<ErrorEntity> errorAction)
        {
            var queryCommonParams = new List<QueryCommonParam>();
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "accountId", ParamValue = AccountId + string.Empty });
            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") });
            QueryCommonHelper.QueryCommon(QueryStatement.SearchDeliveryComplete, queryCommonParams,
               new Action<List<DeliveryCompleteModel>>((completes) =>
               {
                   if (successAction != null)
                   {
                       successAction(completes);
                   }
               }), (error) =>
               {
                   if (errorAction != null)
                   {
                      
                       error.RequestFunc = Client_Resource.Resources_Service_Complete;
                       errorAction(error);
                   }
               });
        }
        /// <summary>
        /// 申报点选仓单查询MTP2.0
        /// </summary>
        /// <param name="accountId"></param>
        /// <param name="deliveryGoodsId"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryDeliveryWhRecieptInfo(ulong accountId, uint deliveryGoodsId, Action<List<DeliveryWhRecieptInfo>> successAction, Action<ErrorEntity> errorAction)
        {
            var queryCommonParams = new List<QueryCommonParam>();
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "accountId", ParamValue = accountId + string.Empty });
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "goodsid", ParamValue = deliveryGoodsId + string.Empty });
            QueryCommonHelper.QueryCommon(QueryStatement.SearchDeliveryWhRecieptInfo, queryCommonParams,
                new Action<List<DeliveryWhRecieptInfo>>((itemDetails) =>
                {
                    if (successAction != null)
                    {
                        successAction(itemDetails);
                    }
                }), (error) =>
                {
                    if (errorAction != null)
                    {
                        //RequestFunc = 卖交割仓单信息查询
                        error.RequestFunc = Client_Resource.Resources_Service_QueryDeliveryWhRecieptInfo;
                        errorAction(error);
                    }
                });
        }


        /// <summary>
        ///  交割提货个人信息查询请求
        /// </summary>
        /// <param name="DepositPersonalInfoReqModel">交割提货个人信息查询请求内容</param>
        /// <param name="successAction">成功回应</param>
        /// <param name="errorAction">失败回应</param>
        public void SearchDepositPersonalInfoReq(DepositPersonalInfoReqModel reqModel, Action<DepositPersonalInfoRspModel> successAction,
            Action<ErrorEntity> errorAction)
        {
            return;

            //var reqeust = _deliveryAdapter.ToDepositPersonalInfoReq(reqModel);
            //var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_DepositPersonalInfoReq };
            //LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            //{
            //    var responeEntrity = _deliveryAdapter.ToDepositPersonalInfoRsp(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_SearchDepositPersonalInfoReq });
            //        }
            //    }
            //}), new Action<int, string>((errorCode, errorDesc) =>
            //{     ////通信错误
            //    if (errorAction != null)
            //    {
            //        errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = Client_Resource.Resources_Service_SearchDepositPersonalInfoReq });
            //    }
            //}));
        }


        /// <summary>
        /// 仓单变更流水查询
        /// </summary>
        /// <param name="ChangeOperator">变更操作人</param>
        /// <param name="WRCode">仓单号</param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void SearchWRChangeFlow(uint ChangeOperator, string WRCode, Action<List<WRChangeFlowModel>> successAction, Action<ErrorEntity> errorAction)
        {
            var queryCommonParams = new List<QueryCommonParam>();
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "ChangeOperator", ParamValue = ChangeOperator + string.Empty });
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "WRCode", ParamValue = WRCode + string.Empty });
            QueryCommonHelper.QueryCommon(QueryStatement.SearchWRChangeFlowData, queryCommonParams,
                new Action<List<WRChangeFlowModel>>((itemDetails) =>
                {
                    if (successAction != null)
                    {
                        successAction(itemDetails);
                    }
                }), (error) =>
                {
                    if (errorAction != null)
                    {
                        //RequestFunc = 仓单变更流水查询
                        error.RequestFunc = Client_Resource.Resources_Service_SearchWRChangeFlow;
                        errorAction(error);
                    }
                });
        }

        /// <summary>
        /// 查询履约计划明细
        /// </summary>
        /// <param name="accountId">变更操作人</param>
        /// <param name="PlanId">履约计划id</param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void SearchDeliveryPerformDetailPlan(long PlanId, bool isHistory , Action<List<DeliveryPerformDetailPlanModel>> successAction, Action<ErrorEntity> errorAction)
        {
            var queryCommonParams = new List<QueryCommonParam>();
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "deliveryid", ParamValue = PlanId + string.Empty });
            var statement =isHistory?QueryStatement.QueryDeliveryHistoryPerformDetailPlan :QueryStatement.QueryDeliveryPerformDetailPlan;

            QueryCommonHelper.QueryCommon(statement, queryCommonParams,
                new Action<List<DeliveryPerformDetailPlanModel>>((itemDetails) =>
                {
                    if (successAction != null)
                    {
                        successAction(itemDetails);
                    }
                }), (error) =>
                {
                    if (errorAction != null)
                    {
                        //RequestFunc = 查询履约计划明细
                        error.RequestFunc = Client_Resource.Resources_Service_SearchDeliveryPerformDetailPlan;
                        errorAction(error);
                    }
                });
        }

        /// <summary>
        /// 交割关系配置查询
        /// </summary>
        /// <param name="RELATIONID">交割关系id</param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void SearchRelationPerformConfig(long RelationId, Action<List<RelationperformConfigModel>> successAction, Action<ErrorEntity> errorAction)
        {
            var queryCommonParams = new List<QueryCommonParam>();
            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "RelationId", ParamValue = RelationId + string.Empty });
            QueryCommonHelper.QueryCommon(QueryStatement.SearchRelationPerformConfig, queryCommonParams,
                new Action<List<RelationperformConfigModel>>((itemDetails) =>
                {
                    UserManager.UpdateCacheOrder(itemDetails);
                    if (successAction != null)
                    {
                        successAction(itemDetails);
                    }
                }), (error) =>
                {
                    if (errorAction != null)
                    {
                        //RequestFunc = 交割关系配置查询
                        error.RequestFunc = Client_Resource.Resources_Service_SearchRelationPerformConfig;
                        errorAction(error);
                    }
                });
        }

        /// <summary>
        /// 查询账号某商品的仓单
        /// </summary>
        /// <param name="accountId"></param>
        /// <param name="deliveryGoodsId"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryDeliveryWarehouseOrders(ulong accountId, uint deliveryGoodsId, Action<List<DeliveryWarehouse>> successAction, Action<ErrorEntity> errorAction)
        {
            var queryCommonParams = new List<QueryCommonParam>();
             
                queryCommonParams.Add(new QueryCommonParam() { ParamKey = "accountId", ParamValue = accountId + string.Empty });
                queryCommonParams.Add(new QueryCommonParam() { ParamKey = "DeliveryGoodsId", ParamValue = deliveryGoodsId+string.Empty });
              
            
            QueryCommonHelper.QueryCommon(QueryStatement.SearchDeliveryWarehouseOrder, queryCommonParams,
                new Action<List<DeliveryWarehouse>>((orderDetails) =>
                {
                    UserManager.UpdateCacheOrder(orderDetails);
                    if (successAction != null)
                    {
                        successAction(orderDetails);
                    }
                }), (error) =>
                {
                    if (errorAction != null)
                    {
                        //RequestFunc = 仓单查询 
                        error.RequestFunc = Client_Resource.Resources_Service_QueryDeliveryWarehouseOrders;
                        errorAction(error);
                    }
                });
        }

        /// <summary>
        /// 仓单Id
        /// </summary>
        /// <param name="wrid"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>
        public void QueryDeliveryWarehouseOrders(uint wrid, Action<List<DeliveryWarehouse>> successAction, Action<ErrorEntity> errorAction)
        {
            var queryCommonParams = new List<QueryCommonParam>();

            queryCommonParams.Add(new QueryCommonParam() { ParamKey = "WRID", ParamValue = wrid + string.Empty });

            QueryCommonHelper.QueryCommon(QueryStatement.SearchDeliveryWarehouseOrder, queryCommonParams,
                new Action<List<DeliveryWarehouse>>((orderDetails) =>
                {
                    UserManager.UpdateCacheOrder(orderDetails);
                    if (successAction != null)
                    {
                        successAction(orderDetails);
                    }
                }), (error) =>
                {
                    if (errorAction != null)
                    {
                        //RequestFunc = 仓单查询 
                        error.RequestFunc = Client_Resource.Resources_Service_QueryDeliveryWarehouseOrders;
                        errorAction(error);
                    }
                });
        }
        /// <summary>
        /// 交割申报单查询
        /// </summary>
        /// <param name="statement"></param>
        /// <param name="queryCommonParams"></param>
        /// <param name="successAction"></param>
        /// <param name="errorAction"></param>

        public void QueryDeliveryDeclareByCapitalAccount(string statement, List<QueryCommonParam> queryCommonParams,
            Action<List<DeliveryEntrustOrder>> successAction, Action<ErrorEntity> errorAction)
        {
            QueryCommonHelper.QueryCommon(statement, queryCommonParams, new Action<List<DeliveryEntrustOrder>>((deliveryLst) =>
            {
                if (successAction != null)
                {
                    successAction(deliveryLst);
                }
            }), (error) =>
            {
                if (errorAction != null)
                {
                    error.RequestFunc = Client_Resource.Resources_Service_QueryHoldingDetails;
                    errorAction(error);
                }
            });
        }

        public void QueryDryOrdersByCapitalAccount(string statement, List<QueryCommonParam> queryCommonParams,
            Action<List<DryHoldDetail>> successAction, Action<ErrorEntity> errorAction)
        {
            QueryCommonHelper.QueryCommon(statement, queryCommonParams, new Action<List<DryHoldDetail>>((deliveryLst) =>
            {
                if (successAction != null)
                {
                    successAction(deliveryLst);
                }
            }), (error) =>
            {
                if (errorAction != null)
                {
                    error.RequestFunc = Client_Resource.Resources_Service_QueryDeliveryHolders;
                    errorAction(error);
                }
            });
        }

        public void QueryDeliveryWarehouseOrdersNew(uint goodsId, uint deliveryGoodsId, uint tradeProperty,
            Action<DeliveryWRRspModel> successAction,
            Action<ErrorEntity> errorAction)
        {
            var reqeust = _deliveryAdapter.ToDeliveryWRReq(goodsId, deliveryGoodsId, tradeProperty);
            var packgage = new TCPPackage() { Content = reqeust, FunCode = FuncCode.FID_DeliveryWRReq };
            LinkManager.Instance.TradeTcpLinkProxy.SendPackage(packgage, new Action<TCPPackage>((revPackgage) =>
            {
                var responeEntrity = _deliveryAdapter.ToDeliveryWRRsp(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_SearchDepositPersonalInfoReq });
                    }
                }
            }), new Action<int, string>((errorCode, errorDesc) =>
            {     ////通信错误
                if (errorAction != null)
                {
                    errorAction(new ErrorEntity() { ReturnCode = errorCode, ReturnDesc = errorDesc, RequestFunc = Client_Resource.Resources_Service_SearchDepositPersonalInfoReq });
                }
            }));
        }
    }
}