/// <summary>
/// 强制核收时创建多付退款单
/// </summary>
/// <param name="netpayEntity">支付信息实体</param>
/// <param name="refundEntity">退款信息实体</param>
private void CreateRefundInfoForForceCheck(NetPayInfo netpayEntity, SOIncomeRefundInfo refundEntity)
{
refundEntity.RefundPoint = 0;
refundEntity.RefundReason = 5; //客户多付款
refundEntity.HaveAutoRMA = false; //非物流拒收
refundEntity.Status = RefundStatus.Origin;
refundEntity.OrderType = RefundOrderType.OverPayment;
refundEntity.SOSysNo = netpayEntity.SOSysNo;
refundEntity.OrderSysNo = netpayEntity.SOSysNo;
//查询是否已经存在退款信息
var refundList = ObjectFactory <SOIncomeRefundProcessor> .Instance.GetListByCriteria(new SOIncomeRefundInfo()
{
OrderSysNo = netpayEntity.SOSysNo.Value,
OrderType = RefundOrderType.OverPayment
});
if (refundList != null && refundList.Count > 0)
{
refundEntity.SysNo = refundList[0].SysNo;
ObjectFactory <SOIncomeRefundProcessor> .Instance.Update(refundEntity);
}
else
{
refundEntity.PayAmount = netpayEntity.PayAmount;
ObjectFactory <SOIncomeRefundProcessor> .Instance.Create(refundEntity);
}
}
/// <summary>
/// 审核移仓单
/// </summary>
protected virtual void VerifyShiftRequest(NetPayInfo netpayInfo)
{
int shiftSysNo = ExternalDomainBroker.GetShiftSysNoBySOSysNo(netpayInfo.SOSysNo.Value);
if (shiftSysNo > 0)
{
try
{
//调用Inventory接口审核移仓单
ExternalDomainBroker.VerifyShiftRequest(shiftSysNo);
//记录操作日志，该支付单的移仓单审核成功
ObjectFactory <ICommonBizInteract> .Instance.CreateOperationLog(
GetMessageString("NetPay_Log_VerifyShiftRequestSuccess", ServiceContext.Current.UserSysNo, netpayInfo.SysNo.Value)
, ECCentral.BizEntity.Common.BizLogType.Finance_NetPay_Verify
, netpayInfo.SysNo.Value
, netpayInfo.CompanyCode);
}
catch (System.Exception ex)
{
//审核移仓单失败，记录操作日志，该支付单的移仓单审核失败
ObjectFactory <ICommonBizInteract> .Instance.CreateOperationLog(
GetMessageString("NetPay_Log_VerifyShiftRequestFailed", ServiceContext.Current.UserSysNo, netpayInfo.SysNo.Value, ex.Message)
, ECCentral.BizEntity.Common.BizLogType.Finance_NetPay_Verify
, netpayInfo.SysNo.Value
, netpayInfo.CompanyCode);
}
}
}
public RefundResult Refund(RefundEntity refundEntity)
{
RefundResult result = new RefundResult();
result.IsSync = true;
NetPayInfo netpayInfo = ObjectFactory <NetPayProcessor> .Instance.GetValidBySOSysNo(refundEntity.SOSysNo);
string partner = AppSettingManager.GetSetting("Invoice", "IPSPartner");
string IPSSecurityKey = AppSettingManager.GetSetting("Invoice", "IPSSecurityKey");
string sign = Sign(string.Format("{0}{1}{2}{3}{4}", partner, refundEntity.SOSysNo.ToString(), refundEntity.OrderDate.ToString("yyyyMMdd"), refundEntity.RefundAmt.ToString("f2"), IPSSecurityKey));
RefundMsg msg = new IPSPay.ServiceSoapClient().Refund(partner, sign, refundEntity.OrderDate.ToString("yyyyMMdd"), refundEntity.SOSysNo.ToString(), (double)refundEntity.RefundAmt, "");
if (msg.ErrCode == "0000")
{
if (msg.Sign == Sign(string.Format("{0}{1}{2}{3}{4}{5}{6}", partner, msg.TradeBillNo, msg.TradeTime, msg.RealRefundAmount.ToString("f2"), msg.CanRefundAmount.ToString("f2"), msg.RefundBillNo, IPSSecurityKey)))
{
result.Result = true;
}
else
{
result.Result = false;
result.Message = "验签失败";
}
}
else
{
result.Result = false;
result.Message = GetMessage(msg.ErrCode);
//result.Message += refundEntity.SOSysNo.ToString() + " " + refundEntity.OrderDate.ToString("YYYYMMDD");
}
return(result);
}
/// <summary>
/// CS审核退款单前预检查
/// </summary>
/// <param name="entity"></param>
protected virtual void PreCheckForCSAudit(SOIncomeRefundInfo entity, SOIncomeRefundInfo info)
{
////创建人，客服审核人，财务审核人不能相同
//if (entity.CreateUserSysNo == info.AuditUserSysNo)
//{
// ThrowBizException("SOInComeRefund_CSAudit_CreateUserAndAuditUserCanNotSame");
//}
if (entity.Status != RefundStatus.Origin)
{
ThrowBizException("SOIncomeRefund_CSAudit_CanNotAudit");
}
//多付款退款单需要NetPay或邮局电汇审核通过后才能进行审核
if (entity.OrderType == RefundOrderType.OverPayment)
{
NetPayInfo netPayQueryCriteria = new NetPayInfo
{
SOSysNo = entity.SOSysNo,
Status = NetPayStatus.Approved
};
List<NetPayInfo> netPayList = ObjectFactory<NetPayProcessor>.Instance.GetListByCriteria(netPayQueryCriteria);
if (netPayList.Count == 0)
{
List<PostPayInfo> postPayList = ObjectFactory<PostPayProcessor>.Instance.GetListBySOSysNoAndStatus(entity.SOSysNo.Value, PostPayStatus.Yes, PostPayStatus.Splited);
if (postPayList.Count == 0)
{
ThrowBizException("SOIncomeRefund_CSAudit_NoValidNetPayOrPostPay");
}
}
}
}
/// <summary>
/// 创建网上支付信息
/// </summary>
/// <param name="input">待创建的网上支付信息</param>
/// <returns>创建后的网上支付信息</returns>
public virtual NetPayInfo Create(NetPayInfo netpayEntity, SOIncomeRefundInfo refundEntity, bool isForceCheck)
{
if (netpayEntity.SOSysNo == null)
{
throw new ArgumentNullException("netpayEntity.SOSysNo");
}
return(ObjectFactory <NetPayProcessor> .Instance.Create(netpayEntity, refundEntity, isForceCheck));
}
public NetPayInfo CreateNetPay(CheckNetPayReq request)
{
NetPayInfo netPayInfo = null;
SOIncomeRefundInfo refundInfo = null;
request.Convert(out netPayInfo, out refundInfo);
return(ObjectFactory <NetPayAppService> .Instance.Create(netPayInfo, refundInfo, request.IsForceCheck.Value));
}
/// <summary>
/// 创建netpay
/// </summary>
/// <param name="entity">netpay实体信息</param>
/// <returns>创建好的netpay</returns>
public NetPayInfo Create(NetPayInfo entity)
{
DataCommand command = DataCommandManager.GetDataCommand("InsertNetPay");
command.SetParameterValue(entity);
entity.SysNo = Convert.ToInt32(command.ExecuteScalar());
return(LoadBySysNo(entity.SysNo.Value));
}
/// <summary>
/// 拆分NetPay时更新NetPay
/// </summary>
/// <param name="entity"></param>
public virtual void SplitForSO(NetPayInfo entity)
{
if (!entity.SysNo.HasValue)
{
throw new ArgumentNullException("entity.SysNo");
}
m_NetpayDA.UpdateStatusSplitForSO(entity);
}
/// <summary>
/// 创建NetPay
/// </summary>
/// <param name="netpayEntity">网上支付实体</param>
/// <param name="refundEntity">退款实体</param>
/// <param name="isForceCheck">是否强制核收，如果是强制核收，refundEntity必须要有值</param>
/// <returns>创建好的netpay实体</returns>
public virtual NetPayInfo Create(NetPayInfo netpayEntity, SOIncomeRefundInfo refundEntity, bool isForceCheck)
{
SOBaseInfo soBaseInfo = ExternalDomainBroker.GetSOBaseInfo(netpayEntity.SOSysNo.Value);
//创建前预检查
PreCheckForCreate(netpayEntity, refundEntity, soBaseInfo, isForceCheck);
TransactionOptions options = new TransactionOptions();
options.IsolationLevel = IsolationLevel.ReadCommitted;
options.Timeout = TimeSpan.FromMinutes(2);
using (TransactionScope ts = new TransactionScope(TransactionScopeOption.Required, options))
{
//Step 1:写入退款信息
bool isOverpay = netpayEntity.PayAmount > soBaseInfo.ReceivableAmount;
if (isForceCheck && isOverpay)
{
refundEntity.CompanyCode = soBaseInfo.CompanyCode;
CreateRefundInfoForForceCheck(netpayEntity, refundEntity);
}
//Step 2:写入网上支付信息
netpayEntity.Status = NetPayStatus.Origin;
netpayEntity.ExternalKey = m_NetpayDA.GetExternalKeyBySOSysNo(netpayEntity.SOSysNo.Value);
netpayEntity.MasterSoSysNo = soBaseInfo.SOSplitMaster;
netpayEntity.CompanyCode = soBaseInfo.CompanyCode;
if (string.IsNullOrEmpty(netpayEntity.Note))
{
netpayEntity.Note = "add by newegg employees.";
}
netpayEntity = m_NetpayDA.Create(netpayEntity);
//如果生成netpay记录的订单有母单，则更新netpay的母单信息
if (soBaseInfo.SOSplitMaster.HasValue && soBaseInfo.SOSplitMaster.Value > 0)
{
var masterSO = ExternalDomainBroker.GetSOBaseInfo(soBaseInfo.SOSplitMaster.Value);
m_NetpayDA.UpdateMasterSOAmt(masterSO);
}
//发送创建netpay消息
EventPublisher.Publish(new CreateNetpayMessage()
{
NetpaySysNo = netpayEntity.SysNo.Value,
CurrentUserSysNo = ServiceContext.Current.UserSysNo
});
ts.Complete();
}
//记录业务Log
ObjectFactory <ICommonBizInteract> .Instance.CreateOperationLog(
GetMessageString("NetPay_Log_Create", ServiceContext.Current.UserSysNo, netpayEntity.SysNo)
, ECCentral.BizEntity.Common.BizLogType.Finance_NetPay_AddVerified
, netpayEntity.SysNo.Value
, netpayEntity.CompanyCode);
return(netpayEntity);
}
public void UpdateStatusSplitForSO(NetPayInfo entity)
{
DataCommand command = DataCommandManager.GetDataCommand("UpdateNetPayStatusSplitForSO");
command.SetParameterValue("@SysNo", entity.SysNo);
command.SetParameterValue("@Status", entity.Status);
command.ExecuteNonQuery();
}
/// <summary>
/// 作废网上支付
/// </summary>
/// <param name="sysNo"></param>
public virtual void Abandon(int sysNo)
{
NetPayInfo netpay = LoadBySysNo(sysNo);
if (netpay == null)
{
ThrowBizException("NetPay_RecordNotExist", sysNo);
}
if (netpay.Status != NetPayStatus.Origin)
{
ThrowBizException("NetPay_StatusNotAllowAbandon");
}
TransactionOptions options = new TransactionOptions();
options.IsolationLevel = IsolationLevel.ReadUncommitted;
options.Timeout = TimeSpan.FromMinutes(2);
using (TransactionScope ts = new TransactionScope(TransactionScopeOption.Required, options))
{
//更新netpay状态为已作废
m_NetpayDA.UpdateStatus(sysNo, NetPayStatus.Abandon);
//2012-06-13 fixbug：检查订单是否有多付退款记录，有则将多付退款记录作废
var overpayRefundList = ObjectFactory <SOIncomeRefundProcessor> .Instance.GetListByCriteria(new SOIncomeRefundInfo()
{
OrderSysNo = netpay.SOSysNo,
OrderType = RefundOrderType.OverPayment,
Status = RefundStatus.Origin
});
if (overpayRefundList != null && overpayRefundList.Count > 0)
{
//作废多付退款记录
ObjectFactory <ISOIncomeRefundDA> .Instance.UpdateStatus(overpayRefundList[0].SysNo.Value
, ServiceContext.Current.UserSysNo, RefundStatus.Abandon, DateTime.Now);
}
//发送netpay作废Message
EventPublisher.Publish <NetpayAbandonedMessage>(new NetpayAbandonedMessage()
{
NetpaySysNo = sysNo,
CurrentUserSysNo = ServiceContext.Current.UserSysNo
});
ts.Complete();
}
//记录操作日志
ObjectFactory <ICommonBizInteract> .Instance.CreateOperationLog(
GetMessageString("NetPay_Log_Abandon", ServiceContext.Current.UserSysNo, netpay.SysNo)
, ECCentral.BizEntity.Common.BizLogType.Finance_NetPay_Abandon
, netpay.SysNo.Value
, netpay.CompanyCode);
}
/// <summary>
/// 一单款到发货通过
/// </summary>
/// <param name="entity"></param>
/// <param name="soNetPayinfo"></param>
private void PassPIASO(SOInfo entity, NetPayInfo soNetPayinfo)
{
//Jin:去掉了NETPAY状态需要为Origin的判断，因为前台网站重构后，对于网上支付，银行回调成功后直接就是审核通过的NETPAY和SOIncome
//if (entity.BaseInfo.SOType != SOType.GroupBuy || soNetPayinfo.Status == NetPayStatus.Origin)
//{
// ExternalDomainBroker.AuditNetPay(soNetPayinfo.SysNo.Value);
//}
//还原原始审核人员
m_auditUserSysNoTemp = m_auditUserSysNo;
if (entity.BaseInfo.SplitType == SOSplitType.Force || entity.BaseInfo.SplitType == SOSplitType.Customer)
{
ObjectFactory <SOProcessor> .Instance.ProcessSO(new SOAction.SOCommandInfo {
Command = SOAction.SOCommand.Split, SOInfo = entity, Parameter = new object[] { true }
});
m_da.UpdateCheckShippingAuditTypeBySysNo(entity.SysNo.Value, AuditType.Manual, "自动审单通过，自动拆单.");
m_da.UpdateSO4AuditUserInfo(entity.SysNo.Value, m_auditUserSysNo);
ObjectFactory <SOLogProcessor> .Instance.WriteSOLog(new SOLogInfo()
{
SOSysNo = entity.BaseInfo.SysNo, OperationType = BizLogType.Sale_SO_Audit, Note = "自动审单通过，自动拆单."
});
}
else
{
//更新时需要验证当前的SO状态
//bool isSuccess = m_da.UpdateSO4PassAutoAudit(entity.SysNo.Value,m_auditUserSysNoTemp);
ObjectFactory <SOProcessor> .Instance.ProcessSO(new SOAction.SOCommandInfo {
Command = SOAction.SOCommand.Audit, SOInfo = entity, Parameter = new object[] { true }
});
//if (isSuccess)
//{
entity.BaseInfo.Status = SOStatus.WaitingOutStock;
m_da.UpdateCheckShippingAuditTypeBySysNo(entity.SysNo.Value, AuditType.Auto, "自动审单通过[款到发货]");
ObjectFactory <SOLogProcessor> .Instance.WriteSOLog(new SOLogInfo()
{
SOSysNo = entity.BaseInfo.SysNo, OperationType = BizLogType.Sale_SO_Audit, Note = "自动审单通过[款到发货]"
});
//}
//else
//{
// ThrowException(entity, "订单不存在或状态已不再是待审核状态");
//}
//发送审核邮件
ObjectFactory <SOProcessor> .Instance.SendMessage(entity, false, false, true);
//更新自动审核发送邮件的标识
m_da.AuditSendMailAndUpdateSO(entity.SysNo.Value);
}
}
/// <summary>
/// 赠品订单自动创建
/// </summary>
/// <param name="soSysNo">订单编号</param>
/// <param name="payAmount">支付金额</param>
/// <param name="payTypeSysNo">支付类型</param>
/// <param name="companyCode">公司编号</param>
/// <returns>NetPay信息</returns>
internal static ECCentral.BizEntity.Invoice.NetPayInfo CreatNetPay(int soSysNo, decimal payAmount, int payTypeSysNo, string companyCode)
{
NetPayInfo netpay = new NetPayInfo();
netpay.SOSysNo = soSysNo;
netpay.PayAmount = payAmount;
netpay.PayTypeSysNo = payTypeSysNo;
netpay.RelatedSoSysNo = soSysNo;
netpay.CompanyCode = companyCode;
netpay.Note = "赠品订单自动创建";
netpay.Source = NetPaySource.Bank;
return(ObjectFactory <IInvoiceBizInteract> .Instance.CreateNetPay(netpay, null, false));
}
/// <summary>
/// 根据查询条件取得netpay列表
/// </summary>
/// <param name="query">查询条件</param>
/// <returns></returns>
public List <NetPayInfo> GetListByCriteria(NetPayInfo query)
{
CustomDataCommand cmd = DataCommandManager.CreateCustomDataCommandFromConfig("GetNetPayList");
using (DynamicQuerySqlBuilder sb = new DynamicQuerySqlBuilder(cmd.CommandText, cmd, null, "SysNo DESC"))
{
sb.ConditionConstructor.AddCondition(QueryConditionRelationType.AND, "SysNo", DbType.Int32, "@SysNo", QueryConditionOperatorType.Equal, query.SysNo);
sb.ConditionConstructor.AddCondition(QueryConditionRelationType.AND, "SOSysNo", DbType.Int32, "@SOSysNo", QueryConditionOperatorType.Equal, query.SOSysNo);
sb.ConditionConstructor.AddCondition(QueryConditionRelationType.AND, "Status", DbType.Int32, "@Status", QueryConditionOperatorType.Equal, query.Status);
cmd.CommandText = sb.BuildQuerySql();
return(cmd.ExecuteEntityList <NetPayInfo>());
}
}
private void map(NetPayInfo oParam, DataRow tempdr)
{
oParam.SysNo = Util.TrimIntNull(tempdr["SysNo"]);
oParam.SOSysNo = Util.TrimIntNull(tempdr["SOSysNo"]);
oParam.PayTypeSysNo = Util.TrimIntNull(tempdr["PayTypeSysNo"]);
oParam.PayAmount = Util.TrimDecimalNull(tempdr["PayAmount"]);
oParam.Source = Util.TrimIntNull(tempdr["Source"]);
oParam.InputTime = Util.TrimDateNull(tempdr["InputTime"]);
oParam.InputUserSysNo = Util.TrimIntNull(tempdr["InputUserSysNo"]);
oParam.ApproveUserSysNo = Util.TrimIntNull(tempdr["ApproveUserSysNo"]);
oParam.ApproveTime = Util.TrimDateNull(tempdr["ApproveTime"]);
oParam.Note = Util.TrimNull(tempdr["Note"]);
oParam.Status = Util.TrimIntNull(tempdr["Status"]);
}
/// <summary>
/// 查询网上支付情况
/// </summary>
/// <param name="sosysno">订单编号</param>
/// <returns>true: 已通过网上支付 / false: 未通过网上支付</returns>
protected bool IsPayed(int sosysno)
{
//查询网上支付情况
NetPayInfo netpay = NetPayManager.GetInstance().Load(sosysno);
if (netpay == null)
{
return(false);
}
else
{
return(true);
}
}
public void Insert(NetPayInfo oParam)
{
TransactionOptions options = new TransactionOptions();
options.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
options.Timeout = TransactionManager.DefaultTimeout;
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, options))
{
new NetPayDac().Insert(oParam);
scope.Complete();
}
}
public void Test_Invoice_NetPayEntityClone()
{
var now = DateTime.Now;
NetPayInfo netpayInfo = new NetPayInfo();
netpayInfo.ApproveTime = now;
netpayInfo.ApproveUserSysNo = 1;
netpayInfo.ChannelID = "channel";
netpayInfo.CompanyCode = "8601";
netpayInfo.ExternalKey = "externalkey";
netpayInfo.GiftCardPayAmt = 1000;
netpayInfo.MasterSoSysNo = 100000;
netpayInfo.Note = "note";
netpayInfo.OrderAmt = 1000;
netpayInfo.PayAmount = 1000;
netpayInfo.PayTypeSysNo = 1;
netpayInfo.PointPay = 1000;
netpayInfo.PrePayAmt = 1000;
netpayInfo.RelatedSoSysNo = 100000;
netpayInfo.ReviewedTime = now;
netpayInfo.ReviewedUserSysNo = 1;
netpayInfo.SOSysNo = 100000;
netpayInfo.Source = NetPaySource.Bank;
netpayInfo.Status = NetPayStatus.Abandon;
netpayInfo.SysNo = 1000;
var cloneNetPayInfo = SerializationUtility.DeepClone <NetPayInfo>(netpayInfo);
Assert.AreEqual(now, cloneNetPayInfo.ApproveTime);
Assert.AreEqual(1, cloneNetPayInfo.ApproveUserSysNo);
Assert.AreEqual("channel", cloneNetPayInfo.ChannelID);
Assert.AreEqual("8601", cloneNetPayInfo.CompanyCode);
Assert.AreEqual("externalkey", cloneNetPayInfo.ExternalKey);
Assert.AreEqual(1000, cloneNetPayInfo.GiftCardPayAmt);
Assert.AreEqual(100000, cloneNetPayInfo.MasterSoSysNo);
Assert.AreEqual("note", cloneNetPayInfo.Note);
Assert.AreEqual(1000, cloneNetPayInfo.OrderAmt);
Assert.AreEqual(1000, cloneNetPayInfo.PayAmount);
Assert.AreEqual(1, cloneNetPayInfo.PayTypeSysNo);
Assert.AreEqual(1000, cloneNetPayInfo.PointPay);
Assert.AreEqual(1000, cloneNetPayInfo.PrePayAmt);
Assert.AreEqual(100000, cloneNetPayInfo.RelatedSoSysNo);
Assert.AreEqual(now, cloneNetPayInfo.ReviewedTime);
Assert.AreEqual(1, cloneNetPayInfo.ReviewedUserSysNo);
Assert.AreEqual(100000, cloneNetPayInfo.SOSysNo);
Assert.AreEqual(NetPaySource.Bank, cloneNetPayInfo.Source);
Assert.AreEqual(NetPayStatus.Abandon, cloneNetPayInfo.Status);
Assert.AreEqual(1000, cloneNetPayInfo.SysNo);
}
public void AddVerified(NetPayInfo oParam, int userSysNo)
{
TransactionOptions options = new TransactionOptions();
options.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
options.Timeout = TransactionManager.DefaultTimeout;
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, options))
{
this.Insert(oParam);
this.Verify(oParam.SysNo, userSysNo);
scope.Complete();
}
}
protected void btnEnter_Click(object sender, EventArgs e)
{
if (txtTradeNo.Text != string.Empty)
{
int Result = 0;
bool IsAdd = true;
int SOSysNo = Int32.Parse(lblSOID.Text.Substring(1));
SOAlipayInfo oInfo = SaleManager.GetInstance().LoadSOAlipay(SOSysNo);
if (oInfo == null)
{
oInfo = new SOAlipayInfo();
oInfo.SOSysNo = SOSysNo;
oInfo.AlipayTradeNo = txtTradeNo.Text.Trim();
Result = SaleManager.GetInstance().InsertSOAlipay(oInfo);
lblResult.Text = "输入支付宝交易号完成!";
}
else
{
IsAdd = false;
oInfo.AlipayTradeNo = txtTradeNo.Text.Trim();
Result = SaleManager.GetInstance().UpdateSOAlipay(oInfo);
lblResult.Text = "更新支付宝交易号完成!";
}
if (Result == 1)
{
SOInfo order = SaleManager.GetInstance().LoadSOMaster(SOSysNo);
if (order != null)
{
if (IsAdd)
{
NetPayInfo netpay = new NetPayInfo();
netpay.SOSysNo = SOSysNo;
netpay.PayTypeSysNo = order.PayTypeSysNo;
netpay.InputTime = DateTime.Now;
netpay.Source = (int)AppEnum.NetPaySource.Bank;
netpay.PayAmount = order.GetTotalAmt();
netpay.Status = (int)AppEnum.NetPayStatus.Origin;
netpay.Note = "支付宝即时到帐付款";
NetPayManager.GetInstance().Insert(netpay);
}
}
lblResult.Visible = true;
}
}
}
/// <summary>
/// 审核netpay预检查
/// </summary>
/// <param name="netpayInfo"></param>
/// <param name="soBaseInfo"></param>
/// <param name="isForceCheck"></param>
protected virtual void PreCheckForAudit(NetPayInfo netpayInfo, SOBaseInfo soBaseInfo)
{
if (netpayInfo.Status != NetPayStatus.Origin)
{
ThrowBizException("NetPay_StatusNotAllowCheck");
}
if (soBaseInfo.ReferenceSysNo.HasValue && soBaseInfo.SOType == SOType.GroupBuy)
{
//团购正在进行中，请待团购结束后再进行审核 部分失败的团购订单也予以审核通过
if (soBaseInfo.SettlementStatus != SettlementStatus.Success && soBaseInfo.SettlementStatus != SettlementStatus.PlanFail)
{
ThrowBizException("NetPay_GroupingBuyOrderNotAllowCheck", netpayInfo.SOSysNo);
}
}
if (soBaseInfo.HoldStatus == SOHoldStatus.WebHold)
{
ThrowBizException("NetPay_HoldOrderNotAllowCheck", netpayInfo.SOSysNo);
}
//输入的订单的支付方式要与订单中的支付方式一致
if (netpayInfo.PayTypeSysNo != soBaseInfo.PayTypeSysNo)
{
ThrowBizException("NetPay_PayTypeNotSameNotAllowCheck");
}
//验证订单的付款方式是不是“网上支付”
if (!IsNetPayType(soBaseInfo.PayTypeSysNo.Value, soBaseInfo.SysNo.Value))
{
ThrowBizException("NetPay_SOPayTypeIsNotNet");
}
//Nick.Y.Zheng 实收金额与订单金额不相等，且误差超过1分钱，则不通过，否则通过
//实收金额少于订单金额，不允许核收。
decimal currPayAmount = netpayInfo.PayAmount.HasValue ? netpayInfo.PayAmount.Value : 0m;
//if (netpayInfo.PayAmount != soBaseInfo.ReceivableAmount
// && Math.Abs(currPayAmount - soBaseInfo.ReceivableAmount) > 0.01m)
//{
// ThrowBizException("NetPay_PayAmoutNotEqualNotAllowCheck");
//}
//实收金额少于订单金额，不允许核收。
if (netpayInfo.PayAmount < soBaseInfo.ReceivableAmount && Math.Abs(currPayAmount - soBaseInfo.ReceivableAmount) > 0.01m)
{
ThrowBizException("NetPay_PayAmoutNotEnoughNotAllowCheck");
}
}
private void Abandon(NetPayInfo dbInfo)
{
TransactionOptions options = new TransactionOptions();
options.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
options.Timeout = TransactionManager.DefaultTimeout;
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, options))
{
Hashtable ht = new Hashtable(5);
ht.Add("SysNo", dbInfo.SysNo);
ht.Add("Status", (int)AppEnum.NetPayStatus.Abandon);
new NetPayDac().Update(ht);
scope.Complete();
}
}
public void Verify(int netpaySysNo, int userSysNo)
{
TransactionOptions options = new TransactionOptions();
options.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
options.Timeout = TransactionManager.DefaultTimeout;
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, options))
{
NetPayInfo dbInfo = Load(netpaySysNo);
if (dbInfo.Status != (int)AppEnum.NetPayStatus.Origin)
{
throw new BizException("netpay: not origin, can't verify");
}
dbInfo.Status = (int)AppEnum.NetPayStatus.Verified;
Hashtable ht = new Hashtable(5);
ht.Add("SysNo", dbInfo.SysNo);
ht.Add("ApproveUserSysNo", userSysNo);
ht.Add("ApproveTime", DateTime.Now);
ht.Add("Status", dbInfo.Status);
new NetPayDac().Update(ht);
//so income 的唯一性那边会判断的
SOIncomeInfo oIncome = new SOIncomeInfo();
oIncome.OrderType = (int)AppEnum.SOIncomeOrderType.SO;
oIncome.OrderSysNo = dbInfo.SOSysNo;
oIncome.OrderAmt = dbInfo.PayAmount;
oIncome.IncomeStyle = (int)AppEnum.SOIncomeStyle.Advanced;
oIncome.IncomeAmt = dbInfo.PayAmount;
oIncome.IncomeUserSysNo = userSysNo;
oIncome.IncomeTime = DateTime.Now;
oIncome.Status = (int)AppEnum.SOIncomeStatus.Origin;
SOIncomeManager.GetInstance().Insert(oIncome);
scope.Complete();
}
}
public NetPayInfo LoadVerified(int soSysNo)
{
NetPayInfo oInfo = null;
TransactionOptions options = new TransactionOptions();
options.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
options.Timeout = TransactionManager.DefaultTimeout;
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, options))
{
string sql = "select * from finance_netpay where sosysno =" + soSysNo + " and status=" + (int)AppEnum.NetPayStatus.Verified;
DataSet ds = SqlHelper.ExecuteDataSet(sql);
if (Util.HasMoreRow(ds))
{
oInfo = new NetPayInfo();
map(oInfo, ds.Tables[0].Rows[0]);
}
scope.Complete();
}
return(oInfo);
}
/// <summary>
/// 构造销售收款单信息
/// </summary>
private SOIncomeInfo CreateSOIncomeInfo(NetPayInfo netpayInfo, SOBaseInfo soBaseInfo)
{
var soIncomeInfo = new SOIncomeInfo()
{
IncomeStyle = SOIncomeOrderStyle.Advanced,
OrderType = SOIncomeOrderType.SO,
OrderSysNo = netpayInfo.SOSysNo,
OrderAmt = soBaseInfo.SOTotalAmount,
IncomeAmt = netpayInfo.PayAmount,
PrepayAmt = soBaseInfo.PrepayAmount,
Status = SOIncomeStatus.Origin,
MasterSoSysNo = soBaseInfo.SOSplitMaster,
PointPay = soBaseInfo.PointPay / decimal.Parse(AppSettingManager.GetSetting("Invoice", "PointExChangeRate")),
GiftCardPayAmt = soBaseInfo.GiftCardPay,
PayAmount = netpayInfo.PayAmount,
CompanyCode = soBaseInfo.CompanyCode //取订单上的CompanyCode
};
//SOIncomeProcessor检查，如果已经存在收款单记录，则不允许创建
return(ObjectFactory <SOIncomeProcessor> .Instance.Create(soIncomeInfo));
}
public void SOIncomeAbandon(int soSysNo)
{
TransactionOptions options = new TransactionOptions();
options.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
options.Timeout = TransactionManager.DefaultTimeout;
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, options))
{
NetPayInfo dbInfo = LoadVerified(soSysNo);
if (dbInfo != null)
{
if (dbInfo.Status != (int)AppEnum.NetPayStatus.Verified)
{
throw new BizException("netpay: not verified, can't abandon");
}
Abandon(dbInfo);
}
scope.Complete();
}
}
public void ManualAbandon(int netpaySysNo)
{
TransactionOptions options = new TransactionOptions();
options.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
options.Timeout = TransactionManager.DefaultTimeout;
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, options))
{
NetPayInfo dbInfo = Load(netpaySysNo);
if (dbInfo.Status != (int)AppEnum.NetPayStatus.Origin)
{
throw new BizException("netpay: not origin, can't abandon");
}
Abandon(dbInfo);
scope.Complete();
}
}
/// <summary>
/// 根据订单编号作废netpay
/// </summary>
/// <param name="soSysNo"></param>
public virtual void AbandonBySOSysNo(int soSysNo)
{
NetPayInfo netpayInfo = GetValidBySOSysNo(soSysNo);
if (netpayInfo != null)
{
TransactionOptions options = new TransactionOptions();
options.IsolationLevel = IsolationLevel.ReadUncommitted;
options.Timeout = TimeSpan.FromMinutes(2);
using (TransactionScope ts = new TransactionScope(TransactionScopeOption.Required, options))
{
m_NetpayDA.AbandonBySOSysNo(soSysNo);
//发送netpay作废Message
EventPublisher.Publish <NetpayAbandonedMessage>(new NetpayAbandonedMessage()
{
NetpaySysNo = netpayInfo.SysNo.Value,
CurrentUserSysNo = ServiceContext.Current.UserSysNo
});
ts.Complete();
}
}
}
/// <summary>
/// 创建NetPay
/// </summary>
/// <param name="netpayEntity">网上支付实体</param>
/// <param name="refundEntity">退款实体</param>
/// <param name="isForceCheck">是否强制核收，如果是强制核收，refundEntity必须要有值</param>
/// <returns>创建好的netpay实体</returns>
public NetPayInfo CreateNetPay(NetPayInfo netpayEntity, SOIncomeRefundInfo refundEntity, bool isForceCheck)
{
return(ObjectFactory <NetPayProcessor> .Instance.Create(netpayEntity, refundEntity, isForceCheck));
}
// public void UnVerify(NetPayInfo oParam)
// {
// TransactionContext ctx =
// TransactionContextFactory.GetContext(TransactionAffinity.Required);
// try
// {
// ctx.Enter();
//
// NetPayInfo dbInfo = Load(oParam.SysNo);
// if ( dbInfo.Status != (int)AppEnum.NetPayStatus.Verified)
// throw new BizException("netpay: not verified, can't cancel verify");
//
// oParam.Status = (int)AppEnum.NetPayStatus.Origin;
//
// Hashtable ht = new Hashtable(5);
// ht.Add("SysNo", oParam.SysNo);
// ht.Add("ApproveUserSysNo", oParam.ApproveUserSysNo);
// ht.Add("ApproveTime", oParam.ApproveTime);
// ht.Add("Status", oParam.Status);
//
// new NetPayDac().Update(ht);
//
// //???????????????????????
// //SOIncomeManager.GetInstance().Delete((int)AppEnum.SOIncomeOrderType.SO, oParam.SOSysNo);
//
//
// }
// catch(Exception ex)
// {
// ctx.VoteRollback();
// throw ex;
// }
// finally
// {
// ctx.Exit();
// }
// }
public void Import()
{
/* 涉及的问题
* 1 还货记录的处理
* 2 库存的处理
* 3 状态的处理
* 4 还有单据id的对应，这个要特别注意
*/
if (!AppConfig.IsImportable)
{
throw new BizException("Is Importable is false");
}
string sql = " select top 1 sysno from finance_netpay";
DataSet ds = SqlHelper.ExecuteDataSet(sql);
if (Util.HasMoreRow(ds))
{
throw new BizException("the table finance_netpay is not empty");
}
TransactionOptions options = new TransactionOptions();
options.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
options.Timeout = TransactionManager.DefaultTimeout;
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, options))
{
//因为原来没有inputuser，所以用1
string sql_old = @"select
a.sosysno, a.payamount,
a.source, a.inputtime,
con_paytype.newsysno as paytypesysno,
con_user.newsysno as approveUserSysno,
a.approveTime,
a.note,
a.status,
'1' as inputusersysno,
'1' as sysno
from
ipp2003..net_pay as a,
ippconvert..paytype as con_paytype,
ippconvert..sys_user as con_user
where
a.paytypesysno = con_paytype.oldsysno
and a.approveusersysno *= con_user.oldsysno
--and status <>-1
order by sosysno, a.status desc" ;
DataSet ds_old = SqlHelper.ExecuteDataSet(sql_old);
if (!Util.HasMoreRow(ds_old))
{
return;
}
//int currentSoSysNo = AppConst.IntNull;
foreach (DataRow dr in ds_old.Tables[0].Rows)
{
/* oldstatus
* -1 deleted
* 0 origin
* 1 aduited
*
* oldsource
* 0 bank insert
* 1 employee insert
* 导数据的规则是：只插入遇到相同的sosysno的第一个
*/
NetPayInfo oNetPay = new NetPayInfo();
map(oNetPay, dr);
// if ( currenSoSysNo != oNetPay.SOSysNo )
// {
// currenSoSysNo = oNetPay.SOSysNo;
// this.Insert(oNetPay);
// }
this.Insert(oNetPay);
}
scope.Complete();
}
}
