def post(self, request):
result = third_pay.add_bank_card(request)
if result.get('ret_code') == 0:
try:
CoopRegister(request).process_for_binding_card(request.user)
except:
logger.exception('bind_card_callback_failed for %s' %
str(request.user))
return Response(result)
def test_all_processors_for_session(self):
#for yiruite
self.request.GET = {'promo_token': 'yiruite', 'tid': '123456'}
self.request.session = {}
coop_reg = CoopRegister(self.request)
coop_reg.all_processors_for_session()
assert self.request.session == {
'channel_code': 'yiruite',
'channel_user': '******'
}
#for default
self.request.GET = {'promo_token': 'pptv'}
self.request.session = {}
coop_reg = CoopRegister(self.request)
coop_reg.all_processors_for_session()
assert self.request.session == {'channel_code': 'pptv'}
def test_get_user_channel_processor(self):
self.request.GET = {'promo_token': 'yiruite', 'tid': '123456'}
self.request.session = {}
coop_reg = CoopRegister(self.request)
coop_reg.all_processors_for_session()
#prepare user data
prepare_user()
#prepare channel data
Channels(code='yiruite', name='yiruite').save()
coop_reg.all_processors_for_user_register(get_user(), None)
assert coop_reg.get_user_channel_processor(
get_user()).c_code == 'yiruite'
clear_db(Channels, User, IntroducedBy)
def test_all_processors_for_register_for_default(self):
self.request.GET = {'promo_token': 'pptv'}
self.request.session = {}
coop_reg = CoopRegister(self.request)
coop_reg.all_processors_for_session()
#prepare user data
prepare_user()
#prepare channel data
Channels(code='pptv', name='pptv').save()
coop_reg.all_processors_for_user_register(get_user(), None)
introduced_by = IntroducedBy.objects.filter(user=get_user()).get()
clear_db(Channels, User, IntroducedBy)
def process_for_bind_card(user, card, req_res, request):
# Modify by hb on 2015-12-24 : 如果ret_code返回非0, 还需进一步判断card是否有绑定记录, 因为有可能出现充值失败但绑卡成功的情况
try:
bind_flag = 0
if (card.bank.channel == 'kuaipay' and req_res.get('ret_code')
== 0) or (card.bank.channel == 'yeepay'
and req_res.get('ret_code') == 22000):
bind_flag = 1
else:
card = Card.objects.filter(user=user, id=card.id).first()
if card and (card.is_bind_huifu or card.is_bind_kuai
or card.is_bind_yee):
logger.error(
'=20151224= deposit failed but binding success: [%s] [%s]'
% (card.user, card.no))
bind_flag = 1
if bind_flag == 1:
CoopRegister(request).process_for_binding_card(user)
except Exception, ex:
logger.exception(
'=20151224= bind_card_callback_failed: [%s] [%s] [%s]' %
(user, card.no, ex))
def test_all_processors_for_register_for_yiruite(self):
self.request.GET = {'promo_token': 'yiruite', 'tid': '123456'}
self.request.session = {}
coop_reg = CoopRegister(self.request)
coop_reg.all_processors_for_session()
#prepare user data
prepare_user()
#prepare channel data
Channels(code='yiruite', name='yiruite').save()
coop_reg.all_processors_for_user_register(get_user(), None)
today = date.today()
start_day = (today - timedelta(days=1)).strftime('%Y%m%d')
end_day = (today + timedelta(days=1)).strftime('%Y%m%d')
md5_sign = md5()
md5_sign.update(start_day + end_day + settings.WLB_FOR_YIRUITE_KEY)
sign = md5_sign.hexdigest()
print start_day, end_day, sign
assert CoopQuery().get_all_user_info_for_coop(
'yiruite', 0, start_day, end_day, sign)[0]['tid'] == '123456'
clear_db(Channels, User, IntroducedBy)
def handle_pay_result(cls, request):
# TODO Add a log
flag = False
order_id = request.POST.get('OrdId', '')
try:
pay_info = PayInfo.objects.select_for_update().get(pk=order_id)
except PayInfo.DoesNotExist:
logger.warning('Order not found, order id: ' + order_id + ', response: ' + request.body)
return PayResult.EXCEPTION
if pay_info.status == PayInfo.SUCCESS:
return PayResult.DEPOSIT_SUCCESS
amount = request.POST.get('OrdAmt', '')
code = request.POST.get('RespCode', '')
message = request.POST.get('ErrMsg', '')
pay_info.error_code = code
pay_info.error_message = message
pay_info.response = request.body
pay_info.response_ip = get_client_ip(request)
result = u''
try:
pay = HuifuPay()
if pay.verify_sign(request.POST.dict(), HuifuPay.PAY_FIELDS):
if pay_info.amount != decimal.Decimal(amount):
pay_info.status = PayInfo.FAIL
pay_info.error_message += u' 金额不匹配'
logger.error('Amount mismatch, order id: %s request amount: %f response amount: %s',
order_id, float(pay_info.amount), amount)
result = PayResult.EXCEPTION
else:
if code == '000000':
keeper = MarginKeeper(pay_info.user, pay_info.order.pk)
margin_record = keeper.deposit(amount)
pay_info.margin_record = margin_record
pay_info.status = PayInfo.SUCCESS
result = PayResult.DEPOSIT_SUCCESS
phone = pay_info.user.wanglibaouserprofile.phone
flag = True
else:
pay_info.status = PayInfo.FAIL
result = PayResult.DEPOSIT_FAIL
else:
pay_info.error_message = 'Invalid signature. Order id: ' + order_id
logger.error(pay_info.error_message)
pay_info.status = PayInfo.EXCEPTION
result = PayResult.EXCEPTION
except (socket.error, SignException) as e:
pay_info.error_message = str(e)
pay_info.status = PayInfo.EXCEPTION
logger.fatal('sign error! order id: ' + order_id + ' ' + str(e))
result = PayResult.EXCEPTION
pay_info.save()
if flag:
device = split_ua(request)
try:
# fix@chenweibi, add order_id
tools.deposit_ok.apply_async(kwargs={"user_id": pay_info.user.id, "amount": pay_info.amount,
"device": device, "order_id": pay_info.order_id})
CoopRegister(request).process_for_recharge(pay_info.user, pay_info.order_id)
except:
pass
OrderHelper.update_order(pay_info.order, pay_info.user, pay_info=model_to_dict(pay_info), status=pay_info.status)
return result
def pre_pay(self, request):
"""
返回跳转信息{'message': message,'form': form}供跳转js使用，message包含报错信息
form包含跳转信息
:param request:
:return:
"""
if not request.user.wanglibaouserprofile.id_is_valid:
return self.render_to_response({
'message': u'请先进行实名认证'
})
form = dict()
message = ''
try:
amount_str = request.POST.get('amount', '')
amount = decimal.Decimal(amount_str). \
quantize(TWO_PLACES, context=decimal.Context(traps=[decimal.Inexact]))
amount_str = str(amount)
if amount <= 0:
# todo handler the raise
raise decimal.DecimalException()
gate_id = request.POST.get('gate_id', '')
bank = Bank.objects.get(gate_id=gate_id)
# Store this as the default bank
request.user.wanglibaouserprofile.deposit_default_bank_name = bank.name
request.user.wanglibaouserprofile.save()
pay_info = PayInfo()
pay_info.amount = amount
pay_info.total_amount = amount
pay_info.type = PayInfo.DEPOSIT
pay_info.status = PayInfo.INITIAL
pay_info.user = request.user
pay_info.bank = bank
pay_info.channel = "huifu"
pay_info.request_ip = get_client_ip(request)
order = OrderHelper.place_order(request.user, Order.PAY_ORDER, pay_info.status,
pay_info=model_to_dict(pay_info))
pay_info.order = order
pay_info.save()
post = {
'OrdId': pay_info.pk,
'GateId': gate_id,
'OrdAmt': amount_str
}
form = self.pay(post)
pay_info.request = str(form)
pay_info.status = PayInfo.PROCESSING
pay_info.save()
OrderHelper.update_order(order, request.user, pay_info=model_to_dict(pay_info), status=pay_info.status)
# 处理第三方渠道的用户充值回调
CoopRegister(request).process_for_recharge(request.user, order.id)
except decimal.DecimalException:
message = u'金额格式错误'
except Bank.DoesNotExist:
message = u'请选择有效的银行'
except (socket.error, SignException) as e:
message = PayResult.RETRY
pay_info.status = PayInfo.FAIL
pay_info.error_message = str(e)
pay_info.save()
OrderHelper.update_order(order, request.user, pay_info=model_to_dict(pay_info), status=pay_info.status)
logger.fatal('sign error! order id: ' + str(pay_info.pk) + ' ' + str(e))
result = {
'message': message,
'form': form
}
return result
class P2PTrader(object):
def __init__(self, product, user, order_id=None, request=None):
self.user = user
self.product = product
if self.product.status != u"正在招标":
raise P2PException(u'购买的标不在招标状态')
self.request = request
if order_id is None:
self.order_id = OrderHelper.place_order(user,
order_type=u'产品申购',
product_id=product.id,
status=u'新建').id
else:
self.order_id = order_id
self.margin_keeper = MarginKeeper(user=user, order_id=self.order_id)
self.product_keeper = ProductKeeper(product, order_id=self.order_id)
self.equity_keeper = EquityKeeper(user=user,
product=product,
order_id=self.order_id)
if request:
self.device = split_ua(request)
self.device_type = self.device['device_type']
else:
self.device = split_ua(request)
self.device_type = "pc"
def purchase(self, amount, redpack=0, platform=u''):
description = u'购买P2P产品 %s %s 份' % (self.product.short_name, amount)
is_full = False
product_balance_after = 0
if self.user.wanglibaouserprofile.frozen:
raise P2PException(u'用户账户已冻结，请联系客服')
with transaction.atomic():
if redpack:
# 为防止用户同时打开两个浏览器同时使用加息券和红包，须先检测
coupons = RedPackRecord.objects.filter(user=self.user, product_id=self.product.id) \
.filter(redpack__event__rtype='interest_coupon')
if coupons:
raise P2PException(u'已经选择过加息券，不能重复或叠加使用')
else:
this_redpack = RedPackRecord.objects.filter(
pk=redpack).first()
this_rtype = this_redpack.redpack.event.rtype
coupons = RedPackRecord.objects.filter(user=self.user, product_id=self.product.id) \
.exclude(redpack__event__rtype='interest_coupon')
if coupons and this_rtype == 'interest_coupon':
raise P2PException(u'红包和加息券不能同时叠加使用')
redpack_order_id = OrderHelper.place_order(
self.user,
order_type=u'优惠券消费',
redpack=redpack,
product_id=self.product.id,
status=u'新建').id
result = redpack_backends.consume(redpack, amount, self.user,
self.order_id,
self.device_type,
self.product.id)
if result['ret_code'] != 0:
raise Exception, result['message']
if result['rtype'] != 'interest_coupon':
red_record = self.margin_keeper.redpack_deposit(
result['deduct'],
u"购买P2P抵扣%s元" % result['deduct'],
order_id=redpack_order_id,
savepoint=False)
OrderHelper.update_order(
Order.objects.get(pk=redpack_order_id),
user=self.user,
status=u'成功',
amount=amount,
deduct=result['deduct'],
redpack=redpack)
product_record = self.product_keeper.reserve(amount,
self.user,
savepoint=False,
platform=platform)
margin_record = self.margin_keeper.freeze(amount,
description=description,
savepoint=False)
equity = self.equity_keeper.reserve(amount,
description=description,
savepoint=False)
OrderHelper.update_order(Order.objects.get(pk=self.order_id),
user=self.user,
status=u'份额确认',
amount=amount)
product_balance_after = product_record.product_balance_after
if product_balance_after <= 0:
is_full = True
# fix@chenweibin, add order_id
# Modify by hb on 2015-11-25 : add "try-except"
try:
logger.debug("=20151125= decide_first.apply_async : [%s], [%s], [%s], [%s], [%s], [%s]" % \
(self.user.id, amount, self.device['device_type'], self.order_id, self.product.id, is_full) )
tools.decide_first.apply_async(
kwargs={
"user_id": self.user.id,
"amount": amount,
"device": self.device,
"order_id": self.order_id,
"product_id": self.product.id,
"is_full": is_full,
"product_balance_after": product_balance_after
})
except Exception, reason:
logger.debug(
"=20151125= decide_first.apply_async Except:{0}".format(
reason))
pass
try:
logger.debug(
"=20151125= CoopRegister.process_for_purchase : [%s], [%s]" %
(self.user.id, self.order_id))
CoopRegister(self.request).process_for_purchase(
self.user, self.order_id)
except Exception, reason:
logger.debug(
"=20151125= CoopRegister.process_for_purchase Except:{0}".
format(reason))
pass
def process_request(self, request):
token = request.GET.get(settings.PROMO_TOKEN_QUERY_STRING, None)
if token:
request.session[settings.PROMO_TOKEN_QUERY_STRING] = token
CoopRegister(request).all_processors_for_session()
"ylb_period": int(period)
},
queue='celery_ylb')
except Exception, e:
logger.debug(
'tools.decide_first.apply_async failed with = {} !!!'.format(
e.message))
# 模拟一个request
request = urllib2.Request("")
try:
logger.info(
u"=遍历渠道= CoopRegister.process_for_purchase : {}, {}".format(
user, product.id))
CoopRegister(request).process_for_purchase_yuelibao(
user, product.id)
except Exception, e:
logger.debug(
u"=遍历渠道= CoopRegister.process_for_purchase Except:{}".format(
e))
# ruike qudao
try:
kargs = {
'amount': amount_source,
'order_id': product.id,
'user': user,
'request': request,
'product': None,
}
ruike_obj = RuiKeDistributer(request, kargs)
def create(self, request):
card = Card()
card.user = request.user
no = request.DATA.get('no', '')
if no:
card.no = no
else:
return Response(
{
"message": u"银行账号不能为空",
'error_number': ErrorNumber.card_number_error
},
status=status.HTTP_400_BAD_REQUEST)
is_default = request.DATA.get('is_default', False)
if is_default == 'true':
card.is_default = True
elif is_default == 'false':
card.is_default = False
else:
return Response(
{
"message": u"设置是否默认银行卡错误",
'error_number': ErrorNumber.card_isdefault_error
},
status=status.HTTP_400_BAD_REQUEST)
if not re.match('^[\d]{0,25}$', card.no):
return Response(
{
"message": u"银行账号超过长度",
'error_number': ErrorNumber.form_error
},
status=status.HTTP_400_BAD_REQUEST)
bank_id = request.DATA.get('bank', '')
exist_cards = Card.objects.filter(no=card.no)
exist_cards1 = Card.objects.filter(user=card.user,
no__startswith=card.no[:6],
no__endswith=card.no[-4:]).first()
if exist_cards or exist_cards1:
return Response(
{
"message": u"您输入的银行卡号已绑定，请尝试其他银行卡号码，如非本人操作请联系客服",
'error_number': ErrorNumber.duplicate
},
status=status.HTTP_400_BAD_REQUEST)
try:
card.bank = Bank.objects.get(pk=bank_id)
except:
return Response(
{
"message": u"没有找到该银行",
'error_number': ErrorNumber.not_find
},
status=status.HTTP_400_BAD_REQUEST)
# passport user
if not request.user.wanglibaouserprofile.id_number[0].isdigit():
card.is_bind_yee = True
card.is_bind_kuai = True
card.save()
try:
# 处理第PC三方用户绑卡回调
CoopRegister(request).process_for_binding_card(request.user)
except Exception, e:
logger.error(e)
pay_info.status = PayInfo.SUCCESS
logger.error("orderId:%s yeepay response status:%s" % (orderId, params['status']))
rs = {"ret_code":0, "message":"success", "amount":amount, "uid":pay_info.user.id}
else:
pay_info.status = PayInfo.FAIL
logger.error("orderId:%s yeepay response status: %s" % (orderId, params['status']))
rs = {"ret_code":20087, "message":PayResult.DEPOSIT_FAIL}
pay_info.save()
if rs['ret_code'] == 0:
device_type = pay_info.device
try:
# fix@chenweibi, add order_id
tools.deposit_ok.apply_async(kwargs={"user_id": pay_info.user.id, "amount": pay_info.amount,
"device": device_type, "order_id": orderId})
CoopRegister(request).process_for_recharge(pay_info.user, pay_info.order_id)
except:
pass
# 充值成功后，更新本次银行使用的时间
if len(pay_info.card_no) == 10:
Card.objects.filter(user=pay_info.user, no__startswith=pay_info.card_no[:6], no__endswith=pay_info.card_no[-4:]).update(last_update=timezone.now())
else:
Card.objects.filter(user=pay_info.user, no=pay_info.card_no).update(last_update=timezone.now())
OrderHelper.update_order(pay_info.order, pay_info.user, pay_info=model_to_dict(pay_info), status=pay_info.status)
return rs
def query_trx_result(self, order_id):
res = self._query_trx_result(order_id)
def order_after_pay_succcess(self,
amount,
order_id,
res_ip=None,
res_content=None,
request=None,
need_bind_card=False):
"""
处理订单和用户的账户
:param amount:
:param order_id:
:param user_id:
:param ip:
:param res_content:
:return:
"""
# 参数校验
pay_info = PayInfo.objects.select_for_update().filter(
order_id=order_id).first()
if not pay_info:
# return {"ret_code":20131, "message":"order not exist", "amount": amount}
raise ThirdPayError(20131, 'order not exist')
if pay_info.status == PayInfo.SUCCESS:
return {
"ret_code": 0,
"message": PayResult.DEPOSIT_SUCCESS,
"amount": amount
}
if fmt_two_amount(pay_info.amount) != fmt_two_amount(amount):
raise ThirdPayError(20132, PayResult.EXCEPTION)
if pay_info.user_id != pay_info.user_id:
raise ThirdPayError(20133, PayResult.EXCEPTION)
# 更新pay_info和margin信息
pay_info.error_message = ""
if res_content:
pay_info.response = res_content
if res_ip:
pay_info.response_ip = res_ip
pay_info.fee = self.FEE
keeper = MarginKeeper(pay_info.user, pay_info.order.pk)
margin_record = keeper.deposit(amount)
pay_info.margin_record = margin_record
pay_info.status = PayInfo.SUCCESS
pay_info.save()
# 更新order信息
# if len(pay_info.card_no) == 10:
# Card.objects.filter(user=pay_info.user, no__startswith=pay_info.card_no[:6], no__endswith=pay_info.card_no[-4:]).update(last_update=timezone.now(), is_bind_kuai=True)
# else:
# Card.objects.filter(user=pay_info.user, no=pay_info.card_no).update(last_update=timezone.now(), is_bind_kuai=True)
OrderHelper.update_order(pay_info.order,
pay_info.user,
pay_info=model_to_dict(pay_info),
status=pay_info.status)
# 绑卡
if need_bind_card:
self.add_card(pay_info.card_no, pay_info.bank, pay_info.user,
pay_info.channel)
try:
user = pay_info.user
CoopRegister(request).process_for_recharge(user, order_id)
# tools.deposit_ok(request.user.id, amount, pay_info.device, order_id)
tools.deposit_ok.apply_async(
kwargs={
"user_id": user.id,
"amount": amount,
"device": pay_info.device,
"order_id": order_id
})
except:
logger.exception('recharge_call_back faile for ' + str(user) +
str(order_id))
logger.critical("orderId:%s success" % order_id)
rs = {
"ret_code": 0,
"message": "success",
"amount": amount,
"margin": margin_record.margin_current,
"order_id": order_id
}
return rs