def SubModuleDoFst():
AfaLoggerFunc.tradeInfo( '***农信银系统: 往账.本地类操作交易[RCC001_8569]进入***' )
#=====判断输入接口值是否存在====
if(not TradeContext.existVariable("STRDAT")):
return AfaFlowControl.ExitThisFlow('A099', '起始日期[STRDAT]不存在')
if(not TradeContext.existVariable("ENDDAT")):
return AfaFlowControl.ExitThisFlow('A099', '结束日期[ENDDAT]不存在')
if TradeContext.ENDDAT > AfaUtilTools.GetHostDate():
return AfaFlowControl.ExitThisFlow('S999', '结束日期必须在当前日期之前')
#=====获取主机日期==================
TradeContext.BJEDTE=AfaUtilTools.GetHostDate( )
#===========生成行内记账文件====================
#===========文件格式===========================
#交易日期|起始日期|终止日期|交易机构号|往来标志|收费总金额|汇兑类笔数|汇兑类总金额|汇票类笔数|汇票类总金额|
#通存通兑类笔数|通存通兑类总金额|信息类笔数|信息类总金额|记录状态|备用字段 1|备用字段 2|备用字段 3|备用字段 4
file_path = os.environ['AFAP_HOME'] + "/data/rccps/host/"
file_name = 'rccsxfile' + TradeContext.BJEDTE
TradeContext.OCCAMT = 0 #总金额
TradeContext.CONT = 0 #总笔数
rb = open(file_path + file_name,'w')
sqlStr = "select distinct NCCWKDAT,BESBNO from rcc_trcsta "
sqlStr = sqlStr + "where NCCWKDAT >= '" + TradeContext.STRDAT + "' and NCCWKDAT <= '" + TradeContext.ENDDAT + "'"
sqlStr = sqlStr + "and BRSFLG = '" + PL_BRSFLG_SND + "' order by NCCWKDAT,BESBNO"
AfaLoggerFunc.tradeInfo(sqlStr)
records = AfaDBFunc.SelectSql(sqlStr)
if (records == None):
return AfaFlowControl.ExitThisFlow('A099', '查询[RCC_NCCWKDAT]表异常')
else:
for i in range(len(records)):
sqlStr_1 = "select t.TRCCO,t.ts,t.ts*double(t1.BPADAT) from("
sqlStr_1 = sqlStr_1 + "select TRCCO,sum(TCNT) ts from rcc_trcsta"
sqlStr_1 = sqlStr_1 + " where NCCWKDAT = '" + records[i][0] + "' and BESBNO = '" + records[i][1] + "'"
sqlStr_1 = sqlStr_1 + " group by TRCCO"
sqlStr_1 = sqlStr_1 + ") t,RCC_PAMTBL t1 where t.TRCCO = t1.BPARAD and double(t1.BPADAT) > 0"
AfaLoggerFunc.tradeDebug(sqlStr_1)
res = AfaDBFunc.SelectSql(sqlStr_1)
if (res == None):
return AfaFlowControl.ExitThisFlow('A099', '查询[RCC_NCCWKDAT]表异常')
amount20 = 0
sum20 = 0
amount21 = 0
sum21 = 0
amount30 = 0
sum30 = 0
amount99 = 0
sum99 = 0
AfaLoggerFunc.tradeInfo(res)
for j in range(len(res)):
if(len(res[j][0]) < 7):
return AfaFlowControl.ExitThisFlow('A099', '[RCC_PAMTBL]表交易代码[' + res[j][0] + ']异常')
elif((res[j][0])[:2] == '20'):
amount20 = amount20 + float(res[j][2])
sum20 = sum20 + int(res[j][1])
elif((res[j][0])[:2] == '21'):
amount21 = amount21 + float(res[j][2])
sum21 = sum21 + int(res[j][1])
elif((res[j][0])[:2] == '30'):
amount30 = amount30 + float(res[j][2])
sum30 = sum30 + int(res[j][1])
elif((res[j][0])[:2] == '99'):
amount99 = amount99 + float(res[j][2])
sum99 = sum99 + int(res[j][1])
Amount = amount20 + amount21 + amount30 + amount99
#=====如果总金额不大于零，则进入下次循环=================
if(Amount <= 0):
continue
TradeContext.OCCAMT = TradeContext.OCCAMT + Amount
TradeContext.CONT = TradeContext.CONT + 1
lines = ""
lines = lines + str(records[i][0]).strip().ljust(8, ' ') + "|"
lines = lines + str(TradeContext.STRDAT).strip().ljust(8, ' ') + "|"
lines = lines + str(TradeContext.ENDDAT).strip().ljust(8, ' ') + "|"
lines = lines + str(records[i][1]).strip().ljust(10,' ') + "|"
lines = lines + str(Amount).strip().ljust(15,' ') + "|"
lines = lines + str(sum20).strip().ljust(8,' ') + "|"
lines = lines + str(amount20).strip().ljust(15,' ') + "|"
lines = lines + str(sum21).strip().ljust(8,' ') + "|"
lines = lines + str(amount21).strip().ljust(15,' ') + "|"
lines = lines + str(sum30).strip().ljust(8,' ') + "|"
lines = lines + str(amount30).strip().ljust(15,' ') + "|"
lines = lines + str(sum99).strip().ljust(8,' ') + "|"
lines = lines + str(amount99).strip().ljust(15,' ') + "|"
lines = lines + str('0').ljust(1,' ') + "|"
lines = lines + str('').ljust(62,' ') + "|"
lines = lines + str('').ljust(62,' ') + "|"
lines = lines + str('').ljust(62,' ') + "|"
lines = lines + str('').ljust(62,' ') + "|"
rb.write(lines + "\n")
rb.close()
#===========文件转换============================
AfaLoggerFunc.tradeInfo('>>>文件转换')
sFileName = file_name
dFileName = 'RCCSXFILE.SX'+ TradeContext.BJEDTE
fldName = 'nxsxa.fld'
if( not rccpsCronFunc.FormatFile('1', fldName, sFileName, dFileName)):
return AfaFlowControl.ExitThisFlow('A099', '转换主机对账文件编码异常')
#===========上传记账文件========================
AfaLoggerFunc.tradeInfo('>>>上传记账文件')
if( not rccpsFtpFunc.putHost(dFileName)):
return AfaFlowControl.ExitThisFlow('A099', '上传记账文件异常')
AfaLoggerFunc.tradeInfo('>>>触发主机接口')
#===========发送主机交易===========================
TradeContext.HostCode = '8823' #交易码
TradeContext.OCCAMT = str(TradeContext.OCCAMT)
AfaLoggerFunc.tradeInfo('>>>扣收金额'+ str(TradeContext.OCCAMT))
TradeContext.fileName = 'SX' + TradeContext.BJEDTE #文件名
rccpsHostFunc.CommHost( TradeContext.HostCode )
AfaLoggerFunc.tradeInfo("主机返回码[" + TradeContext.errorCode + "],主机返回信息[" + TradeContext.errorMsg +"]")
if TradeContext.errorCode != '0000':
return AfaFlowControl.ExitThisFlow(TradeContext.errorCode, TradeContext.errorMsg)
TradeContext.errorCode = '0000'
TradeContext.errorMsg = '成功'
AfaLoggerFunc.tradeInfo( '***农信银系统: 往账.本地类操作交易[RCC001_8569]退出***' )
return True
def SubModuleDoFst():
AfaLoggerFunc.tradeInfo( '***农信银系统：来账.中心类操作(1.本地操作).折通兑来帐请求报文接收[TRCC006_1140]进入***' )
#初始化返回码
TradeContext.PRCCO = 'RCCI0000'
TradeContext.STRINFO = "成功"
#判断是否重复报文
AfaLoggerFunc.tradeInfo(">>>开始判断是否重复报文")
sel_dict = {'COTRCNO':TradeContext.TRCNO,'COTRCDAT':TradeContext.TRCDAT,'SNDBNKCO':TradeContext.SNDBNKCO}
record = rccpsDBTrcc_wtrbka.selectu(sel_dict)
if record == None:
AfaLoggerFunc.tradeDebug('>>>判断是否重复扣款确认报文,查询通存通兑业务登记簿相同报文异常')
TradeContext.PRCCO = "NN1ID999"
TradeContext.STRINFO = "数据库其他错误"
elif len(record) > 0:
AfaLoggerFunc.tradeInfo('通存通兑业务登记簿中存在相同数据,重复报文,返回拒绝应答报文')
TradeContext.PRCCO = 'NN1ISO999'
TradeContext.STRINFO = "重复报文"
AfaLoggerFunc.tradeInfo(">>>结束判断是否重复报文")
#登记通存通兑登记簿
AfaLoggerFunc.tradeInfo(">>>开始登记通存通兑业务登记簿")
#=====币种转换====
if TradeContext.CUR == 'CNY':
TradeContext.CUR = '01'
#=====手续费收取方式=====
if float(TradeContext.CUSCHRG) > 0.001:
TradeContext.CHRGTYP = '1'
else:
TradeContext.CHRGTYP = '0'
#====开始向字典赋值====
if TradeContext.PRCCO == 'RCCI0000':
wtrbka_dict = {}
if not rccpsMap1140CTradeContext2Dwtrbka_dict.map(wtrbka_dict):
AfaLoggerFunc.tradeDebug('>>>字典赋值出错')
TradeContext.PRCCO = "NN1ID999"
TradeContext.STRINFO = "数据库其他错误"
wtrbka_dict['DCFLG'] = PL_DCFLG_DEB #借贷标识
wtrbka_dict['OPRNO'] = PL_TDOPRNO_TD #业务种类
#=====开始插入数据库====
if TradeContext.PRCCO == 'RCCI0000':
if not rccpsDBFunc.insTransWtr(wtrbka_dict):
AfaLoggerFunc.tradeDebug('>>>登记通存通兑业务登记簿异常')
TradeContext.PRCCO = "NN1ID999"
TradeContext.STRINFO = "数据库其他错误"
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
TradeContext.PRCCO = "NN1ID999"
TradeContext.STRINFO = "数据库其他错误"
AfaLoggerFunc.tradeInfo(">>>结束登记通存通兑业务登记簿")
#设置业务状态为行内收妥成功
AfaLoggerFunc.tradeInfo(">>>开始设置业务状态为收妥成功")
stat_dict = {}
stat_dict['BSPSQN'] = TradeContext.BSPSQN
stat_dict['BJEDTE'] = TradeContext.BJEDTE
stat_dict['BCSTAT'] = PL_BCSTAT_BNKRCV
stat_dict['BDWFLG'] = PL_BDWFLG_SUCC
if TradeContext.PRCCO == 'RCCI0000':
if not rccpsState.setTransState(stat_dict):
AfaLoggerFunc.tradeDebug('>>>设置业务状态收妥成功异常')
TradeContext.PRCCO = "NN1ID999"
TradeContext.STRINFO = "数据库其他错误"
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
TradeContext.PRCCO = "NN1ID999"
TradeContext.STRINFO = "数据库其他错误"
AfaLoggerFunc.tradeInfo(">>>结束设置业务状态为收妥成功")
#设置业务状态为自动扣款处理中
AfaLoggerFunc.tradeInfo(">>>开始设置业务状态为自动扣款处理中")
if TradeContext.PRCCO == 'RCCI0000':
if not rccpsState.newTransState(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_AUTOPAY,PL_BDWFLG_WAIT):
AfaLoggerFunc.tradeDebug('>>>设置业务状态为自动扣款处理中异常')
TradeContext.PRCCO = "NN1ID999"
TradeContext.STRINFO = "数据库其他错误"
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
TradeContext.PRCCO = "NN1ID999"
TradeContext.STRINFO = "数据库其他错误"
AfaLoggerFunc.tradeInfo(">>>开始设置业务状态为自动扣款处理中")
TradeContext.BCSTAT = PL_BCSTAT_AUTOPAY #状态:自动扣款
TradeContext.BCSTATNM = "自动扣款"
#进行必要性检查,若校验通过,则返回成功应答报文,若校验未通过,则返回拒绝应答报文
AfaLoggerFunc.tradeInfo(">>>开始必要性检查")
#检查冲正登记簿中是否有此笔业务的冲正业务,存在则返回拒绝应答报文,并设置业务状态为冲正处理中
if TradeContext.PRCCO == 'RCCI0000':
atcbka_where_dict = {}
atcbka_where_dict['ORMFN'] = TradeContext.MSGFLGNO
atcbka_dict = rccpsDBTrcc_atcbka.selectu(atcbka_where_dict)
if atcbka_dict == None:
AfaLoggerFunc.tradeInfo(">>>查询冲正登记簿异常")
TradeContext.PRCCO = 'NN1ID999'
TradeContext.STRINFO = "查询冲正登记簿异常"
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
else:
if len(atcbka_dict) <= 0:
AfaLoggerFunc.tradeInfo(">>>此交易未被冲正,继续校验")
else:
AfaLoggerFunc.tradeInfo(">>>此交易已被冲正,返回拒绝应答报文")
TradeContext.PRCCO = 'NN1IO307'
TradeContext.STRINFO = "此交易已被冲正"
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
#解密客户密码
if TradeContext.PRCCO == 'RCCI0000':
MIMA = ' '
PIN = TradeContext.CURPIN
ACC = TradeContext.PYRACC
AfaLoggerFunc.tradeDebug('密码[' + PIN + ']')
AfaLoggerFunc.tradeDebug('账号[' + ACC + ']')
ret = jiami.secDecryptPin(PIN,ACC,MIMA)
if ret != 0:
AfaLoggerFunc.tradeDebug("ret=[" + str(ret) + "]")
AfaLoggerFunc.tradeDebug('调用加密服务器失败')
TradeContext.PRCCO = 'NN1IS999'
TradeContext.STRINFO = "解密密码失败"
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
else:
TradeContext.CURPIN = MIMA
AfaLoggerFunc.tradeDebug('密码new[' + TradeContext.CURPIN + ']')
#唐斌新增#
sql = "SELECT ischkactname,ischklate FROM rcc_chlabt where transcode='"+TradeContext.TransCode+"' and channelno= '"+(TradeContext.SNDCLKNO)[6:8]+"'"
AfaLoggerFunc.tradeInfo(sql)
records = AfaDBFunc.SelectSql( sql)
if (records == None):
return False
elif (len(records) == 0):
AfaLoggerFunc.tradeDebug("查询结果为空,查询条件[" + sql + "]")
return False
AfaLoggerFunc.tradeDebug(str(records))
#校验账户状态是否正常和账号户名是否相符
if TradeContext.PRCCO == 'RCCI0000':
#调用主机接口查询账户信息
TradeContext.HostCode = '8810'
TradeContext.ACCNO = TradeContext.PYRACC
AfaLoggerFunc.tradeDebug("gbj test :" + TradeContext.ACCNO)
rccpsHostFunc.CommHost( TradeContext.HostCode )
if TradeContext.errorCode != '0000':
#return AfaFlowControl.ExitThisFlow(TradeContext.errorCode,TradeContext.errorMsg)
AfaLoggerFunc.tradeInfo("查询账户信息异常,主机返回码[" + TradeContext.errorCode + "],主机返回信息[" + TradeContext.errorMsg +"]")
#TradeContext.PRCCO = 'NN1IA999'
TradeContext.PRCCO = rccpsDBFunc.HostErr2RccErr(TradeContext.errorCode)
TradeContext.STRINFO = TradeContext.errorMsg
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
else:
#查询成功,更新通存通兑登记簿账务机构号
AfaLoggerFunc.tradeInfo(">>>查询主机账户成功")
#if( TradeContext.BESBNO != PL_BESBNO_BCLRSB ):
# AfaLoggerFunc.tradeInfo(">>>" + TradeContext.BESBNO + ">>>" + TradeContext.ACCSO)
# if( TradeContext.BESBNO[:6] != TradeContext.ACCSO[:6] ):
# AfaLoggerFunc.tradeInfo(">>>不许跨法人做此交易")
# TradeContext.PRCCO = 'NN1IO999'
# TradeContext.STRINFO = "接收行与账户开户行不属于同一法人"
# TradeContext.BCSTAT = PL_BCSTAT_MFERFE
# TradeContext.BCSTATNM = "拒绝"
#检查本机构是否有通存通兑业务权限
if not rccpsDBFunc.chkTDBESAuth(TradeContext.ACCSO):
TradeContext.PRCCO = 'NN1IO999'
TradeContext.STRINFO = "本账户开户机构无通存通兑业务权限"
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
AfaLoggerFunc.tradeInfo(">>>开始更新机构号为开户机构")
TradeContext.BESBNO = TradeContext.ACCSO
wtrbka_update_dict = {'BESBNO':TradeContext.ACCSO}
wtrbka_where_dict = {'BJEDTE':TradeContext.BJEDTE,'BSPSQN':TradeContext.BSPSQN}
ret = rccpsDBTrcc_wtrbka.updateCmt(wtrbka_update_dict,wtrbka_where_dict)
if ret <= 0:
AfaLoggerFunc.tradeInfo(">>>更新机构号为开户机构异常")
TradeContext.PRCCO = 'NN1ID006'
TradeContext.STRINFO = "更新账务机构号异常"
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
else:
AfaLoggerFunc.tradeInfo(">>>更新机构号为开户机构成功")
AfaLoggerFunc.tradeDebug("主机返回户名ACCNM :[" + TradeContext.ACCNM + "]")
AfaLoggerFunc.tradeDebug("报文接收户名PYRNAM:[" + TradeContext.PYRNAM + "]")
AfaLoggerFunc.tradeDebug("主机返回账户状态ACCST:[" + TradeContext.ACCST + "]")
AfaLoggerFunc.tradeDebug("证件类型ACITY:[" + TradeContext.ACITY + "]")
AfaLoggerFunc.tradeDebug("证件号码ACINO:[" + TradeContext.ACINO + "]")
if TradeContext.ACCNM != TradeContext.PYRNAM:
#唐斌新增#
if(records[0][0]=='1'):
AfaLoggerFunc.tradeInfo(">>>账号户名不符")
TradeContext.PRCCO = 'NN1IA102'
TradeContext.STRINFO = '账号户名不符'
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
elif TradeContext.ACCST != '0' and TradeContext.ACCST != '2':
AfaLoggerFunc.tradeInfo(">>>账户状态不正常")
TradeContext.PRCCO = 'NN1IA999'
TradeContext.STRINFO = '账户状态不正常'
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
elif not (TradeContext.ACCCD == '0428' and TradeContext.ACCEM == '21111'):
AfaLoggerFunc.tradeInfo(">>>此账户非个人结算户")
TradeContext.PRCCO = 'NN1IA999'
TradeContext.STRINFO = '此账户非个人结算户'
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
#=====交易金额判断====
chk_dict = {}
chk_dict['BPARAD'] = 'TD001' #通存通兑凭证金额校验
dict = rccpsDBTrcc_pamtbl.selectu(chk_dict)
AfaLoggerFunc.tradeInfo('dict='+str(dict))
if dict == None:
AfaLoggerFunc.tradeInfo(">>>校验交易金额失败")
TradeContext.PRCCO = 'NN1ID003'
TradeContext.STRINFO = '校验交易金额失败'
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
if len(dict) == 0:
AfaLoggerFunc.tradeInfo(">>>查询PAMTBL校验交易金额表记录错误")
TradeContext.PRCCO = 'NN1ID010'
TradeContext.STRINFO = '查询PAMTBL校验交易金额表记录错误'
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
#=====判断农信银中心规定校验凭证上线====
if float(TradeContext.OCCAMT) > float(dict['BPADAT']):
#=====交易金额大于农信银中心规定金额，需要输入证件====
if TradeContext.existVariable('CERTTYPE') and len(TradeContext.CERTTYPE) == 0:
AfaLoggerFunc.tradeInfo(">>>请选择证件类型")
TradeContext.PRCCO = 'NN1IA999'
TradeContext.STRINFO = '请选择证件类型'
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
elif(TradeContext.CERTTYPE == '06'):
if( TradeContext.ACITY != '06' and TradeContext.ACITY != '07' and TradeContext.ACITY != '08' and TradeContext.ACITY != '09'):
AfaLoggerFunc.tradeInfo(">>>证件类型错误")
TradeContext.PRCCO = 'NN1IA999'
TradeContext.STRINFO = '证件类型错误'
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
elif( TradeContext.CERTTYPE != TradeContext.ACITY ):
AfaLoggerFunc.tradeInfo(">>>证件类型错误")
TradeContext.PRCCO = 'NN1IA999'
TradeContext.STRINFO = '证件类型错误'
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
if TradeContext.existVariable('CERTNO') and len(TradeContext.CERTNO) == 0:
AfaLoggerFunc.tradeInfo(">>>请输入证件号码")
TradeContext.PRCCO = 'NN1IA999'
TradeContext.STRINFO = '请输入证件号码'
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
elif( TradeContext.CERTNO != TradeContext.ACINO ):
AfaLoggerFunc.tradeInfo(">>>证件号码错误")
TradeContext.PRCCO = 'NN1IA999'
TradeContext.STRINFO = '证件号码错误'
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
#校验交易金额是否超当日限额
if not rccpsDBFunc.chkLimited(TradeContext.BJEDTE,TradeContext.PYRACC,TradeContext.OCCAMT):
AfaLoggerFunc.tradeInfo(">>>交易金额超限")
TradeContext.PRCCO = 'NN1IA999'
TradeContext.STRINFO = '交易金额超限'
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
AfaLoggerFunc.tradeInfo(">>>结束必要性检查")
#发起主机记账
AfaLoggerFunc.tradeInfo(">>>开始发起主机记账")
TradeContext.sCertType = TradeContext.CERTTYPE
TradeContext.sCertNo = TradeContext.CERTNO
TradeContext.sOccamt = TradeContext.OCCAMT
TradeContext.sCuschrg = TradeContext.CUSCHRG
AfaLoggerFunc.tradeInfo(">>>" + TradeContext.PRCCO)
if TradeContext.PRCCO == 'RCCI0000':
TradeContext.HostCode = '8813' #调用8813主机接口
#TradeContext.PASSWD = TradeContext.CURPIN
#来账对方现金收取手续费
if( TradeContext.CHRGTYP != '1' ):
TradeContext.RCCSMCD = PL_RCCSMCD_XJTDLZ #主机摘要代码
TradeContext.SBAC = TradeContext.PYRACC #借方账户:付款人账户
TradeContext.ACNM = TradeContext.PYRNAM #借方户名 付款人户名
TradeContext.RBAC = TradeContext.BESBNO + PL_ACC_NXYDQSLZ #贷方账户:农信银待清算来账
TradeContext.RBAC = rccpsHostFunc.CrtAcc(TradeContext.RBAC, 25)
TradeContext.OTNM = '农信银待清算来账' #贷方户名:
TradeContext.CTFG = '7' #本金 手续费标识 7 本金 8手续费 9 本金＋手续费
TradeContext.PKFG = 'T' #通存通兑标识
TradeContext.WARNTNO = '49' + TradeContext.BNKBKNO
TradeContext.CERTTYPE = ''
TradeContext.CERTNO = ''
TradeContext.PASSWD = TradeContext.CURPIN #密码
AfaLoggerFunc.tradeInfo( '借方账号:' + TradeContext.SBAC )
AfaLoggerFunc.tradeInfo( '贷方账号:' + TradeContext.RBAC )
AfaLoggerFunc.tradeInfo( '凭证号码:' + TradeContext.WARNTNO )
else:
#对方转账收取手续费时s
TradeContext.ACUR = '3' #记账次数
#=========交易金额============
TradeContext.RCCSMCD = PL_RCCSMCD_XJTDLZ #摘要代码
TradeContext.SBAC = TradeContext.PYRACC #借方账号
TradeContext.ACNM = TradeContext.PYRNAM #借方户名
TradeContext.RBAC = TradeContext.BESBNO + PL_ACC_NXYDJLS #贷方账号
TradeContext.RBAC = rccpsHostFunc.CrtAcc(TradeContext.RBAC,25)
TradeContext.OTNM = '待解临时款项' #贷方户名
TradeContext.OCCAMT = str(TradeContext.sOccamt) #发生额
TradeContext.CTFG = '7' #本金 手续费标识 7 本金 8手续费 9 本金＋手续费
TradeContext.PKFG = 'T' #通存通兑标识
TradeContext.WARNTNO = '49' + TradeContext.BNKBKNO
TradeContext.PASSWD = TradeContext.CURPIN #密码
TradeContext.sCertType = TradeContext.CERTTYPE
TradeContext.sCertNo = TradeContext.CERTNO
TradeContext.CERTTYPE = ''
TradeContext.CERTNO = ''
AfaLoggerFunc.tradeInfo( '>>>交易金额:借方账号' + TradeContext.SBAC )
AfaLoggerFunc.tradeInfo( '>>>交易金额:贷方账号' + TradeContext.RBAC )
AfaLoggerFunc.tradeInfo( '凭证号码:' + TradeContext.WARNTNO )
#=========结算手续费收入户===========
TradeContext.I2SMCD = PL_RCCSMCD_SXF #摘要代码
TradeContext.I2SBAC = TradeContext.PYRACC #借方账号
TradeContext.I2ACNM = TradeContext.PYRNAM #借方户名
TradeContext.I2RBAC = TradeContext.BESBNO + PL_ACC_NXYDJLS #贷方账号
TradeContext.I2RBAC = rccpsHostFunc.CrtAcc(TradeContext.I2RBAC,25)
TradeContext.I2OTNM = '待解临时款项' #贷方户名
TradeContext.I2TRAM = str(TradeContext.sCuschrg) #发生额
TradeContext.I2CTFG = '8' #本金 手续费标识 7 本金 8手续费 9 本金＋手续费
TradeContext.I2PKFG = 'T' #通存通兑标识
TradeContext.I2WARNTNO = '49' + TradeContext.BNKBKNO
TradeContext.I2PASSWD = TradeContext.CURPIN #密码
AfaLoggerFunc.tradeInfo( '>>>结算手续费收入户:借方账号' + TradeContext.I2SBAC )
AfaLoggerFunc.tradeInfo( '>>>结算手续费收入户:贷方账号' + TradeContext.I2RBAC )
AfaLoggerFunc.tradeInfo( '凭证号码:' + TradeContext.I2WARNTNO )
#=========交易金额+手续费===================
TradeContext.I3SMCD = PL_RCCSMCD_XJTDLZ #摘要代码
TradeContext.I3SBAC = TradeContext.BESBNO + PL_ACC_NXYDJLS #借方账号
TradeContext.I3SBAC = rccpsHostFunc.CrtAcc(TradeContext.I3SBAC,25)
TradeContext.I3ACNM = '待解临时款项' #借方户名
TradeContext.I3RBAC = TradeContext.BESBNO + PL_ACC_NXYDQSLZ #贷方账号
TradeContext.I3RBAC = rccpsHostFunc.CrtAcc(TradeContext.I3RBAC,25)
TradeContext.I3OTNM = '农信银来账' #贷方户名
TradeContext.I3TRAM = rccpsUtilTools.AddDot(TradeContext.OCCAMT,TradeContext.CUSCHRG) #发生额
TradeContext.I3CTFG = '9' #本金 手续费标识 7 本金 8手续费 9 本金＋手续费
TradeContext.I3PKFG = 'T' #通存通兑标识
AfaLoggerFunc.tradeInfo( '>>>交易金额+手续费:借方账号' + TradeContext.I3SBAC )
AfaLoggerFunc.tradeInfo( '>>>交易金额+手续费:贷方账号' + TradeContext.I3RBAC )
rccpsHostFunc.CommHost( TradeContext.HostCode )
AfaLoggerFunc.tradeInfo(">>>结束发起主机记账")
#TradeContext.errorCode, TradeContext.errorMsg = '0000', '主机成功'
#根据主机返回码,设置业务状态为自动入账成功或失败
AfaLoggerFunc.tradeInfo(">>>开始根据主机放回码,设置业务状态为自动扣款成功或失败")
stat_dict = {}
stat_dict['BJEDTE'] = TradeContext.BJEDTE
stat_dict['BSPSQN'] = TradeContext.BSPSQN
stat_dict['BESBNO'] = TradeContext.BESBNO
stat_dict['BETELR'] = TradeContext.BETELR
stat_dict['SBAC'] = TradeContext.SBAC
stat_dict['ACNM'] = TradeContext.ACNM
stat_dict['RBAC'] = TradeContext.RBAC
stat_dict['OTNM'] = TradeContext.OTNM
#=====modify by pgt 1129====
stat_dict['MGID'] = TradeContext.errorCode
if TradeContext.existVariable('TRDT'):
stat_dict['TRDT'] = TradeContext.TRDT
if TradeContext.existVariable('TLSQ'):
stat_dict['TLSQ'] = TradeContext.TLSQ
stat_dict['STRINFO'] = TradeContext.errorMsg
AfaLoggerFunc.tradeInfo("主机返回码[" + TradeContext.errorCode + "],主机返回信息[" + TradeContext.errorMsg +"]")
if TradeContext.errorCode == '0000':
#=====发送农信银成功,设置状态为自动入账成功====
stat_dict['BCSTAT'] = PL_BCSTAT_AUTOPAY
stat_dict['BDWFLG'] = PL_BDWFLG_SUCC
TradeContext.PRCCO = 'RCCI0000'
TradeContext.STRINFO = '成功'
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999', "设置业务状态为自动入账成功异常")
AfaLoggerFunc.tradeInfo(">>>设置业务状态为自动扣款成功完成")
else:
#=====发送农信银失败,设置状态为拒绝成功====
stat_dict['BCSTAT'] = PL_BCSTAT_MFERFE
stat_dict['BDWFLG'] = PL_BDWFLG_SUCC
#TradeContext.PRCCO = 'NN1CA999'
TradeContext.PRCCO = rccpsDBFunc.HostErr2RccErr(TradeContext.errorCode)
AfaLoggerFunc.tradeInfo(">>>>>>>>>>>>>>>>>>>>" + TradeContext.PRCCO)
TradeContext.STRINFO = TradeContext.errorMsg
if not rccpsState.setTransState(stat_dict):
AfaLoggerFunc.tradeFatal( '设置业务状态为拒绝成功异常' )
TradeContext.PRCCO = "NN1ID999"
TradeContext.STRINFO = "数据库其他错误"
AfaLoggerFunc.tradeInfo(">>>设置业务状态为拒绝成功完成")
else:
stat_dict = {}
stat_dict['BJEDTE'] = TradeContext.BJEDTE
stat_dict['BSPSQN'] = TradeContext.BSPSQN
stat_dict['BESBNO'] = TradeContext.BESBNO
stat_dict['BETELR'] = TradeContext.BETELR
stat_dict['PRCCO'] = TradeContext.PRCCO
stat_dict['STRINFO'] = TradeContext.STRINFO
stat_dict['BCSTAT'] = PL_BCSTAT_MFERFE
stat_dict['BDWFLG'] = PL_BDWFLG_SUCC
if not rccpsState.setTransState(stat_dict):
AfaLoggerFunc.tradeFatal( '设置业务状态为拒绝成功异常' )
TradeContext.PRCCO = "NN1ID999"
TradeContext.STRINFO = "数据库其他错误"
AfaLoggerFunc.tradeInfo(">>>设置业务状态为拒绝成功完成")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
TradeContext.PRCCO = "NN1ID999"
TradeContext.STRINFO = "数据库其他错误"
AfaLoggerFunc.tradeInfo(">>>开始根据主机放回码,设置业务状态为自动入账成功或失败")
#为自动扣款应答报文赋值
TradeContext.sysType = 'rccpst'
TradeContext.MSGTYPCO = 'SET007' #报文类代码
#TradeContext.RCVMBRCO = TradeContext.SNDMBRCO #接收方成员行号
TradeContext.RCVSTLBIN = TradeContext.SNDMBRCO #收款方成员行号
TradeContext.SNDSTLBIN = TradeContext.RCVMBRCO #付款方成员行号
TradeContext.SNDBRHCO = TradeContext.BESBNO #发起行网点号
TradeContext.SNDCLKNO = TradeContext.BETELR #发起行柜员号
TradeContext.SNDTRDAT = TradeContext.BJEDTE #发起行交易日期
TradeContext.SNDTRTIM = TradeContext.BJETIM #发起行交易时间
TradeContext.ORMFN = TradeContext.MSGFLGNO #参考报文标识号
TradeContext.MSGFLGNO = TradeContext.SNDMBRCO + TradeContext.BJEDTE + TradeContext.SerialNo #报文标识号
TradeContext.NCCWKDAT = TradeContext.NCCworkDate #中心工作日期
TradeContext.OPRTYPNO = '30' #业务类型
TradeContext.ROPRTPNO = TradeContext.OPRTYPNO #参考业务类型
TradeContext.TRANTYP = '0' #传输类型
TradeContext.CERTTYPE = TradeContext.sCertType
TradeContext.CERTNO = TradeContext.sCertNo
TradeContext.OCCAMT = TradeContext.sOccamt
TradeContext.CUSCHRG = TradeContext.sCuschrg
TradeContext.CUR = 'CNY' #货币符号
AfaLoggerFunc.tradeInfo( '***农信银系统：来账.中心类操作(1.本地操作).折通兑来帐请求报文接收[TRCC006_1140]退出***' )
return True
def SubModuleDoFst():
AfaLoggerFunc.tradeInfo( '***农信银系统: 往账.本地类操作交易[RCC001_8591]通存通兑错帐处理标识维护进入***' )
AfaLoggerFunc.tradeInfo('个性化处理(本地操作)')
#=====判断接口变量是否存在====
if not TradeContext.existVariable("SNDBNKCO"):
return AfaFlowControl.ExitThisFlow('A099','发送行号不能为空' )
if not TradeContext.existVariable("TRCDAT"):
return AfaFlowControl.ExitThisFlow('A009','委托日期不能为空')
if not TradeContext.existVariable("TRCNO"):
return AfaFlowControl.ExitThisFlow('A009','交易流水号不能为空')
if not TradeContext.existVariable("BJEDTE"):
return AfaFlowControl.ExitThisFlow('A009','报单日期不能为空')
if not TradeContext.existVariable("BSPSQN"):
return AfaFlowControl.ExitThisFlow('A009','报单序号不能为空')
AfaLoggerFunc.tradeInfo('个性化处理结束(本地操作)')
#=====得到nccwkdat====
if not rccpsFunc.GetNCCDate( ) : #NCCworkDate
raise AfaFlowControl.flowException( )
#=====查询错账登记簿====
where_dict = {}
where_dict = {'BJEDTE':TradeContext.BJEDTE,'BSPSQN':TradeContext.BSPSQN,'SNDBNKCO':TradeContext.SNDBNKCO,'TRCDAT':TradeContext.TRCDAT,'TRCNO':TradeContext.TRCNO}
tddzcz_record = rccpsDBTrcc_tddzcz.selectu(where_dict)
if(tddzcz_record == None):
return AfaFlowControl.ExitThisFlow('A009','查询错账登记簿失败')
elif(len(tddzcz_record) == 0):
return AfaFlowControl.ExitThisFlow('A009','查询错账登记簿为空')
else:
AfaLoggerFunc.tradeInfo("查询错账登记簿成功")
#=====查询原业务的信息====
AfaLoggerFunc.tradeInfo('查询原业务信息')
where_dict = {}
where_dict = {'BJEDTE':TradeContext.BJEDTE,'BSPSQN':TradeContext.BSPSQN}
wtrbka_record = rccpsDBTrcc_wtrbka.selectu(where_dict)
if(wtrbka_record == None):
return AfaFlowControl.ExitThisFlow('A009','查询业务登记簿失败')
elif(len(wtrbka_record) == 0):
return AfaFlowControl.ExitThisFlow('A009','查询业务登记簿为空')
else:
AfaLoggerFunc.tradeInfo('查询业务登记簿成功')
#=====查询业务的当前信息====
wtr_dict = {}
if not rccpsDBFunc.getTransWtr(TradeContext.BJEDTE,TradeContext.BSPSQN,wtr_dict):
return AfaFlowControl.ExitThisFlow('A009','查询业务的当前信息失败')
if(wtr_dict['BRSFLG'] == PL_BRSFLG_SND):
sstlog_dict = {}
if not rccpsState.getTransStateSet(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_ACC,PL_BDWFLG_SUCC,sstlog_dict):
return AfaFlowControl.ExitThisFlow('A009','查询业务状态信息失败')
wtr_dict['FEDT'] = sstlog_dict['FEDT']
wtr_dict['RBSQ'] = sstlog_dict['RBSQ']
TradeContext.CLDT = wtr_dict['FEDT']
TradeContext.UNSQ = wtr_dict['RBSQ']
if rccpsGetFunc.GetRBSQ(PL_BRSFLG_SND) == -1 : #RBSQ
return AfaFlowControl.ExitThisFlow('A099','产生前置流水号失败')
TradeContext.FEDT=AfaUtilTools.GetHostDate( ) #FEDT
#=====判断当前业务是否已经结转====
if(wtr_dict['BCSTAT'] == PL_BCSTAT_TRAS and wtr_dict['BDWFLG'] == PL_BDWFLG_SUCC):
return AfaFlowControl.ExitThisFlow('A009','该账务已经结转')
#=====判断业务的往来标示====
AfaLoggerFunc.tradeInfo('<<<<<<判断业务的往来标示')
if(wtrbka_record['BRSFLG'] == PL_BRSFLG_SND):
AfaLoggerFunc.tradeInfo('<<<<<<业务为往账')
acc = 0
hcac = 0
canc = 0
cancel = 0
#=====查询是否有记账成功的状态====
sstlog_list = []
if rccpsState.getTransStateSetm(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_ACC,PL_BDWFLG_SUCC,sstlog_list):
acc = len(sstlog_list)
#=====查询是否有抹账的状态====
sstlog_list = []
if rccpsState.getTransStateSetm(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_HCAC,PL_BDWFLG_SUCC,sstlog_list):
hcac = len(sstlog_list)
#=====查询是否有冲销的状态====
sstlog_list = []
if rccpsState.getTransStateSetm(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_CANC,PL_BDWFLG_SUCC,sstlog_list):
canc = len(sstlog_list)
#=====查询是否有冲正的状态====
ssltog_list = []
if rccpsState.getTransStateSetm(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_CANCEL,PL_BDWFLG_SUCC,sstlog_list):
cancel = len(sstlog_list)
#=====判断是否需要清算状态调整====
AfaLoggerFunc.tradeInfo('<<<<<<判断是否需要清算状态调整')
if(acc - (hcac + canc + cancel) >= 0):
AfaLoggerFunc.tradeInfo('<<<<<<需要进行清算状态调整')
TradeContext.BETELR = PL_BETELR_AUTO
TradeContext.BRSFLG = wtrbka_record['BRSFLG']
TradeContext.CHRGTYP = wtrbka_record['CHRGTYP']
TradeContext.BESBNO = wtrbka_record['BESBNO']
#=====卡折存现/本转异地====
if(wtrbka_record['TRCCO'] in ('3000002','3000003','3000004','3000005')):
AfaLoggerFunc.tradeInfo('卡折存现/本转异地')
TradeContext.HostCode = '8813'
TradeContext.ACUR = '1'
TradeContext.RCCSMCD = PL_RCCSMCD_DZBJ
TradeContext.SBAC = wtrbka_record['BESBNO'] + PL_ACC_NXYDQSWZ #借方账号
TradeContext.SBAC = rccpsHostFunc.CrtAcc(TradeContext.SBAC,25)
TradeContext.ACNM = '农信银待清算往账' #借方户名
TradeContext.RBAC = wtrbka_record['BESBNO'] + PL_ACC_NXYWZ #贷方账号
TradeContext.RBAC = rccpsHostFunc.CrtAcc(TradeContext.RBAC,25)
TradeContext.OTNM = '农信银往账' #贷方户名
TradeContext.OCCAMT = str(wtrbka_record['OCCAMT']) #发生额
TradeContext.PKFG = 'W'
TradeContext.CTFG = '7'
#=====卡折取现/异地转本地====
elif(wtrbka_record['TRCCO'] in ('3000102','3000103','3000104','3000105')):
AfaLoggerFunc.tradeInfo('卡折取现/异地转本地')
if(wtrbka_record['CHRGTYP'] == '1'): #转收
AfaLoggerFunc.tradeInfo("<<<<<转收手续费")
TradeContext.HostCode = '8813'
TradeContext.ACUR = '1'
TradeContext.RCCSMCD = PL_RCCSMCD_DZBJ
TradeContext.SBAC = wtrbka_record['BESBNO'] + PL_ACC_NXYWZ #借方账号
TradeContext.SBAC = rccpsHostFunc.CrtAcc(TradeContext.SBAC,25)
TradeContext.ACNM = '农信银往账'
TradeContext.RBAC = wtrbka_record['BESBNO'] + PL_ACC_NXYDQSWZ #贷方账号
TradeContext.RBAC = rccpsHostFunc.CrtAcc(TradeContext.RBAC,25)
TradeContext.OTNM = '农信银待清算往账'
TradeContext.OCCAMT = str(wtrbka_record['OCCAMT'] + wtrbka_record['CUSCHRG'])
TradeContext.PKFG = 'W'
TradeContext.CTFG = '9'
else: #现收
AfaLoggerFunc.tradeInfo("<<<<<现收手续费，或不收")
TradeContext.HostCode = '8813'
TradeContext.ACUR = '1'
TradeContext.RCCSMCD = PL_RCCSMCD_DZBJ
TradeContext.SBAC = wtrbka_record['BESBNO'] + PL_ACC_NXYWZ #借方账号
TradeContext.SBAC = rccpsHostFunc.CrtAcc(TradeContext.SBAC,25)
TradeContext.ACNM = '农信银往账'
TradeContext.RBAC = wtrbka_record['BESBNO'] + PL_ACC_NXYDQSWZ #贷方账号
TradeContext.RBAC = rccpsHostFunc.CrtAcc(TradeContext.RBAC,25)
TradeContext.OTNM = '农信银待清算往账'
TradeContext.OCCAMT = str(wtrbka_record['OCCAMT'])
TradeContext.PKFG = 'W'
TradeContext.CTFG = '9'
else:
return AfaFlowControl.ExitThisFlow('A099','原交易交易代码非法')
#=====增加原交易的状态--结转====
if not rccpsState.newTransState(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_TRAS,PL_BDWFLG_WAIT):
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow('A099','增加原交易的状态--结转，失败')
else:
AfaDBFunc.CommitSql()
#=====调用主机交易====
rccpsHostFunc.CommHost( TradeContext.HostCode )
#=====判断主机交易是否成功====
if(TradeContext.errorCode != '0000'):
AfaLoggerFunc.tradeInfo("主机交易失败")
#=====更改原交易状态====
state_dict = {'BJEDTE':TradeContext.BJEDTE,'BSPSQN':TradeContext.BSPSQN,'BCSTAT':PL_BCSTAT_TRAS,'BDWFLG':PL_BDWFLG_FAIL}
state_dict['STRINFO'] = TradeContext.errorMsg
if not rccpsState.setTransState(state_dict):
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow('A099','更改原交易状态失败')
else:
AfaDBFunc.CommitSql()
return AfaFlowControl.ExitThisFlow('A099','主机记账失败')
else:
AfaLoggerFunc.tradeInfo('主机记账成功')
#=====更改原交易状态====
state_dict = {}
state_dict['BJEDTE'] = TradeContext.BJEDTE
state_dict['BSPSQN'] = TradeContext.BSPSQN
state_dict['BCSTAT'] = PL_BCSTAT_TRAS
state_dict['BDWFLG'] = PL_BDWFLG_SUCC
if(TradeContext.existVariable("SBAC")):
state_dict['SBAC'] = TradeContext.SBAC
if(TradeContext.existVariable("RBAC")):
state_dict['RBAC'] = TradeContext.RBAC
state_dict['STRINFO'] = '主机成功'
if(TradeContext.existVariable('TRDT')):
state_dict['TRDT'] = TradeContext.TRDT
if(TradeContext.existVariable('TLSQ')):
state_dict['TLSQ'] = TradeContext.TLSQ
if not rccpsState.setTransState(state_dict):
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow('A099','更改原交易状态失败')
else:
AfaDBFunc.CommitSql()
else:
return AfaFlowControl.ExitThisFlow('A009','原交易不能进行清算调整')
else:
AfaLoggerFunc.tradeInfo('<<<<<<业务为来账')
autopay = 0
auto = 0
hcac = 0
canc = 0
cancel = 0
#=====查询是否有记账成功的状态====
sstlog_list = []
if rccpsState.getTransStateSetm(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_AUTO,PL_BDWFLG_SUCC,sstlog_list):
auto = len(sstlog_list)
sstlog_list = []
if rccpsState.getTransStateSetm(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_AUTOPAY,PL_BDWFLG_SUCC,sstlog_list):
autopay = len(sstlog_list)
#=====查询是否有抹账的状态====
sstlog_list = []
if rccpsState.getTransStateSetm(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_HCAC,PL_BDWFLG_SUCC,sstlog_list):
hcac = len(sstlog_list)
#=====查询是否有冲销的状态====
sstlog_list = []
if rccpsState.getTransStateSetm(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_CANC,PL_BDWFLG_SUCC,sstlog_list):
canc = len(sstlog_list)
#=====查询是否有冲正的状态====
ssltog_list = []
if rccpsState.getTransStateSetm(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_CANCEL,PL_BDWFLG_SUCC,sstlog_list):
cancel = len(sstlog_list)
#=====判断原业务是否需要进行清算状态调整====
AfaLoggerFunc.tradeInfo("判断原业务是否需要进行清算状态调整")
if((auto + autopay) - (hcac + canc + cancel) >= 0):
AfaLoggerFunc.tradeInfo("原业务需要进行清算状态调整")
TradeContext.BETELR = PL_BETELR_AUTO
TradeContext.BRSFLG = wtrbka_record['BRSFLG']
TradeContext.CHRGTYP = wtrbka_record['CHRGTYP']
TradeContext.BESBNO = wtrbka_record['BESBNO']
#=====卡折存现/本转异地====
if(wtrbka_record['TRCCO'] in ('3000002','3000003','3000004','3000005')):
AfaLoggerFunc.tradeInfo('卡折存现/本转异地')
TradeContext.HostCode = '8813'
TradeContext.ACUR = '1'
TradeContext.RCCSMCD = PL_RCCSMCD_DZBJ
TradeContext.SBAC = wtrbka_record['BESBNO'] + PL_ACC_NXYLZ
TradeContext.SBAC = rccpsHostFunc.CrtAcc(TradeContext.SBAC,25)
TradeContext.ACNM = '农信银来账'
TradeContext.RBAC = wtrbka_record['BESBNO'] + PL_ACC_NXYDQSLZ
TradeContext.RBAC = rccpsHostFunc.CrtAcc(TradeContext.RBAC,25)
TradeContext.OTNM = '农信银待清算来账'
TradeContext.OCCAMT = str(wtrbka_record['OCCAMT'])
TradeContext.PKFG = 'W'
TradeContext.CTFG = '7'
#=====卡折取现/异地转本地====
elif(wtrbka_record['TRCCO'] in ('3000102','3000103','3000104','3000105')):
AfaLoggerFunc.tradeInfo('卡折存现/本转异地')
TradeContext.HostCode = '8813'
TradeContext.ACUR = '1'
TradeContext.RCCSMCD = PL_RCCSMCD_DZBJ
TradeContext.SBAC = wtrbka_record['BESBNO'] + PL_ACC_NXYDQSLZ
TradeContext.SBAC = rccpsHostFunc.CrtAcc(TradeContext.SBAC,25)
TradeContext.ACNM = '农信银待清算来账'
TradeContext.RBAC = wtrbka_record['BESBNO'] + PL_ACC_NXYLZ
TradeContext.RBAC = rccpsHostFunc.CrtAcc(TradeContext.RBAC,25)
TradeContext.OTNM = '农信银来账'
TradeContext.OCCAMT = str(wtrbka_record['OCCAMT'] + wtrbka_record['CUSCHRG'])
TradeContext.PKFG = 'W'
TradeContext.CTFG = '9'
else:
return AfaFlowControl.ExitThisFlow('A099','原交易交易代码非法')
#=====增加原交易的状态--结转====
if not rccpsState.newTransState(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_TRAS,PL_BDWFLG_WAIT):
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow('A099','增加原交易的状态--结转，失败')
else:
AfaDBFunc.CommitSql()
#=====调用主机交易====
rccpsHostFunc.CommHost( TradeContext.HostCode )
#=====判断主机交易是否成功====
if(TradeContext.errorCode != '0000'):
AfaLoggerFunc.tradeInfo("主机交易失败")
#=====更改原交易状态====
state_dict = {'BJEDTE':TradeContext.BJEDTE,'BSPSQN':TradeContext.BSPSQN,'BCSTAT':PL_BCSTAT_TRAS,'BDWFLG':PL_BDWFLG_FAIL}
state_dict['STRINFO'] = TradeContext.errorMsg
if not rccpsState.setTransState(state_dict):
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow('A099','更改原交易状态失败')
else:
AfaDBFunc.CommitSql()
return AfaFlowControl.ExitThisFlow('A099','主机记账失败')
else:
AfaLoggerFunc.tradeInfo('主机记账成功')
#=====更改原交易状态====
state_dict = {}
state_dict['BJEDTE'] = TradeContext.BJEDTE
state_dict['BSPSQN'] = TradeContext.BSPSQN
state_dict['BCSTAT'] = PL_BCSTAT_TRAS
state_dict['BDWFLG'] = PL_BDWFLG_SUCC
state_dict['STRINFO'] = '主机成功'
if(TradeContext.existVariable("SBAC")):
state_dict['SBAC'] = TradeContext.SBAC
if(TradeContext.existVariable("RBAC")):
state_dict['RBAC'] = TradeContext.RBAC
if(TradeContext.existVariable('TRDT')):
state_dict['TRDT'] = TradeContext.TRDT
if(TradeContext.existVariable('TLSQ')):
state_dict['TLSQ'] = TradeContext.TLSQ
if not rccpsState.setTransState(state_dict):
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow('A099','更改原交易状态失败')
else:
AfaDBFunc.CommitSql()
else:
return AfaFlowControl.ExitThisFlow('A009','原交易不能进行清算调整')
#=====给修改字典赋值====
update_dict = {}
update_dict = {'ISDEAL':'1','NOTE3':'此笔错账已结转'}
where_dict = {}
where_dict = {'SNDBNKCO':TradeContext.SNDBNKCO,'TRCDAT':TradeContext.TRCDAT,'TRCNO':TradeContext.TRCNO,\
'BJEDTE':TradeContext.BJEDTE,'BSPSQN':TradeContext.BSPSQN}
#=====修改数据库中的数据====
AfaLoggerFunc.tradeInfo("通存通兑错帐处理标识修改")
res = rccpsDBTrcc_tddzcz.updateCmt(update_dict,where_dict)
if( res == -1 ):
return AfaFlowControl.ExitThisFlow('A099','修改通存通兑错帐处理标识失败')
elif( res == 0 ):
return AfaFlowControl.ExitThisFlow('A099','交易记录不存在')
#=====向下发的通知表中插入数据====
AfaLoggerFunc.tradeInfo("<<<<<<向通知表中插入数据")
insert_dict = {}
insert_dict['NOTDAT'] = AfaUtilTools.GetHostDate( )
insert_dict['BESBNO'] = wtrbka_record['BESBNO']
if(wtrbka_record['BRSFLG'] == PL_BRSFLG_RCV):
insert_dict['STRINFO'] = "此笔错账["+wtrbka_record['BSPSQN']+"]["+wtrbka_record['BJEDTE']+"]已做手工结转处理"
else:
insert_dict['STRINFO'] = "此笔错账["+wtrbka_record['BSPSQN']+"]["+wtrbka_record['BJEDTE']+"]已做手工结转处理 请用8522补打往账凭证"
if not rccpsDBTrcc_notbka.insertCmt(insert_dict):
return AfaFlowControl.ExitThisFlow('S999','向下发的通知表中插入数据失败')
AfaLoggerFunc.tradeInfo("<<<<<<向通知表中插入数据成功")
#=====给输出接口赋值====
TradeContext.errorCode = "0000"
TradeContext.errorMsg = "修改通存通兑错帐处理标识成功"
TradeContext.ISDEAL = '1'
# TradeContext.TLSQ = TradeContext.TLSQ
# TradeContext.RBSQ = TradeContext.RBSQ
# TradeContext.TRDT = TradeContext.TRDT
AfaLoggerFunc.tradeInfo( '***农信银系统: 往账.本地类操作交易[RCC001_8591]通存通兑错帐处理标识维护退出***' )
return True
def SubModuleDoSnd():
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.主机类操作(2.主机记账).往账发送[TRCC002_8506]进入***' )
AfaLoggerFunc.tradeInfo( '>>>开始更新主机返回结果信息' )
#=====从主机返回信息取借贷方账号和主机返回信息====
sstlog = {}
sstlog["BJEDTE"] = TradeContext.BJEDTE #交易日期
sstlog["BSPSQN"] = TradeContext.BSPSQN #报单序号
sstlog["SBAC"] = TradeContext.SBAC #借方账号
sstlog["ACNM"] = TradeContext.PYRNAM #借方户名
sstlog["RBAC"] = TradeContext.RBAC #贷方账号
sstlog["OTNM"] = '0651科目' #贷方户名
#=====判断主机返回结果====
if TradeContext.errorCode != '0000':
sstlog['BCSTAT'] = PL_BCSTAT_ACC
sstlog['BDWFLG'] = PL_BDWFLG_FAIL
sstlog["MGID"] = TradeContext.errorCode #主机返回码
sstlog["STRINFO"] = TradeContext.errorMsg #主机返回信息
elif TradeContext.errorCode == '0000':
sstlog['BCSTAT'] = PL_BCSTAT_ACC
sstlog['BDWFLG'] = PL_BDWFLG_SUCC
sstlog["TRDT"] = TradeContext.TRDT #主机日期
sstlog["TLSQ"] = TradeContext.TLSQ #主机流水号
sstlog["MGID"] = TradeContext.MGID #主机返回信息
sstlog["DASQ"] = TradeContext.DASQ #销账序号
#测试用
AfaLoggerFunc.tradeInfo( 'TradeContext.__status__ ='+TradeContext.__status__)
if TradeContext.__status__=='2': #异常情况
#====需要触发主机抹账交易===
#汇兑往帐抹帐字典赋值
input_dict = {}
input_dict['BJEDTE'] = TradeContext.BJEDTE
input_dict['BSPSQN'] = TradeContext.BSPSQN
input_dict['PYRACC'] = TradeContext.PYRACC #付款人账号
input_dict['OCCAMT'] = str(TradeContext.OCCAMT)
input_dict['BBSSRC'] = TradeContext.BBSSRC
input_dict['BESBNO'] = TradeContext.BESBNO
#调用汇兑往帐抹帐
rccpsEntries.HDWZMZ(input_dict)
#=====调用主机函数进行抹账
rccpsHostFunc.CommHost( TradeContext.HostCode )
#=====判断主机返回值====
if TradeContext.errorCode == '0000':
sstlog['BCSTAT'] = PL_BCSTAT_ACC
sstlog['BDWFLG'] = PL_BDWFLG_FAIL
TradeContext.errorCode = 'D011' #赋值返回错误
TradeContext.errorMsg = '记账失败，系统自动冲正成功'
else:
sstlog['BCSTAT'] = PL_BCSTAT_ACC
sstlog['BDWFLG'] = PL_BDWFLG_WAIT
TradeContext.errorCode = 'D011' #赋值返回错误
TradeContext.errorMsg = '记账失败，系统自动冲正失败'
#=====修改sstlog表中数据====
AfaLoggerFunc.tradeInfo( '字典：' + str(sstlog) )
if not rccpsState.setTransState(sstlog):
return AfaFlowControl.ExitThisFlow(TradeContext.errorCode, TradeContext.errorMsg)
else:
#=====commit操作====
AfaDBFunc.CommitSql()
AfaLoggerFunc.tradeInfo('>>>commit成功')
#=====判断主机返回，不成功返回错误到前台====
if TradeContext.errorCode != '0000':
return AfaFlowControl.ExitThisFlow(TradeContext.errorCode, TradeContext.errorMsg)
#=====赋值农信银中心需要字段====
TradeContext.TRANTYP = '0' #传输类型
TradeContext.OPRTYPNO = '20' #业务属性
#TradeContext.BJEDTE = TradeContext.NCCworkDate
#TradeContext.TRCDAT = TradeContext.NCCworkDate
#=====设置sstlog表中状态为：抹账-处理中====
TradeContext.BCSTAT = PL_BCSTAT_SND
TradeContext.BDWFLG = PL_BDWFLG_WAIT
if not rccpsState.newTransState(TradeContext.BJEDTE,TradeContext.BSPSQN,TradeContext.BCSTAT,TradeContext.BDWFLG):
#=====RollBack操作====
if not AfaDBFunc.RollbackSql():
return AfaFlowControl.ExitThisFlow('M999', '发送农信银中心失败,设置状态失败,系统自动回滚')
else:
#=====commit操作====
if not AfaDBFunc.CommitSql():
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow('M999', '发送农信银中心失败,设置状态失败,系统自动回滚')
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.主机类操作(2.主机记账).往账发送[TRCC002_8506]退出***' )
return True
def SubModuleDoTrd():
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.主机类操作(3.中心记账).往账发送[TRCC002_8506]进入***' )
AfaLoggerFunc.tradeInfo( '>>>判断发送农信银中心返回结果' )
#=====设置记账函数接口====
sstlog_dict = {}
sstlog_dict["BJEDTE"] = TradeContext.BJEDTE #交易日期
sstlog_dict["BSPSQN"] = TradeContext.BSPSQN #报单序号
#=====判断第三方返回值,返回成功时====
if TradeContext.errorCode == '0000':
sstlog_dict['BCSTAT'] = PL_BCSTAT_SND
sstlog_dict['BDWFLG'] = PL_BDWFLG_SUCC
#=====设置状态为发送成功====
if not rccpsState.setTransState(sstlog_dict):
#=====RollBack操作====
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow(TradeContext.errorCode, TradeContext.errorMsg)
else:
#=====commit操作====
AfaDBFunc.CommitSql()
TradeContext.errorCode = '0000'
TradeContext.errorMsg = '发送农信银中心成功'
#=====判断第三方返回值,返回失败时====
else:
sstlog_dict['BCSTAT'] = PL_BCSTAT_SND
sstlog_dict['BDWFLG'] = PL_BDWFLG_FAIL
#=====设置状态为发送失败====
if not rccpsState.setTransState(sstlog_dict):
#=====RollBack操作====
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow(TradeContext.errorCode, TradeContext.errorMsg)
else:
#=====commit操作====
AfaDBFunc.CommitSql()
AfaLoggerFunc.tradeDebug( '>>>commit send succ' )
#=====调用主机函数进行抹账====
AfaLoggerFunc.tradeInfo('>>>开始抹账处理')
#=====设置sstlog表中状态为：抹账-处理中====
TradeContext.BOSPSQ = TradeContext.BSPSQN
TradeContext.BOJEDT = TradeContext.BJEDTE
TradeContext.BCSTAT = PL_BCSTAT_HCAC
TradeContext.BDWFLG = PL_BDWFLG_WAIT
if not rccpsState.newTransState(TradeContext.BJEDTE,TradeContext.BSPSQN,TradeContext.BCSTAT,TradeContext.BDWFLG):
#=====RollBack操作====
if not AfaDBFunc.RollbackSql():
return AfaFlowControl.ExitThisFlow('M999', '发送农信银中心失败,设置状态失败,系统自动回滚')
else:
#=====commit操作====
if not AfaDBFunc.CommitSql():
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow('M999', '发送农信银中心失败,设置状态失败,系统自动回滚')
#=====字典赋值====
sstlog_new = {}
sstlog_new["BJEDTE"] = TradeContext.BJEDTE #交易日期
sstlog_new["BSPSQN"] = TradeContext.BSPSQN #报单序号
#汇兑往帐抹帐字典赋值
input_dict = {}
input_dict['BJEDTE'] = TradeContext.BJEDTE
input_dict['BSPSQN'] = TradeContext.BSPSQN
input_dict['PYRACC'] = TradeContext.PYRACC #付款人账号
input_dict['OCCAMT'] = str(TradeContext.OCCAMT)
input_dict['BBSSRC'] = TradeContext.BBSSRC
input_dict['BESBNO'] = TradeContext.BESBNO
#调用汇兑往帐抹帐
rccpsEntries.HDWZMZ(input_dict)
#=====设置记账函数接口====
rccpsHostFunc.CommHost( TradeContext.HostCode )
if TradeContext.errorCode == '0000':
sstlog_new['DASQ'] = TradeContext.DASQ
sstlog_new['PRTCNT'] = 1 #打印次数
sstlog_new['BCSTAT'] = PL_BCSTAT_HCAC
sstlog_new['BDWFLG'] = PL_BDWFLG_SUCC
sstlog_new['SBAC'] = TradeContext.SBAC
sstlog_new['RBAC'] = TradeContext.RBAC
sstlog_new["MGID"] = TradeContext.errorCode #主机返回码
sstlog_new["STRINFO"]= TradeContext.errorMsg #主机返回信息
sstlog_new["TRDT"] = TradeContext.TRDT #主机日期
sstlog_new["TLSQ"] = TradeContext.TLSQ #主机流水号
TradeContext.errorCode = 'D011' #赋值返回错误
TradeContext.errorMsg = '发送农信银中心失败，系统自动冲正成功'
else:
sstlog_new['BCSTAT'] = PL_BCSTAT_HCAC
sstlog_new['BDWFLG'] = PL_BDWFLG_FAIL
TradeContext.errorCode = 'D011' #赋值返回错误
TradeContext.errorMsg = '发送农信银中心失败，系统自动冲正失败'
#=====修改sstlog表中记录状态为：抹账-成功/失败====
if not rccpsState.setTransState(sstlog_new):
return AfaFlowControl.ExitThisFlow(TradeContext.errorCode, TradeContext.errorMsg)
else:
#=====commit操作====
AfaDBFunc.CommitSql()
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.主机类操作(3.中心记账).往账发送[TRCC002_8506]退出***' )
return True
def main( ):
AfaLoggerFunc.tradeInfo('***农信银系统: 往账.主机类操作模板['+TradeContext.TemplateCode+'_'+TradeContext.TransCode+']进入***')
try:
#=====================初始化返回报文变量================================
TradeContext.tradeResponse=[]
#=====================获取系统日期时间==================================
TradeContext.BJEDTE=AfaUtilTools.GetHostDate( )
#TradeContext.BJEDTE = PL_BJEDTE
TradeContext.BJETIM=AfaUtilTools.GetSysTime( )
#TradeContext.TRCDAT = PL_BJEDTE
#关彬捷 20081111 修改委托日期为中心日期
#TradeContext.TRCDAT=AfaUtilTools.GetHostDate( )
#修改结束
#=====================系统公共校验======================================
if not rccpsFunc.ChkPubInfo(PL_BRSFLG_SND) :
raise AfaFlowControl.flowException( )
#=====================系统状态校验======================================
if not rccpsFunc.ChkSysInfo( 'RCCPS' ) :
raise AfaFlowControl.flowException( )
#=====================机构合法性校验====================================
if not rccpsFunc.ChkUnitInfo( PL_BRSFLG_SND ) :
raise AfaFlowControl.flowException( )
#=====================获取中心日期====================================
if not rccpsFunc.GetNCCDate( ) :
raise AfaFlowControl.flowException( )
#关彬捷 20081111 修改委托日期为中心日期
TradeContext.TRCDAT=TradeContext.NCCworkDate
#修改结束
#=====================获取平台流水号====================================
if rccpsGetFunc.GetSerialno(PL_BRSFLG_SND) == -1 :
raise AfaFlowControl.flowException( )
#=====================获取中心流水号====================================
if rccpsGetFunc.GetRccSerialno( ) == -1 :
raise AfaFlowControl.flowException( )
#=====================动态加载交易脚本==================================
trxModuleName = 'T'+TradeContext.TemplateCode+'_'+TradeContext.TransCode
try:
trxModuleHandle=__import__( trxModuleName )
except Exception, e:
AfaLoggerFunc.tradeInfo(e)
raise AfaFlowControl.flowException( 'A0001', '加载交易脚本失败或交易脚本不存在,执行交易失败' )
#=====================交易前处理(登记流水,主机前处理)===================
if not trxModuleHandle.SubModuleDoFst( ) :
raise AfaFlowControl.flowException( )
#=====================与主机通讯========================================
rccpsHostFunc.CommHost( TradeContext.HostCode )
#=====================交易中处理(修改流水,主机后处理,中心前处理)========
if not trxModuleHandle.SubModuleDoSnd( ) :
raise AfaFlowControl.flowException( )
#=====================与中心通讯(回执)==================================
AfaAfeFunc.CommAfe()
#=====================交易后处理========================================
if not trxModuleHandle.SubModuleDoTrd():
raise AfaFlowControl.flowException( )
#=====================自动打包==========================================
AfaFunc.autoPackData()
#=====================退出模板==========================================
AfaLoggerFunc.tradeInfo('***农信银系统: 往账.主机类操作模板['+TradeContext.TemplateCode+'_'+TradeContext.TransCode+']退出***')
def SubModuleDoSnd():
AfaLoggerFunc.tradeInfo('>>>主机记账后处理')
#=====开始向字典赋值====
sst_dict = {}
sst_dict['BSPSQN'] = TradeContext.BSPSQN #报单序号
sst_dict['BJEDTE'] = TradeContext.BJEDTE #交易日期
sst_dict['SBAC'] = TradeContext.SBAC #借方账号
sst_dict['BESBNO'] = TradeContext.BESBNO #机构号
if (TradeContext.existVariable( "NOTE3" ) and len(TradeContext.NOTE3) != 0):
sst_dict['NOTE3'] = TradeContext.NOTE3 #备注3
AfaLoggerFunc.tradeDebug('>>>test NOTE3 =['+TradeContext.NOTE3 +']')
sst_dict['BJETIM'] = TradeContext.BJETIM #交易时间
sst_dict['MGID'] = TradeContext.errorCode #主机返回代码
sst_dict['STRINFO'] = TradeContext.errorMsg #主机返回信息
sst_dict['BETELR'] = TradeContext.BETELR #柜员号
#=====开始判断主机返回结果====
out_context_dict = {}
if TradeContext.errorCode == '0000' :
AfaLoggerFunc.tradeDebug('>>>主机通讯成功,更新表状态开始')
trcbka_jgh = {}
trcbka_where = {}
trcbka_jgh['BESBNO'] = TradeContext.BESBNO
trcbka_where['BSPSQN'] = TradeContext.BSPSQN
trcbka_where['BJEDTE'] = TradeContext.BJEDTE
if not rccpsDBTrcc_trcbka.updateCmt( trcbka_jgh,trcbka_where ):
#=====RollBack操作====
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow('D002', '更新数据库出错,RollBack成功')
else:
#=====commit操作====
AfaDBFunc.CommitSql()
AfaLoggerFunc.tradeInfo('更新登记簿，COMMIT成功')
if (TradeContext.existVariable( "RBAC" ) and len(TradeContext.RBAC) != 0):
sst_dict['RBAC'] = TradeContext.RBAC
AfaLoggerFunc.tradeDebug('>>>test RBAC =['+TradeContext.RBAC +']')
if (TradeContext.existVariable( "REAC" ) and len(TradeContext.REAC) != 0):
sst_dict['REAC'] = TradeContext.REAC
AfaLoggerFunc.tradeDebug('>>>test REAC =['+TradeContext.REAC +']')
#自动挂账
if TradeContext.accflag == 1 :
sst_dict['BCSTAT'] = PL_BCSTAT_HANG #自动挂账
AfaLoggerFunc.tradeDebug('>>>test BCSTAT=['+str(sst_dict['BCSTAT']) +']')
#自动入账
elif TradeContext.accflag == 0 :
sst_dict['BCSTAT'] = PL_BCSTAT_AUTO #自动入账
AfaLoggerFunc.tradeDebug('>>>test BCSTAT=['+str(sst_dict['BCSTAT']) +']')
if (TradeContext.existVariable( "DASQ" ) and len(TradeContext.DASQ) != 0):
sst_dict['DASQ'] = TradeContext.DASQ #销账序号
AfaLoggerFunc.tradeDebug('>>>test DASQ =['+TradeContext.DASQ +']')
sst_dict['BDWFLG'] = PL_BDWFLG_SUCC #成功
AfaLoggerFunc.tradeDebug('>>>test BDWFLG=['+str(sst_dict['BDWFLG']) +']')
sst_dict['TRDT'] = TradeContext.TRDT #主机日期
AfaLoggerFunc.tradeDebug('>>>test TRDT =['+TradeContext.TRDT +']')
sst_dict['TLSQ'] = TradeContext.TLSQ #主机流水
AfaLoggerFunc.tradeDebug('>>>test TLSQ =['+TradeContext.TLSQ +']')
AfaLoggerFunc.tradeDebug('>>>主机通讯成功,更新表状态结束')
out_context_dict['PRCCO'] = 'RCCI0000'
out_context_dict['STRINFO'] = '成功'
else :
if TradeContext.accflag == 1 :
sst_dict['BCSTAT'] = PL_BCSTAT_HANG #自动挂账
sst_dict['BDWFLG'] = PL_BDWFLG_FAIL #处理失败
out_context_dict['PRCCO'] = 'RCCI1056'
out_context_dict['STRINFO'] = '挂账失败,交易失败'
elif TradeContext.accflag == 0 :
#记账失败,挂代理机构账
TradeContext.BESBNO = TradeContext.BESBNOFIRST
#汇兑来帐挂帐字典赋值
input_dict = {}
input_dict['accflag'] = str(TradeContext.accflag) #记挂标志
input_dict['OCCAMT'] = TradeContext.OCCAMT #交易金额
input_dict['BESBNO'] = TradeContext.BESBNOFIRST
#调用汇兑记账接口
rccpsEntries.HDLZGZ(input_dict)
rccpsHostFunc.CommHost( '8813' )
sst_dict = {}
sst_dict['BSPSQN'] = TradeContext.BSPSQN #报单序号
AfaLoggerFunc.tradeDebug('>>>test BSPSQN=['+TradeContext.BSPSQN+']')
sst_dict['BJEDTE'] = TradeContext.BJEDTE #交易日期
AfaLoggerFunc.tradeDebug('>>>test BJEDTE=['+TradeContext.BJEDTE+']')
sst_dict['SBAC'] = TradeContext.SBAC #借方账号
AfaLoggerFunc.tradeDebug('>>>test SBAC=['+TradeContext.SBAC+']')
sst_dict['BESBNO'] = TradeContext.BESBNO #机构号
AfaLoggerFunc.tradeDebug('>>>test BESBNO=['+TradeContext.BESBNO+']')
if (TradeContext.existVariable( "NOTE3" ) and len(TradeContext.NOTE3) != 0):
sst_dict['NOTE3'] = TradeContext.NOTE3 #备注3
AfaLoggerFunc.tradeDebug('>>>test NOTE3 =['+TradeContext.NOTE3 +']')
sst_dict['BJETIM'] = TradeContext.BJETIM #交易时间
AfaLoggerFunc.tradeDebug('>>>test BJETIM=['+TradeContext.BJETIM+']')
sst_dict['MGID'] = TradeContext.errorCode #主机返回代码
sst_dict['STRINFO'] = TradeContext.errorMsg #主机返回信息
sst_dict['BETELR'] = TradeContext.BETELR #柜员号
if TradeContext.errorCode == '0000':
AfaLoggerFunc.tradeDebug(">>>SubModuleDoSnd--挂帐成功")
sst_dict['BCSTAT'] = PL_BCSTAT_HANG
sst_dict['BDWFLG'] = PL_BDWFLG_SUCC
out_context_dict['PRCCO'] = 'RCCI0000'
out_context_dict['STRINFO'] = '成功'
else:
AfaLoggerFunc.tradeDebug(">>>SubModuleDoSnd--挂帐失败")
sst_dict['BCSTAT'] = PL_BCSTAT_HANG
sst_dict['BDWFLG'] = PL_BDWFLG_FAIL
out_context_dict['PRCCO'] = 'RCCI1056'
out_context_dict['STRINFO'] = '挂账失败,交易失败'
AfaLoggerFunc.tradeDebug('>>>当前业务状态[' + str(sst_dict['BCSTAT']) + ']')
AfaLoggerFunc.tradeDebug('>>>当前流转标志[' + str(sst_dict['BDWFLG']) + ']')
#=====设置状态为 记账/挂账-成功 ====
if not rccpsState.setTransState(sst_dict):
#=====RollBack操作====
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow(TradeContext.errorCode, TradeContext.errorMsg)
else:
#=====commit操作====
AfaDBFunc.CommitSql()
AfaLoggerFunc.tradeDebug('>>>commit成功')
# 关彬捷 20080730 更新原交易状态为退汇成功
if TradeContext.BOJEDT != "" and TradeContext.BOSPSQ != "":
AfaLoggerFunc(">>>开始修改原交易状态为退汇成功")
if not rccpsState.newTransState(TradeContext.BOJEDT,TradeContext.BOSPSQ,PL_BCSTAT_QTR,PL_BDWFLG_SUCC):
#return False
return AfaFlowControl.ExitThisFlow('S999','设置状态出错')
AfaLoggerFunc(">>>开始修改原交易状态为退汇成功")
#=====开始设置通讯回执报文信息====
AfaLoggerFunc.tradeInfo('>>>开始组织通讯回执报文')
out_context_dict['sysType'] = 'rccpst'
out_context_dict['TRCCO'] = '9900503'
out_context_dict['MSGTYPCO'] = 'SET008'
out_context_dict['RCVMBRCO'] = TradeContext.SNDMBRCO
out_context_dict['SNDMBRCO'] = TradeContext.RCVMBRCO
out_context_dict['SNDBRHCO'] = TradeContext.BESBNO
out_context_dict['SNDCLKNO'] = TradeContext.BETELR
out_context_dict['SNDTRDAT'] = TradeContext.BJEDTE
out_context_dict['SNDTRTIM'] = TradeContext.BJETIM
out_context_dict['MSGFLGNO'] = out_context_dict['SNDMBRCO'] + TradeContext.BJEDTE + TradeContext.SerialNo
out_context_dict['ORMFN'] = TradeContext.MSGFLGNO
out_context_dict['NCCWKDAT'] = TradeContext.NCCworkDate
out_context_dict['OPRTYPNO'] = '99'
out_context_dict['ROPRTPNO'] = TradeContext.OPRTYPNO
out_context_dict['TRANTYP'] = '0'
out_context_dict['ORTRCCO'] = TradeContext.TRCCO
rccpsMap0000Dout_context2CTradeContext.map(out_context_dict)
return True
def SubModuleDoFst():
#time.sleep(60)
AfaLoggerFunc.tradeInfo("农信银系统：来账.中心类操作(1.本地操作).柜台冲销来账接收[TRCC006_1145]进入")
#=====判断是否为重复交易====
AfaLoggerFunc.tradeInfo(">>>判断是否为重复交易")
where_dict = {}
where_dict = {'TRCDAT':TradeContext.TRCDAT,'TRCNO':TradeContext.TRCNO,'SNDBNKCO':TradeContext.SNDBNKCO}
record = rccpsDBTrcc_mpcbka.selectu(where_dict)
if( record == None ):
AfaLoggerFunc.tradeDebug(">>>查找冲销登记簿异常,抛弃报文,等待中心发送自动冲正报文")
return AfaFlowControl.ExitThisFlow('A099',"查找冲销登记簿异常")
elif( len(record) > 0 ): #重复交易
AfaLoggerFunc.tradeDebug(">>>冲销交易重复")
else:
AfaLoggerFunc.tradeDebug(">>>非重复交易")
#=====开始登记柜台冲销登记簿====
AfaLoggerFunc.tradeDebug(">>>开始登记冲销登记簿")
#TradeContext.ORMFN = TradeContext.MSGFLGNO #参考报文标示号
TradeContext.ORTRCDAT = TradeContext.TRCDAT
mpcbka_insert_dict = {}
if not rccpsMap1145CTradeContext2Dmpcbka_dict.map(mpcbka_insert_dict):
AfaLoggerFunc.tradeDebug("为冲销登记簿字典赋值失败")
return AfaFlowControl.ExitThisFlow('S999','为字典赋值失败,抛弃报文,等待中心自动冲正')
res = rccpsDBTrcc_mpcbka.insertCmt(mpcbka_insert_dict)
if( res == -1):
AfaLoggerFunc.tradeDebug(">>>登记冲销登记簿失败")
return AfaFlowControl.ExitThisFlow('S999','插入数据库失败,抛弃报文,等待中心自动冲正')
#=====commit数据====
AfaDBFunc.CommitSql()
#=====查找自动冲正登记簿是否存在记录====
AfaLoggerFunc.tradeDebug(">>>判断是否存在自动冲正报文")
atcbka_where = {'ORMFN':TradeContext.MSGFLGNO}
atcbka_dict = rccpsDBTrcc_atcbka.selectu(atcbka_where)
if( len(atcbka_dict) > 0 ):
#=====冲销业务存在自动冲正报文,更新表数据为冲销失败,回复冲销失败报文====
AfaLoggerFunc.tradeDebug('>>>已存在自动冲正报文,拒绝冲销,回复拒绝报文')
#=====为返回冲销成功发送拒绝回执====
TradeContext.MSGTYPCO = 'SET010' #报文类代码
TradeContext.PRCCO = 'NN1IA999' #中心返回码
TradeContext.ORMFN = TradeContext.MSGFLGNO #参考报文标示号
TradeContext.SNDSTLBIN= TradeContext.RCVMBRCO #发送成员行号
TradeContext.RCVSTLBIN= TradeContext.SNDMBRCO #接收成员行号
TradeContext.STRINFO = '原交易已自动冲正,不允许再次冲销' #附言
return True
else:
AfaLoggerFunc.tradeDebug('>>>未查找到针对冲销报文的自动冲正报文,流程继续')
#=====查找原交易是否存在====
AfaLoggerFunc.tradeDebug(">>>查找原交易是否存在")
where_dict = {'TRCDAT':TradeContext.ORMFN[10:18],'TRCNO':TradeContext.ORTRCNO,'SNDBNKCO':TradeContext.SNDBNKCO}
wtrbka_dict = rccpsDBTrcc_wtrbka.selectu(where_dict)
if( wtrbka_dict == -1 ):
AfaLoggerFunc.tradeInfo(">>>查找原交易失败,原业务中心流水号["+str(TradeContext.ORTRCNO)+"]")
return AfaFlowControl.ExitThisFlow('A099',"查找原交易失败,抛弃报文,等待中心自动冲正")
if( len(wtrbka_dict) == 0 ):
#=====未查找到原交易====
AfaLoggerFunc.tradeDebug(">>>查找原交易失败,未收到原交易,直接回复拒绝报文")
#=====为返回冲销成功发送成功回执====
TradeContext.MSGTYPCO = 'SET010' #报文类代码
TradeContext.ORMFN = TradeContext.MSGFLGNO #参考报文标示号
TradeContext.SNDSTLBIN= TradeContext.RCVMBRCO #发送成员行号
TradeContext.RCVSTLBIN= TradeContext.SNDMBRCO #接收成员行号
#关彬捷 20081222 修改:如果未找到原业务,则返回拒绝应答
TradeContext.PRCCO = 'NN1IA999' #中心返回码
TradeContext.STRINFO = '无此交易' #附言
return True
else:
#=====查找原交易成功====
AfaLoggerFunc.tradeInfo(">>>查找原交易成功")
#=====将原报单序号 原交易日期更新到冲销登记簿中====
AfaLoggerFunc.tradeInfo('>>>更新原报单序号\原交易日期')
mpcbka_where={}
mpcbka_where['BSPSQN'] = TradeContext.BSPSQN #报单序号
mpcbka_where['BJEDTE'] = TradeContext.BJEDTE #交易日期
mpcbka_dict ={}
mpcbka_dict['BOJEDT'] = wtrbka_dict['BJEDTE'] #原交易日期
mpcbka_dict['BOSPSQ'] = wtrbka_dict['BSPSQN'] #原报单序号
mpcbka_dict['BESBNO'] = wtrbka_dict['BESBNO'] #原机构号
mpcbka_dict['STRINFO'] = TradeContext.STRINFO #附言
mpcbka_dict['OPRNO'] = PL_TDOPRNO_CX #业务类型
ret = rccpsDBTrcc_mpcbka.update(mpcbka_dict,mpcbka_where)
if ret <= 0:
AfaDBFunc.RollBackSql( )
return AfaFlowControl.ExitThisFlow('S999', "更新冲销登记簿原报单序号和原交易日期异常,抛弃报文")
else:
AfaDBFunc.CommitSql( )
AfaLoggerFunc.tradeInfo(">>>结束更新冲销登记簿原交易日期和原报单序号")
#=====查找原来账业务业务状态====
AfaLoggerFunc.tradeInfo(">>>查找原业务状态")
spbsta_where = {'BJEDTE':wtrbka_dict['BJEDTE'],'BSPSQN':wtrbka_dict['BSPSQN']}
spbsta_dict = rccpsDBTrcc_spbsta.selectu(spbsta_where)
if( spbsta_dict == None ):
AfaLoggerFunc.tradeDebug(">>>查找原业务状态失败,发送中心失败报文")
#=====为返回冲销成功发送拒绝回执====
TradeContext.MSGTYPCO = 'SET010' #报文类代码
TradeContext.PRCCO = 'RCCO1006' #中心返回码
TradeContext.ORMFN = TradeContext.MSGFLGNO #参考报文标示号
TradeContext.SNDSTLBIN= TradeContext.RCVMBRCO #发送成员行号
TradeContext.RCVSTLBIN= TradeContext.SNDMBRCO #接收成员行号
TradeContext.STRINFO = '开户行处理失败' #附言
return True
#关彬捷 20081226 新增查询交易当前状态详细信息
#查询交易当前状态详细信息
sstlog_where = {'BJEDTE':wtrbka_dict['BJEDTE'],'BSPSQN':wtrbka_dict['BSPSQN'],'BCURSQ':spbsta_dict['BCURSQ']}
spbsta_dict = rccpsDBTrcc_sstlog.selectu(sstlog_where)
if( spbsta_dict == None ):
AfaLoggerFunc.tradeDebug(">>>查找原业务状态失败,发送中心失败报文")
#=====为返回冲销成功发送拒绝回执====
TradeContext.MSGTYPCO = 'SET010' #报文类代码
TradeContext.PRCCO = 'RCCO1006' #中心返回码
TradeContext.ORMFN = TradeContext.MSGFLGNO #参考报文标示号
TradeContext.SNDSTLBIN= TradeContext.RCVMBRCO #发送成员行号
TradeContext.RCVSTLBIN= TradeContext.SNDMBRCO #接收成员行号
TradeContext.STRINFO = '开户行处理失败' #附言
return True
#关彬捷 20081226 新增若交易当前状态为自动扣款,自动入账,冲销,冲正处理中状态,则直接拒绝此冲销
if (spbsta_dict['BCSTAT'] == PL_BCSTAT_AUTO or spbsta_dict['BCSTAT'] == PL_BCSTAT_AUTOPAY or spbsta_dict['BCSTAT'] == PL_BCSTAT_CANC or spbsta_dict['BCSTAT'] == PL_BCSTAT_CANCEL) and spbsta_dict['BDWFLG'] == PL_BDWFLG_WAIT:
#=====为返回冲销成功发送拒绝回执====
TradeContext.MSGTYPCO = 'SET010' #报文类代码
TradeContext.PRCCO = 'RCCO1006' #中心返回码
TradeContext.ORMFN = TradeContext.MSGFLGNO #参考报文标示号
TradeContext.SNDSTLBIN= TradeContext.RCVMBRCO #发送成员行号
TradeContext.RCVSTLBIN= TradeContext.SNDMBRCO #接收成员行号
TradeContext.STRINFO = '原交易账务状态未知' #附言
return True
#关彬捷 20081226 新增若交易当前状态为自动扣款,自动入账,冲销,冲正失败状态,则调用8816查询账务状态
if (spbsta_dict['BCSTAT'] == PL_BCSTAT_AUTO or spbsta_dict['BCSTAT'] == PL_BCSTAT_AUTOPAY or spbsta_dict['BCSTAT'] == PL_BCSTAT_CANC or spbsta_dict['BCSTAT'] == PL_BCSTAT_CANCEL) and spbsta_dict['BDWFLG'] == PL_BDWFLG_FAIL:
AfaLoggerFunc.tradeDebug('>>>调用8816查找该业务[' + wtrbka_dict['BSPSQN'] + ']状态')
TradeContext.HostCode = '8816' #主机交易码
TradeContext.OPFG = '1' #查询类型
TradeContext.NBBH = 'RCC' #代理业务标识
TradeContext.FEDT = spbsta_dict['FEDT'] #原前置日期
TradeContext.RBSQ = spbsta_dict['RBSQ'] #原前置流水号
TradeContext.DAFG = '1' #抹/记账标志 1:记 2:抹
TradeContext.BESBNO = spbsta_dict['BESBNO'] #机构号
TradeContext.BETELR = spbsta_dict['BETELR'] #柜员号
rccpsHostFunc.CommHost( TradeContext.HostCode )
#=====分析主机返回====
if TradeContext.errorCode == '0000':
#此账务已成功记主机账,修改原交易状态为记账成功
AfaLoggerFunc.tradeInfo("此账务已成功记主机账,修改原交易状态为记账成功")
stat_dict = {}
stat_dict['BJEDTE'] = spbsta_dict['BJEDTE']
stat_dict['BSPSQN'] = spbsta_dict['BSPSQN']
stat_dict['BCSTAT'] = spbsta_dict['BCSTAT']
stat_dict['BDWFLG'] = PL_BDWFLG_SUCC
stat_dict['TRDT'] = HostContext.O1DADT #主机日期
stat_dict['TLSQ'] = HostContext.O1AMTL #主机流水
stat_dict['MGID'] = '0000'
stat_dict['STRINFO']= '主机成功'
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999','设置原交易业务状态为记账成功异常')
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
#更新查询出交易状态
spbsta_dict['BDWFLG'] = PL_BDWFLG_SUCC
spbsta_dict['TRDT'] = HostContext.O1DADT
spbsta_dict['TLSQ'] = HostContext.O1AMTL
elif TradeContext.errorCode == 'XCR0001':
AfaLoggerFunc.tradeInfo(">>>主机返回原交易记账失败,继续冲销")
else:
AfaLoggerFunc.tradeInfo(">>>查询原交易账务状态异常,返回拒绝应答")
#=====为返回冲销成功发送拒绝回执====
TradeContext.MSGTYPCO = 'SET010' #报文类代码
TradeContext.PRCCO = 'RCCO1006' #中心返回码
TradeContext.ORMFN = TradeContext.MSGFLGNO #参考报文标示号
TradeContext.SNDSTLBIN= TradeContext.RCVMBRCO #发送成员行号
TradeContext.RCVSTLBIN= TradeContext.SNDMBRCO #接收成员行号
TradeContext.STRINFO = '原交易账务状态未知' #附言
return True
#=====根据来往帐标识进行冲销状态判断====
if( wtrbka_dict['BRSFLG'] == PL_BRSFLG_RCV ):
#=====来账业务====
AfaLoggerFunc.tradeDebug(">>>来账业务")
#=====PL_BCSTAT_AUTOPAY 自动扣款====
#=====PL_BCSTAT_AUTO 自动入账====
#=====PL_BCSTAT_CONFPAY 确认付款====
#=====PL_BCSTAT_CONFACC 确认入账====
#=====PL_BCSTAT_MFERFE 拒绝====
#=====PL_BCSTAT_CANC 冲销====
#=====PL_BCSTAT_CANCEL 冲正====
if( ((spbsta_dict['BCSTAT']==PL_BCSTAT_AUTO or spbsta_dict['BCSTAT']==PL_BCSTAT_AUTOPAY) and spbsta_dict['BDWFLG']==PL_BDWFLG_FAIL) \
or (spbsta_dict['BCSTAT'] == PL_BCSTAT_MFERFE and spbsta_dict['BDWFLG'] == PL_BDWFLG_SUCC) \
or (spbsta_dict['BCSTAT'] == PL_BCSTAT_CANC and spbsta_dict['BDWFLG'] == PL_BDWFLG_SUCC) \
or (spbsta_dict['BCSTAT'] == PL_BCSTAT_CANCEL and spbsta_dict['BDWFLG'] == PL_BDWFLG_SUCC) \
or (spbsta_dict['BCSTAT'] == PL_BCSTAT_CONFPAY and spbsta_dict['BDWFLG'] == PL_BDWFLG_SUCC) \
or (spbsta_dict['BCSTAT'] == PL_BCSTAT_CONFACC and spbsta_dict['BDWFLG'] == PL_BDWFLG_SUCC)):
#=====不允许冲销====
AfaLoggerFunc.tradeDebug(">>>原业务["+str(spbsta_dict['BSPSQN'])+"]记账失败或被拒绝,发送成功报文")
#=====根据交易状态新增冲销-成功状态====
if spbsta_dict['BCSTAT'] not in (PL_BCSTAT_MFERFE,PL_BCSTAT_CANC,PL_BCSTAT_CANCEL):
#=====新增原业务状态为冲销-成功====
AfaLoggerFunc.tradeDebug('>>>新增原业务状态为冲销-成功')
if not rccpsState.newTransState(spbsta_dict['BJEDTE'],spbsta_dict['BSPSQN'],PL_BCSTAT_CANC,PL_BDWFLG_SUCC):
AfaDBFunc.RollBackSql()
return AfaFlowControl.ExitThisFlow('S999','设置业务状态为冲销-成功异常')
else:
AfaDBFunc.CommitSql()
else:
AfaLoggerFunc.tradeDebug('>>>原业务状态为[拒绝/冲销/冲正],不需要新增状态')
#=====为返回冲销成功发送拒绝回执====
TradeContext.MSGTYPCO = 'SET010' #报文类代码
TradeContext.PRCCO = 'RCCI0000' #中心返回码
TradeContext.ORMFN = TradeContext.MSGFLGNO #参考报文标示号
TradeContext.SNDSTLBIN= TradeContext.RCVMBRCO #发送成员行号
TradeContext.RCVSTLBIN= TradeContext.SNDMBRCO #接收成员行号
TradeContext.STRINFO = '原业务冲销成功' #附言
return True
else:
#=====直接调用8820冲销原业务====
status={}
if not rccpsState.getTransStateCur(spbsta_dict['BJEDTE'],spbsta_dict['BSPSQN'],status):
return AfaFlowControl.ExitThisFlow('S999','取原业务主机流水号和日期失败,抛弃报文')
TradeContext.BOSPSQ = status['RBSQ'] #原报单序号
TradeContext.BOJEDT = status['FEDT'] #原交易日期
TradeContext.HostCode = '8820' #主机交易码
#=====新增原业务状态为冲销-处理中====
AfaLoggerFunc.tradeDebug('>>>新增原业务状态为冲销-处理中')
if not rccpsState.newTransState(spbsta_dict['BJEDTE'],spbsta_dict['BSPSQN'],PL_BCSTAT_CANC,PL_BDWFLG_WAIT):
AfaDBFunc.RollBackSql()
return AfaFlowControl.ExitThisFlow('S999','设置业务状态为冲销-处理中异常')
else:
AfaDBFunc.CommitSql()
#=====向主机发起8820抹账处理====
AfaLoggerFunc.tradeDebug('>>>向主机发起8820抹账处理')
rccpsHostFunc.CommHost( TradeContext.HostCode )
#=====判断主机返回====
sstlog_dict={}
sstlog_dict['BJEDTE'] = spbsta_dict['BJEDTE']
sstlog_dict['BSPSQN'] = spbsta_dict['BSPSQN']
sstlog_dict['BCSTAT'] = PL_BCSTAT_CANC
sstlog_dict['MGID'] = TradeContext.errorCode #主机返回码
if TradeContext.existVariable('BOJEDT'): #前置日期
sstlog_dict['FEDT'] = TradeContext.BOJEDT
if TradeContext.existVariable('BOSPSQ'): #前置流水号
sstlog_dict['RBSQ'] = TradeContext.BOSPSQ
if TradeContext.existVariable('TRDT'): #主机日期
sstlog_dict['TRDT'] = TradeContext.TRDT
if TradeContext.existVariable('TLSQ'): #主机流水号
sstlog_dict['TLSQ'] = TradeContext.TLSQ
#关彬捷 20090219 增加冲销成功的主机错误码判断:SXR0010(此笔交易已被冲正)
if TradeContext.errorCode in ('0000','SXR0010'):
#=====更改状态====
sstlog_dict['BDWFLG'] = PL_BDWFLG_SUCC #流转标识 PL_BDWFLG_SUCC 成功
sstlog_dict['STRINFO'] = '来账冲销成功' #附言
TradeContext.PRCCO = 'RCCI0000'
TradeContext.STRINFO = '原业务冲销成功'
else:
sstlog_dict['BDWFLG'] = PL_BDWFLG_FAIL #流转标识 PL_BDWFLG_FAIL 失败
sstlog_dict['MGID'] = TradeContext.errorCode #主机返回码
sstlog_dict['STRINFO'] = TradeContext.errorMsg #主机返回信息
TradeContext.PRCCO = 'NN1IA999'
TradeContext.STRINFO = '原业务冲销失败 ' + TradeContext.errorMsg
#=====修改原业务状态====
AfaLoggerFunc.tradeDebug('>>>修改原业务状态')
res = rccpsState.setTransState(sstlog_dict)
if( res == False ):
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow('A099', '更改被冲正的交易状态失败')
AfaDBFunc.CommitSql( )
#关彬捷 20081226 修改如果冲销失败则回滚冲销前状态
if TradeContext.errorCode not in ('0000','SXR0010'):
#冲销失败,回滚状态为冲销前状态
if not rccpsState.newTransState(spbsta_dict['BJEDTE'],spbsta_dict['BSPSQN'],spbsta_dict['BCSTAT'],spbsta_dict['BDWFLG']):
AfaDBFunc.RollBackSql()
return AfaFlowControl.ExitThisFlow('S999','回滚状态为冲销前状态异常')
else:
AfaDBFunc.CommitSql()
sstlog_dict = {}
sstlog_dict['BJEDTE'] = spbsta_dict['BJEDTE']
sstlog_dict['BSPSQN'] = spbsta_dict['BSPSQN']
sstlog_dict['BCSTAT'] = spbsta_dict['BCSTAT']
sstlog_dict['BDWFLG'] = spbsta_dict['BDWFLG']
sstlog_dict['NOTE3'] = '原业务冲销失败,回滚为冲销前状态'
if spbsta_dict.has_key('FEDT'): #前置日期
sstlog_dict['FEDT'] = spbsta_dict['FEDT']
if spbsta_dict.has_key('RBSQ'): #前置流水号
sstlog_dict['RBSQ'] = spbsta_dict['RBSQ']
if spbsta_dict.has_key('TRDT'): #主机日期
sstlog_dict['TRDT'] = spbsta_dict['TRDT']
if spbsta_dict.has_key('TLSQ'): #主机流水号
sstlog_dict['TLSQ'] = spbsta_dict['TLSQ']
sstlog_dict['MGID'] = spbsta_dict['MGID'] #主机返回码
sstlog_dict['STRINFO'] = spbsta_dict['STRINFO'] #主机返回信息
if not rccpsState.setTransState(sstlog_dict):
return AfaFlowControl.ExitThisFlow('S999','回滚状态为冲销前状态详细信息异常')
else:
AfaDBFunc.CommitSql()
#=====发送回执====
AfaLoggerFunc.tradeDebug('>>>发送成功回执到对方行')
#=====为返回冲销成功发送成功回执====
TradeContext.MSGTYPCO = 'SET010' #报文类代码
#TradeContext.PRCCO = 'RCCI0000' #中心返回码
#TradeContext.STRINFO = '原业务冲销成功' #附言
TradeContext.ORMFN = TradeContext.MSGFLGNO #参考报文标示号
TradeContext.SNDSTLBIN= TradeContext.RCVMBRCO #发送成员行号
TradeContext.RCVSTLBIN= TradeContext.SNDMBRCO #接收成员行号
else:
#=====往帐业务====
AfaLoggerFunc.tradeDebug(">>>往帐业务")
#=====发送回执====
AfaLoggerFunc.tradeDebug('>>>发送成功回执到对方行')
#=====为返回冲销成功发送成功回执====
TradeContext.MSGTYPCO = 'SET010' #报文类代码
TradeContext.PRCCO = 'RCCO1006' #中心返回码
TradeContext.ORMFN = TradeContext.MSGFLGNO #参考报文标示号
TradeContext.SNDSTLBIN= TradeContext.RCVMBRCO #发送成员行号
TradeContext.RCVSTLBIN= TradeContext.SNDMBRCO #接收成员行号
TradeContext.STRINFO = '往帐业务只能受理方冲销' #附言
AfaLoggerFunc.tradeInfo("农信银系统：来账.中心类操作(1.本地操作).柜台冲销来账接收[TRCC006_1145]退出")
return True
def SubModuleDoSnd():
AfaLoggerFunc.tradeInfo("交易中处理(修改流水,主机后处理,中心前处理)")
AfaLoggerFunc.tradeInfo("errorCode<<<<<<<<<<<"+TradeContext.errorCode)
AfaLoggerFunc.tradeInfo("errorMsg<<<<<<<<<<"+TradeContext.errorMsg)
#=====判断主机交易是否成功====
if( TradeContext.errorCode != '0000' ):
AfaLoggerFunc.tradeInfo("主机交易失败")
TradeContext.PRCCO = "NN1CA999" #返回码
TradeContext.STRINFO = "主机失败 "+TradeContext.errorMsg[7:]+" " #附言
TradeContext.AVLBAL = "0.00" #可用余额
TradeContext.ACCBAL = "0.00" #账面余额
#=====更新余额查询登记簿====
AfaLoggerFunc.tradeInfo("组织更新字典")
where_dict = {'BJEDTE':TradeContext.BJEDTE,'BSPSQN':TradeContext.BSPSQN}
update_dict = {'STRINFO':TradeContext.STRINFO,'PRCCO':TradeContext.PRCCO}
AfaLoggerFunc.tradeInfo("开始更新余额查询登记簿")
res = rccpsDBTrcc_balbka.updateCmt(update_dict,where_dict)
if( res == -1 ):
return AfaFlowControl.ExitThisFlow('A009','更新余额查询登记簿失败')
else:
AfaLoggerFunc.tradeInfo("主机交易成功")
AfaLoggerFunc.tradeDebug("<<<<<<ACCBAL=" + str(HostContext.O1ACBL))
AfaLoggerFunc.tradeDebug("<<<<<<AVLBAL=" + str(HostContext.O1CUBL))
TradeContext.PRCCO = "RCCI0000" #返回码
TradeContext.STRINFO = "查询成功" #附言
TradeContext.ACCBAL = HostContext.O1ACBL #帐户余额
TradeContext.AVLBAL = HostContext.O1CUBL #可用余额
##=====判断是否跨法人====
#if( TradeContext.BESBNO != PL_BESBNO_BCLRSB ):
# if( TradeContext.BESBNO[:6] != TradeContext.ACCSO[:6] ):
# AfaLoggerFunc.tradeInfo(">>>不许跨法人做此交易")
# TradeContext.PRCCO = 'NN1IO999'
# TradeContext.STRINFO = "接收行与账户开户行不属于同一法人"
# TradeContext.ACCBAL = '0.00' #帐户余额
# TradeContext.AVLBAL = '0.00' #可用余额
#=====判断开户机构有无通存通兑权限====
if not rccpsDBFunc.chkTDBESAuth(TradeContext.ACCSO):
AfaLoggerFunc.tradeInfo(">>>本账户开户机构无通存通兑业务权限")
TradeContext.PRCCO = 'NN1IO999'
TradeContext.STRINFO = "本账户开户机构无通存通兑业务权限"
TradeContext.ACCBAL = '0.00' #帐户余额
TradeContext.AVLBAL = '0.00' #可用余额
#唐斌新增#
sql = "SELECT ischkactname,ischklate FROM rcc_chlabt where transcode='"+TradeContext.TransCode+"' and channelno= '"+(TradeContext.SNDCLKNO)[6:8]+"'"
AfaLoggerFunc.tradeInfo(sql)
records = AfaDBFunc.SelectSql( sql)
if (records == None):
return False
elif (len(records) == 0):
AfaLoggerFunc.tradeDebug("查询结果为空,查询条件[" + sql + "]")
return False
AfaLoggerFunc.tradeDebug(str(records))
#=====判断账号与户名是否相符====
if(TradeContext.PYENAM != HostContext.O1CUNM):
#唐斌新增#
if(records[0][0]=='1'):
TradeContext.PRCCO = 'NN1IA102'
TradeContext.STRINFO = "户名与账号不符"
TradeContext.ACCBAL = '0.00' #帐户余额
TradeContext.AVLBAL = '0.00' #可用余额
#=====判断账户的状态====
AfaLoggerFunc.tradeInfo("判断账户的状态")
if( TradeContext.ACCST != "0" ):
TradeContext.PRCCO = 'NN1IA999'
TradeContext.STRINFO = "账户状态不正常"
TradeContext.ACCBAL = '0.00' #帐户余额
TradeContext.AVLBAL = '0.00' #可用余额
#=====判断是否为个人结算账户====
if not (TradeContext.ACCCD == '0428' and TradeContext.ACCEM == '21111'):
AfaLoggerFunc.tradeInfo(">>>此账户非个人结算户")
TradeContext.PRCCO = 'NN1IA999'
TradeContext.STRINFO = '此账户非个人结算户'
TradeContext.ACCBAL = '0.00' #帐户余额
TradeContext.AVLBAL = '0.00' #可用余额
#唐斌新增#
if(records[0][1]=='1'):
if (TradeContext.SCTRKINF == ''.rjust(37,'0') or TradeContext.SCTRKINF == ''):
AfaLoggerFunc.tradeInfo("校验磁道信息异常,该业务必须产生磁道信息")
TradeContext.PRCCO = 'NN1IA141'
TradeContext.STRINFO = "校验磁道信息失败 :无磁道信息"
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
if TradeContext.SCTRKINF != ''.rjust(37,'0') and TradeContext.SCTRKINF != '':
#磁道信息非空或37个零,则调用主机接口校验磁道信息
TradeContext.HostCode = '0652'
TradeContext.WARNTNO = TradeContext.PYEACC[6:18]
AfaLoggerFunc.tradeDebug("WARNTNO :" + TradeContext.WARNTNO)
AfaLoggerFunc.tradeDebug("SCTRKINF :" + TradeContext.SCTRKINF)
AfaLoggerFunc.tradeDebug("THTRKINF :" + TradeContext.THTRKINF)
if TradeContext.THTRKINF == ''.rjust(37,'0'):
TradeContext.THTRKINF = ''
AfaLoggerFunc.tradeDebug("THTRKINF :" + TradeContext.THTRKINF)
rccpsHostFunc.CommHost( TradeContext.HostCode )
if TradeContext.errorCode != '0000':
#return AfaFlowControl.ExitThisFlow(TradeContext.errorCode,TradeContext.errorMsg)
AfaLoggerFunc.tradeInfo("校验磁道信息异常,主机返回码[" + TradeContext.errorCode + "],主机返回信息[" + TradeContext.errorMsg +"]")
TradeContext.PRCCO = 'NN1IA141'
TradeContext.STRINFO = "校验磁道信息失败 " + TradeContext.errorMsg
TradeContext.ACCBAL = '0.00' #帐户余额
TradeContext.AVLBAL = '0.00' #可用余额
#=====更新余额查询登记簿====
AfaLoggerFunc.tradeInfo("组织更新字典")
where_dict = {'BJEDTE':TradeContext.BJEDTE,'BSPSQN':TradeContext.BSPSQN}
update_dict = {'AVLBAL':TradeContext.AVLBAL,'ACCBAL':TradeContext.ACCBAL,\
'STRINFO':TradeContext.STRINFO,'PRCCO':TradeContext.PRCCO}
AfaLoggerFunc.tradeInfo("开始更新余额查询登记簿")
res = rccpsDBTrcc_balbka.updateCmt(update_dict,where_dict)
if( res == -1 ):
return AfaFlowControl.ExitThisFlow('A009','更新余额查询登记簿失败')
#=====开始给卡余额查询应答报文赋值====
AfaLoggerFunc.tradeInfo("开始给卡余额查询应答报文赋值")
Rcvmbrco = TradeContext.SNDMBRCO
Sndmbrco = TradeContext.RCVMBRCO
Ormfn = TradeContext.MSGFLGNO
#=====报文头====
TradeContext.MSGTYPCO = 'SET010' #报文类代码
TradeContext.RCVSTLBIN = Rcvmbrco #接受方成员行号
TradeContext.SNDSTLBIN = Sndmbrco #发送方成员行号
TradeContext.SNDBRHCO = TradeContext.BESBNO #发起行网点号
TradeContext.SNDCLKNO = TradeContext.BETELR #发起行柜员号
TradeContext.SNDTRDAT = TradeContext.BJEDTE #发起行交易日期
TradeContext.SNDTRTIM = TradeContext.BJETIM #发起行交易时间
TradeContext.MSGFLGNO = Rcvmbrco+TradeContext.BJEDTE + TradeContext.SerialNo #报文标示号
TradeContext.ORMFN = Ormfn #参考报文标示号
TradeContext.NCCWKDAT = TradeContext.NCCworkDate #中心工作日期
TradeContext.OPRTYPNO = '30' #业务类型
TradeContext.ROPRTPNO = '30' #参考业务类型
TradeContext.TRANTYP = '0' #传输类型
#=====业务要素集====
TradeContext.CURPIN = "" #异地客户密码
AfaLoggerFunc.tradeInfo("TradeContext.AVLBAL<<<<<<" + TradeContext.AVLBAL)
AfaLoggerFunc.tradeInfo("TradeContext.ACCBAL<<<<<<" + TradeContext.ACCBAL)
AfaLoggerFunc.tradeInfo("交易中处理(修改流水,主机后处理,中心前处理) 结束")
return True
def SubModuleDoFst():
time.sleep(10)
AfaLoggerFunc.tradeInfo('>>>进入撤销应答接收')
#==========判断是否重复报文,如果是重复报文,直接进入下一流程================
AfaLoggerFunc.tradeInfo(">>>开始检查是否重复报文")
trccan_where_dict = {}
trccan_where_dict['SNDBNKCO'] = TradeContext.SNDBNKCO
trccan_where_dict['TRCDAT'] = TradeContext.TRCDAT
trccan_where_dict['TRCNO'] = TradeContext.TRCNO
trc_dict = rccpsDBTrcc_trccan.selectu(trccan_where_dict)
if trc_dict == None:
return AfaFlowControl.ExitThisFlow("S999","校验重复报文异常")
if len(trc_dict) > 0:
AfaLoggerFunc.tradeInfo("汇兑查询查复自由格式登记簿中存在相同查复交易,此报文为重复报文,进入下一流程,发送表示成功的通讯回执")
#======为通讯回执报文赋值===============================================
out_context_dict = {}
out_context_dict['TRCCO'] = '9900503'
out_context_dict['MSGTYPCO'] = 'SET008'
out_context_dict['RCVMBRCO'] = TradeContext.SNDMBRCO
out_context_dict['SNDMBRCO'] = TradeContext.RCVMBRCO
out_context_dict['SNDBRHCO'] = TradeContext.BESBNO
out_context_dict['SNDCLKNO'] = TradeContext.BETELR
out_context_dict['SNDTRDAT'] = TradeContext.BJEDTE
out_context_dict['SNDTRTIM'] = TradeContext.BJETIM
out_context_dict['MSGFLGNO'] = out_context_dict['SNDMBRCO'] + TradeContext.BJEDTE + TradeContext.SerialNo
out_context_dict['ORMFN'] = TradeContext.MSGFLGNO
out_context_dict['NCCWKDAT'] = TradeContext.NCCworkDate
out_context_dict['OPRTYPNO'] = '99'
out_context_dict['ROPRTPNO'] = TradeContext.OPRTYPNO
out_context_dict['TRANTYP'] = '0'
out_context_dict['ORTRCCO'] = TradeContext.TRCCO
out_context_dict['PRCCO'] = 'RCCI0000'
out_context_dict['STRINFO'] = '重复报文'
rccpsMap0000Dout_context2CTradeContext.map(out_context_dict)
TradeContext.SNDSTLBIN = TradeContext.RCVMBRCO #发起成员行号
return True
AfaLoggerFunc.tradeInfo(">>>结束检查是否重复报文")
#==========根据发送行号,委托日期,交易流水号查询原交易信息===========
AfaLoggerFunc.tradeInfo(">>>开始根据发送行号,委托日期,交易流水号查询交易信息")
dict_where = {}
dict_where['SNDBNKCO'] = TradeContext.OQTSBNK
dict_where['TRCDAT'] = TradeContext.OCADAT
dict_where['TRCNO'] = TradeContext.OCATNO
dict = rccpsDBTrcc_trccan.selectu(dict_where)
if dict == None:
return AfaFlowControl.ExitThisFlow("S999","校验重复报文异常")
tran_dict_where = {}
tran_dict_where['BJEDTE'] = dict['BOJEDT']
tran_dict_where['BSPSQN'] = dict['BOSPSQ']
tran_dict = rccpsDBTrcc_trcbka.selectu(tran_dict_where)
if tran_dict <= 0:
return AfaFlowControl.ExitThisFlow("S999","未找到原交易")
AfaLoggerFunc.tradeInfo(">>>结束根据发送行号,委托日期,交易流水号查询交易信息")
#=====从TradeContext向字典trccan_dict赋值====
TradeContext.BBSSRC = tran_dict['BBSSRC']
TradeContext.BOJEDT = dict['BJEDTE']
TradeContext.BOSPSQ = dict['BSPSQN']
TradeContext.ORTRCCO = dict['TRCCO']
TradeContext.CUR = '01'
TradeContext.OCCAMT = str(dict['OCCAMT'])
AfaLoggerFunc.tradeDebug('>>>资金来源['+TradeContext.BBSSRC+']')
trccan_dict = {}
if not rccpsMap1106CTradeContext2Dtrccan_dict.map(trccan_dict):
return AfaFlowControl.ExitThisFlow('S999','赋值错误')
#=====插入登记簿rcc_trccan====
AfaLoggerFunc.tradeDebug('>>>开始插入数据库')
ret = rccpsDBTrcc_trccan.insertCmt(trccan_dict)
if ret <= 0:
return AfaFlowControl.ExitThisFlow('S999','插入数据库撤销申请登记簿trccan错误,抛弃报文')
#=====更新原撤销申请状态====
trc_update = {}
trc_update_where = {}
trc_update_where['BJEDTE'] = TradeContext.BOJEDT
trc_update_where['BSPSQN'] = TradeContext.BSPSQN
trc_update['CLRESPN']= TradeContext.CLRESPN
ret = rccpsDBTrcc_trccan.updateCmt(trc_update,trc_update_where)
if ret <= 0:
return AfaFlowControl.ExitThisFlow('S999','修改撤销申请登记簿原记录状态错误,抛弃报文')
#=====原汇兑交易流水号,8820抹账使用====
TradeContext.BOJEDT = tran_dict['BJEDTE']
TradeContext.BOSPSQ = tran_dict['BSPSQN']
#=====判断撤销应答标志是否允许撤销 0-允许撤销 1-不允许撤销 ====
if TradeContext.CLRESPN == '1':
#=====发送接收正常回执====
AfaLoggerFunc.tradeDebug('>>>中心不允许撤销,发送成功回执')
out_context_dict = {}
out_context_dict['sysType'] = 'rccpst'
out_context_dict['TRCCO'] = '9900503'
out_context_dict['MSGTYPCO'] = 'SET008'
out_context_dict['RCVMBRCO'] = TradeContext.SNDMBRCO
out_context_dict['SNDMBRCO'] = TradeContext.RCVMBRCO
out_context_dict['SNDBRHCO'] = TradeContext.BESBNO
out_context_dict['SNDCLKNO'] = TradeContext.BETELR
out_context_dict['SNDTRDAT'] = TradeContext.BJEDTE
out_context_dict['SNDTRTIM'] = TradeContext.BJETIM
out_context_dict['MSGFLGNO'] = out_context_dict['SNDMBRCO'] + TradeContext.BJEDTE + TradeContext.SerialNo
out_context_dict['ORMFN'] = TradeContext.MSGFLGNO
out_context_dict['NCCWKDAT'] = TradeContext.NCCworkDate
out_context_dict['OPRTYPNO'] = '99'
out_context_dict['ROPRTPNO'] = TradeContext.OPRTYPNO
out_context_dict['TRANTYP'] = '0'
out_context_dict['ORTRCCO'] = TradeContext.TRCCO
out_context_dict['PRCCO'] = 'RCCI0000'
out_context_dict['STRINFO'] = '成功'
rccpsMap0000Dout_context2CTradeContext.map(out_context_dict)
return True
AfaLoggerFunc.tradeDebug('>>>中心允许撤销,向主机发起记账')
#=====设置sstlog表中原记录状态为：抹账-处理中====
TradeContext.BCSTAT = PL_BCSTAT_HCAC
TradeContext.BDWFLG = PL_BDWFLG_WAIT
if not rccpsState.newTransState(dict['BOJEDT'],dict['BOSPSQ'],TradeContext.BCSTAT,TradeContext.BDWFLG):
return AfaFlowControl.ExitThisFlow('S999','设置状态出错,抛弃此报文')
#=====commit操作====
AfaDBFunc.CommitSql()
AfaLoggerFunc.tradeDebug('>>>开始向主机接口赋值')
#=====设置主机记账/抹账数据====
if TradeContext.BBSSRC == '3':
#=====代销账要发起8813红蓝字记账====
TradeContext.HostCode = '8813'
TradeContext.RCCSMCD = '614' #往撤销
TradeContext.DASQ = ''
TradeContext.RVFG = '0' #红蓝字标志 0
#关彬捷 20080728 修改抹账挂账原因
#TradeContext.NOTE3 = '向主机发起红蓝字记账冲销'
TradeContext.NOTE3 = '中心允许撤销,自动抹账'
TradeContext.RBAC = TradeContext.BESBNO + PL_ACC_NXYDXZ #贷方账号
TradeContext.SBAC = TradeContext.BESBNO + PL_ACC_NXYDQSWZ #借方账号
#=====开始调函数拼贷方账号第25位校验位====
TradeContext.RBAC = rccpsHostFunc.CrtAcc(TradeContext.RBAC, 25)
TradeContext.SBAC = rccpsHostFunc.CrtAcc(TradeContext.SBAC, 25)
AfaLoggerFunc.tradeInfo( '贷方账号:' + TradeContext.RBAC )
AfaLoggerFunc.tradeInfo( '借方账号:' + TradeContext.SBAC )
else:
TradeContext.HostCode = '8820'
#关彬捷 20080728 修改抹账挂账原因
#TradeContext.NOTE3 = '向主机发起抹账'
TradeContext.NOTE3 = '中心允许撤销,自动抹账'
AfaLoggerFunc.tradeDebug('>>>更新sstlog表中原交易状态成功,开始更新交易状态')
#=====设置sstlog标志状态为:抹账-处理中====
if not rccpsState.newTransState(TradeContext.BJEDTE,TradeContext.BSPSQN,TradeContext.BCSTAT,TradeContext.BDWFLG):
return AfaFlowControl.ExitThisFlow('S999','设置状态出错,抛弃此报文')
else:
#=====commit操作====
AfaDBFunc.CommitSql()
AfaLoggerFunc.tradeDebug('>>>开始调用主机函数')
AfaLoggerFunc.tradeDebug('>>>主机交易代码['+TradeContext.HostCode+']')
#=====向主机发起抹账操作====
rccpsHostFunc.CommHost(TradeContext.HostCode)
#=====判断主机返回结果设置状态====
sstlog_dict = {}
sstlog_dict['BJEDTE'] = TradeContext.BJEDTE
AfaLoggerFunc.tradeDebug('>>>交易日期['+TradeContext.BJEDTE+']')
sstlog_dict['BSPSQN'] = TradeContext.BSPSQN
AfaLoggerFunc.tradeDebug('>>>报单序号['+TradeContext.BSPSQN+']')
sstlog_dict['BCSTAT'] = TradeContext.BCSTAT
AfaLoggerFunc.tradeDebug('>>>业务状态['+TradeContext.BCSTAT+']')
sstlog_dict['NOTE4'] = TradeContext.errorMsg
AfaLoggerFunc.tradeDebug('>>>主机返回信息['+TradeContext.errorMsg+']')
sstlog_dict['NOTE3'] = TradeContext.NOTE3
AfaLoggerFunc.tradeDebug('>>>NOTE3['+TradeContext.NOTE3+']')
AfaLoggerFunc.tradeDebug('>>>errorCode['+TradeContext.errorCode+']')
if TradeContext.existVariable('TRDT'):
sstlog_dict['TRDT'] = TradeContext.TRDT
AfaLoggerFunc.tradeDebug('>>>主机日期['+TradeContext.TRDT+']')
if TradeContext.existVariable('TLSQ'):
sstlog_dict['TLSQ'] = TradeContext.TLSQ
AfaLoggerFunc.tradeDebug('>>>主机流水['+TradeContext.TLSQ+']')
if TradeContext.errorCode == '0000':
AfaLoggerFunc.tradeDebug('>>>测试')
if TradeContext.HostCode == '8813':
sstlog_dict['DASQ'] = TradeContext.DASQ
AfaLoggerFunc.tradeDebug('>>>销账序号['+TradeContext.DASQ+']')
sstlog_dict['SBAC'] = TradeContext.SBAC
AfaLoggerFunc.tradeDebug('>>>借方账号['+TradeContext.SBAC+']')
sstlog_dict['RBAC'] = TradeContext.RBAC
AfaLoggerFunc.tradeDebug('>>>贷方账号['+TradeContext.RBAC+']')
AfaLoggerFunc.tradeDebug('>>>测试2')
sstlog_dict['BDWFLG'] = PL_BDWFLG_SUCC
else:
AfaLoggerFunc.tradeDebug('>>>测试1')
sstlog_dict['BDWFLG'] = PL_BDWFLG_FAIL
AfaLoggerFunc.tradeDebug('>>>主机返回信息')
#=====设置原交易状态====
if not rccpsState.setTransState(sstlog_dict):
return AfaFlowControl.ExitThisFlow('S999','更新主机返回信息出错,抛弃报文')
#=====commit操作====
AfaDBFunc.CommitSql()
#=====设置交易状态====
sstlog_dict['BJEDTE'] = TradeContext.BOJEDT
sstlog_dict['BSPSQN'] = TradeContext.BOSPSQ
if not rccpsState.setTransState(sstlog_dict):
return AfaFlowControl.ExitThisFlow('S999','更新主机返回信息出错,抛弃报文')
#=====commit操作====
AfaDBFunc.CommitSql()
#=====发送回执,其它错误====
out_context_dict = {}
out_context_dict['sysType'] = 'rccpst'
out_context_dict['TRCCO'] = '9900503'
out_context_dict['MSGTYPCO'] = 'SET008'
out_context_dict['RCVMBRCO'] = TradeContext.SNDMBRCO
out_context_dict['SNDMBRCO'] = TradeContext.RCVMBRCO
out_context_dict['SNDBRHCO'] = TradeContext.BESBNO
out_context_dict['SNDCLKNO'] = TradeContext.BETELR
out_context_dict['SNDTRDAT'] = TradeContext.BJEDTE
out_context_dict['SNDTRTIM'] = TradeContext.BJETIM
out_context_dict['MSGFLGNO'] = out_context_dict['SNDMBRCO'] + TradeContext.BJEDTE + TradeContext.SerialNo
out_context_dict['ORMFN'] = TradeContext.MSGFLGNO
out_context_dict['NCCWKDAT'] = TradeContext.NCCworkDate
out_context_dict['OPRTYPNO'] = '99'
out_context_dict['ROPRTPNO'] = TradeContext.OPRTYPNO
out_context_dict['TRANTYP'] = '0'
out_context_dict['ORTRCCO'] = TradeContext.TRCCO
out_context_dict['PRCCO'] = 'RCCI0000'
out_context_dict['STRINFO'] = '成功'
rccpsMap0000Dout_context2CTradeContext.map(out_context_dict)
return True
def SubModuleDoFst():
AfaLoggerFunc.tradeInfo(" 农信银系统：来账.中心类操作(1.本地操作).折本转异应答报文接收[TRCC006_1155]进入 ")
#=================初始化返回信息============================================
if AfaUtilTools.trim(TradeContext.STRINFO) == "":
TradeContext.STRINFO = rccpsDBFunc.getErrInfo(TradeContext.PRCCO)
AfaLoggerFunc.tradeDebug("TradeContext.STRINFO=" + TradeContext.STRINFO)
#=================必要性检查===============================================
AfaLoggerFunc.tradeInfo(">>>开始必要性检查")
#=================若交易已被冲正或冲销,则停止处理================================
AfaLoggerFunc.tradeInfo(">>>开始检查此交易是否已被冲正")
where_sql = "ORMFN = '" + TradeContext.ORMFN + "'"
ret = rccpsDBTrcc_atcbka.count(where_sql)
if ret < 0:
return AfaFlowControl.ExitThisFlow("S999","查询冲正登记簿异常,退出主流程")
if ret > 0:
return AfaFlowControl.ExitThisFlow("S999","冲正登记簿中存在对此交易的冲正,退出主流程")
AfaLoggerFunc.tradeInfo(">>>结束检查此交易是否已被冲正")
AfaLoggerFunc.tradeInfo(">>>开始检查此交易是否已被冲销")
ret = rccpsDBTrcc_mpcbka.count(where_sql)
if ret < 0:
return AfaFlowControl.ExitThisFlow("S999","查询冲销登记簿异常,退出主流程")
if ret > 0:
return AfaFlowControl.ExitThisFlow("S999","冲销登记簿中存在对此交易的冲销,退出主流程")
AfaLoggerFunc.tradeInfo(">>>结束检查此交易是否已被冲销")
AfaLoggerFunc.tradeInfo(">>>结束必要性检查")
#=================匹配原交易信息===========================================
AfaLoggerFunc.tradeInfo(">>>开始匹配原交易")
wtr_dict = {}
if not rccpsDBFunc.getTransWtrAK(TradeContext.SNDBNKCO,TradeContext.TRCDAT,TradeContext.TRCNO,wtr_dict):
return AfaFlowControl.ExitThisFlow('S999', "未找到原存款请求交易,停止处理")
TradeContext.BJEDTE = wtr_dict['BJEDTE']
TradeContext.BSPSQN = wtr_dict['BSPSQN']
TradeContext.TRCCO = wtr_dict['TRCCO']
TradeContext.BESBNO = wtr_dict['BESBNO']
TradeContext.BETELR = wtr_dict['BETELR']
TradeContext.OCCAMT = str(wtr_dict['OCCAMT'])
TradeContext.CHRGTYP = wtr_dict['CHRGTYP']
TradeContext.LOCCUSCHRG = str(wtr_dict['CUSCHRG'])
TradeContext.PYRTYP = wtr_dict['PYRTYP']
TradeContext.PYRACC = wtr_dict['PYRACC']
TradeContext.PYRNAM = wtr_dict['PYRNAM']
TradeContext.CERTTYPE = wtr_dict['CERTTYPE']
TradeContext.CERTNO = wtr_dict['CERTNO']
TradeContext.TERMID = wtr_dict['TERMID']
TradeContext.WARNTNO = wtr_dict['BNKBKNO']
AfaLoggerFunc.tradeInfo(">>>结束匹配原交易")
#=================若应答报文回复拒绝,则设置状态为拒绝,停止处理=============
if TradeContext.PRCCO != 'RCCI0000':
AfaLoggerFunc.tradeInfo(">>>对方返回拒绝应答")
#=============设置业务状态为拒绝处理中=================================
if not rccpsState.newTransState(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_MFERFE,PL_BDWFLG_WAIT):
return AfaFlowControl.ExitThisFlow('S999',"设置业务状态为拒绝处理中异常")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
stat_dict = {}
stat_dict['BJEDTE'] = TradeContext.BJEDTE
stat_dict['BSPSQN'] = TradeContext.BSPSQN
stat_dict['BESBNO'] = TradeContext.BESBNO
stat_dict['BETELR'] = TradeContext.BETELR
stat_dict['BCSTAT'] = PL_BCSTAT_MFERFE
stat_dict['BDWFLG'] = PL_BDWFLG_SUCC
stat_dict['PRCCO'] = TradeContext.PRCCO
stat_dict['STRINFO'] = TradeContext.STRINFO
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999', "设置业务状态为拒绝成功异常")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
#=============发起主机抹账=============================================
AfaLoggerFunc.tradeInfo(">>>开始设置业务状态为抹账处理中")
#=====特殊处理 关彬捷 20081127 调8813抹账,需产生新的前置流水号进行记账====
if rccpsGetFunc.GetRBSQ(PL_BRSFLG_SND) == -1 :
return AfaFlowControl.ExisThisFlow('S999',"产生新的前置流水号异常")
#为抹账赋值会计分录
entries_dict = {}
entries_dict['FEDT'] = wtr_dict['BJEDTE']
entries_dict['RBSQ'] = wtr_dict['BSPSQN']
entries_dict['PYRACC'] = wtr_dict['PYRACC']
entries_dict['PYRNAM'] = wtr_dict['PYRNAM']
entries_dict['PYEACC'] = wtr_dict['PYEACC']
entries_dict['PYENAM'] = wtr_dict['PYENAM']
entries_dict['OCCAMT'] = wtr_dict['OCCAMT']
entries_dict['CHRGTYP'] = wtr_dict['CHRGTYP']
entries_dict['CUSCHRG'] = wtr_dict['CUSCHRG']
entries_dict['RCCSMCD'] = PL_RCCSMCD_CZ
TradeContext.BRSFLG = PL_BRSFLG_SND
rccpsEntries.KZBZYWZMZ(entries_dict)
#====设置业务状态为抹账处理中====
if not rccpsState.newTransState(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_HCAC,PL_BDWFLG_WAIT):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态为抹账处理中异常')
AfaLoggerFunc.tradeInfo(">>>结束设置业务状态为抹账处理中")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
#====自动抹账====
AfaLoggerFunc.tradeInfo(">>>开始发起主机抹账")
#=====调起抹账主机接口====
rccpsHostFunc.CommHost( TradeContext.HostCode )
AfaLoggerFunc.tradeInfo(">>>结束发起主机抹账")
stat_dict = {}
stat_dict['BJEDTE'] = TradeContext.BJEDTE
stat_dict['BSPSQN'] = TradeContext.BSPSQN
stat_dict['MGID'] = TradeContext.errorCode
stat_dict['STRINFO'] = TradeContext.errorMsg
AfaLoggerFunc.tradeInfo("TradeContext.errorCode = [" + TradeContext.errorCode + "]")
if TradeContext.errorCode == '0000':
AfaLoggerFunc.tradeInfo(">>>开始设置业务状态为抹账成功")
stat_dict['BCSTAT'] = PL_BCSTAT_HCAC
stat_dict['BDWFLG'] = PL_BDWFLG_SUCC
stat_dict['TRDT'] = TradeContext.TRDT
stat_dict['TLSQ'] = TradeContext.TLSQ
stat_dict['PRTCNT'] = 1
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态抹账成功异常')
AfaLoggerFunc.tradeInfo(">>>结束设置业务状态为抹账成功")
else:
AfaLoggerFunc.tradeInfo(">>>开始设置业务状态为抹账失败")
stat_dict['BCSTAT'] = PL_BCSTAT_HCAC
stat_dict['BDWFLG'] = PL_BDWFLG_FAIL
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态抹账成功异常')
AfaLoggerFunc.tradeInfo(">>>结束设置业务状态为抹账失败")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
return AfaFlowControl.ExitThisFlow("S999","对方拒绝,停止处理")
else:
AfaLoggerFunc.tradeInfo(">>>对方返回成功应答")
#=================设置业务状态为确认付款处理中=============================
AfaLoggerFunc.tradeInfo(">>>开始设置业务状态为确认付款处理中")
if not rccpsState.newTransState(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_CONFPAY,PL_BDWFLG_WAIT):
return AfaFlowControl.ExitThisFlow('S999',"设置业务状态为确认付款处理中异常")
AfaLoggerFunc.tradeInfo(">>>结束设置业务状态为确认付款处理中")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
#=================更新存款确认委托日期和交易流水号=========================
AfaLoggerFunc.tradeInfo(">>>开始更新存款确认委托日期和交易流水号")
wtrbka_update_dict = {}
wtrbka_update_dict['COTRCDAT'] = TradeContext.TRCDAT
wtrbka_update_dict['COTRCNO'] = TradeContext.SerialNo
wtrbka_update_dict['COMSGFLGNO'] = TradeContext.RCVMBRCO + TradeContext.TRCDAT + TradeContext.SerialNo
wtrbka_where_dict = {}
wtrbka_where_dict['BJEDTE'] = TradeContext.BJEDTE
wtrbka_where_dict['BSPSQN'] = TradeContext.BSPSQN
ret = rccpsDBTrcc_wtrbka.update(wtrbka_update_dict,wtrbka_where_dict)
if ret <= 0:
return AfaFlowControl.ExitThisFlow('S999', "更新存款确认委托日期和交易流水号异常")
AfaLoggerFunc.tradeInfo(">>>结束更新存款确认委托日期和交易流水号")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
#=================为存款确认请求报文做准备=================================
AfaLoggerFunc.tradeInfo(">>>开始为存款确认请求报文做准备")
TradeContext.MSGTYPCO = 'SET009'
TradeContext.SNDSTLBIN = TradeContext.RCVMBRCO
TradeContext.RCVSTLBIN = TradeContext.SNDMBRCO
TradeContext.SNDBRHCO = TradeContext.BESBNO
TradeContext.SNDCLKNO = TradeContext.BETELR
#TradeContext.SNDTRDAT = TradeContext.BJEDTE
#TradeContext.SNDTRTIM = TradeContext.BJETIM
#TradeContext.MSGFLGNO = TradeContext.SNDMBRCO + TradeContext.BJEDTE + TradeContext.TRCNO
TradeContext.ORMFN = TradeContext.ORMFN
TradeContext.OPRTYPNO = '30'
TradeContext.ROPRTPNO = '30'
TradeContext.TRANTYP = '0'
TradeContext.ORTRCCO = TradeContext.TRCCO
TradeContext.ORTRCNO = TradeContext.TRCNO
TradeContext.TRCCO = '3000503'
TradeContext.TRCNO = TradeContext.SerialNo
TradeContext.CURPIN = ""
TradeContext.STRINFO = '收到存款应答,自动发送存款确认'
AfaLoggerFunc.tradeInfo(">>>结束为存款确认请求报文做准备")
AfaLoggerFunc.tradeInfo(" 农信银系统：来账.中心类操作(1.本地操作).卡本转异应答报文接收[TRCC006_1155]退出 ")
return True
def SubModuleDoTrd():
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.主机类操作(3.中心记账).行内账户转异地[TRCC002_8563]进入***' )
#=================设置业务状态为发送成功或失败,若发送失败则自动抹账========
stat_dict = {}
stat_dict['BJEDTE'] = TradeContext.BJEDTE
stat_dict['BSPSQN'] = TradeContext.BSPSQN
stat_dict['BESBNO'] = TradeContext.BESBNO
stat_dict['BETELR'] = TradeContext.BETELR
stat_dict['BCSTAT'] = PL_BCSTAT_SND
stat_dict['BDWFLG'] = PL_BDWFLG_SUCC
stat_dict['PRCCO'] = TradeContext.errorCode
stat_dict['STRINFO'] = TradeContext.errorMsg
AfaLoggerFunc.tradeInfo("TradeContext.errorCode = [" + TradeContext.errorCode + "]")
if TradeContext.errorCode == '0000':
AfaLoggerFunc.tradeInfo(">>>开始设置业务状态为发送成功")
stat_dict['BCSTAT'] = PL_BCSTAT_SND
stat_dict['BDWFLG'] = PL_BDWFLG_SUCC
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999', "设置业务状态为发送成功异常")
AfaLoggerFunc.tradeInfo(">>>结束设置业务状态为发送成功")
else:
AfaLoggerFunc.tradeInfo(">>>开始设置业务状态为发送失败")
stat_dict['BCSTAT'] = PL_BCSTAT_SND
stat_dict['BDWFLG'] = PL_BDWFLG_FAIL
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999', "设置业务状态为发送失败异常")
AfaLoggerFunc.tradeInfo(">>>结束设置业务状态为发送失败")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
#=============发起主机抹账=============================================
AfaLoggerFunc.tradeInfo(">>>开始设置业务状态为抹账处理中")
#=====特殊处理 关彬捷 20081127 调8813抹账,需产生新的前置流水号进行记账====
if rccpsGetFunc.GetRBSQ(PL_BRSFLG_SND) == -1 :
return AfaFlowControl.ExisThisFlow('S999',"产生新的前置流水号异常")
#为抹账会计分录赋值
if TradeContext.CHRGTYP == '0':
#现金收取
AfaLoggerFunc.tradeInfo(">>>现金收取手续费")
TradeContext.HostComm = '8813'
TradeContext.ACUR = '2' #重复次数
TradeContext.PKFG = 'T' #通存通兑标识
TradeContext.OCCAMT = "-" + str(TradeContext.OCCAMT) #出票金额
TradeContext.RCCSMCD = PL_RCCSMCD_BZYWZ #主机摘要码:本转异往账
TradeContext.SBAC = TradeContext.PYRACC #借方账号:客户账
TradeContext.ACNM = TradeContext.PYRNAM #借方户名
TradeContext.RBAC = TradeContext.BESBNO + PL_ACC_NXYDQSWZ #贷方账号:汇出汇款
TradeContext.RBAC = rccpsHostFunc.CrtAcc(TradeContext.RBAC,25)
TradeContext.OTNM = "农信银待清算往账"
TradeContext.PASSWD = TradeContext.PASSWD #付款人密码
if TradeContext.PYRTYP == '0':
TradeContext.WARNTNO = TradeContext.SBAC[6:18]
TradeContext.CERTTYPE = TradeContext.CERTTYPE #证件类型
TradeContext.CERTNO = TradeContext.CERTNO #证件号码
TradeContext.CTFG = '7' #本金标识:本金-1
AfaLoggerFunc.tradeInfo("借方账号1:[" + TradeContext.SBAC + "]")
AfaLoggerFunc.tradeInfo("贷方账号1:[" + TradeContext.RBAC + "]")
AfaLoggerFunc.tradeInfo("凭证号码1:[" + TradeContext.WARNTNO + "]")
TradeContext.I2PKFG = 'T' #通存通兑标识
TradeContext.I2RVFG = '2' #红蓝字标志 2
TradeContext.I2CATR = '0' #现转标识:0-现金
TradeContext.I2TRAM = str(TradeContext.LOCCUSCHRG) #手续费金额
TradeContext.I2SMCD = PL_RCCSMCD_SXF #主机摘要码:手续费
TradeContext.I2SBAC = "" #借方账号:柜员尾箱
TradeContext.I2ACNM = ""
TradeContext.I2RBAC = TradeContext.BESBNO + PL_ACC_TCTDSXF #贷方账号:通存通兑手续费
TradeContext.I2RBAC = rccpsHostFunc.CrtAcc(TradeContext.I2RBAC,25)
TradeContext.I2OTNM = "手续费"
TradeContext.I2CTFG = '8' #本金标识:手续费-0
AfaLoggerFunc.tradeInfo("借方账号2:[" + TradeContext.I2SBAC + "]")
AfaLoggerFunc.tradeInfo("贷方账号2:[" + TradeContext.I2RBAC + "]")
else:
TradeContext.HostCode='8820'
TradeContext.BOJEDT = TradeContext.BJEDTE
TradeContext.BOSPSQ = TradeContext.BSPSQN
#====设置业务状态为抹账处理中====
if not rccpsState.newTransState(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_HCAC,PL_BDWFLG_WAIT):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态为抹账处理中异常')
AfaLoggerFunc.tradeInfo(">>>结束设置业务状态为抹账处理中")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
#====自动抹账====
AfaLoggerFunc.tradeInfo(">>>开始发起主机抹账")
#=====调起抹账主机接口====
rccpsHostFunc.CommHost( TradeContext.HostCode )
AfaLoggerFunc.tradeInfo(">>>结束发起主机抹账")
stat_dict = {}
stat_dict['BJEDTE'] = TradeContext.BJEDTE
stat_dict['BSPSQN'] = TradeContext.BSPSQN
stat_dict['MGID'] = TradeContext.errorCode
stat_dict['STRINFO'] = TradeContext.errorMsg
AfaLoggerFunc.tradeInfo("TradeContext.errorCode = [" + TradeContext.errorCode + "]")
if TradeContext.errorCode == '0000':
AfaLoggerFunc.tradeInfo(">>>开始设置业务状态为抹账成功")
stat_dict['BCSTAT'] = PL_BCSTAT_HCAC
stat_dict['BDWFLG'] = PL_BDWFLG_SUCC
stat_dict['TRDT'] = TradeContext.TRDT
stat_dict['TLSQ'] = TradeContext.TLSQ
stat_dict['PRTCNT'] = 1 #打印次数
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态抹账成功异常')
AfaLoggerFunc.tradeInfo(">>>结束设置业务状态为抹账成功")
else:
AfaLoggerFunc.tradeInfo(">>>开始设置业务状态为抹账失败")
stat_dict['BCSTAT'] = PL_BCSTAT_HCAC
stat_dict['BDWFLG'] = PL_BDWFLG_FAIL
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态抹账成功异常')
AfaLoggerFunc.tradeInfo(">>>结束设置业务状态为抹账失败")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.主机类操作(3.中心记账).行内账户转异地[TRCC002_8563]退出***' )
return True
def SubModuleDoFst():
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.主机类操作(1.本地操作).行内账户转异地[TRCC002_8563]进入***' )
#=================必要性检查===============================================
AfaLoggerFunc.tradeInfo(">>>开始必要性检查")
#检查本机构是否有通存通兑业务权限
if not rccpsDBFunc.chkTDBESAuth(TradeContext.BESBNO):
return AfaFlowControl.ExitThisFlow("S999","本机构无通存通兑业务权限")
if TradeContext.PYRTYP == '1':
#折,调用8811校验支付条件
AfaLoggerFunc.tradeInfo(">>>开始校验付款人账号支付条件")
TradeContext.HostCode = '8811'
TradeContext.ACCNO = TradeContext.PYRACC #付款人账户
if TradeContext.PYRTYP == '0':
TradeContext.WARNTNO = TradeContext.PYRACC[6:18]
rccpsHostFunc.CommHost( TradeContext.HostCode )
if TradeContext.errorCode != '0000':
return AfaFlowControl.ExitThisFlow('S999','查询账户支付条件异常:' + TradeContext.errorMsg[7:])
elif TradeContext.PAYTYP != TradeContext.HPAYTYP:
return AfaFlowControl.ExitThisFlow('S999','支付条件错误')
AfaLoggerFunc.tradeInfo(">>>结束校验付款人账号支付条件")
AfaLoggerFunc.tradeInfo(">>>结束必要性检查")
#=================登记通存通兑业务登记簿===================================
AfaLoggerFunc.tradeInfo(">>>开始登记通存通兑业务登记簿")
TradeContext.SNDMBRCO = TradeContext.SNDSTLBIN #发送成员行号
TradeContext.RCVMBRCO = TradeContext.RCVSTLBIN #接收成员行号
TradeContext.TRCNO = TradeContext.SerialNo #交易流水号
TradeContext.NCCWKDAT = TradeContext.NCCworkDate #中心工作日期
TradeContext.MSGFLGNO = TradeContext.SNDMBRCO + TradeContext.TRCDAT + TradeContext.TRCNO
TradeContext.OPRNO = PL_TDOPRNO_BZY #业务种类:行内账户转异地
TradeContext.DCFLG = PL_DCFLG_CRE #借贷标识:贷记
TradeContext.BRSFLG = PL_BRSFLG_SND #往来标识:往账
#if TradeContext.PYITYP == '0' or '2':
# TradeContext.TRCCO = '3000003' #交易代码:3000003卡本转异
#elif TradeContext.PYITYP == '1' or '3':
# TradeContext.TRCCO = '3000005' #交易代码:3000005折本转异
#else:
# return AfaFlowContorl.ExitThisFlow("S999","收款人账户非法")
TradeContext.PYRMBRCO = TradeContext.SNDSTLBIN
TradeContext.PYEMBRCO = TradeContext.RCVSTLBIN
wtrbka_dict = {}
if not rccpsMap8563CTradeContext2Dwtrbka_dict.map(wtrbka_dict):
return AfaFlowContorl.ExitThisFlow("S999","为通存通兑业务登记簿赋值异常")
if not rccpsDBFunc.insTransWtr(wtrbka_dict):
return AfaFlowControl.ExitThisFlow('S999','登记通存通兑业务登记簿异常')
AfaLoggerFunc.tradeInfo(">>>结束登记通存通兑业务登记簿")
#=================设置业务状态为记账处理中=================================
AfaLoggerFunc.tradeInfo(">>>开始设置业务状态为记账处理中")
stat_dict = {}
stat_dict['BJEDTE'] = TradeContext.BJEDTE #交易日期
stat_dict['BSPSQN'] = TradeContext.BSPSQN #报单序号
stat_dict['BCSTAT'] = PL_BCSTAT_ACC #PL_BCSTAT_ACC 记账
stat_dict['BDWFLG'] = PL_BDWFLG_WAIT #PL_BDWFLG_WAIT 处理中
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999','设置状态为记账处理中异常')
AfaLoggerFunc.tradeInfo(">>>结束设置业务状态为记账处理中")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
AfaLoggerFunc.tradeInfo(">>>结束设置业务状态为记账处理中")
#=================为主机记账做准备=========================================
AfaLoggerFunc.tradeInfo(">>>开始为主机记账做准备")
TradeContext.HostCode = '8813'
TradeContext.PKFG = 'T' #通存通兑标识
TradeContext.OCCAMT = str(TradeContext.OCCAMT) #出票金额
TradeContext.RCCSMCD = PL_RCCSMCD_BZYWZ #主机摘要码:本转异往账
TradeContext.SBAC = TradeContext.PYRACC #借方账号:客户账
TradeContext.ACNM = TradeContext.PYRNAM #借方户名
TradeContext.RBAC = TradeContext.BESBNO + PL_ACC_NXYDQSWZ #贷方账号:汇出汇款
TradeContext.RBAC = rccpsHostFunc.CrtAcc(TradeContext.RBAC,25)
TradeContext.OTNM = "农信银待清算往账"
TradeContext.PASSWD = TradeContext.PASSWD #付款人密码
AfaLoggerFunc.tradeInfo("PYRTYP = [" + TradeContext.PYRTYP + "]")
if TradeContext.PYRTYP == '0':
TradeContext.WARNTNO = TradeContext.SBAC[6:18]
TradeContext.CERTTYPE = TradeContext.CERTTYPE #证件类型
TradeContext.CERTNO = TradeContext.CERTNO #证件号码
TradeContext.CTFG = '7' #结转标识:结转-0
AfaLoggerFunc.tradeInfo("借方账号1:[" + TradeContext.SBAC + "]")
AfaLoggerFunc.tradeInfo("贷方账号1:[" + TradeContext.RBAC + "]")
AfaLoggerFunc.tradeInfo("凭证号码1:[" + TradeContext.WARNTNO + "]")
if TradeContext.CHRGTYP == '0':
#现金收取
AfaLoggerFunc.tradeInfo(">>>现金收取手续费")
TradeContext.ACUR = '2' #重复次数
TradeContext.I2PKFG = 'T' #通存通兑标识
TradeContext.I2CATR = '0' #现转标识:0-现金
TradeContext.I2TRAM = str(TradeContext.CUSCHRG) #手续费金额
TradeContext.I2SMCD = PL_RCCSMCD_SXF #主机摘要码:手续费
TradeContext.I2SBAC = "" #借方账号:柜员尾箱
TradeContext.I2ACNM = ""
TradeContext.I2RBAC = TradeContext.BESBNO + PL_ACC_TCTDSXF #贷方账号:通存通兑手续费
TradeContext.I2RBAC = rccpsHostFunc.CrtAcc(TradeContext.I2RBAC,25)
TradeContext.I2OTNM = "手续费"
TradeContext.I2CTFG = '8' #结转标识:不结转-1
elif TradeContext.CHRGTYP == '1':
#本地账户收取
AfaLoggerFunc.tradeInfo(">>>本地账户收取手续费")
TradeContext.ACUR = '2' #重复次数
TradeContext.I2PKFG = '8' #通存通兑标识
TradeContext.I2TRAM = str(TradeContext.CUSCHRG) #手续费金额
TradeContext.I2SMCD = PL_RCCSMCD_SXF #主机摘要码:手续费
TradeContext.I2SBAC = TradeContext.PYRACC #借方账号:客户账
TradeContext.I2ACNM = TradeContext.PYRNAM
TradeContext.I2RBAC = TradeContext.BESBNO + PL_ACC_TCTDSXF #贷方账号:通存通兑手续费
TradeContext.I2RBAC = rccpsHostFunc.CrtAcc(TradeContext.I2RBAC,25)
TradeContext.I2OTNM = "手续费"
TradeContext.I2PSWD = TradeContext.PASSWD #付款人密码
TradeContext.I2WARNTNO = TradeContext.WARNTNO
TradeContext.I2CERTTYPE = TradeContext.CERTTYPE #证件类型
TradeContext.I2CERTNO = TradeContext.CERTNO #证件号码
TradeContext.I2CTFG = 'T' #结转标识:不结转-1
else:
AfaLoggerFunc.tradeInfo(">>>不收手续费")
if TradeContext.existVariable("I2SBAC") and TradeContext.existVariable('I2RBAC'):
AfaLoggerFunc.tradeInfo("借方账号2:[" + TradeContext.I2SBAC + "]")
AfaLoggerFunc.tradeInfo("贷方账号2:[" + TradeContext.I2RBAC + "]")
AfaLoggerFunc.tradeInfo(">>>结束为主机记账做准备")
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.主机类操作(1.本地操作).行内账户转异地[TRCC002_8563]退出***' )
return True
def SubModuleDoFst():
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.回执类操作(1.回执操作).通存通兑业务回执报文接收[TRC004_1147]进入***' )
#=================初始化返回信息============================================
if AfaUtilTools.trim(TradeContext.STRINFO) == "":
TradeContext.STRINFO = rccpsDBFunc.getErrInfo(TradeContext.PRCCO)
AfaLoggerFunc.tradeDebug("TradeContext.STRINFO=" + TradeContext.STRINFO)
#=================匹配原交易信息===========================================
wtrbka_where_dict = {}
wtrbka_where_dict['MSGFLGNO'] = TradeContext.ORMFN
wtrbka_dict = {}
wtrbka_dict = rccpsDBTrcc_wtrbka.selectu(wtrbka_where_dict)
if wtrbka_dict == None:
return AfaFlowControl.ExitThisFlow('S999', "查询通存通兑业务信息登记簿异常")
if len(wtrbka_dict) > 0:
TradeContext.BJEDTE = wtrbka_dict['BJEDTE']
TradeContext.BSPSQN = wtrbka_dict['BSPSQN']
TradeContext.TRCCO = wtrbka_dict['TRCCO']
TradeContext.BESBNO = wtrbka_dict['BESBNO']
TradeContext.BETELR = wtrbka_dict['BETELR']
TradeContext.OCCAMT = str(wtrbka_dict['OCCAMT'])
TradeContext.CHRGTYP = wtrbka_dict['CHRGTYP']
TradeContext.LOCCUSCHRG = str(wtrbka_dict['CUSCHRG'])
TradeContext.PYETYP = wtrbka_dict['PYETYP']
TradeContext.PYEACC = wtrbka_dict['PYEACC']
TradeContext.PYENAM = wtrbka_dict['PYENAM']
TradeContext.PYRTYP = wtrbka_dict['PYRTYP']
TradeContext.PYRACC = wtrbka_dict['PYRACC']
TradeContext.PYRNAM = wtrbka_dict['PYRNAM']
TradeContext.CERTTYPE = wtrbka_dict['CERTTYPE']
TradeContext.CERTNO = wtrbka_dict['CERTNO']
TradeContext.TERMID = wtrbka_dict['TERMID']
TradeContext.WARNTNO = wtrbka_dict['BNKBKNO']
#============设置原交易状态为拒绝======================================
AfaLoggerFunc.tradeInfo(">>>开始设置原交易业务状态为拒绝处理中")
if not rccpsState.newTransState(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_MFERFE,PL_BDWFLG_WAIT):
return AfaFlowControl.ExitThisFlow('S999',"设置业务状态为拒绝处理中异常")
AfaLoggerFunc.tradeInfo(">>>结束设置原交易业务状态为拒绝处理中")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
AfaLoggerFunc.tradeInfo(">>>Commit成功")
AfaLoggerFunc.tradeInfo(">>>开始设置原交易业务状态为拒绝成功")
stat_dict = {}
stat_dict['BJEDTE'] = TradeContext.BJEDTE
stat_dict['BSPSQN'] = TradeContext.BSPSQN
stat_dict['BCSTAT'] = PL_BCSTAT_MFERFE
stat_dict['BDWFLG'] = PL_BDWFLG_SUCC
stat_dict['PRCCO'] = TradeContext.PRCCO
stat_dict['STRINFO'] = TradeContext.STRINFO
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999', "设置业务状态为拒绝成功异常")
AfaLoggerFunc.tradeInfo(">>>结束设置原交易业务状态为拒绝成功")
else:
AfaLoggerFunc.tradeInfo(">>>通存通兑业务登记簿中未找到原请求交易信息,开始查询原存款确认信息")
wtrbka_where_dict = {}
wtrbka_where_dict['COMSGFLGNO'] = TradeContext.ORMFN
wtrbka_dict = {}
wtrbka_dict = rccpsDBTrcc_wtrbka.selectu(wtrbka_where_dict)
if wtrbka_dict == None:
return AfaFlowControl.ExitThisFlow('S999', "查询通存通兑业务信息登记簿异常")
if len(wtrbka_dict) > 0:
TradeContext.BJEDTE = wtrbka_dict['BJEDTE']
TradeContext.BSPSQN = wtrbka_dict['BSPSQN']
TradeContext.TRCCO = wtrbka_dict['TRCCO']
TradeContext.BESBNO = wtrbka_dict['BESBNO']
TradeContext.BETELR = wtrbka_dict['BETELR']
TradeContext.OCCAMT = str(wtrbka_dict['OCCAMT'])
TradeContext.CHRGTYP = wtrbka_dict['CHRGTYP']
TradeContext.LOCCUSCHRG = str(wtrbka_dict['CUSCHRG'])
TradeContext.PYETYP = wtrbka_dict['PYETYP']
TradeContext.PYEACC = wtrbka_dict['PYEACC']
TradeContext.PYENAM = wtrbka_dict['PYENAM']
TradeContext.PYRTYP = wtrbka_dict['PYRTYP']
TradeContext.PYRACC = wtrbka_dict['PYRACC']
TradeContext.PYRNAM = wtrbka_dict['PYRNAM']
TradeContext.CERTTYPE = wtrbka_dict['CERTTYPE']
TradeContext.CERTNO = wtrbka_dict['CERTNO']
TradeContext.TERMID = wtrbka_dict['TERMID']
TradeContext.WARNTNO = wtrbka_dict['BNKBKNO']
#============设置原交易状态为拒绝======================================
AfaLoggerFunc.tradeInfo(">>>开始设置原交易业务状态为拒绝处理中")
if not rccpsState.newTransState(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_MFERFE,PL_BDWFLG_WAIT):
return AfaFlowControl.ExitThisFlow('S999',"设置业务状态为拒绝处理中异常")
AfaLoggerFunc.tradeInfo(">>>结束设置原交易业务状态为拒绝处理中")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
AfaLoggerFunc.tradeInfo(">>>Commit成功")
AfaLoggerFunc.tradeInfo(">>>开始设置原交易业务状态为拒绝成功")
stat_dict = {}
stat_dict['BJEDTE'] = TradeContext.BJEDTE
stat_dict['BSPSQN'] = TradeContext.BSPSQN
stat_dict['BESBNO'] = TradeContext.BESBNO
stat_dict['BETELR'] = TradeContext.BETELR
stat_dict['BCSTAT'] = PL_BCSTAT_MFERFE
stat_dict['BDWFLG'] = PL_BDWFLG_SUCC
stat_dict['PRCCO'] = TradeContext.PRCCO
stat_dict['STRINFO'] = TradeContext.STRINFO
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999', "设置业务状态为拒绝成功异常")
AfaLoggerFunc.tradeInfo(">>>结束设置原交易业务状态为拒绝成功")
else:
AfaLoggerFunc.tradeInfo(">>>通存通兑业务登记簿中未找到原存款确认信息,开始查询余额查询登记簿")
balbka_where_dict = {}
balbka_where_dict['MSGFLGNO'] = TradeContext.ORMFN
balbka_dict = {}
balbka_dict = rccpsDBTrcc_balbka.selectu(balbka_where_dict)
if balbka_dict == None:
return AfaFlowControl.ExitThisFlow('S999', "查询余额查询登记簿异常")
if len(balbka_dict) > 0:
TradeContext.TRCCO = balbka_dict['TRCCO']
#=====更新原余额查询交易返回码=================================
AfaLoggerFunc.tradeInfo(">>>开始更新原余额查询交易返回码")
balbka_update_dict = {}
balbka_update_dict['PRCCO'] = TradeContext.PRCCO
balbka_update_dict['STRINFO'] = TradeContext.STRINFO
ret = rccpsDBTrcc_balbka.update(balbka_update_dict,balbka_where_dict)
if ret <= 0:
return AfaFlowControl.ExitThisFlow('S999', "更新原余额查询交易返回码异常")
AfaLoggerFunc.tradeInfo(">>>结束更新原余额查询交易返回码")
else:
AfaLoggerFunc.tradeInfo(">>>余额查询登记簿中未找到原交易信息,开始查询自动冲正登记簿")
atcbka_where_dict = {}
atcbka_where_dict['MSGFLGNO'] = TradeContext.ORMFN
atcbka_dict = {}
atcbka_dict = rccpsDBTrcc_atcbka.selectu(atcbka_where_dict)
if atcbka_dict == None:
return AfaFlowControl.ExitThisFlow('S999', "查询自动冲正登记簿异常")
if len(atcbka_dict) > 0:
TradeContext.BOJEDT = atcbka_dict['BOJEDT']
TradeContext.BOSPSQ = atcbka_dict['BOSPSQ']
TradeContext.TRCCO = atcbka_dict['TRCCO']
#====更新自动冲正交易返回码================================
AfaLoggerFunc.tradeInfo(">>>开始更新原自动冲正交易返回码")
atcbka_update_dict = {}
atcbka_update_dict['PRCCO'] = TradeContext.PRCCO
atcbka_update_dict['STRINFO'] = TradeContext.STRINFO
ret = rccpsDBTrcc_atcbka.update(atcbka_update_dict,atcbka_where_dict)
if ret<= 0:
return AfaFlowControl.ExitThisFlow('S999', "更新原冲正交易返回码异常")
AfaLoggerFunc.tradeInfo(">>>结束更新原自动冲正交易返回码")
#====设置原被冲正交易业务状态为冲正失败================
#AfaLoggerFunc.tradeInfo(">>>开始设置原被冲正交易业务状态为冲正失败")
#
#stat_dict = {}
#stat_dict['BJEDTE'] = TradeContext.BOJEDT
#stat_dict['BSPSQN'] = TradeContext.BOSPSQ
#stat_dict['BCSTAT'] = PL_BCSTAT_CANC
#stat_dict['BDWFLG'] = PL_BDWFLG_FAIL
#stat_dict['PRCCO'] = TradeContext.PRCCO
#stat_dict['STRINFO'] = TradeContext.STRINFO
#
#if not rccpsState.setTransState(stat_dict):
# return AfaFlowControl.ExitThisFlow('S999', "设置业务状态为冲正失败异常")
#
#AfaLoggerFunc.tradeInfo(">>>结束设置原被冲正交易业务状态为冲正失败")
else:
AfaLoggerFunc.tradeInfo(">>>自动冲正登记簿中未找到原交易信息,开始查询柜面冲销登记簿")
mpcbka_where_dict = {}
mpcbka_where_dict['MSGFLGNO'] = TradeContext.ORMFN
mpcbka_dict = {}
mpcbka_dict = rccpsDBTrcc_mpcbka.selectu(mpcbka_where_dict)
if mpcbka_dict == None:
return AfaFlowControl.ExitThisFlow('S999', "查询柜面冲销登记簿异常")
if len(mpcbka_dict) > 0:
TradeContext.BOJEDT = mpcbka_dict['BOJEDT']
TradeContext.BOSPSQ = mpcbka_dict['BOSPSQ']
TradeContext.TRCCO = mpcbka_dict['TRCCO']
TradeContext.ORTRCCO = mpcbka_dict['ORTRCCO']
TradeContext.BESBNO = mpcbka_dict['BESBNO']
TradeContext.BETELR = mpcbka_dict['BETELR']
TradeContext.TERMID = mpcbka_dict['TERMID']
#====更新柜台冲销交易返回码================================
AfaLoggerFunc.tradeInfo(">>>开始更新原柜台冲销交易返回码")
mpcbka_update_dict = {}
mpcbka_update_dict['PRCCO'] = TradeContext.PRCCO
mpcbka_update_dict['STRINFO'] = TradeContext.STRINFO
ret = rccpsDBTrcc_mpcbka.update(mpcbka_update_dict,mpcbka_where_dict)
if ret <=0:
return AfaFlowControl.ExitThisFlow('S999', "更新原柜面冲销交易返回码异常")
AfaLoggerFunc.tradeInfo(">>>结束更新原柜面冲销交易返回码")
#====设置原被冲销交易业务状态为冲销失败================
#AfaLoggerFunc.tradeInfo(">>>开始设置原被冲销交易业务状态为冲销处理中")
#
#if not rccpsState.newTransState(TradeContext.BOJEDT,TradeContext.BOSPSQ,PL_BCSTAT_CANC,PL_BDWFLG_WAIT):
# return AfaFlowControl.ExitThisFlow('S999', "设置业务状态为冲销失败异常")
#
#AfaLoggerFunc.tradeInfo(">>>结束设置原被冲销交易业务状态为冲销处理中")
#
#if not AfaDBFunc.CommitSql( ):
# AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
# return AfaFlowControl.ExitThisFlow("S999","Commit异常")
#AfaLoggerFunc.tradeInfo(">>>Commit成功")
#
#AfaLoggerFunc.tradeInfo(">>>开始设置原被冲销交易业务状态为冲销失败")
#
#stat_dict = {}
#
#stat_dict['BJEDTE'] = TradeContext.BJEDTE
#stat_dict['BSPSQN'] = TradeContext.BSPSQN
#stat_dict['PRCCO'] = TradeContext.PRCCO
#stat_dict['STRINFO'] = TradeContext.STRINFO
#stat_dict['BCSTAT'] = PL_BCSTAT_CANC
#stat_dict['BDWFLG'] = PL_BDWFLG_FAIL
#
#AfaLoggerFunc.tradeInfo(">>>结束设置原被冲销交易业务状态为冲销失败")
else:
return AfaFlowControl.ExitThisFlow('S999', "未找到原交易信息,丢弃报文")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
AfaLoggerFunc.tradeInfo(">>>Commit成功")
#=================若原交易为通存交易,开始自动抹账==========================
if TradeContext.TRCCO == '3000002' or TradeContext.TRCCO == '3000003' or TradeContext.TRCCO == '3000004' or TradeContext.TRCCO == '3000005':
#=====特殊处理 关彬捷 20081127 调8813抹账,需产生新的前置流水号进行记账====
if rccpsGetFunc.GetRBSQ(PL_BRSFLG_SND) == -1 :
return AfaFlowControl.ExisThisFlow('S999',"产生新的前置流水号异常")
else:
AfaLoggerFunc.tradeInfo(">>>成功产生新的前置流水号")
#为抹账赋值会计分录
entries_dict = {}
entries_dict['FEDT'] = TradeContext.BJEDTE
entries_dict['RBSQ'] = TradeContext.BSPSQN
entries_dict['PYRACC'] = TradeContext.PYRACC
entries_dict['PYRNAM'] = TradeContext.PYRNAM
entries_dict['PYEACC'] = TradeContext.PYEACC
entries_dict['PYENAM'] = TradeContext.PYENAM
entries_dict['OCCAMT'] = TradeContext.OCCAMT
entries_dict['CHRGTYP'] = TradeContext.CHRGTYP
entries_dict['CUSCHRG'] = TradeContext.LOCCUSCHRG
entries_dict['RCCSMCD'] = PL_RCCSMCD_CX
TradeContext.BRSFLG = PL_BRSFLG_SND
if TradeContext.TRCCO == '3000002' or TradeContext.TRCCO == '3000004':
rccpsEntries.KZTCWZMZ(entries_dict)
if TradeContext.TRCCO == '3000003' or TradeContext.TRCCO == '3000005':
rccpsEntries.KZBZYWZMZ(entries_dict)
#=============设置原交易业务状态为抹账处理中===========================
AfaLoggerFunc.tradeInfo(">>>开始设置原交易业务状态为抹账处理中")
#====设置业务状态为抹账处理中====
if not rccpsState.newTransState(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_HCAC,PL_BDWFLG_WAIT):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态为抹账处理中异常')
AfaLoggerFunc.tradeInfo(">>>结束设置原交易业务状态为抹账处理中")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
#=============开始发起主机抹账=========================================
AfaLoggerFunc.tradeInfo(">>>开始主机抹账")
#=====调起抹账主机接口====
rccpsHostFunc.CommHost( TradeContext.HostCode )
AfaLoggerFunc.tradeInfo(">>>结束主机抹账")
AfaLoggerFunc.tradeInfo("TradeContext.errorCode = [" + TradeContext.errorCode + "]")
stat_dict = {}
stat_dict['BJEDTE'] = TradeContext.BJEDTE
stat_dict['BSPSQN'] = TradeContext.BSPSQN
stat_dict['MGID'] = TradeContext.errorCode
stat_dict['STRINFO'] = TradeContext.errorMsg
if TradeContext.errorCode == '0000':
#=========设置原交易业务状态为抹账成功=============================
AfaLoggerFunc.tradeInfo(">>>开始设置业务状态为抹账成功")
stat_dict['BCSTAT'] = PL_BCSTAT_HCAC
stat_dict['BDWFLG'] = PL_BDWFLG_SUCC
stat_dict['TRDT'] = TradeContext.TRDT
stat_dict['TLSQ'] = TradeContext.TLSQ
stat_dict['PRTCNT'] = 1
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态抹账成功异常')
AfaLoggerFunc.tradeInfo(">>>结束设置业务状态为抹账成功")
else:
#=========设置原交易业务状态为抹账失败=============================
AfaLoggerFunc.tradeInfo(">>>开始设置业务状态为抹账失败")
stat_dict['BCSTAT'] = PL_BCSTAT_HCAC
stat_dict['BDWFLG'] = PL_BDWFLG_FAIL
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态抹账成功异常')
AfaLoggerFunc.tradeInfo(">>>结束设置业务状态为抹账失败")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.回执类操作(1.回执操作).通存通兑业务回执报文接收[TRC004_1147]退出***' )
return True
def SubModuleDoFst():
AfaLoggerFunc.tradeInfo( '***农信银系统：来账.中心类操作(1.本地操作).卡通存请求报文接收[TRCC006_1135]进入***' )
#判断是否重复交易
AfaLoggerFunc.tradeInfo(">>>开始判断是否重复报文")
sel_dict = {'TRCNO':TradeContext.TRCNO,'TRCDAT':TradeContext.TRCDAT,'SNDBNKCO':TradeContext.SNDBNKCO}
record = rccpsDBTrcc_wtrbka.selectu(sel_dict)
if record == None:
return AfaFlowControl.ExitThisFlow('S999','判断是否重复报文，查询通存通兑业务登记簿相同报文异常')
elif len(record) > 0:
AfaLoggerFunc.tradeInfo('通存通兑业务登记簿中存在相同数据,重复报文,返回拒绝应答报文')
#=====为应答报文赋值====
TradeContext.sysType = 'rccpst'
TradeContext.MSGTYPCO = 'SET006'
TradeContext.RCVSTLBIN = TradeContext.SNDMBRCO
TradeContext.SNDSTLBIN = TradeContext.RCVMBRCO
TradeContext.SNDBRHCO = TradeContext.BESBNO
TradeContext.SNDCLKNO = TradeContext.BETELR
#TradeContext.SNDTRDAT = TradeContext.BJEDTE
#TradeContext.BJEDTE = TradeContext.SNDTRDAT
#TradeContext.SNDTRTIM = TradeContext.BJETIM
TradeContext.ORMFN = TradeContext.MSGFLGNO
#TradeContext.MSGFLGNO = TradeContext.SNDMBRCO + TradeContext.SNDTRDAT + TradeContext.SerialNo
TradeContext.NCCWKDAT = TradeContext.NCCworkDate
TradeContext.OPRTYPNO = '30'
TradeContext.ROPRTPNO = TradeContext.OPRTYPNO
TradeContext.TRANTYP = '0'
TradeContext.CUR = 'CNY'
TradeContext.PRCCO = 'NN1IM101'
TradeContext.STRINFO = "重复报文"
#=====发送afe====
AfaAfeFunc.CommAfe()
return AfaFlowControl.ExitThisFlow('S999','重复报文，退出处理流程')
AfaLoggerFunc.tradeInfo(">>>结束判断是否重复报文")
#登记通存通兑登记簿
AfaLoggerFunc.tradeInfo(">>>开始登记通存通兑业务登记簿")
#=====币种转换====
if TradeContext.CUR == 'CNY':
TradeContext.CUR = '01'
#=====手续费收取方式=====
if float(TradeContext.CUSCHRG) > 0.001:
TradeContext.CHRGTYP = '1'
else:
TradeContext.CHRGTYP = '0'
#====开始向字典赋值====
wtrbka_dict = {}
if not rccpsMap1135CTradeContext2Dwtrbka_dict.map(wtrbka_dict):
return AfaFlowControl.ExitThisFlow('M999', '字典赋值出错')
wtrbka_dict['DCFLG'] = PL_DCFLG_CRE #借贷标识
wtrbka_dict['OPRNO'] = PL_TDOPRNO_TC #业务种类
#=====开始插入数据库====
if not rccpsDBFunc.insTransWtr(wtrbka_dict):
return False
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
AfaLoggerFunc.tradeInfo(">>>结束登记通存通兑业务登记簿")
#设置业务状态为行内收妥成功
AfaLoggerFunc.tradeInfo(">>>开始设置业务状态为收妥成功")
stat_dict = {}
stat_dict['BSPSQN'] = TradeContext.BSPSQN
stat_dict['BJEDTE'] = TradeContext.BJEDTE
stat_dict['BCSTAT'] = PL_BCSTAT_BNKRCV
stat_dict['BDWFLG'] = PL_BDWFLG_SUCC
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态收妥成功异常')
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
AfaLoggerFunc.tradeInfo(">>>结束设置业务状态为收妥成功")
#设置业务状态为确认入账处理中
AfaLoggerFunc.tradeInfo(">>>开始设置业务状态为确认入账处理中")
if not rccpsState.newTransState(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_CONFACC,PL_BDWFLG_WAIT):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态为确认入账处理中异常')
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
AfaLoggerFunc.tradeInfo(">>>开始设置业务状态为确认入账处理中")
#初始化返回码
TradeContext.PRCCO = 'RCCI0000'
TradeContext.STRINFO = "成功"
TradeContext.BCSTAT = PL_BCSTAT_CONFACC #状态:确认付款
TradeContext.BCSTATNM = "确认付款"
#进行必要性检查,若校验通过,则返回成功应答报文,若校验未通过,则返回拒绝应答报文
AfaLoggerFunc.tradeInfo(">>>开始必要性检查")
#检查冲正登记簿中是否有此笔业务的冲正业务,存在则返回拒绝应答报文,并设置业务状态为冲正处理中
if TradeContext.PRCCO == 'RCCI0000':
atcbka_where_dict = {}
atcbka_where_dict['ORMFN'] = TradeContext.MSGFLGNO
atcbka_dict = rccpsDBTrcc_atcbka.selectu(atcbka_where_dict)
if atcbka_dict == None:
#return AfaFlowControl.ExitThisFlow('S999', "查询冲正登记簿异常")
AfaLoggerFunc.tradeInfo(">>>查询冲正登记簿异常")
TradeContext.PRCCO = 'NN1ID003'
TradeContext.STRINFO = "系统错误,查询冲正登记簿异常"
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
else:
if len(atcbka_dict) <= 0:
AfaLoggerFunc.tradeInfo(">>>此交易未被冲正,继续校验")
else:
AfaLoggerFunc.tradeInfo(">>>此交易已被冲正,返回拒绝应答报文")
TradeContext.PRCCO = 'NN1IO307'
TradeContext.STRINFO = "此交易已被冲正"
TradeContext.BCSTAT = PL_BCSTAT_CANC
TradeContext.BCSTATNM = "冲正"
#唐斌新增#
sql = "SELECT ischkactname,ischklate FROM rcc_chlabt where transcode='"+TradeContext.TransCode+"' and channelno= '"+(TradeContext.SNDCLKNO)[6:8]+"'"
AfaLoggerFunc.tradeInfo(sql)
records = AfaDBFunc.SelectSql( sql)
if (records == None):
return False
elif (len(records) == 0):
AfaLoggerFunc.tradeDebug("查询结果为空,查询条件[" + sql + "]")
return False
AfaLoggerFunc.tradeDebug(str(records))
#校验账户状态是否正常和账号户名是否相符
if TradeContext.PRCCO == 'RCCI0000':
#调用主机接口查询账户信息
TradeContext.HostCode = '8810'
TradeContext.ACCNO = TradeContext.PYEACC
AfaLoggerFunc.tradeDebug("ACCNO :" + TradeContext.ACCNO)
rccpsHostFunc.CommHost( TradeContext.HostCode )
if TradeContext.errorCode != '0000':
#return AfaFlowControl.ExitThisFlow(TradeContext.errorCode,TradeContext.errorMsg)
AfaLoggerFunc.tradeInfo("查询账户信息异常,主机返回码[" + TradeContext.errorCode + "],主机返回信息[" + TradeContext.errorMsg +"]")
TradeContext.PRCCO = rccpsDBFunc.HostErr2RccErr(TradeContext.errorCode)
TradeContext.STRINFO = "查询主机账户信息失败 " + TradeContext.errorMsg
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
else:
#TradeContext.PYENAM = AfaUtilTools.trim(TradeContext.PYENAM)
AfaLoggerFunc.tradeInfo(">>>查询主机账户成功")
#if TradeContext.BESBNO != PL_BESBNO_BCLRSB:
# AfaLoggerFunc.tradeInfo(">>>" + TradeContext.BESBNO + ">>>" + TradeContext.ACCSO)
# if( TradeContext.BESBNO[:6] != TradeContext.ACCSO[:6] ):
# AfaLoggerFunc.tradeInfo(">>>不许跨法人做此交易")
# TradeContext.PRCCO = 'NN1IO999'
# TradeContext.STRINFO = "接收行与账户开户行不属于同一法人"
# TradeContext.BCSTAT = PL_BCSTAT_MFERFE
# TradeContext.BCSTATNM = "拒绝"
#检查本机构是否有通存通兑业务权限
if not rccpsDBFunc.chkTDBESAuth(TradeContext.ACCSO):
TradeContext.PRCCO = 'NN1IO999'
TradeContext.STRINFO = "本账户开户机构无通存通兑业务权限"
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
if TradeContext.PRCCO == 'RCCI0000':
#查询成功,更新通存通兑登记簿账务机构号
AfaLoggerFunc.tradeInfo(">>>开始更新机构号为开户机构")
TradeContext.BESBNO = TradeContext.ACCSO
wtrbka_update_dict = {'BESBNO':TradeContext.ACCSO}
wtrbka_where_dict = {'BJEDTE':TradeContext.BJEDTE,'BSPSQN':TradeContext.BSPSQN}
ret = rccpsDBTrcc_wtrbka.updateCmt(wtrbka_update_dict,wtrbka_where_dict)
if ret <= 0:
AfaLoggerFunc.tradeInfo(">>>更新机构号为开户机构异常")
TradeContext.PRCCO = 'NN1ID006'
TradeContext.STRINFO = "系统错误,更新账务机构号异常"
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
else:
AfaLoggerFunc.tradeInfo(">>>更新机构号为开户机构成功")
AfaLoggerFunc.tradeDebug("主机返回户名ACCNM :[" + TradeContext.ACCNM + "]")
AfaLoggerFunc.tradeDebug("报文接收户名PYENAM:[" + TradeContext.PYENAM + "]")
AfaLoggerFunc.tradeDebug("主机返回账户状态ACCST:[" + TradeContext.ACCST + "]")
if TradeContext.ACCNM != TradeContext.PYENAM:
#唐斌新增#
if(records[0][0]=='1'):
AfaLoggerFunc.tradeInfo(">>>账号户名不符")
TradeContext.PRCCO = 'NN1IA102'
TradeContext.STRINFO = '账号户名不符'
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
elif TradeContext.ACCST != '0' and TradeContext.ACCST != '2':
AfaLoggerFunc.tradeInfo(">>>账户状态不正常")
TradeContext.PRCCO = 'NN1IA999'
TradeContext.STRINFO = '账户状态不正常'
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
elif not (TradeContext.ACCCD == '0428' and TradeContext.ACCEM == '21111'):
AfaLoggerFunc.tradeInfo(">>>此账户非个人结算户")
TradeContext.PRCCO = 'NN1IA999'
TradeContext.STRINFO = '此账户非个人结算户'
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
#校验磁道信息 关彬捷 20081215
#唐斌新增#
if TradeContext.PRCCO == 'RCCI0000':
if(records[0][1]=='1'):
if (TradeContext.SCTRKINF == ''.rjust(37,'0') or TradeContext.SCTRKINF == ''):
AfaLoggerFunc.tradeInfo("校验磁道信息异常,该业务必须产生磁道信息")
TradeContext.PRCCO = 'NN1IA141'
TradeContext.STRINFO = "校验磁道信息失败 :无磁道信息"
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
if TradeContext.SCTRKINF != ''.rjust(37,'0') and TradeContext.SCTRKINF != '':
#磁道信息非空或37个零,则调用主机接口校验磁道信息
TradeContext.HostCode = '0652'
TradeContext.WARNTNO = TradeContext.PYEACC[6:18]
AfaLoggerFunc.tradeDebug("WARNTNO :" + TradeContext.WARNTNO)
AfaLoggerFunc.tradeDebug("SCTRKINF :" + TradeContext.SCTRKINF)
AfaLoggerFunc.tradeDebug("THTRKINF :" + TradeContext.THTRKINF)
if TradeContext.THTRKINF == ''.rjust(37,'0'):
TradeContext.THTRKINF = ''
AfaLoggerFunc.tradeDebug("THTRKINF :" + TradeContext.THTRKINF)
rccpsHostFunc.CommHost( TradeContext.HostCode )
if TradeContext.errorCode != '0000':
#return AfaFlowControl.ExitThisFlow(TradeContext.errorCode,TradeContext.errorMsg)
AfaLoggerFunc.tradeInfo("校验磁道信息异常,主机返回码[" + TradeContext.errorCode + "],主机返回信息[" + TradeContext.errorMsg +"]")
TradeContext.PRCCO = 'NN1IA141'
TradeContext.STRINFO = "校验磁道信息失败 " + TradeContext.errorMsg
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
#校验凭证状态是否正常
if TradeContext.PRCCO == 'RCCI0000':
#调用主机接口查询凭证信息
TradeContext.HostCode = '8811'
TradeContext.ACCNO = TradeContext.PYEACC
TradeContext.WARNTNO = TradeContext.PYEACC[6:18]
AfaLoggerFunc.tradeDebug("ACCNO :" + TradeContext.ACCNO)
AfaLoggerFunc.tradeDebug("WARNTNO :" + TradeContext.WARNTNO)
rccpsHostFunc.CommHost( TradeContext.HostCode )
if TradeContext.errorCode != '0000':
#return AfaFlowControl.ExitThisFlow(TradeContext.errorCode,TradeContext.errorMsg)
AfaLoggerFunc.tradeInfo("查询凭证信息异常,主机返回码[" + TradeContext.errorCode + "],主机返回信息[" + TradeContext.errorMsg +"]")
TradeContext.PRCCO = 'NN1IA999'
TradeContext.STRINFO = "查询主机凭证信息失败 " + TradeContext.errorMsg
TradeContext.BCSTAT = PL_BCSTAT_MFERFE
TradeContext.BCSTATNM = "拒绝"
# else:
# #查询成功
# AfaLoggerFunc.tradeInfo(">>>查询主机凭证信息成功")
# AfaLoggerFunc.tradeInfo(">>>凭证信息ACCSTCD:[" + TradeContext.ACCSTCD + "]")
#
# if TradeContext.ACCSTCD != '0':
# TradeContext.PRCCO = 'RCCI1000'
# TradeContext.STRINFO = '账户凭证状态不正常'
# TradeContext.BCSTAT = PL_BCSTAT_MFERFE
# TradeContext.BCSTATNM = "拒绝"
AfaLoggerFunc.tradeInfo(">>>结束必要性检查")
#AfaLoggerFunc.tradeInfo("gbj_test:SNDTRDAT=[" + TradeContext.SNDTRDAT + "]")
#为应答报文赋值
TradeContext.sysType = 'rccpst'
TradeContext.MSGTYPCO = 'SET006'
TradeContext.RCVSTLBIN = TradeContext.SNDMBRCO
TradeContext.SNDSTLBIN = TradeContext.RCVMBRCO
TradeContext.SNDBRHCO = TradeContext.BESBNO
TradeContext.SNDCLKNO = TradeContext.BETELR
#TradeContext.SNDTRDAT = TradeContext.BJEDTE
#TradeContext.SNDTRTIM = TradeContext.BJETIM
TradeContext.ORMFN = TradeContext.MSGFLGNO
#TradeContext.MSGFLGNO = TradeContext.SNDMBRCO + TradeContext.SNDTRDAT + TradeContext.SerialNo
TradeContext.NCCWKDAT = TradeContext.NCCworkDate
TradeContext.ROPRTPNO = TradeContext.OPRTYPNO
TradeContext.OPRTYPNO = '30'
TradeContext.TRANTYP = '0'
TradeContext.CUR = 'CNY'
AfaLoggerFunc.tradeInfo( '***农信银系统：来账.中心类操作(1.本地操作).卡通存请求报文接收[TRCC006_1135]退出***' )
return True
def SubModuleDoFst():
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.本地类操作交易(1.本地操作).错帐控制交易信息联动查询[TRCC001_8596]进入***' )
#=====必要性检查====
#=====判断输入接口是否存在====
TradeContext.BJEDTE=AfaUtilTools.GetHostDate( )
TradeContext.TRCDAT=TradeContext.BJEDTE
#获取流水号
seqName="RCC_SEQ"
sqlStr = "SELECT NEXTVAL FOR " + seqName + " FROM SYSIBM.SYSDUMMY1"
records = AfaDBFunc.SelectSql( sqlStr )
if records == None :
raise AfaFlowControl.ExitThisFlow('A0025', AfaDBFun.sqlErrMsg )
TradeContext.TRCNO=str( records[0][0] ).rjust( 8, '0' )
if( not TradeContext.existVariable( "ORTRCDAT" ) ):
return AfaFlowControl.ExitThisFlow('A099', '原委托日期[ORTRCDAT]不存在')
if( not TradeContext.existVariable( "ORSNDBNK" ) ):
return AfaFlowControl.ExitThisFlow('A099', '原发送行号[ORSNDBNK]不存在')
if( not TradeContext.existVariable( "ORTRCNO" ) ):
return AfaFlowControl.ExitThisFlow('A099', '原交易流水号[ORTRCNO]不存在')
#=====组织查询字典====
AfaLoggerFunc.tradeInfo(">>>开始组织查询字典")
wheresql_dic={}
wheresql_dic['TRCDAT'] =TradeContext.ORTRCDAT
wheresql_dic['SNDBNKCO'] =TradeContext.ORSNDBNK
wheresql_dic['TRCNO'] =TradeContext.ORTRCNO
wheresql_dic['TRCCO'] ='3000508' #交易码
wheresql_dic['CONSTS'] ='0'
#=====开始查询数据库====
records=rccpsDBTrcc_acckj.selectu(wheresql_dic) #查询错帐控制解控登记簿
AfaLoggerFunc.tradeDebug('>>>记录['+str(records)+']')
if(records==None):
return AfaFlowControl.ExitThisFlow('A099','查询失败' )
elif(len(records)==0):
TradeContext.UNCONRST ='1'
TradeContext.STRINFO = '错帐解控失败，原错帐控制记录不存在'
return AfaFlowControl.ExitThisFlow('S999', "错帐解控失败，原错帐控制记录不存在")
else:
if((records['ORTRCCO']=='3000103')or(records['ORTRCCO']=='3000105' )or(records['ORTRCCO']=='3000102')or(records['ORTRCCO']=='3000104')):
TradeContext.ACCNO = records['ORPYRACC'] #解控账号
TradeContext.ACCNONAME = records['ORPYRNAM'] #户名
else:
TradeContext.ACCNO = records['ORPYEACC'] #解控账号
TradeContext.ACCNONAME = records['ORPYENAM'] #户名
TradeContext.ERRCONBAL = records['ERRCONBAL'] #解控金额
TradeContext.ORMFN = records['MSGFLGNO'] #参考报文标识号
TradeContext.BETELR = records['BETELR'] #柜员号
TradeContext.BESBNO = records['BESBNO'] #机构号
#TradeContext.NCCWKDAT = records['NCCWKDAT']
TradeContext.SNDMBRCO = records['SNDMBRCO'] #发送方成员行号
TradeContext.RCVMBRCO = records['RCVMBRCO'] #接受成员行行号
TradeContext.SNDBNKCO = records['SNDBNKCO']
TradeContext.SNDBNKNM = records['SNDBNKNM']
TradeContext.RCVBNKCO = records['RCVBNKCO']
TradeContext.RCVBNKNM = records['RCVBNKNM']
TradeContext.AMOUNT = str(records['ERRCONBAL'])
AfaLoggerFunc.tradeInfo(">>>开始组织查询字典，看是否是重复解控")
wheresql_dic={}
wheresql_dic['TRCCO'] ='3000509' #交易码
wheresql_dic['ORTRCDAT'] =TradeContext.ORTRCDAT #原交易日期
wheresql_dic['ORSNDBNK'] =TradeContext.ORSNDBNK #原发送行号
wheresql_dic['ORTRCNO'] =TradeContext.ORTRCNO #原交易流水号
wheresql_dic['UNCONRST'] ='0'
#=====开始查询数据库====
records=rccpsDBTrcc_acckj.selectu(wheresql_dic) #查询错帐控制解控登记簿
AfaLoggerFunc.tradeDebug('>>>记录['+str(records)+']')
if(records==None):
return AfaFlowControl.ExitThisFlow('A099','查询失败' )
if(len(records)>0):
if (records['UNCONRST'] == '0'): #解控状态
TradeContext.UNCONSTS ='0'
TradeContext.STRINFO = '错帐解控失败，原错帐已经解控'
return AfaFlowControl.ExitThisFlow('S999', "错帐解控失败，原错帐已经解控")
#=====组织登记错帐控制解控登记簿的插入字典====
AfaLoggerFunc.tradeInfo("组织登记错帐控制解控登记簿的插入字典")
insert_dict = {}
insert_dict['TRCDAT'] = TradeContext.BJEDTE #委托日期
insert_dict['BSPSQN'] = '0' #保单序号
insert_dict['MSGFLGNO'] = '1' #报文标识号
insert_dict['ORMFN'] = TradeContext.ORMFN #参考报文标识号
insert_dict['TRCCO'] = '3000509' #交易码
insert_dict['BRSFLG'] = '0' #往来标识
insert_dict['BESBNO'] = TradeContext.BESBNO #机构号
insert_dict['BEACSB'] = "" #账务机构号
insert_dict['BETELR'] = TradeContext.BETELR #机构柜员号
insert_dict['BEAUUS'] = "" #授权柜员号
insert_dict['BEAUPS'] = "" #授权柜员密码
insert_dict['TERMID'] = "" #终端号
insert_dict['OPTYPE'] ='' #业务类型
insert_dict['NCCWKDAT'] = TradeContext.BJEDTE #农信银中心日期
insert_dict['TRCNO'] = TradeContext.TRCNO #交易流水号
insert_dict['SNDMBRCO'] = TradeContext.SNDMBRCO #发送方成员行号
insert_dict['RCVMBRCO'] = TradeContext.RCVMBRCO #接受成员行行号
insert_dict['SNDBNKCO'] = TradeContext.SNDBNKCO #发送方行号
insert_dict['SNDBNKNM'] = TradeContext.SNDBNKNM #发送方行名
insert_dict['RCVBNKCO'] = TradeContext.RCVBNKCO #接受行号
insert_dict['RCVBNKNM'] = TradeContext.RCVBNKNM #接受行名
insert_dict['ORTRCDAT'] = TradeContext.ORTRCDAT #原委托日期
insert_dict['ORTRCCO'] = '3000508' #原交易代码
insert_dict['ORTRCNO'] = TradeContext.ORTRCNO #交易流水号
insert_dict['ORSNDSUBBNK'] = '' #原发起成员行号
insert_dict['ORSNDBNK'] = TradeContext.ORSNDBNK #原发起行号
insert_dict['ORRCVSUBBNK'] = '' #原接受成员行行号
insert_dict['ORRCVBNK'] = '' #原接受行名
insert_dict['ORPYRACC'] = '' #原付款人账号
insert_dict['ORPYRNAM'] = '' #原付款人名称
insert_dict['ORPYEACC'] = '' #原收款人账号
insert_dict['ORPYENAM'] = '' #原收款人名称
insert_dict['CUR'] = '01' #币种
insert_dict['OCCAMT'] = '0' #原交易金额
insert_dict['CHRG'] = '0' #手续费
insert_dict['ERRCONBAL'] = TradeContext.ERRCONBAL #错帐控制金额
insert_dict['BALANCE'] = ""
insert_dict['UNCONRST']= ""
insert_dict['CONSTS'] = ""
insert_dict['PRCCO'] =""
insert_dict['STRINFO'] = '' #附言
insert_dict['NOTE1'] = TradeContext.BJETIM #时间
insert_dict['NOTE2'] = ""
insert_dict['NOTE3'] = ""
insert_dict['NOTE4'] = ""
insert_dict['NOTE5'] = ""
#=====登记错帐控制解控登记簿====
AfaLoggerFunc.tradeInfo("开始登记错帐控制解控登记簿")
AfaLoggerFunc.tradeInfo(insert_dict)
res = rccpsDBTrcc_acckj.insertCmt(insert_dict)
if( res == -1 ):
return AfaFlowControl.ExitThisFlow('A009','登记错帐控制解控登记簿失败')
TradeContext.BETELR = records['BETELR'] #柜员号
#=====================与主机通讯进行错帐解控========================================
#TradeContext.BESBNO='3401010079'
#TradeContext.BETELR ='007907'
#TradeContext.TERMID='1234567890'
TradeContext.kjflag='1' #错帐控制标识位
TradeContext.HostCode = '0061'
rccpsHostFunc.CommHost('0061')
AfaLoggerFunc.tradeInfo("交易中处理(修改流水,主机后处理)")
AfaLoggerFunc.tradeInfo("errorCode<<<<<<<<<<<"+TradeContext.errorCode)
AfaLoggerFunc.tradeInfo("errorMsg<<<<<<<<<<"+TradeContext.errorMsg)
#=====判断主机交易是否成功====
if( TradeContext.errorCode != '0000' ):
AfaLoggerFunc.tradeInfo("主机交易失败")
TradeContext.PRCCO = "NN1CA999" #返回码
TradeContext.STRINFO = "主机失败 "+TradeContext.errorMsg[7:]+" " #附言
TradeContext.UNCONRST='1'
#=====更新错帐控制解控登记簿====
AfaLoggerFunc.tradeInfo("组织更新字典")
where_dict = {'ORTRCDAT':TradeContext.ORTRCDAT,'ORSNDBNK':TradeContext.ORSNDBNK,'ORTRCNO':TradeContext.ORTRCNO,'TRCCO':'3000509','TRCNO':TradeContext.TRCNO} #原委托日期，原发送行号，原交易流水号
update_dict = {'UNCONRST':TradeContext.UNCONRST,'STRINFO':TradeContext.STRINFO,'PRCCO':TradeContext.PRCCO} #错误信息描述和返回码
AfaLoggerFunc.tradeInfo("开始更新错帐控制解控登记簿")
res = rccpsDBTrcc_acckj.updateCmt(update_dict,where_dict)
if( res == -1 ):
return AfaFlowControl.ExitThisFlow('A009','更新错帐控制解控登记簿失败')
AfaLoggerFunc.tradeInfo(res)
else:
AfaLoggerFunc.tradeInfo("主机交易成功")
#=====更新错帐控制解控登记簿====
AfaLoggerFunc.tradeInfo("组织更新字典")
TradeContext.PRCCO = "RCCI0000" #返回码
TradeContext.UNCONRST='0'
TradeContext.STRINFO = "错帐解控成功" #附言
where_dict = {'ORTRCDAT':TradeContext.ORTRCDAT,'ORSNDBNK':TradeContext.ORSNDBNK,'ORTRCNO':TradeContext.ORTRCNO,'TRCCO':'3000509','TRCNO':TradeContext.TRCNO} #原委托日期，原发送行号，原交易流水号
update_dict = {'UNCONRST':TradeContext.UNCONRST,'STRINFO':TradeContext.STRINFO,'PRCCO':TradeContext.PRCCO} #错误信息描述和返回码
AfaLoggerFunc.tradeInfo("开始更新错帐控制解控登记簿")
res = rccpsDBTrcc_acckj.updateCmt(update_dict,where_dict)
if( res == -1 ):
return AfaFlowControl.ExitThisFlow('A009','更新错帐控制解控登记簿失败')
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.本地类操作(1.本地操作)错帐控制解控交易信息联动查询[TRCC001_8598]退出***')
return True
def SubModuleDoFst():
#=====判断是否重复交易====
sel_dict = {'TRCNO':TradeContext.TRCNO,'TRCDAT':TradeContext.TRCDAT,'SNDBNKCO':TradeContext.SNDBNKCO}
record = rccpsDBTrcc_existp.selectu(sel_dict)
if record == None:
return AfaFlowControl.ExitThisFlow('S999','判断是否重复报文，查询汇兑业务登记簿相同报文异常')
elif len(record) > 0:
AfaLoggerFunc.tradeInfo('紧急止付业务登记簿中存在相同数据,重复报文,进入下一流程')
#=====为通讯回执报文赋值====
out_context_dict = {}
out_context_dict['sysType'] = 'rccpst'
out_context_dict['TRCCO'] = '9900503'
out_context_dict['MSGTYPCO'] = 'SET008'
out_context_dict['RCVMBRCO'] = TradeContext.SNDMBRCO
out_context_dict['SNDMBRCO'] = TradeContext.RCVMBRCO
out_context_dict['SNDBRHCO'] = TradeContext.BESBNO
out_context_dict['SNDCLKNO'] = TradeContext.BETELR
out_context_dict['SNDTRDAT'] = TradeContext.BJEDTE
out_context_dict['SNDTRTIM'] = TradeContext.BJETIM
out_context_dict['ORMFN'] = TradeContext.MSGFLGNO
out_context_dict['MSGFLGNO'] = out_context_dict['SNDMBRCO'] + TradeContext.BJEDTE + TradeContext.SerialNo
out_context_dict['NCCWKDAT'] = TradeContext.NCCworkDate
out_context_dict['OPRTYPNO'] = '99'
out_context_dict['ROPRTPNO'] = TradeContext.OPRTYPNO
out_context_dict['TRANTYP'] = '0'
out_context_dict['ORTRCCO'] = trc_dict['TRCCO']
out_context_dict['PRCCO'] = 'RCCI0000'
out_context_dict['STRINFO'] = '重复报文'
rccpsMap0000Dout_context2CTradeContext.map(out_context_dict)
#=====发送afe====
AfaAfeFunc.CommAfe()
return AfaFlowControl.ExitThisFlow('S999','重复报文，退出处理流程')
#=====根据发送行号,委托日期,交易流水号查询原交易信息===========
AfaLoggerFunc.tradeInfo(">>>开始根据发送行号,委托日期,交易流水号查询交易信息")
trc_dict = {}
if not rccpsDBFunc.getTransTrcPK(TradeContext.SNDMBRCO,TradeContext.ORTRCDAT,TradeContext.ORTRCNO,trc_dict):
return AfaFlowControl.ExitThisFlow('S999','汇兑业务登记簿中无此交易,抛弃报文')
AfaLoggerFunc.tradeInfo(">>>结束根据发送行号,委托日期,交易流水号查询交易信息")
#=====需要插入紧急止付业务登记簿existp====
existp = {}
if not rccpsMap1130CTradeContext2Dexistp.map(existp):
return AfaFlowControl.ExitThisFlow('S999','字典赋值出错,抛弃报文')
existp['BOJEDT'] = trc_dict['BJEDTE']
existp['BOSPSQ'] = trc_dict['BSPSQN']
existp['CUR'] = '01'
#=====张恒 20091203 新增 将机构落到原交易机构 ====
existp['BESBNO'] = trc_dict['BESBNO']
ret = rccpsDBTrcc_existp.insertCmt(existp)
if ret < 0:
return AfaFlowControl.ExitThisflow('S999','插入止付业务登记簿出错,抛弃报文')
#======检查原业务状态是否为自动挂账－成功====
#if not (trc_dict['BCSTAT'] != PL_BCSTAT_HANG and trc_dict['BDWFLG'] != PL_BDWFLG_SUCC ):
if (trc_dict['BCSTAT'] != PL_BCSTAT_HANG or trc_dict['TRCCO'][:2] != '20' or trc_dict['TRCCO'] == '2000009'):
out_context_dict = {}
out_context_dict['sysType'] = 'rccpst'
out_context_dict['TRCCO'] = '9900503'
out_context_dict['MSGTYPCO'] = 'SET008'
out_context_dict['RCVMBRCO'] = TradeContext.SNDMBRCO
out_context_dict['SNDMBRCO'] = TradeContext.RCVMBRCO
out_context_dict['SNDBRHCO'] = TradeContext.BESBNO
out_context_dict['SNDCLKNO'] = TradeContext.BETELR
out_context_dict['SNDTRDAT'] = TradeContext.BJEDTE
out_context_dict['SNDTRTIM'] = TradeContext.BJETIM
out_context_dict['ORMFN'] = TradeContext.MSGFLGNO
out_context_dict['MSGFLGNO'] = out_context_dict['SNDMBRCO'] + TradeContext.BJEDTE + TradeContext.SerialNo
out_context_dict['NCCWKDAT'] = TradeContext.NCCworkDate
out_context_dict['OPRTYPNO'] = '99'
out_context_dict['ROPRTPNO'] = TradeContext.OPRTYPNO
out_context_dict['TRANTYP'] = '0'
out_context_dict['ORTRCCO'] = trc_dict['TRCCO']
out_context_dict['PRCCO'] = 'RCCI0000'
out_context_dict['STRINFO'] = '该笔业务已入账，不允许退汇'
rccpsMap0000Dout_context2CTradeContext.map(out_context_dict)
TradeContext.SNDSTLBIN = TradeContext.RCVMBRCO #发起成员行号
#=====发送afe====
AfaAfeFunc.CommAfe()
return AfaFlowControl.ExitThisFlow('S999','重复报文，退出处理流程')
TradeContext.BOSPSQ = trc_dict['BSPSQN']
TradeContext.BOJEDT = trc_dict['BJEDTE']
TradeContext.ORPYRACC = trc_dict['PYRACC']
TradeContext.ORPYRNAM = trc_dict['PYRNAM']
TradeContext.ORPYEACC = trc_dict['PYEACC']
TradeContext.ORPYENAM = trc_dict['PYENAM']
TradeContext.ORTRCCO = trc_dict['TRCCO']
#=====汇兑业务登记簿trcbka赋值新增一条记录====
trc_dict['BOJEDT'] = trc_dict['BJEDTE']
trc_dict['BOSPSQ'] = trc_dict['BSPSQN']
trc_dict['ORTRCDAT']= trc_dict['TRCDAT']
trc_dict['ORTRCNO'] = trc_dict['TRCNO']
trc_dict['ORTRCCO'] = trc_dict['TRCCO']
trc_dict['TRCCO'] = '2000004'
trc_dict['OPRNO'] = '09'
trc_dict['DCFLG'] = PL_DCFLG_CRE
trc_dict['BJEDTE'] = TradeContext.BJEDTE
trc_dict['BSPSQN'] = TradeContext.BSPSQN
trc_dict['TRCDAT'] = TradeContext.TRCDAT
trc_dict['TRCNO'] = TradeContext.SerialNo
trc_dict['BRSFLG'] = PL_BRSFLG_SND #往账
trc_dict['BBSSRC'] = '3' #待销账
#=====接收成员行号与发送成员行号互换====
TradeContext.temp = trc_dict['SNDMBRCO']
trc_dict['SNDMBRCO']= trc_dict['RCVMBRCO']
trc_dict['RCVMBRCO']= TradeContext.temp
#=====接收行号与发送行号互换====
TradeContext.temp = trc_dict['SNDBNKCO']
trc_dict['SNDBNKCO']= trc_dict['RCVBNKCO']
trc_dict['RCVBNKCO']= TradeContext.temp
#=====接收行名与发送行名互换====
TradeContext.temp = trc_dict['SNDBNKNM']
trc_dict['SNDBNKNM']= trc_dict['RCVBNKNM']
trc_dict['RCVBNKNM']= TradeContext.temp
#=====开始插入数据库====
if not rccpsDBFunc.insTransTrc(trc_dict):
#=====RollBack操作====
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow('D002', '插入数据库出错,RollBack成功')
else:
#=====commit操作====
AfaDBFunc.CommitSql()
AfaLoggerFunc.tradeInfo('插入汇兑业务登记簿，COMMIT成功')
#=====设置状态为记账-处理中====
sstlog = {}
sstlog['BSPSQN'] = TradeContext.BSPSQN
sstlog['BJEDTE'] = TradeContext.BJEDTE
sstlog['BCSTAT'] = PL_BCSTAT_ACC
sstlog['BDWFLG'] = PL_BDWFLG_WAIT
if not rccpsState.setTransState(sstlog):
#=====RollBack操作====
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow(TradeContext.errorCode, TradeContext.errorMsg)
else:
#=====commit操作====
AfaDBFunc.CommitSql()
AfaLoggerFunc.tradeInfo('>>>commit成功')
#=====开始拼借贷方账号====
TradeContext.DASQ = trc_dict['DASQ']
TradeContext.RBAC = TradeContext.BESBNO + PL_ACC_NXYDQSWZ
TradeContext.OCCAMT= TradeContext.OROCCAMT
TradeContext.HostCode = '8813'
#=====开始调函数拼贷方账号第25位校验位====
TradeContext.RBAC = rccpsHostFunc.CrtAcc(TradeContext.RBAC, 25)
AfaLoggerFunc.tradeInfo( '贷方账号:' + TradeContext.RBAC )
rccpsHostFunc.CommHost(TradeContext.HostCode)
AfaLoggerFunc.tradeInfo( '>>>开始判断主机返回结果' )
status_dict = {}
status_dict['BSPSQN'] = TradeContext.BSPSQN #报单序号
status_dict['BJEDTE'] = TradeContext.BJEDTE #交易日期
status_dict['BCSTAT'] = PL_BCSTAT_ACC #记账
#=====判断主机返回结果====
if TradeContext.errorCode != '0000':
status_dict['BDWFLG'] = PL_BDWFLG_FAIL #失败
else:
status_dict['BDWFLG'] = PL_BDWFLG_SUCC #成功
status_dict['TRDT'] = TradeContext.TRDT #主机日期
status_dict['TLSQ'] = TradeContext.TLSQ #主机流水号
status_dict['MGID'] = TradeContext.MGID #主机返回信息
status_dict['DASQ'] = TradeContext.DASQ #销账序号
#=====修改退汇记录的状态====
if not rccpsState.setTransState(status_dict):
#=====RollBack操作====
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow(TradeContext.errorCode, TradeContext.errorMsg)
else:
#=====commit操作====
AfaDBFunc.CommitSql()
AfaLoggerFunc.tradeInfo('>>>commit成功')
#=====判断主机返回结果,是否继续流程====
if TradeContext.errorCode != '0000':
out_context_dict = {}
out_context_dict['sysType'] = 'rccpst'
out_context_dict['TRCCO'] = '9900503'
out_context_dict['MSGTYPCO'] = 'SET008'
out_context_dict['RCVMBRCO'] = TradeContext.SNDMBRCO
out_context_dict['SNDMBRCO'] = TradeContext.RCVMBRCO
out_context_dict['SNDBRHCO'] = TradeContext.BESBNO
out_context_dict['SNDCLKNO'] = TradeContext.BETELR
out_context_dict['SNDTRDAT'] = TradeContext.TRCDAT
out_context_dict['SNDTRTIM'] = TradeContext.BJETIM
out_context_dict['ORMFN'] = TradeContext.MSGFLGNO
out_context_dict['MSGFLGNO'] = out_context_dict['SNDMBRCO'] + TradeContext.BJEDTE + TradeContext.SerialNo
out_context_dict['NCCWKDAT'] = TradeContext.NCCworkDate
out_context_dict['OPRTYPNO'] = '99'
out_context_dict['ROPRTPNO'] = TradeContext.OPRTYPNO
out_context_dict['TRANTYP'] = '0'
out_context_dict['ORTRCCO'] = TradeContext.ORTRCCO
out_context_dict['PRCCO'] = 'RCCI0000'
out_context_dict['STRINFO'] = '该笔业务已入账，不允许退汇'
rccpsMap0000Dout_context2CTradeContext.map(out_context_dict)
TradeContext.SNDSTLBIN = TradeContext.RCVMBRCO #发起成员行号
#=====发送afe====
AfaAfeFunc.CommAfe()
return AfaFlowControl.ExitThisFlow('S999','该笔业务已被主机处理，不允许退汇')
#=====新增记录的状态为：发送-处理中====
if not rccpsState.newTransState(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_SND,PL_BDWFLG_WAIT):
#=====RollBack操作====
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow('M999', '设置状态失败,系统自动回滚')
else:
#=====commit操作====
AfaDBFunc.CommitSql()
out_context_dict = {}
out_context_dict['sysType'] = 'rccpst'
out_context_dict['TRCCO'] = '9900503'
out_context_dict['MSGTYPCO'] = 'SET008'
out_context_dict['RCVMBRCO'] = TradeContext.SNDMBRCO
out_context_dict['SNDMBRCO'] = TradeContext.RCVMBRCO
out_context_dict['SNDBRHCO'] = TradeContext.BESBNO
out_context_dict['SNDCLKNO'] = TradeContext.BETELR
out_context_dict['SNDTRDAT'] = TradeContext.TRCDAT
out_context_dict['SNDTRTIM'] = TradeContext.BJETIM
out_context_dict['ORMFN'] = TradeContext.MSGFLGNO
out_context_dict['MSGFLGNO'] = out_context_dict['SNDMBRCO'] + TradeContext.BJEDTE + TradeContext.SerialNo
out_context_dict['NCCWKDAT'] = TradeContext.NCCworkDate
out_context_dict['OPRTYPNO'] = '99'
out_context_dict['ROPRTPNO'] = TradeContext.OPRTYPNO
out_context_dict['TRANTYP'] = '0'
out_context_dict['ORTRCCO'] = TradeContext.ORTRCCO
out_context_dict['PRCCO'] = 'RCCI0000'
out_context_dict['STRINFO'] = '成功'
rccpsMap0000Dout_context2CTradeContext.map(out_context_dict)
TradeContext.SNDSTLBIN = TradeContext.RCVMBRCO #发起成员行号
return True
def SubModuleDoFst():
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.中心类操作(1.本地操作).柜台冲销[TRCC003_8565]进入***' )
#=====校验变量的合法性====
if not TradeContext.existVariable("BOJEDT"):
return AfaFlowControl.ExitThisFlow('A099','原交易日期不能为空')
if not TradeContext.existVariable("BOSPSQ"):
return AfaFlowControl.ExitThisFlow('A099','原报单序号不能为空')
if not TradeContext.existVariable("RESNNM"):
return AfaFlowControl.ExitThisFlow('A099','冲销原因不能为空')
#查询原交易信息
wtr_dict = {}
if not rccpsDBFunc.getTransWtr(TradeContext.BOJEDT,TradeContext.BOSPSQ,wtr_dict):
return AfaFlowControl.ExitThisFlow("S999","无此交易")
#判断原交易是否为往账
if( wtr_dict['BRSFLG'] != PL_BRSFLG_SND):
return AfaFlowControl.ExitThisFlow('A099','此交易非往账,禁止冲销')
#判断被冲销交易的日期是否为当日
if( wtr_dict['NCCWKDAT'] != TradeContext.NCCworkDate ):
return AfaFlowControl.ExitThisFlow('A099','此交易非当日交易,禁止冲销')
#判断当前机构是否为原交易机构
if( wtr_dict['BESBNO'] != TradeContext.BESBNO ):
return AfaFlowControl.ExitThisFlow('A099','当前机构非原交易机构,禁止冲销')
#判断当前柜员是否为原交易柜员
if( wtr_dict['BETELR'] != TradeContext.BETELR ):
return AfaFlowControl.ExitThisFlow('A099','当前柜员非原交易柜员,禁止冲销')
#判断原交易状态是否允许冲销
AfaLoggerFunc.tradeInfo("开始判断原交易信息是否允许冲销")
#=====add by pgt 12-9=====
#able_to_cancel = 1 #允许冲销的标示，1为不允许，0为允许
#
#if wtr_dict['TRCCO'] in ('3000002','3000003','3000004','3000005'): #通存或者本转异
# #状态为:确认付款,清算,发送处理中,发送成功,允许冲销
# if(wtr_dict['BCSTAT'] == PL_BCSTAT_CONFPAY or wtr_dict['BCSTAT'] == PL_BCSTAT_MFESTL or (wtr_dict['BCSTAT'] == PL_BCSTAT_SND and (wtr_dict['BDWFLG'] == PL_BDWFLG_WAIT or wtr_dict['BDWFLG'] == PL_BDWFLG_SUCC))):
# able_to_cancel = 0
#
#elif wtr_dict['TRCCO'] in ('3000102','3000103','3000104','3000105'): #通兑或者异转本
# #状态为:记账,清算,发送处理中,发送成功,允许冲销
# if(wtr_dict['BCSTAT'] == PL_BCSTAT_ACC or wtr_dict['BCSTAT'] == PL_BCSTAT_MFESTL or (wtr_dict['BCSTAT'] == PL_BCSTAT_SND and (wtr_dict['BDWFLG'] == PL_BDWFLG_WAIT or wtr_dict['BDWFLG'] == PL_BDWFLG_SUCC))):
# able_to_cancel = 0
#
#else:
# return AfaFlowControl.ExitThisFlow("S999","本交易非通存或通兑账务类交易,禁止冲销")
#
##冲销失败允许冲销
#if(wtr_dict['BCSTAT'] == PL_BCSTAT_CANC and wtr_dict['BDWFLG'] == PL_BDWFLG_FAIL):
# able_to_cancel = 0
#
#if(able_to_cancel == 1):
# return AfaFlowControl.ExitThisFlow("S999","此交易当前状态为[" + wtr_dict['BCSTAT'] + "][" + wtr_dict['BDWFLG'] + "],禁止冲销")
#
#else:
# AfaLoggerFunc.tradeDebug('>>>>>>此交易当前状态允许冲销')
if wtr_dict['TRCCO'] in ('3000002','3000003','3000004','3000005'): #通存或者本转异
#状态为:确认付款,清算,发送处理中,发送成功,允许冲销
if not (wtr_dict['BCSTAT'] == PL_BCSTAT_CONFPAY or wtr_dict['BCSTAT'] == PL_BCSTAT_MFESTL or (wtr_dict['BCSTAT'] == PL_BCSTAT_SND and (wtr_dict['BDWFLG'] == PL_BDWFLG_WAIT or wtr_dict['BDWFLG'] == PL_BDWFLG_SUCC))):
return AfaFlowControl.ExitThisFlow("S999","此交易当前状态为[" + wtr_dict['BCSTAT'] + "[" + wtr_dict['BDWFLG'] + "],禁止冲销")
elif wtr_dict['TRCCO'] in ('3000102','3000103','3000104','3000105'): #通兑或者异转本
#状态为:记账,清算,发送处理中,发送成功,允许冲销
if not (wtr_dict['BCSTAT'] == PL_BCSTAT_ACC or wtr_dict['BCSTAT'] == PL_BCSTAT_MFESTL or (wtr_dict['BCSTAT'] == PL_BCSTAT_SND and (wtr_dict['BDWFLG'] == PL_BDWFLG_WAIT or wtr_dict['BDWFLG'] == PL_BDWFLG_SUCC))):
return AfaFlowControl.ExitThisFlow("S999","此交易当前状态为[" + wtr_dict['BCSTAT'] + "][" + wtr_dict['BDWFLG'] + "],禁止冲销")
else:
return AfaFlowControl.ExitThisFlow("S999","本交易非通存或通兑账务类交易,禁止冲销")
if wtr_dict['BCSTAT'] == PL_BCSTAT_ACC and wtr_dict['BDWFLG'] != PL_BDWFLG_SUCC:
#原交易当前状态为记账,且流转处理标识非成功,则调用8816查询此笔业务主机账务状态
AfaLoggerFunc.tradeDebug('>>>调用8816查找该业务[' + wtr_dict['BSPSQN'] + '状态')
TradeContext.HostCode = '8816' #主机交易码
TradeContext.OPFG = '1' #查询类型
TradeContext.NBBH = 'RCC' #代理业务标识
TradeContext.FEDT = wtr_dict['FEDT'] #原前置日期
TradeContext.RBSQ = wtr_dict['RBSQ'] #原前置流水号
TradeContext.DAFG = '1' #抹/记账标志 1:记 2:抹
TradeContext.BESBNO = wtr_dict['BESBNO'] #机构号
TradeContext.BETELR = wtr_dict['BETELR'] #柜员号
rccpsHostFunc.CommHost( TradeContext.HostCode )
#=====分析主机返回====
if TradeContext.errorCode == '0000':
if HostContext.O1STCD == '0':
#此账务已成功记主机账,修改原交易状态为记账成功
stat_dict = {}
stat_dict['BJEDTE'] = TradeContext.BOJEDT
stat_dict['BOSPSQ'] = tradeContext.BOSPSQ
stat_dict['BCSTAT'] = PL_BCSTAT_ACC
stat_dict['BDWFLG'] = PL_BDWFLG_SUCC
stat_dict['TRDT'] = HostContext.O1DADT #主机日期
stat_dict['TLSQ'] = HostContext.O1AMTL #主机流水
stat_dict['MGID'] = '0000'
stat_dict['STRINFO']= '主机成功'
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999','设置原交易业务状态为记账成功异常')
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
else:
return AfaFlowControl.ExitThisFlow('S999','原交易主机账务状态与中台不符,禁止提交')
elif TradeContext.errorCode == 'XCR0001':
AfaLoggerFunc.tradeInfo(">>>主机返回原交易记账失败,继续冲销")
else:
return AfaFlowControl.ExitThisFlow('S999','查询主机账务异常,请稍后再冲销')
AfaLoggerFunc.tradeInfo("结束判断原交易信息是否允许冲销")
#登记柜台冲销登记簿
AfaLoggerFunc.tradeInfo("开始登记柜台冲销登记簿")
TradeContext.SNDMBRCO = TradeContext.SNDSTLBIN
TradeContext.RCVMBRCO = wtr_dict['RCVMBRCO']
TradeContext.ORTRCDAT = wtr_dict['TRCDAT']
TradeContext.OPRNO = PL_TDOPRNO_CX
TradeContext.NCCWKDAT = TradeContext.NCCworkDate
TradeContext.MSGFLGNO = TradeContext.SNDSTLBIN + TradeContext.NCCworkDate + TradeContext.SerialNo
TradeContext.ORMFN = wtr_dict['MSGFLGNO']
TradeContext.TRCCO = "3000504"
TradeContext.TRCNO = TradeContext.SerialNo
TradeContext.ORTRCCO = wtr_dict['TRCCO']
TradeContext.ORTRCNO = wtr_dict['TRCNO']
TradeContext.SNDBNKCO = wtr_dict['SNDBNKCO']
TradeContext.SNDBNKNM = wtr_dict['SNDBNKNM']
TradeContext.RCVBNKCO = wtr_dict['RCVBNKCO']
TradeContext.RCVBNKNM = wtr_dict['RCVBNKNM']
insert_dict = {}
if not rccpsMap8565CTradeContext2Dmpcbka.map(insert_dict):
return AfaFlowControl.ExitThisFlow('S999','登记柜台冲销登记簿失败')
AfaLoggerFunc.tradeInfo('>>>开始登记柜台冲销登记簿')
res = rccpsDBTrcc_mpcbka.insertCmt(insert_dict)
if( res <= 0 ):
return AfaFlowControl.ExitThisFlow('S999','登记柜台冲销登记簿失败')
AfaLoggerFunc.tradeInfo('>>>结束登记柜台冲销登记簿')
#为发送柜面冲销报文做准备
#=====报文头====
TradeContext.MSGTYPCO = 'SET009'
TradeContext.RCVSTLBIN= wtr_dict['RCVMBRCO']
#TradeContext.SNDBRHCO = TradeContext.BESBNO
#TradeContext.SNDCLKNO = TradeContext.BETELR
#TradeContext.SNDTRDAT = TradeContext.BJEDTE
#TradeContext.SNDTRTIM = TradeContext.BJETIM
#TradeContext.MSGFLGNO = TradeContext.SNDSTLBIN + TradeContext.TRCDAT + TradeContext.SerialNo
#TradeContext.ORMFN = wtr_dict['MSGFLGNO']
#TradeContext.NCCWKDAT = TradeContext.NCCworkDate
TradeContext.OPRTYPNO = "30"
TradeContext.ROPRTPNO = "30"
TradeContext.TRANTYP = "0"
#=====业务要素集====
TradeContext.CUR = wtr_dict['CUR']
TradeContext.OCCAMT = str(wtr_dict['OCCAMT'])
#手续费处理
if wtr_dict['TRCCO'] == '3000002' or wtr_dict['TRCCO'] == '3000003' or wtr_dict['TRCCO'] == '3000004' or wtr_dict['TRCCO'] == '3000005':
TradeContext.CUSCHRG = "0.00"
elif wtr_dict['TRCCO'] == '3000102' or wtr_dict['TRCCO'] == '3000103' or wtr_dict['TRCCO'] == '3000104' or wtr_dict['TRCCO'] == '3000105':
if wtr_dict['CHRGTYP'] == '1':
TradeContext.CUSCHRG = str(wtr_dict['CUSCHRG'])
else:
TradeContext.CUSCHRG = '0.00'
TradeContext.PYRACC = wtr_dict['PYRACC']
TradeContext.PYRNAM = wtr_dict['PYRNAM']
TradeContext.PYEACC = wtr_dict['PYEACC']
TradeContext.PYENAM = wtr_dict['PYENAM']
TradeContext.CURPIN = ""
TradeContext.STRINFO = ""
TradeContext.PRCCO = ""
#=====扩展要素集====
TradeContext.RESNCO = TradeContext.RESNNM
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.中心类操作(1.本地操作).柜台冲销[TRCC003_8565]退出***' )
return True
def SubModuleDoFst():
AfaLoggerFunc.tradeInfo( ">>>开始汇兑来账接收处理" )
#=====判断是否重复交易====
sel_dict = {'TRCNO':TradeContext.TRCNO,'TRCDAT':TradeContext.TRCDAT,'SNDBNKCO':TradeContext.SNDBNKCO}
record = rccpsDBTrcc_trcbka.selectu(sel_dict)
if record == None:
return AfaFlowControl.ExitThisFlow('S999','判断是否重复报文，查询汇兑业务登记簿相同报文异常')
elif len(record) > 0:
AfaLoggerFunc.tradeInfo('汇兑业务登记簿中存在相同数据,重复报文,进入下一流程')
#=====为通讯回执报文赋值====
out_context_dict = {}
out_context_dict['sysType'] = 'rccpst'
out_context_dict['TRCCO'] = '9900503'
out_context_dict['MSGTYPCO'] = 'SET008'
out_context_dict['RCVMBRCO'] = TradeContext.SNDMBRCO
out_context_dict['SNDMBRCO'] = TradeContext.RCVMBRCO
out_context_dict['SNDBRHCO'] = TradeContext.BESBNO
out_context_dict['SNDCLKNO'] = TradeContext.BETELR
out_context_dict['SNDTRDAT'] = TradeContext.BJEDTE
out_context_dict['SNDTRTIM'] = TradeContext.BJETIM
out_context_dict['ORMFN'] = TradeContext.MSGFLGNO
out_context_dict['MSGFLGNO'] = out_context_dict['SNDMBRCO'] + TradeContext.BJEDTE + TradeContext.SerialNo
out_context_dict['NCCWKDAT'] = TradeContext.NCCworkDate
out_context_dict['OPRTYPNO'] = '99'
out_context_dict['ROPRTPNO'] = TradeContext.OPRTYPNO
out_context_dict['TRANTYP'] = '0'
out_context_dict['ORTRCCO'] = TradeContext.TRCCO
out_context_dict['PRCCO'] = 'RCCI0000'
out_context_dict['STRINFO'] = '重复报文'
rccpsMap0000Dout_context2CTradeContext.map(out_context_dict)
#=====发送afe====
AfaAfeFunc.CommAfe()
return AfaFlowControl.ExitThisFlow('S999','重复报文，退出处理流程')
AfaLoggerFunc.tradeInfo(">>>结束判断是否重复报文")
#=====币种转换====
if TradeContext.CUR == 'CNY':
TradeContext.CUR = '01'
#====开始向字典赋值====
trcbka_dict = {}
if not rccpsMap1101CTradeContext2Dtrcbka_dict.map(trcbka_dict):
return AfaFlowControl.ExitThisFlow('M999', '字典赋值出错')
trcbka_dict['DCFLG'] = PL_DCFLG_CRE #借贷标识.贷
trcbka_dict['OPRNO'] = '00' #业务属性
#=====开始插入数据库====
if not rccpsDBFunc.insTransTrc(trcbka_dict):
#=====RollBack操作====
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow('D002', '插入数据库出错,RollBack成功')
else:
#=====commit操作====
AfaDBFunc.CommitSql()
AfaLoggerFunc.tradeInfo('插入汇兑业务登记簿，COMMIT成功')
#=====设置状态为收妥====
sstlog = {}
sstlog['BSPSQN'] = TradeContext.BSPSQN
sstlog['BJEDTE'] = TradeContext.BJEDTE
sstlog['BCSTAT'] = PL_BCSTAT_BNKRCV
sstlog['BDWFLG'] = PL_BDWFLG_SUCC
#=====设置状态为 收妥-成功 ====
if not rccpsState.setTransState(sstlog):
#=====RollBack操作====
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow(TradeContext.errorCode, TradeContext.errorMsg)
else:
#=====commit操作====
AfaDBFunc.CommitSql()
AfaLoggerFunc.tradeInfo('>>>commit成功')
##========================= START 张恒 增加于20091011 来帐落机构及入帐挂账处理 =====================##
#初始化记挂账标识,记账.0,挂账.1,默认记账
accflag = 0
#接收机构暂存
TradeContext.BESBNOFIRST = TradeContext.BESBNO
if accflag == 0:
AfaLoggerFunc.tradeInfo(">>>开始校验密押")
#=====开始调用密押服务器进行核押====
SNDBANKCO = TradeContext.SNDBNKCO
RCVBANKCO = TradeContext.RCVBNKCO
SNDBANKCO = SNDBANKCO.rjust(12,'0')
RCVBANKCO = RCVBANKCO.rjust(12,'0')
AMOUNT = TradeContext.OCCAMT.split('.')[0] + TradeContext.OCCAMT.split('.')[1]
AMOUNT = AMOUNT.rjust(15,'0')
INFO = ' '
INFO = INFO.rjust(60,' ')
AfaLoggerFunc.tradeDebug('处理类型(0-编押 1-核押):' + str(PL_SEAL_DEC) )
AfaLoggerFunc.tradeDebug('业务种类(1-现金汇票 2-转账汇票 3-电子汇兑业务):' +str(PL_TYPE_DZHD) )
AfaLoggerFunc.tradeDebug('委托日期:' + TradeContext.TRCDAT )
AfaLoggerFunc.tradeDebug('交易流水号:' + TradeContext.TRCNO )
AfaLoggerFunc.tradeDebug('AMOUNT=' + str(AMOUNT) )
AfaLoggerFunc.tradeDebug('SNDBANKCO=' + str(SNDBANKCO) )
AfaLoggerFunc.tradeDebug('RCVBANKCO=' + str(RCVBANKCO) )
AfaLoggerFunc.tradeDebug('密押:' + TradeContext.SEAL )
AfaLoggerFunc.tradeDebug('OTHERINFO[' + str(INFO) + ']')
ret = miya.DraftEncrypt(PL_SEAL_DEC,PL_TYPE_DZHD,TradeContext.TRCDAT,TradeContext.TRCNO,AMOUNT,SNDBANKCO,RCVBANKCO,'',TradeContext.SEAL)
if ret != 0:
#密押错,挂账
AfaLoggerFunc.tradeInfo("密押校验未通过,ret=[" + str(ret) + "]")
accflag = 1
TradeContext.NOTE3 = "密押错,挂账!"
else:
#密押校验通过
AfaLoggerFunc.tradeInfo("密押校验通过")
AfaLoggerFunc.tradeInfo(">>>结束校验密押")
#校验账号是否非法
if accflag == 0:
AfaLoggerFunc.tradeInfo("开始校验账号是否非法")
if (len(TradeContext.PYEACC) != 23) and (len(TradeContext.PYEACC) != 19) :
accflag = 1
TradeContext.NOTE3 = '此账号不是对公或对私账号,挂账!'
AfaLoggerFunc.tradeInfo("结束校验账号是否非法")
#调用主机接口查询账户信息
if accflag == 0:
#调用8810查询账户信息
AfaLoggerFunc.tradeInfo("开始查询账户信息")
TradeContext.ACCNO = TradeContext.PYEACC
TradeContext.HostCode = '8810'
rccpsHostFunc.CommHost( '8810' )
if TradeContext.errorCode != '0000':
accflag = 1
TradeContext.NOTE3 = '查询收款人信息失败,挂账!'
elif TradeContext.errorCode == '0000' and len(TradeContext.ACCSO) == 0 :
accflag = 1
TradeContext.NOTE3 = '查询收款人开户机构失败,挂账!'
AfaLoggerFunc.tradeInfo("结束查询账户信息")
#校验账户状态是否正常
if accflag == 0:
AfaLoggerFunc.tradeInfo("开始校验是否跨法人")
if TradeContext.ACCSO[0:6] != TradeContext.BESBNO[0:6] :
accflag = 1
TradeContext.NOTE3 = '接收行与账户开户行跨法人,挂账!'
AfaLoggerFunc.tradeInfo("结束校验是否跨法人")
#校验开户机构是否建立代理关系
if accflag == 0:
AfaLoggerFunc.tradeInfo("开始校验接收行与开户机构是否为同一机构")
if TradeContext.ACCSO != TradeContext.BESBNOFIRST:
khjg = {}
khjg['BESBNO'] = TradeContext.ACCSO
khjg['BTOPSB'] = TradeContext.BESBNOFIRST
khjg['SUBFLG'] = PL_SUBFLG_SUB
rec = rccpsDBTrcc_subbra.selectu(khjg)
if rec == None:
accflag = 1
TradeContext.NOTE3 = '查询账户代理关系失败,挂账!'
elif len(rec) <= 0:
accflag = 1
TradeContext.NOTE3 = '账户未建立代理关系,挂账!'
else:
#接收机构与开户机构存在代理关系,设置机构号为开户机构号
TradeContext.BESBNO = TradeContext.ACCSO
AfaLoggerFunc.tradeInfo("结束校验接收行与开户机构是否为同一机构")
#校验账号状态是否正常
if accflag == 0:
AfaLoggerFunc.tradeInfo("开始校验账号状态是否正常")
if TradeContext.ACCST != '0' and TradeContext.ACCST != '2':
accflag = 1
TradeContext.NOTE3 = '账户状态不正常,挂账!'
#在建立代理关系的情况下,账户状态不正常,同样挂账
TradeContext.BESBNO = TradeContext.BESBNOFIRST
AfaLoggerFunc.tradeInfo("结束校验账号状态是否正常")
#校验收款人户名是否一致
if accflag == 0:
AfaLoggerFunc.tradeInfo("开始校验收款人户名是否一致")
if TradeContext.ACCNM != TradeContext.PYENAM :
accflag = 1
TradeContext.NOTE3 = '收款人户名不符,挂账!'
#在建立代理关系的情况下,账户状态不正常,同样挂账
TradeContext.BESBNO = TradeContext.BESBNOFIRST
AfaLoggerFunc.tradeInfo("结束校验收款人户名是否一致")
if (TradeContext.existVariable( "PYEACC" ) and len(TradeContext.PYEACC) != 0): #收款人名称
TradeContext.PYEACCNO = TradeContext.PYEACC
else:
TradeContext.PYEACCNO = ''
if (TradeContext.existVariable( "PYENAM" ) and len(TradeContext.PYENAM) != 0): #收款人名称
TradeContext.OTNM = TradeContext.PYENAM
else:
TradeContext.OTNM = ''
#汇兑往帐记帐字典赋值
TradeContext.SBACACNM = '' #借方户名
input_dict = {}
if (TradeContext.existVariable( "PYRNAM" ) and len(TradeContext.PYRNAM) != 0): #付款人户名
TradeContext.SBACACNM = TradeContext.PYRNAM
input_dict['accflag'] = str(accflag) #记挂标志
input_dict['OCCAMT'] = TradeContext.OCCAMT #交易金额
input_dict['PYEACC'] = TradeContext.PYEACCNO #收款人账号
input_dict['OTNM'] = TradeContext.OTNM #收款人名称
input_dict['BESBNO'] = TradeContext.BESBNO
#调用汇兑记账接口
rccpsEntries.HDLZJZ(input_dict)
TradeContext.accflag = accflag #代理标志
#=====新增sstlog表状态记录====
if not rccpsState.newTransState(TradeContext.BJEDTE,TradeContext.BSPSQN,TradeContext.BCSTAT,TradeContext.BDWFLG):
#=====RollBack操作====
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow('M999', '设置状态['+TradeContext.BCSTAT+']['+TradeContext.BDWFLG+']失败,系统自动回滚')
else:
#=====commit操作====
AfaDBFunc.CommitSql()
return True
def SubModuleDoFst():
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.回执类操作(1.回执操作).通存通兑冲正应答报文接收[TRC004_1161]进入***' )
#=================初始化返回信息============================================
if AfaUtilTools.trim(TradeContext.STRINFO) == "":
TradeContext.STRINFO = rccpsDBFunc.getErrInfo(TradeContext.PRCCO)
AfaLoggerFunc.tradeDebug("TradeContext.STRINFO=" + TradeContext.STRINFO)
#=================初始化返回信息============================================
if AfaUtilTools.trim(TradeContext.STRINFO) == "":
TradeContext.STRINFO = rccpsDBFunc.getErrInfo(TradeContext.PRCCO)
AfaLoggerFunc.tradeDebug("TradeContext.STRINFO=" + TradeContext.STRINFO)
#查询原冲正交易信息
atcbka_dict = {}
atcbka_where_dict = {}
atcbka_where_dict['MSGFLGNO'] = TradeContext.ORMFN
atcbka_dict = rccpsDBTrcc_atcbka.selectu(atcbka_where_dict)
if atcbka_dict == None:
return AfaFlowControl.ExitThisFlow("S999","查询原冲正交易信息异常")
if len(atcbka_dict) <= 0:
return AfaFlowControl.ExitThisFlow("S999","未找到原冲正交易信息,丢弃报文")
#查询原被冲正交易是否已开始被冲销
mpcbka_dict = {}
mpcbka_where_dict = {}
mpcbka_where_dict['ORMFN'] = atcbka_dict['ORMFN']
mpcbka_dict = rccpsDBTrcc_mpcbka.selectu(mpcbka_where_dict)
if mpcbka_dict == None:
return AfaFlowControl.ExitThisFlow("S999","查询原冲正交易信息异常")
if len(mpcbka_dict) > 0:
return AfaFlowControl.ExitThisFlow("S999","原交易已开始冲销,停止处理本冲正应答")
#=====给机构号和柜员号赋值====
TradeContext.BETELR = atcbka_dict['BETELR']
TradeContext.BESBNO = atcbka_dict['BESBNO']
#更新冲正登记簿中心返回信息
AfaLoggerFunc.tradeInfo(">>>开始更新冲正登记簿中心返回信息")
atcbka_update_dict = {}
atcbka_update_dict['PRCCO'] = TradeContext.PRCCO
atcbka_update_dict['STRINFO'] = TradeContext.STRINFO
ret = rccpsDBTrcc_atcbka.update(atcbka_update_dict,atcbka_where_dict)
if ret <= 0:
return AfaFlowControl.ExitThisFlow("S999","更新冲正登记簿异常")
AfaLoggerFunc.tradeInfo(">>>结束更新冲正登记簿中心返回信息")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
if atcbka_dict['ORTRCCO'] != '3000504':
AfaLoggerFunc.tradeInfo(">>>原被冲正交易为通存或通兑账务类交易")
#查询原被冲正交易信息
wtr_dict = {}
if not rccpsDBFunc.getTransWtr(atcbka_dict['BOJEDT'],atcbka_dict['BOSPSQ'],wtr_dict):
return AfaFlowControl.ExitThisFlow("S999","查询原被冲正交易信息异常")
#如果原被冲正交易当前状态已为冲正,表示已收到冲正应答,停止处理
if wtr_dict['BCSTAT'] == PL_BCSTAT_CANCEL:
return AfaFlowControl.ExitThisFlow("S999","已收到冲正应答,丢弃报文")
TradeContext.TERMID = wtr_dict['TERMID']
TradeContext.BRSFLG = wtr_dict['BRSFLG']
#若原被冲正交易为通存类交易,应抹账
if wtr_dict['TRCCO'] in ('3000002','3000003','3000004','3000005'):
AfaLoggerFunc.tradeInfo(">>>开始发起主机抹账")
#为抹账赋值会计分录
entries_dict = {}
entries_dict['FEDT'] = wtr_dict['BJEDTE']
entries_dict['RBSQ'] = wtr_dict['BSPSQN']
entries_dict['PYRACC'] = wtr_dict['PYRACC']
entries_dict['PYRNAM'] = wtr_dict['PYRNAM']
entries_dict['PYEACC'] = wtr_dict['PYEACC']
entries_dict['PYENAM'] = wtr_dict['PYENAM']
entries_dict['OCCAMT'] = wtr_dict['OCCAMT']
entries_dict['CHRGTYP'] = wtr_dict['CHRGTYP']
entries_dict['CUSCHRG'] = wtr_dict['CUSCHRG']
entries_dict['RCCSMCD'] = PL_RCCSMCD_CX
TradeContext.BRSFLG = wtr_dict['BRSFLG']
if TradeContext.ORTRCCO == '3000002' or TradeContext.ORTRCCO == '3000004':
rccpsEntries.KZTCWZMZ(entries_dict)
if TradeContext.ORTRCCO == '3000003' or TradeContext.ORTRCCO == '3000005':
rccpsEntries.KZBZYWZMZ(entries_dict)
#=====生成新的前置日期和前置流水号====
if rccpsGetFunc.GetRBSQ(PL_BRSFLG_SND) == -1 :
return AfaFlowControl.ExisThisFlow('S999',"产生新的前置流水号异常")
#设置原交易状态为冲正处理中
AfaLoggerFunc.tradeInfo('>>>开始设置原交易状态为冲正处理中')
if not rccpsState.newTransState(wtr_dict['BJEDTE'],wtr_dict['BSPSQN'],PL_BCSTAT_CANCEL,PL_BDWFLG_WAIT):
return AfaFlowControl.ExitThisFlow('S999',"设置业务状态为冲正处理中异常")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
AfaLoggerFunc.tradeInfo('>>>结束设置原交易状态为冲正处理中')
#=====调起主机接口=====
rccpsHostFunc.CommHost( TradeContext.HostCode )
AfaLoggerFunc.tradeInfo(">>>结束发起主机记账")
else:
AfaLoggerFunc.tradeInfo(">>>原交易未记账,冲正不抹账")
#设置原交易状态为冲正处理中
AfaLoggerFunc.tradeInfo('>>>开始设置原交易状态为冲正处理中')
if not rccpsState.newTransState(wtr_dict['BJEDTE'],wtr_dict['BSPSQN'],PL_BCSTAT_CANCEL,PL_BDWFLG_WAIT):
return AfaFlowControl.ExitThisFlow('S999',"设置业务状态为冲正处理中异常")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
AfaLoggerFunc.tradeInfo('>>>结束设置原交易状态为冲正处理中')
TradeContext.errorCode = "0000"
TradeContext.errorMsg = "冲正前未记账,冲正不抹账"
#根据主机返回信息,设置交易状态
stat_dict = {}
stat_dict['BJEDTE'] = wtr_dict['BJEDTE']
stat_dict['BSPSQN'] = wtr_dict['BSPSQN']
stat_dict['MGID'] = TradeContext.errorCode
stat_dict['STRINFO'] = TradeContext.errorMsg
AfaLoggerFunc.tradeInfo("TradeContext.errorCode = [" + TradeContext.errorCode + "]")
if TradeContext.errorCode == '0000':
#设置原交易状态为冲正成功
AfaLoggerFunc.tradeInfo("<<<<<<<开始更改原交易状态为冲正成功")
stat_dict['BCSTAT'] = PL_BCSTAT_CANCEL
stat_dict['BDWFLG'] = PL_BDWFLG_SUCC
if TradeContext.existVariable('TRDT'):
stat_dict['TRDT'] = TradeContext.TRDT
if TradeContext.existVariable('TLSQ'):
stat_dict['TLSQ'] = TradeContext.TLSQ
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态为冲正成功异常')
AfaLoggerFunc.tradeInfo("<<<<<<<结束更改原交易状态为冲正成功")
else:
#设置原交易状态为冲正失败
AfaLoggerFunc.tradeInfo("<<<<<<<开始更改原交易状态为冲正失败")
stat_dict['BCSTAT'] = PL_BCSTAT_CANCEL
stat_dict['BDWFLG'] = PL_BDWFLG_FAIL
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态为冲正失败异常')
AfaLoggerFunc.tradeInfo("<<<<<<<结束更改原交易状态为冲正成功")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
else:
AfaLoggerFunc.tradeInfo(">>>原被冲正交易为冲销交易")
#查询原冲销交易详细信息
AfaLoggerFunc.tradeInfo(">>>冲销交易报单日期[" + atcbka_dict['BOJEDT'] + "]报单序号[" + atcbka_dict['BOSPSQ'] + "]")
AfaLoggerFunc.tradeInfo(">>>开始查询原冲销交易详细信息")
mpc_dict = {}
if not rccpsDBFunc.getTransMpc(atcbka_dict['BOJEDT'],atcbka_dict['BOSPSQ'],mpc_dict):
return AfaFlowControl.ExitThisFlow("S999","查询原冲销交易详细信息异常")
AfaLoggerFunc.tradeInfo(">>>结束查询原冲销交易详细信息")
#查询原被冲销交易详细信息
AfaLoggerFunc.tradeInfo(">>>被冲销交易报单日期[" + mpc_dict['BOJEDT'] + "]报单序号[" + mpc_dict['BOSPSQ'] + "]")
AfaLoggerFunc.tradeInfo(">>>开始查询原被冲销交易详细信息")
wtr_dict = {}
if not rccpsDBFunc.getTransWtr(mpc_dict['BOJEDT'],mpc_dict['BOSPSQ'],wtr_dict):
return AfaFlowControl.ExitThisFlow("S999","查询原被冲销交易详细信息异常")
AfaLoggerFunc.tradeInfo(">>>结束查询原被冲销交易详细信息")
#更新冲销登记簿
AfaLoggerFunc.tradeInfo(">>>开始更新冲销登记簿")
mpcbka_update_dict = {}
mpcbka_update_dict['PRCCO'] = "RCCI1000"
mpcbka_update_dict['STRINFO'] = "冲销交易被成功冲正"
mpcbka_where_dict = {}
mpcbka_where_dict['BJEDTE'] = mpc_dict['BJEDTE']
mpcbka_where_dict['BSPSQN'] = mpc_dict['BSPSQN']
ret = rccpsDBTrcc_mpcbka.update(mpcbka_update_dict,mpcbka_where_dict)
if ret <= 0:
return AfaFlowControl.ExitThisFlow("更新冲销登记簿返回码和返回信息异常")
AfaLoggerFunc.tradeInfo(">>>结束更新冲销登记簿")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.回执类操作(1.回执操作).通存通兑冲正应答报文接收[TRC004_1161]退出***' )
return True
def SubModuleDoFst():
AfaLoggerFunc.tradeInfo( "====开始汇兑退汇来账接收处理====" )
#=====判断是否重复交易====
sel_dict = {'TRCNO':TradeContext.TRCNO,'TRCDAT':TradeContext.TRCDAT,'SNDBNKCO':TradeContext.SNDBNKCO}
record = rccpsDBTrcc_trcbka.selectu(sel_dict)
if record == None:
return AfaFlowControl.ExitThisFlow('S999','判断是否重复报文，查询汇兑业务登记簿相同报文异常')
elif len(record) > 0:
AfaLoggerFunc.tradeInfo('汇兑业务登记簿中存在相同数据,重复报文,进入下一流程')
#=====为通讯回执报文赋值====
out_context_dict = {}
out_context_dict['sysType'] = 'rccpst'
out_context_dict['TRCCO'] = '9900503'
out_context_dict['MSGTYPCO'] = 'SET008'
out_context_dict['RCVMBRCO'] = TradeContext.SNDMBRCO
out_context_dict['SNDMBRCO'] = TradeContext.RCVMBRCO
out_context_dict['SNDBRHCO'] = TradeContext.BESBNO
out_context_dict['SNDCLKNO'] = TradeContext.BETELR
out_context_dict['SNDTRDAT'] = TradeContext.BJEDTE
out_context_dict['SNDTRTIM'] = TradeContext.BJETIM
out_context_dict['ORMFN'] = TradeContext.MSGFLGNO
out_context_dict['MSGFLGNO'] = out_context_dict['SNDMBRCO'] + TradeContext.BJEDTE + TradeContext.SerialNo
out_context_dict['NCCWKDAT'] = TradeContext.NCCworkDate
out_context_dict['OPRTYPNO'] = '99'
out_context_dict['ROPRTPNO'] = TradeContext.OPRTYPNO
out_context_dict['TRANTYP'] = '0'
out_context_dict['ORTRCCO'] = TradeContext.TRCCO
out_context_dict['PRCCO'] = 'RCCI0000'
out_context_dict['STRINFO'] = '重复报文'
rccpsMap0000Dout_context2CTradeContext.map(out_context_dict)
#=====发送afe====
AfaAfeFunc.CommAfe()
return AfaFlowControl.ExitThisFlow('S999','重复报文，退出处理流程')
AfaLoggerFunc.tradeInfo(">>>结束判断是否重复报文")
#=====币种转换====
if TradeContext.CUR == 'CNY':
TradeContext.CUR = '01'
#===================查询原交易信息=========================================
AfaLoggerFunc.tradeInfo(">>>开始查询原交易信息")
ortrc_dict = {}
if not rccpsDBFunc.getTransTrcAK(TradeContext.ORSNDBNK,TradeContext.ORTRCDAT,TradeContext.ORTRCNO,ortrc_dict):
AfaLoggerFunc.tradeInfo("未找到原交易信息")
TradeContext.BOJEDT = ""
TradeContext.BOSPSQ = ""
else:
TradeContext.BOJEDT = ortrc_dict['BJEDTE']
TradeContext.BOSPSQ = ortrc_dict['BSPSQN']
#=====刘雨龙 2008-09-17 增加业务类型====
TradeContext.OPRATTNO = ortrc_dict['OPRATTNO']
AfaLoggerFunc.tradeInfo(">>>结束查询原交易信息")
#====开始向字典赋值====
trcbka_dict = {}
if not rccpsMap1101CTradeContext2Dtrcbka_dict.map(trcbka_dict):
return AfaFlowControl.ExitThisFlow('M999', '字典赋值出错')
trcbka_dict['DCFLG'] = PL_DCFLG_CRE #借贷标识
trcbka_dict['OPRNO'] = '09' #业务属性
#=====开始插入数据库====
if not rccpsDBFunc.insTransTrc(trcbka_dict):
#=====RollBack操作====
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow('D002', '插入数据库出错,RollBack成功')
else:
#=====commit操作====
AfaDBFunc.CommitSql()
AfaLoggerFunc.tradeInfo('插入汇兑业务登记簿，COMMIT成功')
##========================= START 张恒 增加于20091011 来帐落机构及入帐挂账处理 =====================##
#初始化记挂账标识,记账.0,挂账.1,默认记账
accflag = 0
#接收机构暂存
TradeContext.BESBNOFIRST = TradeContext.BESBNO
#校验账号是否非法
if accflag == 0:
AfaLoggerFunc.tradeInfo("开始校验账号是否非法")
if (len(TradeContext.PYEACC) != 23) and (len(TradeContext.PYEACC) != 19) :
accflag = 1
TradeContext.NOTE3 = '此账号不是对公或对私账号,挂账!'
AfaLoggerFunc.tradeInfo("结束校验账号是否非法")
#调用主机接口查询账户信息
if accflag == 0:
#调用8810查询账户信息
AfaLoggerFunc.tradeInfo("开始查询账户信息")
TradeContext.ACCNO = TradeContext.PYEACC
TradeContext.HostCode = '8810'
rccpsHostFunc.CommHost( '8810' )
if TradeContext.errorCode != '0000':
accflag = 1
TradeContext.NOTE3 = '查询收款人信息失败,挂账!'
elif TradeContext.errorCode == '0000' and len(TradeContext.ACCSO) == 0 :
accflag = 1
TradeContext.NOTE3 = '查询收款人开户机构失败,挂账!'
AfaLoggerFunc.tradeInfo("结束查询账户信息")
#校验账户状态是否正常
if accflag == 0:
AfaLoggerFunc.tradeInfo("开始校验是否跨法人")
if TradeContext.ACCSO[0:6] != TradeContext.BESBNO[0:6] :
accflag = 1
TradeContext.NOTE3 = '接收行与账户开户行跨法人,挂账!'
AfaLoggerFunc.tradeInfo("结束校验是否跨法人")
#校验开户机构是否建立代理关系
if accflag == 0:
AfaLoggerFunc.tradeInfo("开始校验接收行与开户机构是否为同一机构")
if TradeContext.ACCSO != TradeContext.BESBNOFIRST:
khjg = {}
khjg['BESBNO'] = TradeContext.ACCSO
khjg['BTOPSB'] = TradeContext.BESBNOFIRST
khjg['SUBFLG'] = PL_SUBFLG_SUB
rec = rccpsDBTrcc_subbra.selectu(khjg)
if rec == None:
accflag = 1
TradeContext.NOTE3 = '查询账户代理关系失败,挂账!'
elif len(rec) <= 0:
accflag = 1
TradeContext.NOTE3 = '账户未建立代理关系,挂账!'
else:
#接收机构与开户机构存在代理关系,设置机构号为开户机构号
TradeContext.BESBNO = TradeContext.ACCSO
AfaLoggerFunc.tradeInfo("结束校验接收行与开户机构是否为同一机构")
#校验账号状态是否正常
if accflag == 0:
AfaLoggerFunc.tradeInfo("开始校验账号状态是否正常")
if TradeContext.ACCST != '0' and TradeContext.ACCST != '2':
accflag = 1
TradeContext.NOTE3 = '账户状态不正常,挂账!'
#在建立代理关系的情况下,账户状态不正常,同样挂账
TradeContext.BESBNO = TradeContext.BESBNOFIRST
AfaLoggerFunc.tradeInfo("结束校验账号状态是否正常")
#校验收款人户名是否一致
if accflag == 0:
AfaLoggerFunc.tradeInfo("开始校验收款人户名是否一致")
if TradeContext.ACCNM != TradeContext.PYENAM :
accflag = 1
TradeContext.NOTE3 = '收款人户名不符,挂账!'
#在建立代理关系的情况下,账户状态不正常,同样挂账
TradeContext.BESBNO = TradeContext.BESBNOFIRST
AfaLoggerFunc.tradeInfo("结束校验收款人户名是否一致")
if (TradeContext.existVariable( "PYEACC" ) and len(TradeContext.PYEACC) != 0): #收款人名称
TradeContext.PYEACC = TradeContext.PYEACC
else:
TradeContext.PYEACC = ''
if (TradeContext.existVariable( "PYENAM" ) and len(TradeContext.PYENAM) != 0): #收款人名称
TradeContext.OTNM = TradeContext.PYENAM
else:
TradeContext.OTNM = ''
#汇兑往帐记帐字典赋值
input_dict = {}
input_dict['accflag'] = str(accflag) #记挂标志
input_dict['OCCAMT'] = TradeContext.OCCAMT #交易金额
input_dict['PYEACC'] = TradeContext.PYEACC #收款人账号
input_dict['OTNM'] = TradeContext.OTNM #收款人名称
input_dict['BESBNO'] = TradeContext.BESBNO
#调用汇兑记账接口
rccpsEntries.HDLZJZ(input_dict)
TradeContext.accflag = accflag #代理标志
#=====开始调函数拼贷方账号第25位校验位====
TradeContext.HostCode = '8813' #调用8813主机接口
TradeContext.RCCSMCD = PL_RCCSMCD_HDLZ #主机摘要代码：汇兑来账
TradeContext.ACUR = '1'
##========================= END 张恒 增加于20091011 来帐落机构及入帐挂账处理 =====================##
#=====设置状态为收妥====
sstlog = {}
sstlog['BSPSQN'] = TradeContext.BSPSQN
sstlog['BJEDTE'] = TradeContext.BJEDTE
sstlog['BCSTAT'] = PL_BCSTAT_BNKRCV
sstlog['BDWFLG'] = PL_BDWFLG_SUCC
#=====设置状态为 收妥-成功 ====
if not rccpsState.setTransState(sstlog):
#=====RollBack操作====
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow(TradeContext.errorCode, TradeContext.errorMsg)
else:
#=====commit操作====
AfaDBFunc.CommitSql()
AfaLoggerFunc.tradeInfo('>>>commit成功')
return True
def SubModuleDoFst():
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.回执类操作(1.回执操作).通存通兑冲销应答报文接收[TRC004_1162]进入***' )
#=================初始化返回信息============================================
if AfaUtilTools.trim(TradeContext.STRINFO) == "":
TradeContext.STRINFO = rccpsDBFunc.getErrInfo(TradeContext.PRCCO)
AfaLoggerFunc.tradeDebug("TradeContext.STRINFO=" + TradeContext.STRINFO)
#=================初始化返回信息============================================
if AfaUtilTools.trim(TradeContext.STRINFO) == "":
TradeContext.STRINFO = rccpsDBFunc.getErrInfo(TradeContext.PRCCO)
AfaLoggerFunc.tradeDebug("TradeContext.STRINFO=" + TradeContext.STRINFO)
#查询冲正登记簿中是否有对此冲销交易的冲正
AfaLoggerFunc.tradeInfo(">>>开始检查此冲销交易是否已被冲正")
where_sql = "ORMFN = '" + TradeContext.ORMFN + "'"
ret = rccpsDBTrcc_atcbka.count(where_sql)
if ret < 0:
return AfaFlowControl.ExitThisFlow("S999","查询冲正登记簿异常,退出主流程")
if ret > 0:
return AfaFlowControl.ExitThisFlow("S999","冲正登记簿中存在对此冲销交易的冲正,退出主流程")
AfaLoggerFunc.tradeInfo(">>>结束检查此冲销交易是否已被冲正")
#=====更改柜员号和机构号为发起柜员号、发起机构号====
AfaLoggerFunc.tradeInfo("<<<<<<开始更改柜员号，机构号")
#=====查找冲销交易的信息=====
mpcbka_where_dict = {}
mpcbka_where_dict['MSGFLGNO'] = TradeContext.ORMFN
mpcbka_record = rccpsDBTrcc_mpcbka.selectu(mpcbka_where_dict)
if(mpcbka_record == None):
return AfaFlowControl.ExitThisFlow("S999","查询原冲销交易信息异常")
if(len(mpcbka_record) <= 0):
return AfaFlowControl.ExitThisFlow("S999","未找到原冲销交易信息,丢弃报文")
#=====给机构号和柜员号赋值====
TradeContext.BETELR = mpcbka_record['BETELR']
TradeContext.BESBNO = mpcbka_record['BESBNO']
AfaLoggerFunc.tradeInfo("<<<<<<更改柜员号，机构号结束")
#更新冲销登记簿中心返回信息
AfaLoggerFunc.tradeInfo(">>>开始更新冲销登记簿中心返回信息")
mpcbka_update_dict = {}
mpcbka_update_dict['PRCCO'] = TradeContext.PRCCO
mpcbka_update_dict['STRINFO'] = TradeContext.STRINFO
ret = rccpsDBTrcc_mpcbka.update(mpcbka_update_dict,mpcbka_where_dict)
if ret <= 0:
return AfaFlowControl.ExitThisFlow("S999","更新冲销登记簿异常")
AfaLoggerFunc.tradeInfo(">>>结束更新冲销登记簿中心返回信息")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
#=====查询被冲销交易信息====
AfaLoggerFunc.tradeInfo("<<<<<<开始查询被冲销的交易的信息")
wtrbka_record = {}
if not rccpsDBFunc.getTransWtr(mpcbka_record['BOJEDT'],mpcbka_record['BOSPSQ'],wtrbka_record):
return AfaFlowControl.ExitThisFlow("S999","查询被冲销原交易详细信息异常")
AfaLoggerFunc.tradeInfo("<<<<<<结束查询被冲销的交易的信息")
#====为终端号和往来标识赋值====
TradeContext.TERMID = wtrbka_record['TERMID']
TradeContext.BRSFLG = wtrbka_record['BRSFLG']
#=====判断对方行冲销是否成功=====
AfaLoggerFunc.tradeInfo("<<<<<<判断对方行冲销是否成功PRCCO=[" + TradeContext.PRCCO + "]")
if(TradeContext.PRCCO == 'RCCI0000' or TradeContext.PRCCO == 'RCCO1106'):
AfaLoggerFunc.tradeInfo("<<<<<<对方行冲销成功")
#=====发起主机记账====
AfaLoggerFunc.tradeInfo("<<<<<<开始发起主机记账")
#=====取最后一个记账成功状态的前置日期和前置流水号====
stat_list = []
if rccpsState.getTransStateSetm(wtrbka_record['BJEDTE'],wtrbka_record['BSPSQN'],PL_BCSTAT_ACC,PL_BDWFLG_SUCC,stat_list):
entries_dict = {}
entries_dict['FEDT'] = stat_list[0]['FEDT']
entries_dict['RBSQ'] = stat_list[0]['RBSQ']
entries_dict['PYRACC'] = wtrbka_record['PYRACC']
entries_dict['PYRNAM'] = wtrbka_record['PYRNAM']
entries_dict['PYEACC'] = wtrbka_record['PYEACC']
entries_dict['PYENAM'] = wtrbka_record['PYENAM']
entries_dict['OCCAMT'] = wtrbka_record['OCCAMT']
entries_dict['CHRGTYP'] = wtrbka_record['CHRGTYP']
entries_dict['CUSCHRG'] = wtrbka_record['CUSCHRG']
entries_dict['RCCSMCD'] = PL_RCCSMCD_CX
TradeContext.BRSFLG = wtrbka_record['BRSFLG']
#卡折通存往账抹账会计分录赋值
if wtrbka_record['TRCCO'] == '3000002' or wtrbka_record['TRCCO'] == '3000004':
rccpsEntries.KZTCWZMZ(entries_dict)
#卡折本转异往账抹账会计分录赋值
if wtrbka_record['TRCCO'] == '3000003' or wtrbka_record['TRCCO'] == '3000005':
rccpsEntries.KZBZYWZMZ(entries_dict)
#卡折通兑往账抹账会计分录赋值
if wtrbka_record['TRCCO'] == '3000102' or wtrbka_record['TRCCO'] == '3000104':
rccpsEntries.KZTDWZMZ(entries_dict)
#卡折异转本往账抹账会计分录赋值
if wtrbka_record['TRCCO'] == '3000103' or wtrbka_record['TRCCO'] == '3000105':
rccpsEntries.KZYZBWZMZ(entries_dict)
#=====生成新的前置日期和前置流水号,并且更新到数据库中====
if rccpsGetFunc.GetRBSQ(PL_BRSFLG_SND) == -1 :
return AfaFlowControl.ExisThisFlow('S999',"产生新的前置流水号异常")
#设置原交易状态为冲销处理中
AfaLoggerFunc.tradeInfo('>>>开始设置原交易状态为冲销处理中')
if not rccpsState.newTransState(mpcbka_record['BOJEDT'],mpcbka_record['BOSPSQ'],PL_BCSTAT_CANC,PL_BDWFLG_WAIT):
return AfaFlowControl.ExitThisFlow('S999',"设置业务状态为冲销处理中异常")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
AfaLoggerFunc.tradeInfo('>>>结束设置原交易状态为冲销处理中')
#=====调用主机接口函数=====
rccpsHostFunc.CommHost( TradeContext.HostCode )
AfaLoggerFunc.tradeInfo("<<<<<<发起主机抹账结束")
else:
AfaLoggerFunc.tradeInfo(">>>原交易未记账,冲销不抹账")
#设置原交易状态为冲销处理中
AfaLoggerFunc.tradeInfo('>>>开始设置原交易状态为冲销处理中')
if not rccpsState.newTransState(mpcbka_record['BOJEDT'],mpcbka_record['BOSPSQ'],PL_BCSTAT_CANC,PL_BDWFLG_WAIT):
return AfaFlowControl.ExitThisFlow('S999',"设置业务状态为冲销处理中异常")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
AfaLoggerFunc.tradeInfo('>>>结束设置原交易状态为冲销处理中')
TradeContext.errorCode = '0000'
TradeContext.errorMsg = '原交易未记账,冲销不抹账'
#根据主机返回信息,设置交易状态
stat_dict = {}
stat_dict['BJEDTE'] = wtrbka_record['BJEDTE']
stat_dict['BSPSQN'] = wtrbka_record['BSPSQN']
stat_dict['MGID'] = TradeContext.errorCode
stat_dict['STRINFO']= TradeContext.errorMsg
AfaLoggerFunc.tradeInfo("TradeContext.errorCode = [" + TradeContext.errorCode + "]")
if(TradeContext.errorCode == '0000'):
#=====设置原交易状态为冲销成功====
AfaLoggerFunc.tradeInfo("<<<<<<<开始更改原交易状态为冲销成功")
stat_dict['BCSTAT'] = PL_BCSTAT_CANC
stat_dict['BDWFLG'] = PL_BDWFLG_SUCC
if TradeContext.existVariable('TRDT'):
stat_dict['TRDT'] = TradeContext.TRDT
if TradeContext.existVariable('TLSQ'):
stat_dict['TLSQ'] = TradeContext.TLSQ
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态冲销成功异常')
AfaLoggerFunc.tradeInfo("<<<<<<<结束更改原交易状态为冲销成功")
else:
#=====设置原交易状态为冲销失败====
AfaLoggerFunc.tradeInfo("<<<<<<<开始更改原交易状态为冲销失败")
stat_dict['BCSTAT'] = PL_BCSTAT_CANC
stat_dict['BDWFLG'] = PL_BDWFLG_FAIL
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态冲销失败异常')
AfaLoggerFunc.tradeInfo("<<<<<<<结束更改原交易状态为冲销失败")
else:
AfaLoggerFunc.tradeInfo("<<<<<<对方行冲销拒绝应答,不设置原交易状态")
##设置原交易状态为冲销处理中
#AfaLoggerFunc.tradeInfo('>>>开始设置原交易状态为冲销处理中')
#
#if not rccpsState.newTransState(wtrbka_record['BJEDTE'],wtrbka_record['BSPSQN'],PL_BCSTAT_CANC,PL_BDWFLG_WAIT):
# return AfaFlowControl.ExitThisFlow('S999',"设置业务状态为冲销处理中异常")
#
#AfaLoggerFunc.tradeInfo('>>>结束设置原交易状态为冲销处理中')
#
#if not AfaDBFunc.CommitSql( ):
# AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
# return AfaFlowControl.ExitThisFlow("S999","Commit异常")
#
##=====设置原交易状态为冲销失败====
#AfaLoggerFunc.tradeInfo("<<<<<<<开始更改原交易状态为冲销失败")
#
#stat_dict = {}
#stat_dict['BJEDTE'] = wtrbka_record['BJEDTE']
#stat_dict['BSPSQN'] = wtrbka_record['BSPSQN']
#stat_dict['PRCCO'] = TradeContext.PRCCO
#stat_dict['STRINFO']= TradeContext.STRINFO
#stat_dict['BCSTAT'] = PL_BCSTAT_CANC
#stat_dict['BDWFLG'] = PL_BDWFLG_FAIL
#
#if not rccpsState.setTransState(stat_dict):
# return AfaFlowControl.ExitThisFlow('S999','设置业务状态冲销失败异常')
#
#AfaLoggerFunc.tradeInfo("<<<<<<<结束更改原交易状态为冲销失败")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.回执类操作(1.回执操作).通存通兑冲销应答报文接收[TRC004_1162]退出***' )
return True
def SubModuleDoFst():
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.主机类操作(1.本地操作).往账发送[TRCC002_8506]进入***' )
#====begin 蔡永贵 20110215 增加====
#新票据号是16位，需要取后8位，版本号为02，同时要兼容老票据号8位，版本号为01
if len(TradeContext.BILNO) == 16:
TradeContext.TMP_BILNO = TradeContext.BILNO[-8:]
else:
TradeContext.TMP_BILNO = TradeContext.BILNO
#============end============
AfaLoggerFunc.tradeInfo('>>>RCVSTLBIN: '+TradeContext.RCVSTLBIN)
AfaLoggerFunc.tradeInfo('>>>SNDSTLBIN: '+TradeContext.SNDSTLBIN)
#=====判断是否为同一成员行内====
if TradeContext.RCVSTLBIN == TradeContext.SNDSTLBIN:
return AfaFlowControl.ExitThisFlow('M999','同一成员行内禁止做此业务')
##===== 张恒 增加条件,如网银支付则不校验重复次数. 将手续费标志及金额字段赋值 20091109 ========##
if (TradeContext.existVariable( "CHSHTP" ) and len(TradeContext.CHSHTP) != 0): #手续费收取方式
TradeContext.CHRGTYP = TradeContext.CHSHTP
else:
TradeContext.CHRGTYP = '2' #默认为不收
if (TradeContext.existVariable( "CUSCHRG" ) and len(TradeContext.CUSCHRG) != 0): #手续费金额
TradeContext.LOCCUSCHRG = TradeContext.CUSCHRG
else :
TradeContext.LOCCUSCHRG = '0.00' #默认为0.00
TradeContext.CUSCHRG = '0.00' #异地手续费清0
if str(TradeContext.OPRATTNO) != '12': #网银支付
##=====END=====================================================================================##
#=====检查数据库是否有相同交易====
sql = "BJEDTE = '" + TradeContext.BJEDTE + "'" #日期
sql = sql + " and BESBNO ='" + TradeContext.BESBNO + "'" #机构号
if (TradeContext.existVariable( "PYRACC" ) and len(TradeContext.PYRACC) != 0): #付款人账号
sql = sql + " and PYRACC ='" + TradeContext.PYRACC + "'"
if (TradeContext.existVariable( "RCVBNKCO" ) and len(TradeContext.RCVBNKCO) != 0): #收款行行号
sql = sql + " and RCVBNKCO = '" + TradeContext.RCVBNKCO + "'"
if (TradeContext.existVariable( "PYEACC" ) and len(TradeContext.PYEACC) != 0): #收款人账号
sql = sql + " and PYEACC ='" + TradeContext.PYEACC + "'"
if (TradeContext.existVariable( "OCCAMT" ) and len(TradeContext.OCCAMT) != 0): #金额
sql = sql + " and OCCAMT =" + TradeContext.OCCAMT + ""
if (TradeContext.existVariable( "OPRNO" ) and len(TradeContext.OPRNO) != 0): #业务种类
sql = sql + " and OPRNO ='" + TradeContext.OPRNO + "'"
if (TradeContext.existVariable( "OPRATTNO" ) and len(TradeContext.OPRATTNO) != 0): #业务属性
sql = sql + " and OPRATTNO ='" + TradeContext.OPRATTNO + "'"
if (TradeContext.existVariable( "BBSSRC" ) and len(TradeContext.BBSSRC) != 0): #资金来源
sql = sql + " and BBSSRC ='" + TradeContext.BBSSRC + "'"
if (TradeContext.existVariable( "DASQ" ) and len(TradeContext.DASQ) != 0): #销账序号
sql = sql + " and DASQ ='" + TradeContext.DASQ + "'"
if (TradeContext.existVariable( "BILTYP" ) and len(TradeContext.BILTYP) != 0): #票据种类
sql = sql + " and BILTYP = '" + TradeContext.BILTYP + "'"
if (TradeContext.existVariable( "BILDAT" ) and len(TradeContext.BILDAT) != 0): #票据日期
sql = sql + " and BILDAT = '" + TradeContext.BILDAT + "'"
if (TradeContext.existVariable( "BILNO" ) and len(TradeContext.BILNO) != 0): #票据号码
sql = sql + " and BILNO = '" + TradeContext.BILNO + "'"
if (TradeContext.existVariable( "NOTE1" ) and len(TradeContext.NOTE1) != 0): #备注1
sql = sql + " and NOTE1 = '" + TradeContext.NOTE1 + "'"
#=====调用函数进行多笔查询====
AfaLoggerFunc.tradeInfo( '>>>判断必要的字段是否重复，重复返回错误')
record = rccpsDBTrcc_trcbka.selectm(1,10,sql,"")
if record == None:
return AfaFlowControl.ExitThisFlow('D000','数据库操作失败')
if len(record) > 0:
#====判断必要的字段是否重复，重复返回错误====
for next in range(0, len(record)):
spbsta = {'BJEDTE':TradeContext.BJEDTE,'BSPSQN':record[next]['BSPSQN']}
rep = rccpsDBTrcc_spbsta.selectu(spbsta)
if rep == None:
return AfaFlowControl.ExitThisFlow('D000', '数据库操作错误')
elif len(rep) <= 0:
return AfaFlowControl.ExitThisFlow('D001', '数据库查询相同业务错误')
else:
if rep['BDWFLG'] != PL_BDWFLG_FAIL:
return AfaFlowControl.ExitThisFlow('S000', '相同业务已录入，不允许重复提交')
AfaLoggerFunc.tradeInfo( '>>>开始处理此笔业务' )
#=====资金来源为1-个人结算户时，需要调用8811校验支付条件====
if TradeContext.BBSSRC == '1':
TradeContext.HostCode = '8811'
TradeContext.ACCNO = TradeContext.PYRACC #付款人账户
rccpsHostFunc.CommHost( '8811' )
if TradeContext.errorCode != '0000':
return AfaFlowControl.ExitThisFlow('S999','查询凭证信息出错')
else:
if TradeContext.PAYTYP != TradeContext.HPAYTYP:
return AfaFlowControl.ExitThisFlow('S999','支付条件错误')
#=====开始调用密押服务器====
SEAL = ' '
SNDBANKCO = TradeContext.SNDBNKCO
RCVBANKCO = TradeContext.RCVBNKCO
SNDBANKCO = SNDBANKCO.rjust(12,'0')
RCVBANKCO = RCVBANKCO.rjust(12,'0')
AMOUNT = TradeContext.OCCAMT.split('.')[0] + TradeContext.OCCAMT.split('.')[1]
AMOUNT = AMOUNT.rjust(15,'0')
AfaLoggerFunc.tradeDebug('AMOUNT=' + str(AMOUNT) )
AfaLoggerFunc.tradeDebug('SNDBANKCO=' + str(SNDBANKCO) )
AfaLoggerFunc.tradeDebug('RCVBANKCO=' + str(RCVBANKCO) )
AfaLoggerFunc.tradeDebug('类型：' + str(PL_SEAL_ENC) )
AfaLoggerFunc.tradeDebug('业务类型：' + str(PL_TYPE_DZHD) )
AfaLoggerFunc.tradeDebug('日期' + TradeContext.TRCDAT )
AfaLoggerFunc.tradeDebug('流水' + TradeContext.SerialNo )
AfaLoggerFunc.tradeDebug('密押o[' + SEAL + ']')
ret = miya.DraftEncrypt(PL_SEAL_ENC,PL_TYPE_DZHD,TradeContext.TRCDAT,TradeContext.SerialNo,AMOUNT,SNDBANKCO,RCVBANKCO,'',SEAL)
AfaLoggerFunc.tradeDebug("ret[" + str(ret) + "]")
AfaLoggerFunc.tradeDebug('密押[' + SEAL + ']')
if ret != 0:
return AfaFlowControl.ExitThisFlow('M9999','调用密押服务器失败')
else:
TradeContext.SEAL = SEAL
AfaLoggerFunc.tradeDebug('密押new[' + TradeContext.SEAL + ']')
#=====开始向字典赋值====
TradeContext.DCFLG = PL_DCFLG_CRE
dict = {}
if not rccpsMap8506CTradeContext2Ddict.map(dict):
return AfaFlowControl.ExitThisFlow('M999', '字典赋值出错')
#=====开始插入数据库====
if not rccpsDBFunc.insTransTrc(dict):
#=====RollBack操作====
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow('D002', '插入数据库出错,RollBack成功')
#=====commit操作====
if not AfaDBFunc.CommitSql():
#=====RollBack操作====
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow('D011', '数据库Commit失败')
else:
AfaLoggerFunc.tradeDebug('COMMIT成功')
#====送往主机字段增加收款人名称字段 ===
if (TradeContext.existVariable( "PYRNAM" ) and len(TradeContext.PYRNAM) != 0): #付款人名称
TradeContext.ACNM = TradeContext.PYRNAM
else:
TradeContext.ACNM = ''
if (TradeContext.existVariable( "PYENAM" ) and len(TradeContext.PYENAM) != 0): #收款人名称
TradeContext.OTNM = TradeContext.PYENAM
else:
TradeContext.OTNM = ''
#汇兑往帐记帐字典赋值
input_dict = {}
input_dict['CHRGTYP'] = TradeContext.CHRGTYP #手续费收取方式
input_dict['LOCCUSCHRG'] = TradeContext.LOCCUSCHRG #手续费金额
input_dict['PYRACC'] = TradeContext.PYRACC #付款人账号
input_dict['BBSSRC'] = TradeContext.BBSSRC #资金来源
input_dict['OCCAMT'] = TradeContext.OCCAMT #交易金额
input_dict['ACNM'] = TradeContext.ACNM #付款人名称
input_dict['OTNM'] = TradeContext.OTNM #收款人名称
input_dict['BESBNO'] = TradeContext.BESBNO
#调用汇兑记账接口
rccpsEntries.HDWZJZ(input_dict)
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.主机类操作(1.本地操作).往账发送[TRCC002_8506]退出***' )
return True
def SubModuleDoFst():
AfaLoggerFunc.tradeInfo("'***农信银系统：通存通兑往账交易.差错抹账[8571] 进入")
AfaLoggerFunc.tradeInfo("<<<<<<<个性化处理(本地操作) 进入")
#=====校验变量的合法性====
AfaLoggerFunc.tradeInfo("<<<<<<校验变量的合法性")
if not TradeContext.existVariable("TRCDAT"):
return AfaFlowControl.ExitThisFlow('A099','没有委托日期')
if not TradeContext.existVariable("SNDBNKCO"):
return AfaFlowControl.ExitThisFlow('A099','没有发送行号')
if not TradeContext.existVariable("TRCNO"):
return AfaFlowControl.ExitThisFlow('A099','没有交易流水号')
AfaLoggerFunc.tradeInfo("<<<<<<校验变量的合法性结束")
#=====产生FEDT,RBSQ,NCCworkDate,BJEDTE====
TradeContext.BJEDTE = AfaUtilTools.GetHostDate( ) #BJEDTE
TradeContext.FEDT=AfaUtilTools.GetHostDate( ) #FEDT
if not rccpsFunc.GetNCCDate( ) : #NCCworkDate
raise AfaFlowControl.flowException( )
if rccpsGetFunc.GetRBSQ(PL_BRSFLG_SND) == -1 : #RBSQ
return AfaFlowControl.ExitThisFlow('A099','产生前置流水号失败')
#=====查询交易信息====
AfaLoggerFunc.tradeInfo("<<<<<<开始查询通存通兑业务登记簿")
where_dict = {}
where_dict = {'TRCNO':TradeContext.TRCNO,'SNDBNKCO':TradeContext.SNDBNKCO,'TRCDAT':TradeContext.TRCDAT}
wtrbka_record_dict = rccpsDBTrcc_wtrbka.selectu(where_dict)
if(wtrbka_record_dict == None):
return AfaFlowControl.ExitThisFlow('A099','查询通存通兑业务登记簿失败')
elif(len(wtrbka_record_dict) == 0):
return AfaFlowControl.ExitThisFlow('A099','查询通存通兑业务登记簿结果为空')
else:
AfaLoggerFunc.tradeInfo("<<<<<<查询通存通兑业务登记簿成功")
#=====查询错账登记簿======
AfaLoggerFunc.tradeInfo("<<<<<<开始查询错账登记簿")
where_dict = {}
where_dict = {'TRCNO':TradeContext.TRCNO,'SNDBNKCO':TradeContext.SNDBNKCO,'TRCDAT':TradeContext.TRCDAT}
tddzcz_record_dict = rccpsDBTrcc_tddzcz.selectu(where_dict)
if(tddzcz_record_dict == None):
return AfaFlowControl.ExitThisFlow('A099','查询错账登记簿失败')
elif(len(tddzcz_record_dict) == 0):
AfaLoggerFunc.tradeInfo("<<<<<<查询错账登记簿为空，应向其中补记一笔")
insert_dict = {}
insert_dict['NCCWKDAT'] = wtrbka_record_dict['NCCWKDAT']
insert_dict['SNDBNKCO'] = wtrbka_record_dict['SNDBNKCO']
insert_dict['TRCDAT'] = wtrbka_record_dict['TRCDAT']
insert_dict['TRCNO'] = wtrbka_record_dict['TRCNO']
insert_dict['RCVBNKCO'] = wtrbka_record_dict['RCVBNKCO']
insert_dict['SNDMBRCO'] = wtrbka_record_dict['SNDMBRCO']
insert_dict['RCVMBRCO'] = wtrbka_record_dict['RCVMBRCO']
insert_dict['TRCCO'] = wtrbka_record_dict['TRCCO']
insert_dict['DCFLG'] = wtrbka_record_dict['DCFLG']
insert_dict['PYRACC'] = wtrbka_record_dict['PYRACC']
insert_dict['PYEACC'] = wtrbka_record_dict['PYEACC']
insert_dict['CUR'] = 'CNY'
insert_dict['OCCAMT'] = wtrbka_record_dict['OCCAMT']
insert_dict['LOCOCCAMT'] = wtrbka_record_dict['OCCAMT']
if(wtrbka_record_dict['TRCCO'] in ('3000102','3000103','3000104','3000105') and wtrbka_record_dict['CHRGTYP'] == '1'):
insert_dict['CUSCHRG'] = wtrbka_record_dict['CUSCHRG']
insert_dict['LOCCUSCHRG'] = wtrbka_record_dict['CUSCHRG']
else:
insert_dict['CUSCHRG'] = 0.00
insert_dict['LOCCUSCHRG'] = 0.00
insert_dict['ORTRCNO'] = ""
insert_dict['BJEDTE'] = wtrbka_record_dict['BJEDTE']
insert_dict['BSPSQN'] = wtrbka_record_dict['BSPSQN']
insert_dict['EACTYP'] = ""
insert_dict['EACINF'] = ""
insert_dict['LOCEACTYP'] = ""
insert_dict['LOCEACINF'] = ""
insert_dict['ISDEAL'] = "0"
insert_dict['NOTE1'] = ""
insert_dict['NOTE2'] = ""
insert_dict['NOTE3'] = ""
insert_dict['NOTE4'] = ""
#=====向错账登记簿中补记此笔交易====
if not rccpsDBTrcc_tddzcz.insertCmt(insert_dict):
return AfaFlowControl.ExitThisFlow('A099','向错账登记簿中补记交易失败')
#=====补查错账登记簿，将刚插入的数据查出来====
AfaLoggerFunc.tradeInfo("<<<<<<补查错账登记簿")
where_dict = {}
where_dict = {'SNDBNKCO':TradeContext.SNDBNKCO,'TRCDAT':TradeContext.TRCDAT,'TRCNO':TradeContext.TRCNO}
tddzcz_record_dict = rccpsDBTrcc_tddzcz.selectu(where_dict)
if(tddzcz_record_dict == None):
return AfaFlowControl.ExitThisFlow('A099','查询错账登记簿失败')
elif(len(tddzcz_record_dict) == 0):
return AfaFlowControl.ExitThisFlow('A099','查询通错账登记簿结果为空')
else:
AfaLoggerFunc.tradeInfo("<<<<<<补查错账登记簿成功")
else:
AfaLoggerFunc.tradeInfo("<<<<<<查询错账登记簿成功")
#=====判断此笔业务是否已经处理====
if(tddzcz_record_dict['ISDEAL'] == PL_ISDEAL_ISDO):
return AfaFlowControl.ExitThisFlow('A099','此笔账务已经处理过')
#=====开始行内抹账====
AfaLoggerFunc.tradeInfo("<<<<<<开始行内抹账")
input_dict = {}
input_dict['PYRACC'] = wtrbka_record_dict['PYRACC']
input_dict['PYRNAM'] = wtrbka_record_dict['PYRNAM']
input_dict['PYEACC'] = wtrbka_record_dict['PYEACC']
input_dict['PYENAM'] = wtrbka_record_dict['PYENAM']
input_dict['CHRGTYP'] = wtrbka_record_dict['CHRGTYP']
input_dict['OCCAMT'] = wtrbka_record_dict['OCCAMT']
input_dict['CUSCHRG'] = wtrbka_record_dict['CUSCHRG']
input_dict['RCCSMCD'] = PL_RCCSMCD_CX
TradeContext.NCCworkDate = wtrbka_record_dict['NCCWKDAT']
TradeContext.BESBNO = wtrbka_record_dict['BESBNO']
TradeContext.BETELR = PL_BETELR_AUTO
TradeContext.TERMID = wtrbka_record_dict['TERMID']
#=====判断原交易的往来标示====
AfaLoggerFunc.tradeInfo("<<<<<<判断原交易是来账还是往账")
if(wtrbka_record_dict['BRSFLG'] == PL_BRSFLG_SND):
AfaLoggerFunc.tradeInfo("<<<<<原业务为往账")
TradeContext.BRSFLG = PL_BRSFLG_SND
if(wtrbka_record_dict['TRCCO'] in ('3000002','3000004')):
AfaLoggerFunc.tradeDebug("<<<<<<卡折现金通存往账抹账")
rccpsEntriesErr.KZTCWZMZ(input_dict)
elif(wtrbka_record_dict['TRCCO'] in ('3000003','3000005')):
AfaLoggerFunc.tradeDebug("<<<<<<卡折本转异往账抹账")
rccpsEntriesErr.KZBZYWZMZ(input_dict)
elif(wtrbka_record_dict['TRCCO'] in ('3000102','3000104')):
AfaLoggerFunc.tradeDebug("<<<<<<卡折现金通兑往账抹账")
rccpsEntriesErr.KZTDWZMZ(input_dict)
elif(wtrbka_record_dict['TRCCO'] in ('3000103','3000105')):
AfaLoggerFunc.tradeDebug("<<<<<<卡折异转本往账抹账")
rccpsEntriesErr.KZYZBWZMZ(input_dict)
else:
return AfaFlowControl.ExitThisFlow('S999','非法交易代码')
else:
AfaLoggerFunc.tradeInfo("<<<<<原业务为来账")
TradeContext.BRSFLG = PL_BRSFLG_RCV
if(wtrbka_record_dict['TRCCO'] in ('3000002','3000004')):
AfaLoggerFunc.tradeDebug("<<<<<<卡折现金通存来账抹账")
rccpsEntriesErr.KZTCLZMZ(input_dict)
elif(wtrbka_record_dict['TRCCO'] in ('3000003','3000005')):
AfaLoggerFunc.tradeDebug("<<<<<<卡折本转异来账抹账")
rccpsEntriesErr.KZBZYLZMZ(input_dict)
elif(wtrbka_record_dict['TRCCO'] in ('3000102','3000104')):
AfaLoggerFunc.tradeDebug("<<<<<<卡折现金通兑来账抹账")
rccpsEntriesErr.KZTDLZMZ(input_dict)
elif(wtrbka_record_dict['TRCCO'] in ('3000103','3000105')):
AfaLoggerFunc.tradeDebug("<<<<<<卡折异转本来账抹账")
rccpsEntriesErr.KZYZBLZMZ(input_dict)
else:
return AfaFlowControl.ExitThisFlow('S999','非法交易代码')
#=====判断当前状态是否允许抹账====
# AfaLoggerFunc.tradeInfo("<<<<<<判断交易当前状态是否允许抹账")
# stat_dict = {}
# res = rccpsState.getTransStateCur(wtrbka_record_dict['BJEDTE'],wtrbka_record_dict['BSPSQN'],stat_dict)
# if(res == False):
# return AfaFlowControl.ExitThisFlow('A099','查询业务的当前状态失败')
# else:
# AfaLoggerFunc.tradeInfo("查询业务当前状态成功")
#
# if(stat_dict['BCSTAT'] in (PL_BCSTAT_HCAC,PL_BCSTAT_CANC,PL_BCSTAT_CANCEL) and stat_dict['BDWFLG'] == PL_BDWFLG_SUCC):
# return AfaFlowControl.ExitThisFlow('S999','原业务当前状态不需要抹账，请手工更改处理标识')
acc = 0
autopay = 0
auto = 0
hcac = 0
canc = 0
cancel = 0
#=====查询是否有记账成功的状态====
sstlog_list = []
if rccpsState.getTransStateSetm(wtrbka_record_dict['BJEDTE'],wtrbka_record_dict['BSPSQN'],PL_BCSTAT_ACC,PL_BDWFLG_SUCC,sstlog_list):
acc = len(sstlog_list)
sstlog_list = []
if rccpsState.getTransStateSetm(wtrbka_record_dict['BJEDTE'],wtrbka_record_dict['BSPSQN'],PL_BCSTAT_AUTOPAY,PL_BDWFLG_SUCC,sstlog_list):
autopay = len(sstlog_list)
sstlog_list = []
if rccpsState.getTransStateSetm(wtrbka_record_dict['BJEDTE'],wtrbka_record_dict['BSPSQN'],PL_BCSTAT_AUTO,PL_BDWFLG_SUCC,sstlog_list):
auto = len(sstlog_list)
#=====查询是否有抹账的状态====
sstlog_list = []
if rccpsState.getTransStateSetm(wtrbka_record_dict['BJEDTE'],wtrbka_record_dict['BSPSQN'],PL_BCSTAT_HCAC,PL_BDWFLG_SUCC,sstlog_list):
hcac = len(sstlog_list)
#=====查询是否有冲销的状态====
sstlog_list = []
if rccpsState.getTransStateSetm(wtrbka_record_dict['BJEDTE'],wtrbka_record_dict['BSPSQN'],PL_BCSTAT_CANC,PL_BDWFLG_SUCC,sstlog_list):
canc = len(sstlog_list)
#=====查询是否有冲正的状态====
ssltog_list = []
if rccpsState.getTransStateSetm(wtrbka_record_dict['BJEDTE'],wtrbka_record_dict['BSPSQN'],PL_BCSTAT_CANCEL,PL_BDWFLG_SUCC,sstlog_list):
cancel = len(sstlog_list)
if((acc + autopay + auto) - (hcac + canc + cancel) <= 0):
return AfaFlowControl.ExitThisFlow('S999','此交易未记账或已抹账，禁止提交')
AfaLoggerFunc.tradeInfo("<<<<<<结束判断交易当前状态是否允许抹账")
#=====在上主机前设置原交易的状态====
AfaLoggerFunc.tradeInfo("<<<<<<在上主机前设置原交易的状态")
if not rccpsState.newTransState(wtrbka_record_dict['BJEDTE'],wtrbka_record_dict['BSPSQN'],PL_BCSTAT_HCAC,PL_BDWFLG_WAIT):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态为抹账处理中异常')
else:
AfaDBFunc.CommitSql()
#=====开始调用主机交易====
AfaLoggerFunc.tradeInfo("<<<<<<开始调用主机交易")
rccpsHostFunc.CommHost( TradeContext.HostCode )
AfaLoggerFunc.tradeInfo("<<<<<<结束调用主机交易")
AfaLoggerFunc.tradeInfo("<<<<<<行内抹账结束")
#=====给状态字典赋值====
state_dict = {}
state_dict['BJEDTE'] = wtrbka_record_dict['BJEDTE']
state_dict['BSPSQN'] = wtrbka_record_dict['BSPSQN']
state_dict['BCSTAT'] = PL_BCSTAT_HCAC
state_dict['MGID'] = TradeContext.errorCode
state_dict['STRINFO']= TradeContext.errorMsg
if TradeContext.existVariable('TRDT'):
state_dict['TRDT'] = TradeContext.TRDT
if TradeContext.existVariable('TLSQ'):
state_dict['TLSQ'] = TradeContext.TLSQ
if TradeContext.existVariable('RBSQ'):
state_dict['RBSQ'] = TradeContext.RBSQ
if TradeContext.existVariable('FEDT'):
state_dict['FEDT'] = TradeContext.FEDT
#=====判断主机抹账是否成功====
AfaLoggerFunc.tradeInfo("<<<<<<判断主机抹账是否成功")
AfaLoggerFunc.tradeDebug("<<<<<<errorCode=" + TradeContext.errorCode)
if(TradeContext.errorCode != '0000'):
AfaLoggerFunc.tradeDebug("主机抹账失败")
#=====主机后更改原交易为失败====
AfaLoggerFunc.tradeInfo("<<<<<<主机后更改原交易为抹失败")
state_dict['BDWFLG'] = PL_BDWFLG_FAIL
state_dict['STRINFO'] = TradeContext.errorMsg
if not rccpsState.setTransState(state_dict):
return AfaFlowControl.ExitThisFlow('S999','设置业务为失败异常')
else:
AfaDBFunc.CommitSql()
return AfaFlowControl.ExitThisFlow('S999','主机抹账失败')
else:
AfaLoggerFunc.tradeInfo("<<<<<<主机抹账成功")
#=====主机后更改原交易状态=====
AfaLoggerFunc.tradeInfo("<<<<<<主机后更改原交易为成功")
state_dict['BDWFLG'] = PL_BDWFLG_SUCC
state_dict['STRINFO'] = '主机成功'
if not rccpsState.setTransState(state_dict):
return AfaFlowControl.ExitThisFlow('S999','设置业务为成功异常')
else:
AfaDBFunc.CommitSql()
#=====更改错账登记簿中的处理标示====
AfaLoggerFunc.tradeInfo("<<<<<<更改错账登记簿中的处理标示")
where_dict = {}
where_dict = {'BJEDTE':tddzcz_record_dict['BJEDTE'],'BSPSQN':tddzcz_record_dict['BSPSQN']}
update_dict = {}
update_dict['ISDEAL'] = PL_ISDEAL_ISDO
update_dict['NOTE3'] = '此笔错账已抹账'
res = rccpsDBTrcc_tddzcz.updateCmt(update_dict,where_dict)
if(res == -1):
return AfaFlowControl.ExitThisFlow('S999','主机抹账成功,但更新错账处理标示失败，请手工更新错账处理标示')
else:
AfaLoggerFunc.tradeInfo("<<<<<<更改错账登记簿中的处理标示成功")
#=====向下发的通知表中插入数据====
AfaLoggerFunc.tradeInfo("<<<<<<向通知表中插入数据")
insert_dict = {}
insert_dict['NOTDAT'] = TradeContext.BJEDTE
insert_dict['BESBNO'] = wtrbka_record_dict['BESBNO']
if(wtrbka_record_dict['BRSFLG'] == PL_BRSFLG_RCV):
insert_dict['STRINFO'] = "此笔错账["+wtrbka_record_dict['BSPSQN']+"]["+wtrbka_record_dict['BJEDTE']+"]已做抹账处理"
else:
insert_dict['STRINFO'] = "此笔错账["+wtrbka_record_dict['BSPSQN']+"]["+wtrbka_record_dict['BJEDTE']+"]已做抹账处理 请用8522补打往账凭证"
if not rccpsDBTrcc_notbka.insertCmt(insert_dict):
return AfaFlowControl.ExitThisFlow('S999','向下发的通知表中插入数据失败')
AfaLoggerFunc.tradeInfo("<<<<<<向通知表中插入数据成功")
#=====给输出接口赋值=====
AfaLoggerFunc.tradeInfo("<<<<<<开始给输出接口赋值")
TradeContext.BOSPSQ = wtrbka_record_dict['BSPSQN']
TradeContext.BOJEDT = wtrbka_record_dict['BJEDTE']
TradeContext.TLSQ = TradeContext.TLSQ
TradeContext.BRSFLG = wtrbka_record_dict['BRSFLG']
TradeContext.TRCCO = wtrbka_record_dict['TRCCO']
TradeContext.BEACSB = wtrbka_record_dict['BESBNO']
TradeContext.OROCCAMT = str(wtrbka_record_dict['OCCAMT'])
TradeContext.ORCUR = wtrbka_record_dict['CUR']
TradeContext.ORSNDBNK = wtrbka_record_dict['SNDBNKCO']
TradeContext.ORSNDBNKNM = wtrbka_record_dict['SNDBNKNM']
TradeContext.ORRCVBNK = wtrbka_record_dict['RCVBNKCO']
TradeContext.ORRCVBNKNM = wtrbka_record_dict['RCVBNKNM']
TradeContext.ORPYRACC = wtrbka_record_dict['PYRACC']
TradeContext.ORPYRNAM = wtrbka_record_dict['PYRNAM']
TradeContext.ORPYEACC = wtrbka_record_dict['PYEACC']
TradeContext.ORPYENAM = wtrbka_record_dict['PYENAM']
# TradeContext.SBAC =
# TradeContext.RBAC =
AfaLoggerFunc.tradeDebug("<<<<<<OROCCAMT="+str(TradeContext.OROCCAMT))
AfaLoggerFunc.tradeInfo("<<<<<<结束给输出接口赋值")
AfaLoggerFunc.tradeInfo("<<<<<<<个性化处理(本地操作) 退出")
AfaLoggerFunc.tradeInfo("'***农信银系统：通存通兑往账交易.差错抹账[8571] 退出")
return True
def SubModuleDoFst():
AfaLoggerFunc.tradeInfo( '***农信银系统: 往账.本地类操作交易[RCC004_1163]进入***' )
#=====判断是否存在自动冲正报文====
AfaLoggerFunc.tradeDebug('>>>判断是否存在自动冲正报文')
atcbka_where={'ORMFN':TradeContext.MSGFLGNO}
atcbka_dict = rccpsDBTrcc_atcbka.selectu(atcbka_where)
if( len(atcbka_dict) > 0 ):
#=====冲销业务存在自动冲正报文,更新表数据为冲销失败,回复冲销失败报文====
AfaLoggerFunc.tradeDebug('>>>已存在自动冲正报文,抛弃报文')
return AfaFlowControl.ExitThisFlow('S999','存在自动冲正报文，抛弃报文')
else:
AfaLoggerFunc.tradeDebug('>>>未查找到针对补正报文的自动冲正报文,流程继续')
#=====判断原补正交易是否存在====
AfaLoggerFunc.tradeDebug('>>>判断是否存在原补正报文')
wtrbka_where={'MSGFLGNO':TradeContext.ORMFN}
wtrbka_dict = rccpsDBTrcc_wtrbka.selectu(wtrbka_where)
wtrbka_temp_dict = wtrbka_dict
if len(wtrbka_dict) <= 0:
AfaLoggerFunc.tradeDebug('>>>未找到原补正报文，抛弃报文，不做任何处理')
return AfaFlowControl.ExitThisFlow('S999','未找到原补正报文，抛弃报文，不做任何处理')
else:
AfaLoggerFunc.tradeDebug('>>>找到原补正报文，继续流程处理')
#=====查找原业务====
AfaLoggerFunc.tradeDebug('>>>查询原业务')
wtrbka_where={'BJEDTE':wtrbka_dict['NOTE1'],'BSPSQN':wtrbka_dict['NOTE2']}
wtrbka_dict = rccpsDBTrcc_wtrbka.selectu(wtrbka_where)
if len(wtrbka_dict) <= 0:
AfaLoggerFunc.tradeDebug('>>>未找到原业务，抛弃报文，不做任何处理')
return AfaFlowControl.ExitThisFlow('S999','未找到原业务，抛弃报文，不做任何处理')
else:
AfaLoggerFunc.tradeDebug('>>>找到原业务，继续流程处理')
#=====查找原业务状态====
AfaLoggerFunc.tradeDebug('>>>查找原业务状态')
spb_where = {'BJEDTE':wtrbka_dict['BJEDTE'],'BSPSQN':wtrbka_dict['BSPSQN']}
spb_dict = rccpsDBTrcc_spbsta.selectu(spb_where)
if len(spb_dict) <= 0:
AfaLoggerFunc.tradeDebug('>>>查找原业务状态失败，抛弃报文，不做任何处理')
return AfaFlowControl.ExitThisFlow('S999','查找原业务状态失败，抛弃报文，不做任何处理')
else:
AfaLoggerFunc.tradeDebug('>>>查找原业务状态成功，继续流程处理')
#=====判断原业务状态是否允许进行补正账务补录====
if spb_dict['BCSTAT'] != PL_BCSTAT_CANC and spb_dict['BDWFLG'] != PL_BDWFLG_SUCC:
AfaLoggerFunc.tradeDebug('>>>原业务状态['+str(spbsta_dict['BCSTAT'])+'不允许补正，抛弃报文，不做任何处理')
return AfaFlowControl.ExitThisFlow('S999','原业务不允许补正，抛弃报文，不做任何处理')
else:
AfaLoggerFunc.tradeDebug('>>>原业务进入补正账务流程处理')
#=================若应答报文回复拒绝,则设置状态为拒绝,停止处理=============
if TradeContext.PRCCO != 'RCCI0000':
AfaLoggerFunc.tradeInfo(">>>对方返回拒绝应答")
#=============设置业务状态为拒绝处理中=================================
if not rccpsState.newTransState(wtrbka_temp_dict['BJEDTE'],wtrbka_temp_dict['BSPSQN'],PL_BCSTAT_MFERFE,PL_BDWFLG_SUCC):
return AfaFlowControl.ExitThisFlow('S999',"设置业务状态为拒绝处理中异常")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
return AfaFlowControl.ExitThisFlow("S999","对方拒绝,停止处理")
else:
AfaLoggerFunc.tradeInfo(">>>对方返回成功应答")
#=====记账接口8813I1赋值操作====
TradeContext.HostCode = '8813'
TradeContext.BESBNO = wtrbka_dict['BESBNO'] #机构号
TradeContext.BETELR = wtrbka_dict['BETELR'] #柜员号
TradeContext.TERMID = wtrbka_dict['TERMID'] #终端号
TradeContext.BJEDTE = wtrbka_dict['BJEDTE'] #交易日期
TradeContext.BSPSQN = wtrbka_dict['BSPSQN'] #报单序号
#=====判断交易代码，进行账务补正====
if TradeContext.ORTRCCO in ('3000002','3000004'):
#=====通存====
AfaLoggerFunc.tradeDebug('>>>通存业务补正')
elif TradeContext.ORTRCCO in ('3000102','3000104'):
#=====通兑====
AfaLoggerFunc.tradeDebug('>>>通兑业务补正')
if( wtrbka_dict['CHRGTYP'] != '1'):
TradeContext.RCCSMCD = PL_RCCSMCD_XJTDWZ #主机摘要代码
TradeContext.RBAC = '' #借方账户:付款人账户
TradeContext.RBNM = '现金' #借方户名 付款人户名
TradeContext.SBAC = TradeContext.BESBNO + PL_ACC_NXYDQSWZ #贷方账户:农信银待清算来账
TradeContext.SBAC = rccpsHostFunc.CrtAcc(TradeContext.SBAC, 25)
TradeContext.ACNM = '农信银待清算来账' #贷方户名:
TradeContext.CTFG = '7' #本金 手续费标识 7 本金 8手续费 9 本金＋手续费
TradeContext.PKFG = 'T' #通存通兑标识
TradeContext.CATR = '0' #现金
AfaLoggerFunc.tradeInfo( '借方账号:' + TradeContext.SBAC )
AfaLoggerFunc.tradeInfo( '贷方账号:' + TradeContext.RBAC )
else:
#=====转账====
TradeContext.ACUR = '3' #记账次数
TradeContext.I3TRAM = str(TradeContext.CUSCHRG) #发生额
TradeContext.I2TRAM = str(TradeContext.OCCAMT) #发生额
TradeContext.OCCAMT = rccpsUtilTools.AddDot(TradeContext.OCCAMT,TradeContext.CUSCHRG) #发生额
#=========交易金额+手续费===================
TradeContext.RCCSMCD = PL_RCCSMCD_XJTDWZ #摘要代码
TradeContext.SBAC = TradeContext.BESBNO + PL_ACC_NXYDQSWZ #借方账号
TradeContext.SBAC = rccpsHostFunc.CrtAcc(TradeContext.SBAC,25)
TradeContext.ACNM = '待解临时款项' #借方户名
TradeContext.RBAC = TradeContext.BESBNO + PL_ACC_NXYDJLS #贷方账号
TradeContext.RBAC = rccpsHostFunc.CrtAcc(TradeContext.RBAC,25)
TradeContext.OTNM = '农信银来账' #贷方户名
TradeContext.CTFG = '9' #本金 手续费标识 7 本金 8手续费 9 本金＋手续费
TradeContext.PKFG = 'T' #通存通兑标识
AfaLoggerFunc.tradeInfo( '>>>交易金额+手续费:借方账号' + TradeContext.SBAC )
AfaLoggerFunc.tradeInfo( '>>>交易金额+手续费:贷方账号' + TradeContext.RBAC )
#=========交易金额============
TradeContext.I2SMCD = PL_RCCSMCD_XJTDWZ #摘要代码
TradeContext.I2RBAC = '' #借方账号
TradeContext.I2ACNM = TradeContext.PYRNAM #借方户名
TradeContext.I2SBAC = TradeContext.BESBNO + PL_ACC_NXYDJLS #贷方账号
TradeContext.I2SBAC = rccpsHostFunc.CrtAcc(TradeContext.I2SBAC,25)
TradeContext.I2CTFG = '7' #本金 手续费标识 7 本金 8手续费 9 本金＋手续费
TradeContext.I2PKFG = 'T' #通存通兑标识
TradeContext.I2CATR = '0' #现金
AfaLoggerFunc.tradeInfo( '>>>交易金额:借方账号' + TradeContext.I2SBAC )
AfaLoggerFunc.tradeInfo( '>>>交易金额:贷方账号' + TradeContext.I2RBAC )
#=========结算手续费收入户===========
TradeContext.I3SMCD = PL_RCCSMCD_SXF #摘要代码
TradeContext.I3SBAC = TradeContext.BESBNO + PL_ACC_NXYDJLS #借方账号
TradeContext.I3ACNM = TradeContext.PYRNAM #借方户名
TradeContext.I3RBAC = TradeContext.BESBNO + PL_ACC_TCTDSXF #贷方账号
TradeContext.I3RBAC = rccpsHostFunc.CrtAcc(TradeContext.I3RBAC,25)
TradeContext.I3SBAC = rccpsHostFunc.CrtAcc(TradeContext.I3SBAC,25)
TradeContext.I3OTNM = '待解临时款项' #贷方户名
TradeContext.I3CTFG = '8' #本金 手续费标识 7 本金 8手续费 9 本金＋手续费
TradeContext.I3PKFG = 'T' #通存通兑标识
AfaLoggerFunc.tradeInfo( '>>>结算手续费收入户:借方账号' + TradeContext.I3SBAC )
AfaLoggerFunc.tradeInfo( '>>>结算手续费收入户:贷方账号' + TradeContext.I3RBAC )
elif TradeContext.ORTRCCO in ('3000003','3000005'):
#=====本转异====
AfaLoggerFunc.tradeDebug('>>>本转异业务补正')
elif TradeContext.ORTRCCO in ('3000103','3000105'):
#=====异转本====
AfaLoggerFunc.tradeDebug('>>>异转本业务补正')
#=====判断手续费收取方式====
if wtrbka_dict['CHRGTYP'] == '1':
#=====转账====
TradeContext.ACUR = '3' #记账次数
TradeContext.I3TRAM = str(TradeContext.CUSCHRG) #发生额 手续费
TradeContext.I2TRAM = str(TradeContext.OCCAMT) #发生额 本金
TradeContext.OCCAMT = str(float(TradeContext.OCCAMT) + float(TradeContext.CUSCHRG)) #发生额
#=========交易金额+手续费===================
TradeContext.RCCSMCD = PL_RCCSMCD_YZBWZ #摘要代码 PL_RCCSMCD_YZBWZ 异转本
TradeContext.SBAC = TradeContext.BESBNO + PL_ACC_NXYDQSWZ #借方账号
TradeContext.SBAC = rccpsHostFunc.CrtAcc(TradeContext.SBAC,25)
TradeContext.ACNM = '农信银往账' #借方户名
TradeContext.RBAC = TradeContext.BESBNO + PL_ACC_NXYDJLS #贷方账号
TradeContext.RBAC = rccpsHostFunc.CrtAcc(TradeContext.RBAC,25)
TradeContext.OTNM = '应解汇款' #贷方户名
TradeContext.CTFG = '9' #本金 手续费标识 7 本金 8手续费 9 本金＋手续费
TradeContext.PKFG = 'T' #通存通兑标识
AfaLoggerFunc.tradeInfo( '>>>交易金额+手续费:借方账号' + TradeContext.SBAC )
AfaLoggerFunc.tradeInfo( '>>>交易金额+手续费:贷方账号' + TradeContext.RBAC )
#=========交易金额============
TradeContext.I2SMCD = PL_RCCSMCD_YZBWZ #摘要代码
TradeContext.I2SBAC = TradeContext.BESBNO + PL_ACC_NXYDJLS #借方账号
TradeContext.I2SBAC = rccpsHostFunc.CrtAcc(TradeContext.I2SBAC,25)
TradeContext.I2ACNM = '应解汇款' #借方户名
TradeContext.I2RBAC = TradeContext.PYEACC #贷方账号
TradeContext.I2OTNM = TradeContext.PYENAM #贷方户名
TradeContext.I2CTFG = '7' #本金 手续费标识 7 本金 8手续费 9 本金＋手续费
TradeContext.I2PKFG = 'T' #通存通兑标识
AfaLoggerFunc.tradeInfo( '>>>交易金额:借方账号' + TradeContext.I2SBAC )
AfaLoggerFunc.tradeInfo( '>>>交易金额:贷方账号' + TradeContext.I2RBAC )
#=========结算手续费收入户===========
TradeContext.I3SMCD = PL_RCCSMCD_SXF #摘要代码
TradeContext.I3SBAC = TradeContext.BESBNO + PL_ACC_NXYDJLS #借方账号
TradeContext.I3SBAC = rccpsHostFunc.CrtAcc(TradeContext.I3SBAC,25)
TradeContext.I3ACNM = '应解汇款' #借方户名
TradeContext.I3RBAC = TradeContext.BESBNO + PL_ACC_TCTDSXF #贷方账号
TradeContext.I3RBAC = rccpsHostFunc.CrtAcc(TradeContext.I3RBAC,25)
TradeContext.I3OTNM = '结算手续费' #贷方户名
TradeContext.I3CTFG = '8' #本金 手续费标识 7 本金 8手续费 9 本金＋手续费
TradeContext.I3PKFG = 'T' #通存通兑标识
else:
#=====不收费或者现金====
TradeContext.ACUR = '1' #记账次数
TradeContext.RCCSMCD = PL_RCCSMCD_YZBWZ #摘要代码
TradeContext.SBAC = TradeContext.BESBNO + PL_ACC_NXYDQSWZ #借方账号
TradeContext.SBAC = rccpsHostFunc.CrtAcc(TradeContext.SBAC,25)
TradeContext.RBAC = TradeContext.PYEACC #贷方账号
TradeContext.OTNM = TradeContext.PYENAM #贷方户名
TradeContext.CTFG = '7' #本金 手续费标识 7 本金 8手续费 9 本金＋手续费
TradeContext.PKFG = 'T' #通存通兑标识
else:
#=====原交易代码错，抛弃报文====
AfaLoggerFunc.tradeDebug('>>>原交易代码错，抛弃报文')
return AfaFlowControl.ExitThisFlow('S999','原交易代码错，抛弃报文')
#=====重新生成前置流水号====
if rccpsGetFunc.GetRBSQ(PL_BRSFLG_SND) == -1 :
return AfaFlowControl.ExitThisFlow('S999','重新生成前置流水号失败,抛弃报文')
#=====modify by pgt 12-8====
if wtrbka_temp_dict['DCFLG'] == PL_DCFLG_DEB:
# if TradeContext.ORTRCCO in ('3000102','3000104','3000103','3000105'):
#=====通兑、异转本====
if not rccpsState.newTransState(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_AUTOPAY,PL_BDWFLG_WAIT):
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow('S999','新增自动扣款－处理中失败，抛弃报文')
else:
AfaDBFunc.CommitSql()
#=====向主机发起记账====
rccpsHostFunc.CommHost( TradeContext.HostCode )
#=====判断主机返回====
sstlog_dict={}
sstlog_dict['BJEDTE'] = TradeContext.BJEDTE
sstlog_dict['BSPSQN'] = TradeContext.BSPSQN
sstlog_dict['BCSTAT'] = PL_BCSTAT_AUTOPAY
if TradeContext.errorCode == '0000':
sstlog_dict['BDWFLG'] = PL_BDWFLG_SUCC
sstlog_dict['RBSQ'] = TradeContext.RBSQ
sstlog_dict['TLSQ'] = TradeContext.TLSQ
sstlog_dict['TRDT'] = TradeContext.TRDT
sstlog_dict['MGID'] = TradeContext.errorCode
sstlog_dict['STRINFO']= '主机补正记账成功'
AfaLoggerFunc.tradeInfo('>>>补正记账成功')
else:
sstlog_dict['BDWFLG'] = PL_BDWFLG_FAIL
sstlog_dict['MGID'] = TradeContext.errorCode
sstlog_dict['STRINFO']= TradeContext.errorMsg
AfaLoggerFunc.tradeInfo('>>>补正记账失败')
if not rccpsState.setTransState(sstlog_dict):
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow('S999','修改自动扣款－成功中失败，抛弃报文')
else:
AfaDBFunc.CommitSql()
else:
#====通存、本转异====
AfaLoggerFunc.tradeDebug('>>>新增确认付款－处理中')
if not rccpsState.newTransState(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_CONFACC,PL_BDWFLG_SUCC):
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow('S999','新增确认付款－处理中失败，抛弃报文')
else:
AfaDBFunc.CommitSql()
#=================为存款确认请求报文做准备=================================
AfaLoggerFunc.tradeInfo(">>>开始为存款确认请求报文做准备")
#=====================获取中心流水号====================================
if rccpsGetFunc.GetRccSerialno( ) == -1 :
raise AfaFlowControl.flowException( )
TradeContext.MSGTYPCO = 'SET009'
TradeContext.SNDSTLBIN = TradeContext.RCVMBRCO
TradeContext.RCVSTLBIN = TradeContext.SNDMBRCO
TradeContext.SNDBRHCO = TradeContext.BESBNO
TradeContext.SNDCLKNO = TradeContext.BETELR
TradeContext.ORMFN = TradeContext.ORMFN
TradeContext.OPRTYPNO = '30'
TradeContext.ROPRTPNO = '30'
TradeContext.TRANTYP = '0'
TradeContext.ORTRCCO = '3000505'
TradeContext.ORTRCNO = TradeContext.TRCNO
TradeContext.TRCCO = '3000503'
TradeContext.TRCNO = TradeContext.SerialNo
TradeContext.CURPIN = ""
TradeContext.STRINFO = '收到补正应答,自动发送存款确认'
AfaLoggerFunc.tradeInfo(">>>交易代码["+str(TradeContext.TRCCO)+"]")
AfaLoggerFunc.tradeInfo(">>>结束为存款确认请求报文做准备")
#=====更新原记录的存款确认字段====
#=====modify by pgt 12-8====
wtr_up_where = {'BJEDTE':wtrbka_temp_dict['BJEDTE'],'BSPSQN':wtrbka_temp_dict['BSPSQN']}
# wtr_up_where = {'BJEDTE':TradeContext.BJEDTE,'BSPSQN':TradeContext.BSPSQN}
wtr_end_dict = {}
wtr_end_dict['COTRCDAT'] = TradeContext.TRCDAT
wtr_end_dict['COTRCNO'] = TradeContext.TRCNO
wtr_end_dict['TRCNO'] = TradeContext.ORTRCNO
wtr_end_dict['COMSGFLGNO']= TradeContext.SNDBNKCO+TradeContext.TRCDAT+TradeContext.TRCNO
wtr_end_dict['MSGFLGNO'] = TradeContext.MSGFLGNO
rccpsDBTrcc_wtrbka.update(wtr_end_dict,wtr_up_where)
AfaDBFunc.CommitSql()
AfaAfeFunc.CommAfe()
if TradeContext.errorCode == '0000':
AfaLoggerFunc.tradeInfo('>>>发送成功')
else:
AfaLoggerFunc.tradeInfo('>>>发送失败')
return True
def SubModuleDoTrd():
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.主机类操作(3.中心记账).个人现金通存[TRCC002_8561]进入***' )
#=================设置业务状态为发送成功或失败,若发送失败则自动抹账========
stat_dict = {}
stat_dict['BJEDTE'] = TradeContext.BJEDTE
stat_dict['BSPSQN'] = TradeContext.BSPSQN
stat_dict['BESBNO'] = TradeContext.BESBNO
stat_dict['BETELR'] = TradeContext.BETELR
stat_dict['BCSTAT'] = PL_BCSTAT_SND
stat_dict['BDWFLG'] = PL_BDWFLG_SUCC
stat_dict['PRCCO'] = TradeContext.errorCode
stat_dict['STRINFO'] = TradeContext.errorMsg
AfaLoggerFunc.tradeInfo("TradeContext.errorCode = [" + TradeContext.errorCode + "]")
if TradeContext.errorCode == '0000':
AfaLoggerFunc.tradeInfo(">>>开始设置业务状态为发送成功")
stat_dict['BCSTAT'] = PL_BCSTAT_SND
stat_dict['BDWFLG'] = PL_BDWFLG_SUCC
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999', "设置业务状态为发送成功异常")
AfaLoggerFunc.tradeInfo(">>>结束设置业务状态为发送成功")
else:
AfaLoggerFunc.tradeInfo(">>>开始设置业务状态为发送失败")
stat_dict['BCSTAT'] = PL_BCSTAT_SND
stat_dict['BDWFLG'] = PL_BDWFLG_FAIL
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999', "设置业务状态为发送失败异常")
AfaLoggerFunc.tradeInfo(">>>结束设置业务状态为发送失败")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
#=============发起主机抹账=============================================
AfaLoggerFunc.tradeInfo(">>>开始设置业务状态为抹账处理中")
#=====特殊处理 关彬捷 20081127 调8813抹账,需产生新的前置流水号进行记账====
if rccpsGetFunc.GetRBSQ(PL_BRSFLG_SND) == -1 :
return AfaFlowControl.ExisThisFlow('S999',"产生新的前置流水号异常")
#为抹账会计分录赋值
TradeContext.HostCode='8813'
TradeContext.PKFG = 'T' #通存通兑标识
TradeContext.RVFG = '2' #红蓝字标志 2
TradeContext.CATR = '0' #现转标识:0-现金
TradeContext.RCCSMCD = PL_RCCSMCD_XJTCWZ #主机摘要码:现金通存往账
TradeContext.SBAC = ''
TradeContext.ACNM = ''
TradeContext.RBAC = TradeContext.BESBNO + PL_ACC_NXYDQSWZ #贷方账号
TradeContext.RBAC = rccpsHostFunc.CrtAcc(TradeContext.RBAC,25)
TradeContext.OTNM = "农信银待清算往账"
TradeContext.CTFG = '7' #结转标识:结转-0
AfaLoggerFunc.tradeInfo("借方账号1:[" + TradeContext.SBAC + "]")
AfaLoggerFunc.tradeInfo("贷方账号1:[" + TradeContext.RBAC + "]")
if TradeContext.CHRGTYP == '0':
#现金收取手续费
TradeContext.ACUR = '2' #重复次数
TradeContext.I2PKFG = 'T' #通存通兑标识
TradeContext.I2RVFG = '2' #红蓝字标志 2
TradeContext.I2CATR = '0' #现转标识:0-现金
TradeContext.I2TRAM = TradeContext.LOCCUSCHRG #手续费金额
TradeContext.I2SMCD = PL_RCCSMCD_SXF #主机摘要码:手续费
TradeContext.I2SBAC = ''
TradeContext.I2ACNM = ''
TradeContext.I2RBAC = TradeContext.BESBNO + PL_ACC_TCTDSXF #贷方账号:通存通兑手续费
TradeContext.I2RBAC = rccpsHostFunc.CrtAcc(TradeContext.I2RBAC,25)
TradeContext.I2OTNM = "农信银手续费"
TradeContext.I2CTFG = '8' #结转标识:不结转-1
#====设置业务状态为抹账处理中====
if not rccpsState.newTransState(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_HCAC,PL_BDWFLG_WAIT):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态为抹账处理中异常')
AfaLoggerFunc.tradeInfo(">>>结束设置业务状态为抹账处理中")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
AfaLoggerFunc.tradeInfo(">>>开始发起主机抹账")
#=====调起抹账主机接口====
rccpsHostFunc.CommHost( TradeContext.HostCode )
AfaLoggerFunc.tradeInfo(">>>结束发起主机抹账")
stat_dict = {}
stat_dict['BJEDTE'] = TradeContext.BJEDTE
stat_dict['BSPSQN'] = TradeContext.BSPSQN
stat_dict['MGID'] = TradeContext.errorCode
stat_dict['STRINFO'] = TradeContext.errorMsg
AfaLoggerFunc.tradeInfo("TradeContext.errorCode = [" + TradeContext.errorCode + "]")
if TradeContext.errorCode == '0000':
AfaLoggerFunc.tradeInfo(">>>开始设置业务状态为抹账成功")
stat_dict['BCSTAT'] = PL_BCSTAT_HCAC
stat_dict['BDWFLG'] = PL_BDWFLG_SUCC
stat_dict['TRDT'] = TradeContext.TRDT
stat_dict['TLSQ'] = TradeContext.TLSQ
stat_dict['PRTCNT'] = 1 #打印次数
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态抹账成功异常')
AfaLoggerFunc.tradeInfo(">>>结束设置业务状态为抹账成功")
else:
AfaLoggerFunc.tradeInfo(">>>开始设置业务状态为抹账失败")
stat_dict['BCSTAT'] = PL_BCSTAT_HCAC
stat_dict['BDWFLG'] = PL_BDWFLG_FAIL
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态抹账成功异常')
AfaLoggerFunc.tradeInfo(">>>结束设置业务状态为抹账失败")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
TradeContext.errorCode = '0000'
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.主机类操作(3.中心记账).个人现金通存[TRCC002_8561]退出***' )
return True
rec_sum = 0.00
AfaLoggerFunc.tradeInfo("对账登记簿中中心日期" + LNCCWKDAT + "交易笔数[" + str(rec_count) + "]交易金额[" + str(rec_sum) + "]")
AfaLoggerFunc.tradeInfo(">>>结束获取总笔数和总金额")
TradeContext.HostCode = '8826'
TradeContext.BESBNO = PL_BESBNO_BCLRSB
TradeContext.BETELR = PL_BETELR_AUTO
TradeContext.NBBH = 'RCC'
TradeContext.COUT = rec_count
TradeContext.TOAM = rec_sum
TradeContext.FINA = 'HD' + NCCWKDAT
#================发起注册主机对账======================================
rccpsHostFunc.CommHost( TradeContext.HostCode )
AfaLoggerFunc.tradeInfo("errorCode = [" + TradeContext.errorCode + "]")
AfaLoggerFunc.tradeInfo("errorMsg = [" + TradeContext.errorMsg + "]")
#================判断注册主机对账返回信息==============================
if TradeContext.errorCode != '0000':
rccpsCronFunc.cronExit("S999","注册主机对账异常")
AfaLoggerFunc.tradeInfo(">>>结束注册主机对账")
#================关闭汇兑对账错账文件生成及发送到主机系统调度==========
AfaLoggerFunc.tradeInfo(">>>开始关闭汇兑对账错账文件生成及发送到主机系统调度")
if not rccpsCronFunc.closeCron("00035"):
rccpsCronFunc.cronExit("S999","关闭汇兑对账错账文件生成及发送到主机调度异常")
def SubModuleDoFst():
AfaLoggerFunc.tradeInfo("'***农信银系统：通存通兑往账交易.特殊差错账补记[8593] 进入")
#=====判断必输变量是否存在====
if not TradeContext.existVariable("BESBNO"):
return AfaFlowControl.ExitThisFlow('A099','没有机构号')
if not TradeContext.existVariable("TRCCO"):
return AfaFlowControl.ExitThisFlow('A099','没有交易代码')
if not TradeContext.existVariable("CUSCHRG"):
return AfaFlowControl.ExitThisFlow('A099','没有手续费金额')
if not TradeContext.existVariable("OCCAMT"):
return AfaFlowControl.ExitThisFlow('A099','没有交易金额')
#=====得到账户的开户机构====
AfaLoggerFunc.tradeInfo("<<<<<<查询账户开户机构")
TradeContext.HostCode = '8810'
TradeContext.BETELR = PL_BETELR_AUTO
if(TradeContext.TRCCO in ('3000102','3000103','3000104','3000105')):
TradeContext.ACCNO = TradeContext.PYRACC
AfaLoggerFunc.tradeDebug("ACCNO<<<<<<" + TradeContext.ACCNO)
else:
TradeContext.ACCNO = TradeContext.PYEACC
AfaLoggerFunc.tradeDebug("ACCNO<<<<<<" + TradeContext.ACCNO)
rccpsHostFunc.CommHost( TradeContext.HostCode )
AfaLoggerFunc.tradeDebug("errorCode<<<<<<" + TradeContext.errorCode)
AfaLoggerFunc.tradeDebug("errorMsg<<<<<<" + TradeContext.errorMsg)
AfaLoggerFunc.tradeInfo("<<<<<<判断主机8810交易是否成功")
if(TradeContext.errorCode != '0000'):
return AfaFlowControl.ExitThisFlow('S999',TradeContext.errorMsg)
else:
AfaLoggerFunc.tradeInfo("<<<<<<8810交易成功")
TradeContext.BESBNO = TradeContext.ACCSO
AfaLoggerFunc.tradeInfo("<<<<<<结束查询账户开户机构")
#=====生成保单序号,成员行号，接收行号，接收行名,前置日期，前置流水号====
# if not rccpsFunc.GetNCCDate( ) : #NCCWKDAT
# raise AfaFlowControl.flowException( )
# TradeContext.NCCWKDAT = TradeContext.NCCworkDate
TradeContext.NCCworkDate = TradeContext.NCCWKDAT
where_dict = {} #发送成员行号
where_dict['BANKBIN'] = TradeContext.SNDBNKCO
record = rccpsDBTrcc_paybnk.selectu(where_dict)
if(record == None):
return AfaFlowControl.ExitThisFlow('A099','查询行名行号表失败')
elif(len(record) == 0):
return AfaFlowControl.ExitThisFlow('A099','查询行名行号表结果为空')
else:
TradeContext.STLBANKBIN = record['STLBANKBIN']
# where_dict = {} #接收行号，接收行名
# where_dict['BESBNO'] = TradeContext.BESBNO
# record_tmp = rccpsDBTrcc_subbra.selectu(where_dict)
# if(record_tmp == None):
# return AfaFlowControl.ExitThisFlow('A099','查询机构表失败')
# elif(len(record_tmp) == 0):
# return AfaFlowControl.ExitThisFlow('A099','查询机构表结果为空')
# else:
# TradeContext.BANKBIN = record_tmp['BANKBIN']
# where_dict = {}
# where_dict['BANKBIN'] = TradeContext.BANKBIN
# record = None
# record = rccpsDBTrcc_paybnk.selectu(where_dict)
# if(record == None):
# return AfaFlowControl.ExitThisFlow('A099','查询行名行号表失败')
# elif(len(record) == 0):
# AfaLoggerFunc.tradeInfo("此机构无行号")
# TradeContext.RCVBNKNM = ""
# TradeContext.RCVBNKCO = ""
# else:
# TradeContext.RCVBNKNM = record['BANKNAM']
# TradeContext.RCVBNKCO = record['BANKBIN']
TradeContext.BJEDTE = AfaUtilTools.GetHostDate( ) #BJEDTE
TradeContext.FEDT = AfaUtilTools.GetHostDate( ) #FEDT
if rccpsGetFunc.GetRBSQ(PL_BRSFLG_RCV) == -1 : #RBSQ
return AfaFlowControl.ExitThisFlow('S999','重新生成前置流水号失败,抛弃报文')
TradeContext.BSPSQN = TradeContext.RBSQ
#=====向通存通兑业务登记簿插入数据====
AfaLoggerFunc.tradeInfo("<<<<<<登记通存通兑业务登记簿")
insert_dict = {}
insert_dict['BJEDTE'] = TradeContext.BJEDTE
insert_dict['BSPSQN'] = TradeContext.BSPSQN
insert_dict['BRSFLG'] = "1"
insert_dict['BEACSB'] = ""
insert_dict['BETELR'] = TradeContext.BETELR
insert_dict['BEAUUS'] = TradeContext.BEAUUS
insert_dict['BEAUPS'] = TradeContext.BEAUPS
insert_dict['TERMID'] = TradeContext.TERMID
insert_dict['BESBNO'] = TradeContext.BESBNO
insert_dict['BBSSRC'] = ""
insert_dict['DASQ'] = ""
if(TradeContext.TRCCO in ('3000002','3000003','3000004','3000005')):
insert_dict['DCFLG'] = PL_DCFLG_DEB
else:
insert_dict['DCFLG'] = PL_DCFLG_CRE
if(TradeContext.TRCCO in ('3000002','3000004')):
insert_dict['OPRNO'] = PL_TDOPRNO_TC
elif(TradeContext.TRCCO in ('3000003','3000005')):
insert_dict['OPRNO'] = PL_TDOPRNO_BZY
elif(TradeContext.TRCCO in ('3000102','3000104')):
insert_dict['OPRNO'] = PL_TDOPRNO_TD
else:
insert_dict['OPRNO'] = PL_TDOPRNO_YZB
insert_dict['OPRATTNO'] = ""
insert_dict['NCCWKDAT'] = TradeContext.NCCWKDAT
insert_dict['TRCCO'] = TradeContext.TRCCO
insert_dict['TRCDAT'] = TradeContext.TRCDAT
insert_dict['TRCNO'] = TradeContext.TRCNO
insert_dict['MSGFLGNO'] = ""
insert_dict['COTRCDAT'] = ""
insert_dict['COTRCNO'] = ""
insert_dict['COMSGFLGNO'] = ""
insert_dict['SNDMBRCO'] = TradeContext.STLBANKBIN
insert_dict['RCVMBRCO'] = "1340000008"
insert_dict['SNDBNKCO'] = TradeContext.SNDBNKCO
insert_dict['SNDBNKNM'] = TradeContext.SNDBNKNM
insert_dict['RCVBNKCO'] = TradeContext.RCVBNKCO
insert_dict['RCVBNKNM'] = TradeContext.RCVBNKNM
insert_dict['CUR'] = "01"
insert_dict['OCCAMT'] = TradeContext.OCCAMT
if(float(TradeContext.CUSCHRG) != 0.00 and TradeContext.CUSCHRG != ""):
insert_dict['CHRGTYP']= PL_CHRG_TYPE
chrgtyp = 1
else:
insert_dict['CHRGTYP']= PL_CHRG_CASH
chrgtyp = 0
insert_dict['LOCCUSCHRG'] = ""
insert_dict['CUSCHRG'] = TradeContext.CUSCHRG
insert_dict['PYRTYP'] = ""
insert_dict['PYRACC'] = TradeContext.PYRACC
insert_dict['PYRNAM'] = TradeContext.PYRNAM
insert_dict['PYRADDR'] = ""
insert_dict['PYETYP'] = ""
insert_dict['PYEACC'] = TradeContext.PYEACC
insert_dict['PYENAM'] = TradeContext.PYENAM
insert_dict['PYEADDR'] = ""
insert_dict['STRINFO'] = TradeContext.STRINFO
insert_dict['CERTTYPE'] = ""
insert_dict['CERTNO'] = ""
insert_dict['BNKBKNO'] = ""
insert_dict['BNKBKBAL'] = ""
insert_dict['NOTE1'] = ""
insert_dict['NOTE2'] = ""
insert_dict['NOTE3'] = ""
insert_dict['NOTE4'] = ""
if not rccpsDBTrcc_wtrbka.insertCmt(insert_dict):
return AfaFlowControl.ExitThisFlow('A099','登记通存通兑登记簿失败')
AfaLoggerFunc.tradeInfo("<<<<<<结束登记通存通兑业务登记簿")
#=====查询刚刚插入到业务登记簿中的数据====
where_dict = {}
where_dict = {'BJEDTE':TradeContext.BJEDTE,'BSPSQN':TradeContext.BSPSQN}
wtrbka_record = rccpsDBTrcc_wtrbka.selectu(where_dict)
if(wtrbka_record == None):
return AfaFlowControl.ExitThisFlow('A099','查询通存通兑业务登记簿失败')
elif(len(wtrbka_record) == 0):
return AfaFlowControl.ExitThisFlow('A099','登记通存通兑业务登记簿结果为空')
else:
AfaLoggerFunc.tradeInfo("查询通存通兑业务登记簿成功")
#=====向错账登记簿插入数据====
AfaLoggerFunc.tradeInfo("<<<<<<登记错账登记簿")
insert_dict = {}
insert_dict['NCCWKDAT'] = TradeContext.NCCWKDAT
insert_dict['SNDBNKCO'] = TradeContext.SNDBNKCO
insert_dict['TRCDAT'] = TradeContext.TRCDAT
insert_dict['TRCNO'] = TradeContext.TRCNO
insert_dict['RCVBNKCO'] = TradeContext.RCVBNKCO
insert_dict['SNDMBRCO'] = TradeContext.STLBANKBIN
insert_dict['RCVMBRCO'] = "1340000008"
insert_dict['TRCCO'] = TradeContext.TRCCO
if(TradeContext.TRCCO in ('3000002','3000003','3000004','3000005')):
insert_dict['DCFLG'] = PL_DCFLG_DEB
else:
insert_dict['DCFLG'] = PL_DCFLG_CRE
insert_dict['PYRACC'] = TradeContext.PYRACC
insert_dict['PYEACC'] = TradeContext.PYEACC
insert_dict['CUR'] = "01"
insert_dict['OCCAMT'] = TradeContext.OCCAMT
insert_dict['LOCOCCAMT'] = TradeContext.OCCAMT
if(TradeContext.TRCCO in ('3000102','3000103','3000104','3000105') and wtrbka_record['CHRGTYP'] == PL_CHRG_TYPE ):
insert_dict['CUSCHRG'] = TradeContext.CUSCHRG
insert_dict['LOCCUSCHRG'] = TradeContext.CUSCHRG
else:
insert_dict['CUSCHRG'] = 0.00
insert_dict['LOCCUSCHRG'] = 0.00
insert_dict['ORTRCNO'] = ""
insert_dict['BJEDTE'] = AfaUtilTools.GetHostDate( )
insert_dict['BSPSQN'] = TradeContext.BSPSQN
insert_dict['EACTYP'] = "11"
insert_dict['EACINF'] = "中心无，行内无"
insert_dict['LOCEACTYP'] = "11"
insert_dict['LOCEACINF'] = "中心无，行内无"
insert_dict['ISDEAL'] = PL_ISDEAL_UNDO
insert_dict['NOTE1'] = ""
insert_dict['NOTE2'] = ""
insert_dict['NOTE3'] = ""
insert_dict['NOTE4'] = ""
if not rccpsDBTrcc_tddzcz.insertCmt(insert_dict):
return AfaFlowControl.ExitThisFlow('A099','登记通存通兑登记簿失败')
AfaLoggerFunc.tradeInfo("<<<<<<结束登记错账登记簿")
#=====查询刚刚插入到业务登记簿中的数据====
where_dict = {}
where_dict = {'BJEDTE':TradeContext.BJEDTE,'BSPSQN':TradeContext.BSPSQN}
tddzcz_record = rccpsDBTrcc_tddzcz.selectu(where_dict)
if(tddzcz_record == None):
return AfaFlowControl.ExitThisFlow('A099','查询错账登记簿失败')
elif(len(tddzcz_record) == 0):
return AfaFlowControl.ExitThisFlow('A099','登记错账登记簿结果为空')
else:
AfaLoggerFunc.tradeInfo("查询错账登记簿成功")
#=====开始给会计分录赋值====
AfaLoggerFunc.tradeInfo("<<<<<<开始给会计分录赋值")
TradeContext.BRSFLG = PL_BRSFLG_RCV
TradeContext.BETELR = PL_BETELR_AUTO
AfaLoggerFunc.tradeInfo("<<<<<<BETELR==" + TradeContext.BETELR)
input_dict = {}
input_dict['FEDT'] = TradeContext.FEDT
input_dict['RBSQ'] = TradeContext.RBSQ
input_dict['PYRACC'] = wtrbka_record['PYRACC']
input_dict['PYRNAM'] = wtrbka_record['PYRNAM']
input_dict['PYEACC'] = wtrbka_record['PYEACC']
input_dict['PYENAM'] = wtrbka_record['PYENAM']
input_dict['CHRGTYP'] = wtrbka_record['CHRGTYP']
input_dict['OCCAMT'] = wtrbka_record['OCCAMT']
input_dict['CUSCHRG'] = wtrbka_record['CUSCHRG']
if(wtrbka_record['TRCCO'] in ('3000002','3000004')):
AfaLoggerFunc.tradeDebug("<<<<<<卡折现金通存来账记账")
input_dict['RCCSMCD'] = PL_RCCSMCD_XJTCLZ
rccpsEntriesErr.KZTCLZJZ(input_dict)
elif(wtrbka_record['TRCCO'] in ('3000003','3000005')):
AfaLoggerFunc.tradeDebug("<<<<<<卡折本转异来账记账")
input_dict['RCCSMCD'] = PL_RCCSMCD_BZYLZ
rccpsEntriesErr.KZBZYLZJZ(input_dict)
elif(wtrbka_record['TRCCO'] in ('3000102','3000104')):
AfaLoggerFunc.tradeDebug("<<<<<<卡折现金通兑来账记账")
input_dict['RCCSMCD'] = PL_RCCSMCD_XJTDLZ
rccpsEntriesErr.KZTDLZJZ(input_dict)
elif(wtrbka_record['TRCCO'] in ('3000103','3000105')):
AfaLoggerFunc.tradeDebug("<<<<<<卡折异转本来账记账")
input_dict['RCCSMCD'] = PL_RCCSMCD_YZBLZ
rccpsEntriesErr.KZYZBLZJZ(input_dict)
else:
return AfaFlowControl.ExitThisFlow('A099','交易代码非法')
AfaLoggerFunc.tradeInfo("<<<<<<给会计分录赋值结束")
#=====主机前设置原交易状态====
AfaLoggerFunc.tradeInfo("<<<<<<主机前设置原交易状态")
if not rccpsState.newTransState(wtrbka_record['BJEDTE'],wtrbka_record['BSPSQN'],PL_BCSTAT_ACC,PL_BDWFLG_WAIT):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态为记账处理中异常')
else:
AfaDBFunc.CommitSql()
#=====调用主机交易====
AfaLoggerFunc.tradeInfo("<<<<<<开始调用主机交易")
rccpsHostFunc.CommHost( TradeContext.HostCode )
AfaLoggerFunc.tradeInfo("<<<<<<结束调用主机交易")
AfaLoggerFunc.tradeDebug("errorCode<<<<<<" + TradeContext.errorCode)
AfaLoggerFunc.tradeDebug("errorMsg<<<<<<" + TradeContext.errorMsg)
#=====给状态字典赋值====
state_dict = {}
state_dict['BJEDTE'] = wtrbka_record['BJEDTE']
state_dict['BSPSQN'] = wtrbka_record['BSPSQN']
state_dict['MGID'] = TradeContext.errorCode
if TradeContext.existVariable('TRDT'):
state_dict['TRDT'] = TradeContext.TRDT
if TradeContext.existVariable('TLSQ'):
state_dict['TLSQ'] = TradeContext.TLSQ
if TradeContext.existVariable('RBSQ'):
state_dict['RBSQ'] = TradeContext.RBSQ
if TradeContext.existVariable('FEDT'):
state_dict['FEDT'] = TradeContext.FEDT
#=====判断主机交易是否成功====
AfaLoggerFunc.tradeInfo("<<<<<<判断主机交易是否成功")
AfaLoggerFunc.tradeDebug("<<<<<<errorCode=" + TradeContext.errorCode)
if(TradeContext.errorCode != '0000'):
AfaLoggerFunc.tradeInfo("调用主机交易失败")
#=====主机后更改原交易状态为失败====
state_dict['BDWFLG'] = PL_BDWFLG_FAIL
state_dict['STRINFO'] = TradeContext.errorMsg
state_dict['NOTE3'] = "特殊差错账补记失败"
state_dict['BCSTAT'] = PL_BCSTAT_ACC
if not rccpsState.setTransState(state_dict):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态为失败异常')
else:
AfaDBFunc.CommitSql()
return AfaFlowControl.ExitThisFlow('S999',TradeContext.errorMsg)
else:
#=====主机后更改原交易状态为成功====
state_dict['BDWFLG'] = PL_BDWFLG_SUCC
state_dict['STRINFO'] = '主机成功'
state_dict['NOTE3'] = "特殊差错账补记成功"
if(TradeContext.TRCCO in('3000002','3000004','3000005','3000003')): #通存
state_dict['BCSTAT'] = PL_BCSTAT_AUTO
else:
state_dict['BCSTAT'] = PL_BCSTAT_AUTOPAY
if(TradeContext.existVariable("SBAC")):
state_dict['SBAC'] = TradeContext.SBAC
if(TradeContext.existVariable("RBAC")):
state_dict['RBAC'] = TradeContext.RBAC
if not rccpsState.setTransState(state_dict):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态失败')
else:
AfaDBFunc.CommitSql()
# bcsata = "" #状态标识
# if(TradeContext.TRCCO in('3000002','3000004','3000005','3000003')): #通存
# bcstat = PL_BCSTAT_AUTO
# else:
# bcstat = PL_BCSTAT_AUTOPAY
# if not rccpsState.newTransState(wtrbka_record['BJEDTE'],wtrbka_record['BSPSQN'],bcstat,PL_BDWFLG_SUCC):
# return AfaFlowControl.ExitThisFlow('S999','设置业务状态异常')
# else:
# AfaDBFunc.CommitSql()
#=====更改错账登记簿中的处理标示====
AfaLoggerFunc.tradeInfo("<<<<<<更改错账登记簿中的处理标示")
where_dict = {}
where_dict = {'BJEDTE':tddzcz_record['BJEDTE'],'BSPSQN':tddzcz_record['BSPSQN']}
update_dict = {}
update_dict['ISDEAL'] = PL_ISDEAL_ISDO
update_dict['NOTE3'] = '此笔错账已补记'
res = rccpsDBTrcc_tddzcz.updateCmt(update_dict,where_dict)
if(res == -1):
return AfaFlowControl.ExitThisFlow('S999','主机记账已成功，但更新处理标示失败，请手动更改处理标示')
else:
AfaLoggerFunc.tradeInfo("<<<<<<更改错账登记簿中的处理标示成功")
#=====向下发的通知表中插入数据====
AfaLoggerFunc.tradeInfo("<<<<<<向通知表中插入数据")
insert_dict = {}
insert_dict['NOTDAT'] = AfaUtilTools.GetHostDate( )
insert_dict['BESBNO'] = wtrbka_record['BESBNO']
if(wtrbka_record['BRSFLG'] == PL_BRSFLG_RCV):
insert_dict['STRINFO'] = "此笔错账["+wtrbka_record['BSPSQN']+"]["+wtrbka_record['BJEDTE']+"]已处理"
else:
insert_dict['STRINFO'] = "此笔错账["+wtrbka_record['BSPSQN']+"]["+wtrbka_record['BJEDTE']+"]已处理 请用8522补打往账凭证"
if not rccpsDBTrcc_notbka.insertCmt(insert_dict):
return AfaFlowControl.ExitThisFlow('S999','向下发的通知表中插入数据失败')
AfaLoggerFunc.tradeInfo("<<<<<<向通知表中插入数据成功")
#=====给输出接口赋值====
AfaLoggerFunc.tradeInfo("<<<<<<开始给输出接口赋值")
TradeContext.TRCCO = wtrbka_record['TRCCO']
TradeContext.BRSFLG = wtrbka_record['BRSFLG']
TradeContext.BEACSB = wtrbka_record['BESBNO']
TradeContext.OCCAMT = str(wtrbka_record['OCCAMT'])
TradeContext.BSPSQN = state_dict['TLSQ']
TradeContext.BJEDTE = wtrbka_record['BJEDTE']
AfaLoggerFunc.tradeInfo("<<<<<<结束给输出接口赋值")
AfaLoggerFunc.tradeInfo("<<<<<<<个性化处理(本地操作) 退出")
AfaLoggerFunc.tradeInfo("'***农信银系统：通存通兑往账交易.特殊差错账补记[8593] 退出")
return True
def SubModuleDoFst():
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.本地类操作(1.本地操作).异转本_卡应答[TRCC004_1158]进入***' )
#=================初始化返回信息============================================
if AfaUtilTools.trim(TradeContext.STRINFO) == "":
TradeContext.STRINFO = rccpsDBFunc.getErrInfo(TradeContext.PRCCO)
AfaLoggerFunc.tradeDebug("TradeContext.STRINFO=" + TradeContext.STRINFO)
#=====根据参考报文标识号查找原交易====
TradeContext.ORSNDBNKCO = TradeContext.ORMFN[:10] #原发送行号
TradeContext.BOJEDT = TradeContext.ORMFN[10:18] #原交易日期
TradeContext.ORTRCNO = TradeContext.ORMFN[18:] #原交易流水号
wtr_dict = {}
if not rccpsDBFunc.getTransWtrAK(TradeContext.ORSNDBNKCO,TradeContext.BOJEDT,TradeContext.ORTRCNO,wtr_dict):
#=====查询原交易失败，等待前台超时发起冲正，抛弃此报文====
return AfaFlowControl.ExitThisFlow('S999','等待前台发起冲正，抛弃报文')
AfaLoggerFunc.tradeInfo( '>>>查询原交易结束' )
#=================若应答报文回复拒绝,则设置状态为拒绝,停止处理=============
if TradeContext.PRCCO != 'RCCI0000':
AfaLoggerFunc.tradeInfo(">>>对方返回拒绝应答")
#=============设置业务状态为拒绝处理中=================================
if not rccpsState.newTransState(wtr_dict['BJEDTE'],wtr_dict['BSPSQN'],PL_BCSTAT_MFERFE,PL_BDWFLG_WAIT):
return AfaFlowControl.ExitThisFlow('S999',"设置业务状态为拒绝成功异常")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
#=============设置业务状态为拒绝成功===================================
stat_dict = {}
stat_dict['BJEDTE'] = wtr_dict['BJEDTE']
stat_dict['BSPSQN'] = wtr_dict['BSPSQN']
stat_dict['BCSTAT'] = PL_BCSTAT_MFERFE
stat_dict['BDWFLG'] = PL_BDWFLG_SUCC
stat_dict['PRCCO'] = TradeContext.PRCCO
stat_dict['STRINFO'] = TradeContext.STRINFO
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999', "设置业务状态为拒绝成功异常")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
return AfaFlowControl.ExitThisFlow('S999',"对方拒绝，交易终止")
#====查找自动冲正登记簿是否存在本交易的冲正====
#====查找自动冲正登记簿是否存在本交易的冲正====
wheresql = ''
wheresql = wheresql + "BOJEDT = '" + wtr_dict['BJEDTE'] + "'" #报单日期
wheresql = wheresql + "AND BOSPSQ = '" + wtr_dict['BSPSQN'] + "'" #报单序号
ret = rccpsDBTrcc_atcbka.count(wheresql)
if ret == -1:
return AfaFlowControl.ExitThisFlow('S999','查找自动冲正登记簿异常')
elif ret > 0:
#=====原交易已自动冲正，抛弃报文====
return AfaFlowControl.ExitThisFlow('S999','原交易已冲正，抛弃报文')
AfaLoggerFunc.tradeInfo( '>>>查询冲正登记簿结束' )
#=====主机记账前处理====
TradeContext.BESBNO = wtr_dict['BESBNO'] #机构号
TradeContext.BETELR = wtr_dict['BETELR'] #柜员号
TradeContext.BEAUUS = wtr_dict['BEAUUS'] #授权柜员
TradeContext.BEAUPS = wtr_dict['BEAUPS'] #授权密码
TradeContext.TERMID = wtr_dict['TERMID'] #终端号
TradeContext.BJEDTE = wtr_dict['BJEDTE'] #交易日期
TradeContext.BSPSQN = wtr_dict['BSPSQN'] #报单序号
TradeContext.BRSFLG = wtr_dict['BRSFLG'] #往来账标志
TradeContext.HostCode= '8813' #主机交易码
AfaLoggerFunc.tradeInfo( '>>>主机前处理赋值结束' )
#=====开始更新原交易,新增状态记账－处理中====
if not rccpsState.newTransState(wtr_dict['BJEDTE'],wtr_dict['BSPSQN'],PL_BCSTAT_ACC,PL_BDWFLG_WAIT):
#=====RollBack操作====
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow('M999', '设置状态失败,系统自动回滚')
else:
#=====commit操作====
AfaDBFunc.CommitSql()
AfaLoggerFunc.tradeInfo( '>>>设置状态记账-处理中结束' )
#=====根据原记录中的手续费收取方式，判断账务处理模式====
if wtr_dict['CHRGTYP'] == '1':
#=====转账====
TradeContext.ACUR = '3' #记账次数
#=========交易金额+手续费===================
TradeContext.RCCSMCD = PL_RCCSMCD_YZBWZ #摘要代码 PL_RCCSMCD_YZBWZ 异转本
TradeContext.SBAC = TradeContext.BESBNO + PL_ACC_NXYDQSWZ #借方账号
TradeContext.SBAC = rccpsHostFunc.CrtAcc(TradeContext.SBAC,25)
TradeContext.ACNM = '农信银往账' #借方户名
TradeContext.RBAC = TradeContext.BESBNO + PL_ACC_NXYDJLS #贷方账号
TradeContext.RBAC = rccpsHostFunc.CrtAcc(TradeContext.RBAC,25)
TradeContext.OTNM = '应解汇款' #贷方户名
TradeContext.OCCAMT = str(wtr_dict['OCCAMT'] + wtr_dict['CUSCHRG']) #发生额
TradeContext.PKFG = 'T'
TradeContext.CTFG = '9'
TradeContext.WARNTNO = ''
TradeContext.CERTTYPE = ''
TradeContext.CERTNO = ''
AfaLoggerFunc.tradeInfo( '>>>交易金额+手续费:借方账号' + TradeContext.SBAC )
AfaLoggerFunc.tradeInfo( '>>>交易金额+手续费:贷方账号' + TradeContext.RBAC )
#=========交易金额============
TradeContext.I2SMCD = PL_RCCSMCD_YZBWZ #摘要代码
TradeContext.I2SBAC = TradeContext.BESBNO + PL_ACC_NXYDJLS #借方账号
TradeContext.I2SBAC = rccpsHostFunc.CrtAcc(TradeContext.I2SBAC,25)
TradeContext.I2ACNM = '应解汇款' #借方户名
TradeContext.I2RBAC = TradeContext.PYEACC #贷方账号
TradeContext.I2OTNM = TradeContext.PYENAM #贷方户名
TradeContext.I2TRAM = str(wtr_dict['OCCAMT']) #发生额
TradeContext.I2CTFG = '7'
TradeContext.I2PKFG = 'T'
#TradeContext.I2WARNTNO = ''
#TradeContext.I2CERTTYPE = ''
#TradeContext.I2CERTNO = ''
AfaLoggerFunc.tradeInfo( '>>>交易金额:借方账号' + TradeContext.I2SBAC )
AfaLoggerFunc.tradeInfo( '>>>交易金额:贷方账号' + TradeContext.I2RBAC )
#=========结算手续费收入户===========
TradeContext.I3SMCD = PL_RCCSMCD_SXF #摘要代码
TradeContext.I3SBAC = TradeContext.BESBNO + PL_ACC_NXYDJLS #借方账号
TradeContext.I3SBAC = rccpsHostFunc.CrtAcc(TradeContext.I3SBAC,25)
TradeContext.I3ACNM = '应解汇款' #借方户名
TradeContext.I3RBAC = TradeContext.BESBNO + PL_ACC_TCTDSXF #贷方账号
TradeContext.I3RBAC = rccpsHostFunc.CrtAcc(TradeContext.I3RBAC,25)
TradeContext.I3OTNM = '结算手续费' #贷方户名
TradeContext.I3TRAM = str(wtr_dict['CUSCHRG']) #发生额
TradeContext.I3CTFG = '8'
TradeContext.I3PKFG = 'T'
AfaLoggerFunc.tradeInfo( '>>>结算手续费收入户:借方账号' + TradeContext.I3SBAC )
AfaLoggerFunc.tradeInfo( '>>>结算手续费收入户:贷方账号' + TradeContext.I3RBAC )
elif wtr_dict['CHRGTYP'] == '0':
#=====本金====
TradeContext.ACUR = '2' #记账次数
TradeContext.RCCSMCD = PL_RCCSMCD_YZBWZ #摘要代码
TradeContext.SBAC = TradeContext.BESBNO + PL_ACC_NXYDQSWZ #借方账号
TradeContext.SBAC = rccpsHostFunc.CrtAcc(TradeContext.SBAC,25)
TradeContext.ACNM = '农信银往账' #借方户名
TradeContext.RBAC = TradeContext.PYEACC #贷方账号
TradeContext.OTNM = TradeContext.PYENAM #贷方户名
TradeContext.OCCAMT = str(wtr_dict['OCCAMT']) #金额
TradeContext.CTFG = '7'
TradeContext.PKFG = 'T'
TradeContext.WARNTNO = ''
TradeContext.CERTTYPE = ''
TradeContext.CERTNO = ''
#=====手续费记账赋值====
TradeContext.I2SMCD = PL_RCCSMCD_SXF #摘要代码
TradeContext.I2SBAC = '' #借方账号
TradeContext.I2RBAC = TradeContext.BESBNO + PL_ACC_TCTDSXF #贷方账号
TradeContext.I2RBAC = rccpsHostFunc.CrtAcc(TradeContext.I2RBAC,25)
TradeContext.I2OTNM = '手续费科目' #贷方户名
TradeContext.I2TRAM = str(wtr_dict['CUSCHRG']) #金额
TradeContext.I2CTFG = '8'
TradeContext.I2PKFG = 'T'
TradeContext.I2CATR = '0' #现转标志
elif wtr_dict['CHRGTYP'] == '2':
#=====不收费====
TradeContext.ACUR = '1' #记账次数
TradeContext.RCCSMCD = PL_RCCSMCD_YZBWZ #摘要代码
TradeContext.SBAC = TradeContext.BESBNO + PL_ACC_NXYDQSWZ #借方账号
TradeContext.SBAC = rccpsHostFunc.CrtAcc(TradeContext.SBAC,25)
TradeContext.RBAC = TradeContext.PYEACC #贷方账号
TradeContext.OTNM = TradeContext.PYENAM #贷方户名
TradeContext.OCCAMT = str(wtr_dict['OCCAMT']) #金额
TradeContext.CTFG = '7'
TradeContext.PKFG = 'T'
TradeContext.WARNTNO = ''
TradeContext.CERTTYPE = ''
TradeContext.CERTNO = ''
else:
#=====出错====
return AfaFlowControl.ExitThisFlow('S999','手续费收费方式错，抛弃报文')
AfaLoggerFunc.tradeInfo( '>>>根据手续费收取方式记账赋值处理结束' )
#=====主机记账处理====
rccpsHostFunc.CommHost(TradeContext.HostCode)
#=====主机后处理====
set_dict = {}
set_dict['BSPSQN'] = TradeContext.BSPSQN
set_dict['BJEDTE'] = TradeContext.BJEDTE
set_dict['BCSTAT'] = PL_BCSTAT_ACC
set_dict["SBAC"] = TradeContext.SBAC #借方账号
set_dict["RBAC"] = TradeContext.RBAC #贷方账号
set_dict["OTNM"] = TradeContext.OTNM #贷方户名
set_dict['MGID'] = TradeContext.errorCode #主机返回码
set_dict["STRINFO"]= TradeContext.errorMsg #主机返回信息
if TradeContext.errorCode == '0000':
#=====主机记账成功====
set_dict['BDWFLG'] = PL_BDWFLG_SUCC
set_dict['TRDT'] = TradeContext.TRDT
set_dict['TLSQ'] = TradeContext.TLSQ
else:
set_dict['BDWFLG'] = PL_BDWFLG_FAIL
if not rccpsState.setTransState(set_dict):
return AfaFlowControl.ExitThisFlow(TradeContext.errorCode, TradeContext.errorMsg)
else:
#=====commit操作====
AfaDBFunc.CommitSql()
AfaLoggerFunc.tradeInfo('>>>设置主机返回状态成功')
if TradeContext.errorCode == '0000':
#=====开始更新原交易,新增状态清算成功====
if not rccpsState.newTransState(wtr_dict['BJEDTE'],wtr_dict['BSPSQN'],PL_BCSTAT_MFESTL,PL_BDWFLG_SUCC):
#=====RollBack操作====
AfaDBFunc.RollbackSql()
return AfaFlowControl.ExitThisFlow('M999', '设置状态失败,系统自动回滚')
else:
#=====commit操作====
AfaDBFunc.CommitSql()
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.本地类操作(1.本地操作).异转本_卡应答[TRCC004_1158]退出***' )
return True
def SubModuleDoTrd():
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.主机类操作(3.中心记账).汇票签发[TRCC002_8501]进入***' )
stat_dict = {}
stat_dict['BJEDTE'] = TradeContext.BJEDTE
stat_dict['BSPSQN'] = TradeContext.BSPSQN
stat_dict['BESBNO'] = TradeContext.BESBNO
stat_dict['BETELR'] = TradeContext.BETELR
stat_dict['BCSTAT'] = PL_BCSTAT_SND
stat_dict['BDWFLG'] = PL_BDWFLG_SUCC
stat_dict['PRCCO'] = TradeContext.errorCode
stat_dict['STRINFO'] = TradeContext.errorMsg
AfaLoggerFunc.tradeInfo("TradeContext.errorCode = [" + TradeContext.errorCode + "]")
if TradeContext.errorCode == '0000':
#=====发送农信银成功,设置状态为发送成功====
stat_dict['BCSTAT'] = PL_BCSTAT_SND
stat_dict['BDWFLG'] = PL_BDWFLG_SUCC
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999', "设置业务状态为发送成功异常")
AfaLoggerFunc.tradeInfo(">>>设置业务状态为发送成功")
else:
#=====发送农信银失败,设置状态为发送失败====
stat_dict['BCSTAT'] = PL_BCSTAT_SND
stat_dict['BDWFLG'] = PL_BDWFLG_FAIL
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999', "设置业务状态为发送失败异常")
AfaLoggerFunc.tradeInfo(">>>设置业务状态为发送失败")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
#====自动抹账====
AfaLoggerFunc.tradeInfo(">>>开始自动抹账")
#====设置业务状态为抹账处理中====
if not rccpsState.newTransState(TradeContext.BJEDTE,TradeContext.BSPSQN,PL_BCSTAT_HCAC,PL_BDWFLG_WAIT):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态为抹账处理中异常')
AfaLoggerFunc.tradeInfo(">>>设置业务状态为抹账处理中")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
#=====发起主机抹账====
#=====如果资金来源为代销账，使用8813红字冲销====
TradeContext.BOJEDT = TradeContext.BJEDTE #给前置日期赋值
TradeContext.BOSPSQ = TradeContext.BSPSQN #给前置流水号赋值
if TradeContext.BBSSRC == '3': #待销账
TradeContext.HostCode= '8813'
TradeContext.DASQ = ''
TradeContext.RVFG = '0' #红蓝字标志 0红字
TradeContext.SBAC = TradeContext.BESBNO + PL_ACC_HCHK #借方账号
TradeContext.RBAC = TradeContext.BESBNO + PL_ACC_NXYDXZ #贷方账号
#=====开始调函数拼贷方账号第25位校验位====
TradeContext.SBAC = rccpsHostFunc.CrtAcc(TradeContext.SBAC, 25)
TradeContext.RBAC = rccpsHostFunc.CrtAcc(TradeContext.RBAC, 25)
AfaLoggerFunc.tradeInfo( '借方账号:' + TradeContext.SBAC )
AfaLoggerFunc.tradeInfo( '贷方账号:' + TradeContext.RBAC )
else:
TradeContext.HostCode='8820'
#=====调起抹账主机接口====
rccpsHostFunc.CommHost( TradeContext.HostCode )
stat_dict = {}
stat_dict['BJEDTE'] = TradeContext.BJEDTE
stat_dict['BSPSQN'] = TradeContext.BSPSQN
stat_dict['BESBNO'] = TradeContext.BESBNO
stat_dict['BETELR'] = TradeContext.BETELR
if TradeContext.HostCode == '8813':
stat_dict['SBAC'] = TradeContext.SBAC
stat_dict['RBAC'] = TradeContext.RBAC
if TradeContext.existVariable('TRDT'):
stat_dict['TRDT'] = TradeContext.TRDT
if TradeContext.existVariable('TLSQ'):
stat_dict['TLSQ'] = TradeContext.TLSQ
stat_dict['MGID'] = TradeContext.errorCode
stat_dict['STRINFO'] = TradeContext.errorMsg
AfaLoggerFunc.tradeInfo("TradeContext.errorCode = [" + TradeContext.errorCode + "]")
if TradeContext.errorCode == '0000':
#=====主机抹账成功,设置业务状态为抹账成功====
stat_dict['BCSTAT'] = PL_BCSTAT_HCAC
stat_dict['BDWFLG'] = PL_BDWFLG_SUCC
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态抹账成功异常')
AfaLoggerFunc.tradeInfo(">>>设置业务状态为抹账成功")
else:
#=====主机抹账失败,设置业务状态为抹账失败====
stat_dict['BCSTAT'] = PL_BCSTAT_HCAC
stat_dict['BDWFLG'] = PL_BDWFLG_FAIL
if not rccpsState.setTransState(stat_dict):
return AfaFlowControl.ExitThisFlow('S999','设置业务状态抹账成功异常')
AfaLoggerFunc.tradeInfo(">>>设置业务状态为抹账失败")
AfaLoggerFunc.tradeInfo(">>>结束自动抹账")
if not AfaDBFunc.CommitSql( ):
AfaLoggerFunc.tradeFatal( AfaDBFunc.sqlErrMsg )
return AfaFlowControl.ExitThisFlow("S999","Commit异常")
AfaLoggerFunc.tradeInfo( '***农信银系统：往账.主机类操作(3.中心记帐).汇票签发[TRCC002_8501]退出***' )
return True
