/**  
* PayAbout.aspx.cs
*
* 功 能： 支付相关操作对应服务
* 类 名： PayAbout
*
* Ver    变更日期             负责人  变更内容
* ───────────────────────────────────
* V0.01  2013-4-25 16:66       吴崎均    初版(归并获取帐户信息)
* V0.02  2013-4-25 18:21       吴崎均    添加创建并支付秒杀订单方法
* V0.03  2013-4-27 17:04       吴崎均    编辑创建并支付秒杀订单方法，初步完成秒杀订单生成与支付
* V0.04  2013-4-28 11:57       吴崎均    编辑创建并支付秒杀订单方法，实现秒杀订单生成功后自动受理,增加并完成支付订单方法
* V0.05  2013-5-2 15:00        吴崎均    编辑创建并支付秒杀订单方法，实现支付与秒杀数量双缓冲、支付和秒杀数据校验
* V0.07  2013-5-6 15:53        吴崎均    二次封装通用新建订单方法,并以调用该方法形式改写创建秒杀订单方法
* V0.08  2013-5-7 17:33        吴崎均    统一ajax返回结果1:成功,0:失败,-1:异常,-2:传入数据错误,-3业务数据错误,-4:数据与业务不符合,...-N:数据与业务不符合
* 
*
*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using CY.BLL;
using CY.Model;
using CY.Infrastructure.Common;
using CY.BLL.EC;
using CY.Model.Pay;
using CY.Model.Inquiry;
using CY.BLL.Sys;
using CY.WebForm.cs;
using CY.BLL.Inquiry;

namespace CY.WebForm.Pages.common
{
    /// <summary>
    /// 支付相关操作对应服务类
    /// </summary>
    public partial class PayAbout : BasePage
    {

        /// <summary>
        /// 支付帐户业务逻辑对象
        /// </summary>
        Pay_PaymentAccountBLL _pay_PaymentAccountBLL;
        /// <summary>
        /// 当前支付账号
        /// </summary>
        private Pay_PaymentAccount _pay_PaymentAccount;

        /// <summary>
        /// 初始化
        /// </summary>
        public PayAbout()
        {
            _pay_PaymentAccountBLL = new Pay_PaymentAccountBLL();
        }

        /// <summary>
        /// 页面加载
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void Page_Load(object sender, EventArgs e)
        {
            try
            {
                switch (Request["Target"])
                {
                    case "MergeBuffer"://归并缓冲帐户金额并查看账户信息
                        LoadNewestPaymentAccount();
                        break;
                    case "PaySeckillOrder"://支付秒杀订单
                        PayAndCreateSeckillOrder();
                        break;
                    case "PayOrder"://支付订单
                        PayOrderOnline();
                        break;
                    case "Refund"://退款申请
                        OrderRefund();
                        break;
                    case "ConfirmAcceptOrder"://确认收货
                        AcceptOrder();
                        break;
                    default://普通加载
                        return;
                }
            }
            catch (Exception ex)
            {
                PAGEHandleException(ex);
                Response.Clear();
                Response.Write(-1);
            }
            Response.End();
        }

        /// <summary>
        /// 支付订单
        /// </summary>
        private void PayOrderOnline()
        {
            Response.Clear();
            string orderIdStr = Request["orderid"];
            string payMoneyStr = Request["paymoney"];
            int? orderId = MyConvert.ConvertToInt(orderIdStr);
            decimal? payMoney = MyConvert.ConvertToDecimal(payMoneyStr);

            if (!orderId.HasValue || !payMoney.HasValue)
            {
                Response.Write("-2");
                return;
            }
            else
            {
            }

            if (!PayCheck(payMoney.Value))
            {
                return;
            }//失败时直接跳出

            EC_OrderBLL eC_OrderBLL = new EC_OrderBLL();//实例化订单业务操作对象
            EC_OrderBasic eC_OrderBasic = eC_OrderBLL.GetOrderById(orderId.Value);
            if (null == eC_OrderBasic)
            {
                Response.Write("-5");
                return;
            }
            else
            {
            }

            Pay_Request pay_Request = new Pay_Request();//创建支付请求对象
            pay_Request.Subject = string.Format(UtilConst.ORDER_PAY_SUBJECT_FORMT, eC_OrderBasic.Keyid, eC_OrderBasic.SellerOrderId);//设置支付名目格式
            pay_Request.Payerid = CurrentPayAccount.Keyid.Value;
            pay_Request.Payeeid = AdminAccount.Keyid.Value;
            pay_Request.UsedCredit = 0;//默认使用授信为0
            pay_Request.Paymoney = payMoney.Value;
            pay_Request.BalanceAccount = 4;

            double? commission = MyConvert.ConvertToDouble(CY.Config.WebInfo.Instance.FirmOrderAgencyFee);

            #region 自动外协

            decimal? OutAllMoney = 0;
            OA_CorporateClientsBLL bll_OA_CorporateClientsBLL = new OA_CorporateClientsBLL();//实例化订单业务操作对象
            OA_CorporateClients m_OA_CorporateClients = bll_OA_CorporateClientsBLL.GetDefaultOutFirm(eC_OrderBasic.SellerId);//外协厂商
            if (m_OA_CorporateClients != null && eC_OrderBasic.OrderTypeId == 0)
            {
                InquiryBLL bll_InquiryBLL = new InquiryBLL();
                EC_OrderPrintParameterBLL bll_EC_OrderPrintParameterBLL = new EC_OrderPrintParameterBLL();

                EC_OrderPrintParameter m_EC_OrderPrintParameterNew = new EC_OrderPrintParameter();
                m_EC_OrderPrintParameterNew = bll_EC_OrderPrintParameterBLL.GetModel(eC_OrderBasic.Keyid.Value);
                InquiryCommonModel m_InquiryCommonModel = SerializationHelper.DeSerialize(typeof(InquiryCommonModel), m_EC_OrderPrintParameterNew.PrintParameter) as InquiryCommonModel;

                Guid customerId = Guid.Empty;
                customerId = bll_InquiryBLL.GetCustomerId(m_OA_CorporateClients.FirmId, eC_OrderBasic.SellerId);
                Guid inquiryId = bll_InquiryBLL.GetInquiryId(m_OA_CorporateClients.FirmId, eC_OrderBasic.SellerId);

                InquiryDetail m_InquiryDetail = bll_InquiryBLL.GetInquiryDetail(m_InquiryCommonModel, inquiryId, m_OA_CorporateClients.FirmId, customerId);
                OutAllMoney = m_InquiryDetail.TotalPrice;

            }

            #endregion

            string result = eC_OrderBLL.PayOrder(orderId.Value, pay_Request, commission ?? 0, OutAllMoney.Value) ? "1" : "0";


            Response.Write(result);
        }

        /// <summary>
        /// 加载最新的账户信息
        /// </summary>
        /// <param name="isReturnOnly">是否仅仅返回账户信息 true:将不会在返回流中输出数据Json;false:将会改写支付码并在返回流中输出数据Json</param>
        /// <returns></returns>
        public Pay_PaymentAccount LoadNewestPaymentAccount(bool isReturnOnly = false)
        {
            if (CurrentUser != null)
            {
                Pay_PaymentAccount pay_PaymentAccount = _pay_PaymentAccount = null != _pay_PaymentAccount ? _pay_PaymentAccount : _pay_PaymentAccountBLL.MergeBufferMoneyByMemberId(CurrentUser.MemberId);
                pay_PaymentAccount.PayPwd = isReturnOnly ? pay_PaymentAccount.PayPwd : "none data to you";
                if (pay_PaymentAccount != null)
                {
                    pay_PaymentAccount.SurplusMoney = pay_PaymentAccount.SurplusMoney.Value.ToDecimal2Yen().ToDecimal2();
                }
                if (!isReturnOnly)
                    Response.Write(null == pay_PaymentAccount ? "" : JsonHelper.GetJsonStringByObject(pay_PaymentAccount));//返回账户信息信息
                else
                {
                }
                return pay_PaymentAccount;
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// 支付前检查
        /// </summary>
        /// <param name="payMoney"></param>
        /// <returns></returns>
        private bool PayCheck(decimal payMoney)
        {
            /*获取参数*/
            string rtslav = Request["rtslav"];
            string theDwp = Request["TheDwp"];

            //信息为空则操作错误(-1:为数据错误,0:为操作失败,1:为成功)
            if (string.IsNullOrEmpty(rtslav) || string.IsNullOrEmpty(theDwp))
            {
                Response.Write("-2");
                return false;
            }
            else
            {
            }


            /*
             * 清空格
             */
            rtslav = rtslav.Trim();
            theDwp = theDwp.Trim();


            //编号不是Int或当前用户支付编号没有有效值时或中转账户没有有效值时返回操作失败
            if (!CurrentPayAccount.Keyid.HasValue || 0 == CurrentPayAccount.Keyid.Value
                || !AdminAccount.Keyid.HasValue || 0 == AdminAccount.Keyid.Value)
            {
                Response.Write("-2");
                return false;
            }
            else
            {
            }



            //获取最新账户信息
            Pay_PaymentAccount currentAccount = LoadNewestPaymentAccount(true);


            //解码并与支付码匹配
            if (null == currentAccount || !Pay_PaymentAccountBLL.EqualsPwd(rtslav, HttpContext.Current.Server.UrlDecode(HttpContext.Current.Server.UrlDecode(theDwp)), currentAccount.PayPwd))
            {
                Response.Write("-3");
                return false;
            }
            //判断帐户余额是否足以支付
            if (payMoney > currentAccount.SurplusMoney + currentAccount.SurplusCredit)
            {
                Response.Write("-4");
                return false;
            }
            else
            {
            }

            return true;
        }

        /// <summary>
        /// 支付并生成秒杀订单
        /// </summary>
        private void PayAndCreateSeckillOrder()
        {

            string seckillId = Request["SeckillId"];

            //信息为空则操作错误(-2:为数据错误,0:为操作失败,1:为成功)
            if (string.IsNullOrEmpty(seckillId))
            {
                Response.Write("-2");
                return;
            }
            else
            {
            }


            seckillId = seckillId.Trim();
            int? seckillDataId = MyConvert.ConvertToInt32(seckillId);//获取传回的秒杀编号



            //编号不是Int或当前用户支付编号没有有效值时或中转账户没有有效值时返回操作失败
            if (!seckillDataId.HasValue || !CurrentPayAccount.Keyid.HasValue || 0 == CurrentPayAccount.Keyid.Value
                || !AdminAccount.Keyid.HasValue || 0 == AdminAccount.Keyid.Value)
            {
                Response.Write("-2");
                return;
            }
            else
            {
            }



            EC_SeckillBusinessBLL eC_SeckillBusinessBLL = new EC_SeckillBusinessBLL();//实例化秒杀业务业务对象
            EC_SeckillBusiness eC_SeckillBusiness = eC_SeckillBusinessBLL.SelectModleById(seckillDataId.Value);//重新从数据库获取秒杀业务信息

            if (null == eC_SeckillBusiness || eC_SeckillBusiness.OrderCount == 0 || eC_SeckillBusiness.SurplusOrderCount <= 0 || eC_SeckillBusiness.EndTime < DateTime.Now) //可下单数或者截止日期已到后不可再下单
            {
                Response.Write("-6");//秒杀信息无效为-4
                return;
            }
            else
            {
            }

            if (!PayCheck(eC_SeckillBusiness.Price.Value))
            {
                return;
            }//失败时直接跳出

            EC_MemberBasicBLL eC_MemberBasicBLL = new EC_MemberBasicBLL();//实例化会员基础信息业务对象
            Pay_Request pay_Request = new Pay_Request();//创建支付请求对象

            pay_Request.Subject = UtilConst.ORDER_PAY_SUBJECT_FORMT;//设置支付名目格式
            pay_Request.Payerid = CurrentPayAccount.Keyid.Value;
            pay_Request.Payeeid = AdminAccount.Keyid.Value;
            pay_Request.UsedCredit = 0;//默认使用授信为0
            pay_Request.BalanceAccount = 5;

            pay_Request.Paymoney = eC_SeckillBusiness.Price.Value;//应付金额、交易金额、总价、单价、支付金额全部为特价价格


            EC_OrderBasic orderBasic = new EC_OrderBasic();
            orderBasic.BuyerId = CurrentUser.MemberId;
            orderBasic.BuyerName = CurrentUser.Name;
            orderBasic.SellerId = eC_SeckillBusiness.MemberId;
            orderBasic.SellerName = eC_SeckillBusiness.MemberBasic.Name;
            orderBasic.Operator = CurrentUser.ShortName;
            orderBasic.PrintTypeId = eC_SeckillBusiness.PrintTypeId;
            orderBasic.SumPrice = eC_SeckillBusiness.Price;
            orderBasic.OrderTypeId = -1;//秒杀订单
            //orderBasic.DocumentName = string.Format("{0}[秒杀   订单]", eC_SeckillBusiness.PrintType.PrintName);//设置印件名称为"印刷类型[订单类型]"
            orderBasic.DocumentName = string.Format("{0}", eC_SeckillBusiness.PrintType.PrintName);//设置印件名称为"印刷类型[订单类型]"
            orderBasic.Remark = string.Format("{0}", Request["txtPayRemark"]);//备注
            //新增订单并返回操作结果
            InquiryCommonModel model = new InquiryCommonModel();
            model.PrintDemand = eC_SeckillBusiness.Specifications;
            orderBasic = NewOrder(orderBasic, eC_SeckillBusiness.PrintCount.Value, pay_Request, eC_SeckillBusiness.Keyid.Value, model);

            if (null != orderBasic)
            {
                Response.Write(FormarResultInfo(orderBasic));
            }
            else
            {

                Response.Write("0");//0操作失败
            }



        }

        /// <summary>
        /// 新建订单
        /// </summary>
        /// <param name="eC_AcceptWayBySeller">收货方式</param>
        /// <param name="buyerId">买家编号</param>
        /// <param name="sellerId">卖家编号</param>
        /// <param name="buyerName">卖家名称</param>
        /// <param name="printTypeId">印刷类型编号</param>
        /// <param name="documentName">印件名称</param>
        /// <param name="printCount">印刷数量</param>
        /// <param name="money">订单价格</param>
        /// <param name="orderPrintParameter">订单印刷参数(选填)</param>
        /// <param name="pay_Request">支付请求(选填)</param>
        /// <param name="seckillId">秒杀信息编号(选填)</param>
        /// <param name="orderTypeId">订单类型编号</param>
        /// <returns></returns>
        internal static string NewOrder(EC_AcceptWayBySeller eC_AcceptWayBySeller, Guid buyerId, Guid sellerId, string buyerName, int printTypeId, string documentName, int printCount, decimal money, EC_OrderPrintParameter orderPrintParameter = null, Pay_Request pay_Request = null, int seckillId = 0, int orderTypeId = 0)
        {
            if (null == eC_AcceptWayBySeller)
                return string.Empty;
            else
            {
            }

            EC_OrderBasic eC_OrderBasic = new EC_OrderBasic();//订单主要信息
            EC_OrderExtend eC_OrderExtend = new EC_OrderExtend();//订单扩展信息
            Pay_TradingSingle pay_TradingSingle = new Pay_TradingSingle();//交易单 

            pay_TradingSingle.PayerId = eC_OrderBasic.BuyerId = buyerId;//设置买家为当前收货用户
            pay_TradingSingle.PayeeId = eC_OrderBasic.SellerId = sellerId;//设置卖家为秒杀业务的发布人
            eC_OrderBasic.Remark = string.Format("{0}", "").Trim();//获取备注
            eC_OrderBasic.PrintTypeId = printTypeId;//设置印刷业务类型为秒杀业务的印刷业务类型
            eC_OrderBasic.DocumentName = documentName;//设置印件名称为"秒杀订单:"+印刷业务类型名称
            eC_OrderBasic.Operator = eC_OrderBasic.Creater = buyerName;//制单人/操作人
            eC_OrderBasic.DeliveryTime = DateTime.Now.AddDays(15);//默认15天后交货 

            eC_OrderBasic.OrderTypeId = seckillId == 0 ? orderTypeId : -1;// sys_DictionaryBLL.GetKeyIdByKeyid(-1, "EC_订单类型");//设置订单类型为秒杀订单(MeanValue为-1的"EC_订单类型"为"秒杀订单" 0为"询价订单")
            pay_TradingSingle.TradingStateId = 1;// sys_DictionaryBLL.GetKeyIdByKeyid(1, "Pay_交易状态");//设置交易单的交易状态为交易中MeanValue为1的"Pay_交易状态"为"交易中"
            eC_OrderExtend.ExigencyCaseId = 0;// sys_DictionaryBLL.GetKeyIdByKeyid(0, "OA_紧急程度");//设置紧急程度为一般
            eC_OrderExtend.ProofreadWayId = -1;// sys_DictionaryBLL.GetKeyIdByKeyid(-1, "EC_校稿方式");//设置校稿方式为"自联系"

            //初始化已付金额、已用授信、线上金额、线下金额为0
            pay_TradingSingle.UsedCredit = pay_TradingSingle.PayedMoney = pay_TradingSingle.LineMoney = pay_TradingSingle.OnlineMoney = 0;
            pay_TradingSingle.Remark = "";//初始化备注为空字符

            pay_TradingSingle.PayableMoney =
            pay_TradingSingle.TradingMoney =
            eC_OrderBasic.SumPrice =
            eC_OrderBasic.UnitPrice = money;//应付金额、交易金额、总价、单价全部为特价价格

            if (null == eC_AcceptWayBySeller || !eC_AcceptWayBySeller.Keyid.HasValue)
            {
                return string.Empty;
            }
            else
            {
            }
            double? commission = null == pay_Request ? 0 : MyConvert.ConvertToDouble(CY.Config.WebInfo.Instance.FirmOrderAgencyFee);
            if (!commission.HasValue)
                return string.Empty;
            else
            {
            }

            EC_AcceptWayByOrder eC_AcceptWayByOrder = new EC_AcceptWayByOrder();//创建订单收货方式

            /*
             收货地址
             */
            //Copy 会员收货方式信息到新建的订单收货方式  
            eC_AcceptWayByOrder.City = eC_AcceptWayBySeller.City;
            eC_AcceptWayByOrder.Accepter = eC_AcceptWayBySeller.Accepter;
            eC_AcceptWayByOrder.AccepterPhone = eC_AcceptWayBySeller.AccepterPhone;
            eC_AcceptWayByOrder.AppointCourierCompany = eC_AcceptWayBySeller.AppointCourierCompany;
            eC_AcceptWayByOrder.AccepterAddress = eC_AcceptWayBySeller.AccepterAddress;
            eC_AcceptWayByOrder.AccepterPhoneNum = eC_AcceptWayBySeller.AccepterPhoneNum;//联系电话为收货电话
            eC_AcceptWayByOrder.AcceptContacts = eC_AcceptWayBySeller.AcceptContacts;//收货人为收货信息的联系人
            eC_AcceptWayByOrder.FetchAddress = eC_AcceptWayBySeller.FetchAddress;
            eC_AcceptWayByOrder.FetchPhoneNum = eC_AcceptWayBySeller.FetchPhoneNum;
            eC_AcceptWayByOrder.FetchContacts = eC_AcceptWayBySeller.FetchContacts;
            eC_AcceptWayByOrder.InvoiceDemand = eC_AcceptWayBySeller.InvoiceDemand;

            eC_AcceptWayByOrder.Remark = eC_AcceptWayBySeller.Remark;
            eC_AcceptWayByOrder.AcceptTypeId = eC_AcceptWayBySeller.AcceptTypeId;
            eC_AcceptWayByOrder.Accepter = eC_AcceptWayBySeller.Accepter;
            eC_AcceptWayByOrder.TheAwb = "";
            eC_AcceptWayByOrder.AccepterPhoneNum = eC_AcceptWayBySeller.AccepterPhoneNum;//联系电话为收货电话


            eC_OrderExtend.Contacts = eC_AcceptWayByOrder.AcceptContacts;//收货人为收货信息的联系人
            eC_OrderExtend.ContactPhone = eC_AcceptWayByOrder.AccepterPhoneNum;
            eC_OrderExtend.Contacts = eC_AcceptWayByOrder.Accepter;
            eC_OrderExtend.ContactPhone = eC_AcceptWayByOrder.AccepterPhone;
            eC_OrderExtend.PrintNum = printCount;
            eC_OrderExtend.SurplusPrintNum = printCount;
            eC_OrderExtend.Operate = eC_OrderBasic.Operator;
            eC_OrderExtend.Remark = "";

            EC_OrderBLL eC_OrderBLL = new EC_OrderBLL();//实例化订单业务操作对象
            bool isWin = eC_OrderBLL.NewOrder(eC_OrderBasic, eC_OrderExtend, pay_TradingSingle, eC_AcceptWayByOrder, pay_Request, commission.Value, seckillId, orderPrintParameter);
            string resultJson = string.Format("{0}id:{2},orderId:'{3}',payed:'{4}'{1}", "{", "}", eC_OrderBasic.Keyid, eC_OrderBasic.SellerOrderId, eC_OrderBasic.SumPrice.Value.ToString("F"));
            if (isWin)
            {
                //if (seckillId > 0)//秒杀信息下单后调用清除缓存方法
                //    WebUtil.UpdateCacheByCoverWay(CacheDataFiles.SeckillBusiness);

                //if (eC_OrderBasic.OrderTypeId < 1)//订单类型为线上订单则调用清除缓存方法
                //    WebUtil.UpdateCacheByCoverWay(CacheDataFiles.Order);
            }
            return isWin ? resultJson : string.Empty;

        }

        /// <summary>
        /// 新增外协订单
        /// </summary>
        /// <param name="orderBasic">订单基本信息对象</param>
        /// <param name="orderExtend">订单扩展信息对象</param>
        /// <param name="inquiryCommonModel">订单印刷参数</param>
        /// <param name="isUnite">是否合板</param>
        /// <returns></returns>
        internal static EC_OrderBasic NewOrder(EC_OrderBasic orderBasic, EC_OrderExtend orderExtend, InquiryCommonModel inquiryCommonModel, bool isUnite)
        {
            orderBasic.OrderTypeId = isUnite ? 3 : 2;//合板外协为3专版外协为2
            return NewOrder(orderBasic, inquiryCommonModel.PrintCount, null, 0, inquiryCommonModel, orderExtend);
        }

        /// <summary>
        /// 新增线下订单
        /// </summary>
        /// <param name="orderBasic">订单基本信息对象</param>
        /// <param name="orderExtend">订单扩展信息对象</param>
        /// <param name="inquiryCommonModel">订单印刷参数</param>
        /// <returns></returns>
        internal static EC_OrderBasic NewOrder(EC_OrderBasic orderBasic, EC_OrderExtend orderExtend, InquiryCommonModel inquiryCommonModel)
        {
            return NewOrder(orderBasic, inquiryCommonModel.PrintCount, null, 0, inquiryCommonModel, orderExtend);
        }


        /// <summary>
        /// 新增线下订单
        /// </summary>
        /// <param name="orderBasic">订单基本信息对象</param>
        /// <param name="orderExtend">订单扩展信息对象</param>
        /// <param name="inquiryCommonModel">订单印刷参数</param>
        /// <returns></returns>
        internal static EC_OrderBasic NewOrderSheji(EC_OrderBasic orderBasic, EC_OrderExtend orderExtend, InquiryCommonModel inquiryCommonModel)
        {
            return NewOrderSheji(orderBasic, inquiryCommonModel.PrintCount, null, 0, inquiryCommonModel, orderExtend);
        }


        /// <summary>
        /// 填充订单方法至少BuyerId、BuyerName、SellerId、SellerName、Operator、PrintTypeId、SumPrice、OrderTypeId、DocumentName属性有值
        /// </summary>
        /// <param name="orderBasic">订单基本信息对象</param>
        /// <param name="inquiryCommonModel">收货地址对象</param>
        /// <param name="orderExtend">订单扩展表对象</param>
        /// <param name="filld">填充实体委托</param>
        /// <returns></returns>
        internal static EC_OrderBasic FillOrder(EC_OrderBasic orderBasic, EC_AcceptWayByOrder eC_AcceptWayByOrder, EC_OrderExtend orderExtend = null, CY.WebForm.cs.WebUtil.FillModel filld = null)
        {


            //orderBasic.UnitPrice = orderBasic.UnitPrice.HasValue ? orderBasic.UnitPrice : orderBasic.SumPrice;
            //不允许订单总价为0、自己给自己下单
            if (orderBasic.SumPrice.Value < 0 || orderBasic.SellerId == orderBasic.BuyerId)
                return null;
            else
                ;
            orderBasic.Creater = orderBasic.Operator = string.IsNullOrEmpty(orderBasic.Creater) ? orderBasic.Operator : orderBasic.Creater;
            if (string.IsNullOrEmpty(orderBasic.Creater))
            {
                return null;
            }


            eC_AcceptWayByOrder = null == eC_AcceptWayByOrder ? new EC_AcceptWayByOrder() : eC_AcceptWayByOrder;
            filld = null == filld ? CY.WebForm.Pages.business.OrderEdit.GetAcceptWay : filld;
            filld(eC_AcceptWayByOrder);
            if (null == eC_AcceptWayByOrder)
                return null;
            else
            {
            }


            EC_OrderExtend eC_OrderExtend = null != orderExtend ? orderExtend : new EC_OrderExtend();//订单扩展信息
            Pay_TradingSingle pay_TradingSingle = new Pay_TradingSingle();//交易单 

            pay_TradingSingle.PayerId = orderBasic.BuyerId;//设置买家为当前收货用户
            pay_TradingSingle.PayeeId = orderBasic.SellerId;//设置卖家为秒杀业务的发布人
            orderBasic.OrderTypeId = orderBasic.OrderTypeId.HasValue ? orderBasic.OrderTypeId : 1;//没有类型则默认为1:线下订单
            orderBasic.Remark = string.IsNullOrEmpty(orderBasic.Remark) ? eC_AcceptWayByOrder.Remark : orderBasic.Remark;//获取备注
            eC_AcceptWayByOrder.Operator = orderBasic.Creater;//制单人/操作人
            if(orderBasic.PrintTypeId !=37)
                orderBasic.DeliveryTime = orderBasic.DeliveryTime.HasValue ? orderBasic.DeliveryTime : DateTime.Now.AddDays(15);//默认15天后交货 
            //orderBasic.TheoryCompleteDate = DateTime.Now.AddDays(15);//理论完成日期(确认收货日期)


            eC_OrderExtend.Operate = orderBasic.Operator;
            eC_OrderExtend.Remark = "";

            pay_TradingSingle.TradingStateId = 1;// sys_DictionaryBLL.GetKeyIdByKeyid(1, "Pay_交易状态");//设置交易单的交易状态为交易中MeanValue为1的"Pay_交易状态"为"交易中"

            //初始化已付金额、已用授信、线上金额、线下金额为0
            pay_TradingSingle.UsedCredit = pay_TradingSingle.PayedMoney = pay_TradingSingle.LineMoney = pay_TradingSingle.OnlineMoney = 0;
            pay_TradingSingle.Remark = "";//初始化备注为空字符

            pay_TradingSingle.PayableMoney =
            pay_TradingSingle.TradingMoney =
            orderBasic.SumPrice;//应付金额、交易金额、总价、单价全部为特价价格

            orderBasic.OrderExtend = eC_OrderExtend;
            orderBasic.TradingSingle = pay_TradingSingle;



            return orderBasic;

        }

        /// <summary>
        /// 在线下单 
        /// </summary>
        /// <param name="orderBasic">订单基本信息对象</param>
        /// <param name="printCount">印刷数量</param>
        /// <param name="pay_Request">支付请求</param>
        /// <param name="seckillId">秒杀业务编号</param>
        /// <param name="inquiryCommonModel">订单印刷参数</param>
        /// <param name="orderExtend">订单扩展信息对象</param>
        /// <param name="filld">填充实体委托</param>
        /// <returns></returns>
        private static EC_OrderBasic NewOrder(EC_OrderBasic orderBasic, int printCount, Pay_Request pay_Request = null, int seckillId = 0, InquiryCommonModel inquiryCommonModel = null, EC_OrderExtend orderExtend = null, CY.WebForm.cs.WebUtil.FillModel filld = null)
        {

            EC_AcceptWayByOrder eC_AcceptWayByOrder = new EC_AcceptWayByOrder();
            FillOrder(orderBasic, eC_AcceptWayByOrder, orderExtend, filld);

            //orderBasic.TheoryCompleteDate = DateTime.Now.AddDays(15);//理论完成日期(确认收货日期)
            if (null == orderExtend)
            {
                orderBasic.OrderExtend.ExigencyCaseId = 0;// sys_DictionaryBLL.GetKeyIdByKeyid(0, "OA_紧急程度");//设置紧急程度为一般
                orderBasic.OrderExtend.ProofreadWayId = -1;// sys_DictionaryBLL.GetKeyIdByKeyid(-1, "EC_校稿方式");//设置校稿方式为"自联系"

                //orderBasic.OrderExtend.Contacts = string.IsNullOrEmpty(eC_AcceptWayByOrder.AcceptContacts) ? eC_AcceptWayByOrder.Accepter : eC_AcceptWayByOrder.AcceptContacts;//收货人为收货信息的联系人
                //orderBasic.OrderExtend.ContactPhone = string.IsNullOrEmpty(eC_AcceptWayByOrder.AccepterPhoneNum) ? eC_AcceptWayByOrder.AccepterPhone : eC_AcceptWayByOrder.AccepterPhoneNum;
                EC_MemberBasicBLL _memberBasicBLL = new EC_MemberBasicBLL();
                EC_MemberExtend memberExtend = _memberBasicBLL.GetMemberExtendByMemberId(orderBasic.BuyerId);
                if (memberExtend != null)
                {
                    orderBasic.OrderExtend.Contacts = memberExtend.BusinessContacts;
                    orderBasic.OrderExtend.ContactPhone = memberExtend.PhoneNum;
                }
                orderBasic.OrderExtend.PrintNum = printCount;

                int? billMode = MyConvert.ConvertToInt32(HttpContext.Current.Request["txtBillMode"]);
                if (!eC_AcceptWayByOrder.AcceptTypeId.HasValue || !billMode.HasValue)
                {
                    return null;
                }

                if (null != inquiryCommonModel)
                {
                    if (inquiryCommonModel.DeliveryMode >0)
                    {
                        eC_AcceptWayByOrder.AcceptTypeId = inquiryCommonModel.DeliveryMode;
                        switch (inquiryCommonModel.BillMode)
                        {
                            case 108:
                                eC_AcceptWayByOrder.InvoiceDemand = "不含税价";
                                break;
                            case 109:
                                eC_AcceptWayByOrder.InvoiceDemand = "普通发票";
                                break;
                            case 110:
                                eC_AcceptWayByOrder.InvoiceDemand = "增值税票";
                                break;
                            default:
                                break;
                        }
                        eC_AcceptWayByOrder.Remark = inquiryCommonModel.Remarks ;
                    }
                    orderBasic.OrderExtend.PrintNum = 13 == inquiryCommonModel.PrintTypeId ? inquiryCommonModel.PrintCount * inquiryCommonModel.PrintBoxNumber : orderBasic.OrderExtend.PrintNum;
                }
                else
                    ;
            }
            else
                ;
            orderBasic.OrderExtend.SurplusPrintNum = orderBasic.OrderExtend.SurplusPrintNum.HasValue ? orderBasic.OrderExtend.SurplusPrintNum : orderBasic.OrderExtend.PrintNum;


            double? commission = null == pay_Request ? 0 : MyConvert.ConvertToDouble(CY.Config.WebInfo.Instance.FirmOrderAgencyFee);
            if (!commission.HasValue)
                return null;
            else
            {
            }


            EC_OrderPrintParameter orderPrintParameter = null;
            orderPrintParameter = null == inquiryCommonModel ? null : new EC_OrderPrintParameter()
            {
                PrintParameter = SerializationHelper.Serialize(inquiryCommonModel)
            };

            OA_CorporateClientsBLL oA_CorporateClientsBLL = new BLL.OA_CorporateClientsBLL();
            //下订单前先添加客户
            if (0 >= oA_CorporateClientsBLL.ConvertToCorporateClient(orderBasic.SellerId, orderBasic.BuyerId, orderBasic.Operator))
            {
                return null;//添加客户调用失败则添加订单失败
            }
            else
                ;

            if (orderBasic.SellerId.Equals(orderBasic.BuyerId))
                return null;//买家不能是卖家

            EC_OrderBLL eC_OrderBLL = new EC_OrderBLL();//实例化订单业务操作对象
            bool isWin = eC_OrderBLL.NewOrder(orderBasic, orderBasic.OrderExtend, orderBasic.TradingSingle, eC_AcceptWayByOrder, pay_Request, commission.Value, seckillId, orderPrintParameter);
            return isWin ? orderBasic : null;

        }




        /// <summary>
        /// 在线下单 设计订单
        /// </summary>
        /// <param name="orderBasic">订单基本信息对象</param>
        /// <param name="printCount">印刷数量</param>
        /// <param name="pay_Request">支付请求</param>
        /// <param name="seckillId">秒杀业务编号</param>
        /// <param name="inquiryCommonModel">订单印刷参数</param>
        /// <param name="orderExtend">订单扩展信息对象</param>
        /// <param name="filld">填充实体委托</param>
        /// <returns></returns>
        private static EC_OrderBasic NewOrderSheji(EC_OrderBasic orderBasic, int printCount, Pay_Request pay_Request = null, int seckillId = 0, InquiryCommonModel inquiryCommonModel = null, EC_OrderExtend orderExtend = null, CY.WebForm.cs.WebUtil.FillModel filld = null)
        {

            EC_AcceptWayByOrder eC_AcceptWayByOrder = new EC_AcceptWayByOrder();
            FillOrder(orderBasic, eC_AcceptWayByOrder, orderExtend, filld);

            //orderBasic.TheoryCompleteDate = DateTime.Now.AddDays(15);//理论完成日期(确认收货日期)
            if (null == orderExtend)
            {
                orderBasic.OrderExtend.ExigencyCaseId = 0;// sys_DictionaryBLL.GetKeyIdByKeyid(0, "OA_紧急程度");//设置紧急程度为一般
                orderBasic.OrderExtend.ProofreadWayId = -1;// sys_DictionaryBLL.GetKeyIdByKeyid(-1, "EC_校稿方式");//设置校稿方式为"自联系"

                //orderBasic.OrderExtend.Contacts = string.IsNullOrEmpty(eC_AcceptWayByOrder.AcceptContacts) ? eC_AcceptWayByOrder.Accepter : eC_AcceptWayByOrder.AcceptContacts;//收货人为收货信息的联系人
                //orderBasic.OrderExtend.ContactPhone = string.IsNullOrEmpty(eC_AcceptWayByOrder.AccepterPhoneNum) ? eC_AcceptWayByOrder.AccepterPhone : eC_AcceptWayByOrder.AccepterPhoneNum;
                EC_MemberBasicBLL _memberBasicBLL = new EC_MemberBasicBLL();
                EC_MemberExtend memberExtend = _memberBasicBLL.GetMemberExtendByMemberId(orderBasic.BuyerId);
                if (memberExtend != null)
                {
                    orderBasic.OrderExtend.Contacts = memberExtend.BusinessContacts;
                    orderBasic.OrderExtend.ContactPhone = memberExtend.PhoneNum;
                }
                orderBasic.OrderExtend.PrintNum = printCount;

                int? billMode = MyConvert.ConvertToInt32(HttpContext.Current.Request["txtBillMode"]);
                if (!eC_AcceptWayByOrder.AcceptTypeId.HasValue || !billMode.HasValue)
                {
                    return null;
                }

                if (null != inquiryCommonModel)
                {
                    if (inquiryCommonModel.DeliveryMode > 0)
                    {
                        eC_AcceptWayByOrder.AcceptTypeId = inquiryCommonModel.DeliveryMode;
                        switch (inquiryCommonModel.BillMode)
                        {
                            case 108:
                                eC_AcceptWayByOrder.InvoiceDemand = "不含税价";
                                break;
                            case 109:
                                eC_AcceptWayByOrder.InvoiceDemand = "普通发票";
                                break;
                            case 110:
                                eC_AcceptWayByOrder.InvoiceDemand = "增值税票";
                                break;
                            default:
                                break;
                        }
                        eC_AcceptWayByOrder.Remark = inquiryCommonModel.Remarks;
                    }
                    orderBasic.OrderExtend.PrintNum = 13 == inquiryCommonModel.PrintTypeId ? inquiryCommonModel.PrintCount * inquiryCommonModel.PrintBoxNumber : orderBasic.OrderExtend.PrintNum;
                }
                else
                    ;
            }
            else
                ;
            orderBasic.OrderExtend.SurplusPrintNum = orderBasic.OrderExtend.SurplusPrintNum.HasValue ? orderBasic.OrderExtend.SurplusPrintNum : orderBasic.OrderExtend.PrintNum;


            double? commission = null == pay_Request ? 0 : MyConvert.ConvertToDouble(CY.Config.WebInfo.Instance.FirmOrderAgencyFee);
            if (!commission.HasValue)
                return null;
            else
            {
            }


            EC_OrderPrintParameter orderPrintParameter = null;
            orderPrintParameter = null == inquiryCommonModel ? null : new EC_OrderPrintParameter()
            {
                PrintParameter = SerializationHelper.Serialize(inquiryCommonModel)
            };

            OA_CorporateClientsBLL oA_CorporateClientsBLL = new BLL.OA_CorporateClientsBLL();
            //下订单前先添加客户
            //设计订单用反转的MemberId
            var originalGuid = orderBasic.SellerId;
            Guid reversedGuid = new Guid(originalGuid.ToByteArray().Reverse().ToArray());
            if (0 >= oA_CorporateClientsBLL.ConvertToCorporateClient(reversedGuid, orderBasic.BuyerId, orderBasic.Operator))
            {
                return null;//添加客户调用失败则添加订单失败
            }
            else
                ;

            if (orderBasic.SellerId.Equals(orderBasic.BuyerId))
                return null;//买家不能是卖家

            EC_OrderBLL eC_OrderBLL = new EC_OrderBLL();//实例化订单业务操作对象
            bool isWin = eC_OrderBLL.NewOrder(orderBasic, orderBasic.OrderExtend, orderBasic.TradingSingle, eC_AcceptWayByOrder, pay_Request, commission.Value, seckillId, orderPrintParameter);
            return isWin ? orderBasic : null;

        }

        ///// <summary>
        ///// 在线下单 
        ///// </summary>
        ///// <param name="orderBasic">订单基本信息对象</param>
        ///// <param name="printCount">印刷数量</param>
        ///// <param name="pay_Request">支付请求</param>
        ///// <param name="seckillId">秒杀业务编号</param>
        ///// <param name="inquiryCommonModel">订单印刷参数</param>
        ///// <param name="orderExtend">订单扩展信息对象</param>
        ///// <param name="filld">填充实体委托</param>
        ///// <returns></returns>
        //private static EC_OrderBasic NewOrder(EC_OrderBasic orderBasic, int printCount, Pay_Request pay_Request = null, int seckillId = 0, InquiryCommonModel inquiryCommonModel = null, EC_OrderExtend orderExtend = null, CY.WebForm.cs.WebUtil.FillModel filld = null)
        //{


        //    orderBasic.UnitPrice = orderBasic.UnitPrice.HasValue ? orderBasic.UnitPrice : orderBasic.SumPrice;

        //    orderBasic.Creater = orderBasic.Operator = string.IsNullOrEmpty(orderBasic.Creater) ? orderBasic.Operator : orderBasic.Creater;
        //    if (string.IsNullOrEmpty(orderBasic.Creater))
        //    {
        //        return null;
        //    }


        //    EC_AcceptWayByOrder eC_AcceptWayByOrder = new EC_AcceptWayByOrder();
        //    filld = null == filld ? CY.WebForm.Pages.business.OrderEdit.GetAcceptWay : filld;
        //    filld(eC_AcceptWayByOrder);
        //    if (null == eC_AcceptWayByOrder) return null; else { }


        //    EC_OrderExtend eC_OrderExtend = null != orderExtend ? orderExtend : new EC_OrderExtend();//订单扩展信息
        //    Pay_TradingSingle pay_TradingSingle = new Pay_TradingSingle();//交易单 

        //    pay_TradingSingle.PayerId = orderBasic.BuyerId;//设置买家为当前收货用户
        //    pay_TradingSingle.PayeeId = orderBasic.SellerId;//设置卖家为秒杀业务的发布人
        //    orderBasic.OrderTypeId = orderBasic.OrderTypeId.HasValue ? orderBasic.OrderTypeId : 1;//没有类型则默认为1:线下订单
        //    orderBasic.Remark = string.IsNullOrEmpty(orderBasic.Remark) ? eC_AcceptWayByOrder.Remark : orderBasic.Remark;//获取备注
        //    eC_AcceptWayByOrder.Operator = orderBasic.Creater;//制单人/操作人
        //    orderBasic.DeliveryTime = orderBasic.DeliveryTime.HasValue ? orderBasic.DeliveryTime : DateTime.Now.AddDays(15);//默认15天后交货 
        //    //orderBasic.TheoryCompleteDate = DateTime.Now.AddDays(15);//理论完成日期(确认收货日期)
        //    if (null == orderExtend)
        //    {
        //        eC_OrderExtend.ExigencyCaseId = 0;// sys_DictionaryBLL.GetKeyIdByKeyid(0, "OA_紧急程度");//设置紧急程度为一般
        //        eC_OrderExtend.ProofreadWayId = -1;// sys_DictionaryBLL.GetKeyIdByKeyid(-1, "EC_校稿方式");//设置校稿方式为"自联系"

        //        eC_OrderExtend.Contacts = string.IsNullOrEmpty(eC_AcceptWayByOrder.AcceptContacts) ? eC_AcceptWayByOrder.Accepter : eC_AcceptWayByOrder.AcceptContacts;//收货人为收货信息的联系人
        //        eC_OrderExtend.ContactPhone = string.IsNullOrEmpty(eC_AcceptWayByOrder.AccepterPhoneNum) ? eC_AcceptWayByOrder.AccepterPhone : eC_AcceptWayByOrder.AccepterPhoneNum;
        //        eC_OrderExtend.PrintNum = printCount;
        //        eC_OrderExtend.SurplusPrintNum = eC_OrderExtend.SurplusPrintNum.HasValue ? eC_OrderExtend.SurplusPrintNum : eC_OrderExtend.PrintNum;

        //        int? billMode = MyConvert.ConvertToInt32(HttpContext.Current.Request["txtBillMode"]);
        //        if (!eC_AcceptWayByOrder.AcceptTypeId.HasValue || !billMode.HasValue) { return null; }

        //        if (null != inquiryCommonModel && 0 == inquiryCommonModel.BillMode)
        //        {
        //            inquiryCommonModel.DeliveryMode = eC_AcceptWayByOrder.AcceptTypeId.Value;
        //            inquiryCommonModel.BillMode = billMode.Value;
        //            inquiryCommonModel.Remarks = eC_AcceptWayByOrder.Remark;
        //        }
        //        else ;
        //    }
        //    else ;

        //    eC_OrderExtend.Operate = orderBasic.Operator;
        //    eC_OrderExtend.Remark = "";

        //    pay_TradingSingle.TradingStateId = 1;// sys_DictionaryBLL.GetKeyIdByKeyid(1, "Pay_交易状态");//设置交易单的交易状态为交易中MeanValue为1的"Pay_交易状态"为"交易中"

        //    //初始化已付金额、已用授信、线上金额、线下金额为0
        //    pay_TradingSingle.UsedCredit = pay_TradingSingle.PayedMoney = pay_TradingSingle.LineMoney = pay_TradingSingle.OnlineMoney = 0;
        //    pay_TradingSingle.Remark = "";//初始化备注为空字符

        //    pay_TradingSingle.PayableMoney =
        //    pay_TradingSingle.TradingMoney =
        //    orderBasic.SumPrice;//应付金额、交易金额、总价、单价全部为特价价格

        //    double? commission = null == pay_Request ? 0 : MyConvert.ConvertToDouble(CY.Config.WebInfo.Instance.FirmOrderAgencyFee);
        //    if (!commission.HasValue) return null; else { }


        //    EC_OrderPrintParameter orderPrintParameter = null;
        //    orderPrintParameter = null == inquiryCommonModel ? null : new EC_OrderPrintParameter() { PrintParameter = SerializationHelper.Serialize(inquiryCommonModel) };
        //    orderBasic.OrderExtend = orderExtend;
        //    orderBasic.TradingSingle = pay_TradingSingle;

        //    EC_OrderBLL eC_OrderBLL = new EC_OrderBLL();//实例化订单业务操作对象
        //    bool isWin = eC_OrderBLL.NewOrder(orderBasic, eC_OrderExtend, pay_TradingSingle, eC_AcceptWayByOrder, pay_Request, commission.Value, seckillId, orderPrintParameter);

        //    return isWin ? orderBasic : null;

        //}

        /// <summary>
        /// 新建订单(询价订单、需求订单)
        /// </summary>
        /// <param name="buyerId">买家编号</param>
        /// <param name="buyerName">买家名称</param>
        /// <param name="sellerId">卖家编号</param>
        /// <param name="buyerName">卖家名称</param>
        /// <param name="creater">创建人</param>
        /// <param name="money">订单价格</param>
        /// <param name="inquiryCommonModel">订单印刷参数</param>
        /// <param name="orderTypeId">订单类型</param>
        /// <returns></returns>
        internal static EC_OrderBasic NewOrder(Guid buyerId, string DocumentName,string buyerName, Guid sellerId, string sellerName, string creater, decimal money, InquiryCommonModel inquiryCommonModel, int orderTypeId = 0, CY.WebForm.cs.WebUtil.FillModel filld = null)
        {
            if (null == inquiryCommonModel)
                return null;
            else
                ;
            EC_OrderBasic eC_OrderBasic = new EC_OrderBasic();//订单主要信息 

            eC_OrderBasic.BuyerId = buyerId;//设置买家为当前收货用户
            eC_OrderBasic.BuyerName = buyerName;
            eC_OrderBasic.SellerId = sellerId;//设置卖家为秒杀业务的发布人
            eC_OrderBasic.SellerName = sellerName;

            eC_OrderBasic.PrintTypeId = inquiryCommonModel.PrintTypeId;//设置印刷业务类型为秒杀业务的印刷业务类型
            //eC_OrderBasic.DocumentName = string.Format("{0}[{1}]", inquiryCommonModel.PrintTypeName, orderTypeId == 0 ? "询价订单" : "需求订单");//设置印件名称为"印刷类型[订单类型]"
            if (DocumentName == "")
            {
                eC_OrderBasic.DocumentName = string.Format("{0}", inquiryCommonModel.PrintTypeName);//设置印件名称为"印刷类型[订单类型]"
            }
            else
            {
                eC_OrderBasic.DocumentName = DocumentName;
            }

            eC_OrderBasic.Operator = eC_OrderBasic.Creater = creater;//制单人/操作人
            eC_OrderBasic.OrderTypeId = orderTypeId;//EC_订单类型 默认0:"询价订单"
            eC_OrderBasic.SumPrice =
            eC_OrderBasic.UnitPrice = money;//应付金额、交易金额、总价、单价全部为特价价格 


            return NewOrder(eC_OrderBasic, inquiryCommonModel.PrintCount, null, 0, inquiryCommonModel, null, filld);

        }

        /// <summary>
        /// 格式化订单反馈信息
        /// </summary>
        /// <param name="orderBasic"></param>
        /// <returns></returns>
        internal static string FormarResultInfo(EC_OrderBasic orderBasic)
        {
            return null == orderBasic ? "" : string.Format("{0}id:{2},orderId:'{3}',sumprice:'{4}'{1}", '{', '}', orderBasic.Keyid, orderBasic.SellerOrderId, orderBasic.SumPrice.Value.ToString("F2"));
        }

        /// <summary>
        /// 退款
        /// </summary>
        private void OrderRefund()
        {

            decimal? money = MyConvert.ConvertToDecimal(Request["txtPayablePrice"]);
            if (!money.HasValue)
                return;
            else
                ;



            EC_OrderOperate orderOperate = Request.RequestContext.RouteData.DataTokens["orderOperate"] as EC_OrderOperate;
            Pay_Request[] payRequests = Request.RequestContext.RouteData.DataTokens["payRequests"] as Pay_Request[];//index->0 买家 index->1 卖家
            if (null == payRequests || 1 > payRequests.Length)
            {
                Response.Write("-2");
                return;
            }

            if (1 > payRequests.Length && !PayCheck(payRequests[1].Paymoney * -1))
                return;
            else
                ;//若要扣除卖家帐户金额 则检查卖家帐户是否有足够金额来扣除

            EC_OrderBLL eC_OrderBLL = new EC_OrderBLL();

            bool isWin = eC_OrderBLL.OrderRefund(orderOperate, payRequests);
            string[] resultParam = new string[5];
            resultParam[0] = "{";
            resultParam[1] = "}";
            resultParam[2] = payRequests.Length > 1 ? payRequests[1].Paymoney.ToString("F2") : "0";
            resultParam[3] = payRequests[0].Paymoney.ToString("F2");

            if (isWin && null != orderOperate)
            {
                Sys_DictionaryBLL sys_DictionaryBLL = new Sys_DictionaryBLL();
                resultParam[4] = sys_DictionaryBLL.GetNameByMeanValue(orderOperate.OperateType, "EC_订单状态");
            }
            else
                resultParam[4] = "";


            Response.Write(isWin ? string.Format("{0}sellerMoney:'{2}',buyerMoney:'{3}',orderState:'{4}'{1}", resultParam) : "0");

        }

        /// <summary>
        /// 订单收货
        /// </summary>
        private void AcceptOrder()
        {

            Response.Clear();//清除返回
            EC_OrderBasicBLL eC_OrderBasicBll = new EC_OrderBasicBLL();
            int? orderId = MyConvert.ConvertToInt32(Request["orderid"]);
            if (!orderId.HasValue)
            {
                Response.Write("-2");//-2为数据不正确
                return;
            }
            if (!PayCheck(-1))
                return;
            else
                ;//验证支付码

            bool isWin = false;
            Response.Write((isWin = eC_OrderBasicBll.ConfirmAcceptById(orderId.Value, CurrentUser.MemberId)) ? "1" : "0");
            if (isWin)
            {
                Pay_PaymentAccountBLL _pay_PaymentAccountBLL = new Pay_PaymentAccountBLL();
                EC_OrderBasic m_EC_OrderBasic = eC_OrderBasicBll.SelectModelById(orderId.Value);
                if (m_EC_OrderBasic.OrderTypeId <= 0)
                {
                    isWin = _pay_PaymentAccountBLL.SendPoOrMoToMember(CurrentUser.MemberId, 87, m_EC_OrderBasic.TradingSingle.OnlineMoney);
                }
            }
        }

        /// <summary>
        /// 填充默认收货地址到订单收货地址(必须传当前登录人会员编号到路由对象key：CurrentMemberId)
        /// </summary>
        /// <param name="writeTarget">订单收货地址对象</param>
        /// <returns></returns>
        public static CY.Infrastructure.Domain.IAggregateRoot FillModel(CY.Infrastructure.Domain.IAggregateRoot writeTarget)
        {
            if (null == writeTarget)
                return null;
            else
                ;
            HttpRequest Request = HttpContext.Current.Request;
            object obj = Request.RequestContext.RouteData.DataTokens["CurrentMemberId"];
            if (null == obj)
                return null;
            else
                ;
            Guid memberId = MyConvert.ConvertToGuid(obj);
            EC_AcceptWayBySellerBLL eC_AcceptWayBySellerBLL = new EC_AcceptWayBySellerBLL();
            EC_AcceptWayBySeller acceptWay = eC_AcceptWayBySellerBLL.GetModelByTargetId(memberId);

            if (null == acceptWay)
                return null;
            else
                ;

            int i = 2;
            while (++i < 18)
            {
                writeTarget.Visiter("", i, true, acceptWay.Visiter("", i));
            }
            writeTarget.Visiter("TheAwb", -1, true, "");
            return writeTarget;
        }
    }
}