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 detect(request):
stype = request.DATA.get("type", "").strip()
pagesize = request.DATA.get("pagesize", "10").strip()
pagenum = request.DATA.get("pagenum", "1").strip()
product_id = request.DATA.get("product_id", "").strip()
device = rest_utils.split_ua(request)
device_type = rest_utils.decide_device(device['device_type'])
try:
app_version = device['app_version']
except KeyError:
app_version = ''
if not stype or stype not in ("deposit", "withdraw", "amortization"):
return {"ret_code": 30191, "message": u"错误的类型"}
if not pagesize.isdigit() or not pagenum.isdigit():
return {"ret_code": 30192, "message": u"请输入正确的参数"}
pagesize = int(pagesize)
pagenum = int(pagenum)
if pagesize > 100:
return {"ret_code": 30193, "message": u"参数超出限制"}
if product_id:
if not product_id.isdigit():
return {"ret_code": 30194, "message": u"产品号错误"}
else:
product_id = int(product_id)
user = request.user
if stype == "deposit":
res = _deposit_record(user, pagesize, pagenum)
elif stype == "withdraw":
res = _withdraw_record(user, pagesize, pagenum, app_version)
else:
res = _amo_record(user, pagesize, pagenum, product_id)
return {"ret_code": 0, "data": res, "pagenum": pagenum}
def post(self, request):
red_pack_info = dict()
period = request.POST.get('period', 0)
uid = request.POST.get('userId', 0)
if request.user.id:
uid = request.user.id
# if self.request.user.pk and int(self.request.user.pk) == int(uid):
# 去掉登录验证, 方便PHP
if period and uid:
device = utils.split_ua(self.request)
result = php_redpacks(User.objects.get(pk=uid),
device['device_type'],
period=period)
redpacks = result['packages'].get('available', [])
red_pack_info.update(status=1, redpacks=redpacks)
else:
red_pack_info.update(status=0, msg=u'authentic error!')
return HttpResponse(renderers.JSONRenderer().render(
red_pack_info, 'application/json'))
def post(self, request):
logger.info('web_pay_request_para:' + str(request.POST))
try:
user = request.user
amount = fmt_two_amount(request.POST.get('amount'))
gate_id = request.POST.get('gate_id')
request_ip = get_client_ip(request)
device_type = split_ua(request)['device_type']
channel = PayOrder.get_bank_and_channel(gate_id)[1]
except:
logger.exception('third_pay_error')
result = {'message': '参数错误'}
return self.render_to_response(result)
if channel == 'yeepay':
result = YeeProxyPay().proxy_pay(user, amount, gate_id, request_ip,
device_type)
elif channel == 'baopay':
result = BaoProxyPay().proxy_pay(user, amount, gate_id, request_ip,
device_type)
else:
result = HuifuPay().pre_pay(request)
print 'pay_jump_para' + str(result)
return self.render_to_response(result)
def post(self, request):
token = request.DATA.get("token", "")
device = utils.split_ua(request)
user = request.user
try:
app_version = device['app_version']
except KeyError:
app_version = ''
result = backends.exchange_redpack(token, device['device_type'], user,
app_version)
return Response(result)
def get_context_data(self, id, **kwargs):
context = super(P2PDetailView, self).get_context_data(**kwargs)
cache_backend = redis_backend()
p2p = cache_backend.get_cache_p2p_detail(id)
if not p2p:
raise Http404(u'您查找的产品不存在')
form = PurchaseForm(initial={'product': p2p.get('id')})
user = self.request.user
current_equity = 0
if user.is_authenticated():
equity_record = P2PEquity.objects.filter(user=user, product=p2p.get('id')).first()
if equity_record is not None:
current_equity = equity_record.equity
xunlei_vip = Binding.objects.filter(user=user).filter(btype='xunlei').first()
context.update({
'xunlei_vip': xunlei_vip,
'is_invested': user.wanglibaouserprofile.is_invested
})
orderable_amount = min(p2p.get('limit_amount_per_user') - current_equity, p2p.get('remain'))
# site_data = SiteData.objects.all()[0]
p2p_invest_records = P2PRecord.objects.filter(product=p2p.get('id')).filter(catalog=u'申购')[0:30]
p2p_invest_records_total = P2PRecord.objects.filter(product=p2p.get('id')).filter(catalog=u'申购').count()
device = utils.split_ua(self.request)
if p2p.get('status') == u'正在招标':
red_packets = backends.list_redpack(user, 'available', device['device_type'], p2p.get('id'))
else:
red_packets = None
context.update({
'p2p': p2p,
'p2p_invest_records': p2p_invest_records,
'p2p_invest_records_total': p2p_invest_records_total,
'form': form,
'end_time': p2p.get('end_time'),
'total_earning': p2p.get('total_earning'),
'current_equity': current_equity,
'orderable_amount': orderable_amount,
# 'site_data': site_data,
'announcements': AnnouncementP2P,
'total_fee_earning': p2p.get('total_fee_earning'),
'day_tops': [],
'week_tops': [],
'all_tops': [],
'is_valid': False,
'red_packets': len(red_packets['packages']['available']) if red_packets else 0,
})
return context
def post(self, request):
status = request.DATA.get("status", "")
rtype = request.DATA.get("rtype", "")
product_id = request.DATA.get("product_id", "")
device = utils.split_ua(request)
user = request.user
try:
app_version = device['app_version']
except KeyError:
app_version = ''
result = backends.list_redpack(user, status, device['device_type'],
product_id, rtype, app_version)
return Response(result)
def post(self, request):
trade_id = request.POST.get('tradeId')
user_id = request.POST.get('userId')
product_id = request.POST.get('productId')
token = request.POST.get('token', None)
amount = request.POST.get('amount', 0)
amount_source = request.POST.get('sourceAmount', 0)
# 给用户的返现金额
payback_source = request.POST.get('payBackAmount', 0)
# 红包金额为-1 用于统计已花本金, 还款忽略, 只改状态.
red_packet = -1
# 类型, -1 表示未使用红包
red_packet_type = -1
try:
user = User.objects.filter(pk=user_id).first()
product, status = MonthProduct.objects.get_or_create(
user=user,
product_id=product_id,
trade_id=trade_id,
token=token,
amount=amount,
amount_source=amount_source,
red_packet=red_packet,
red_packet_type=red_packet_type,
)
device = utils.split_ua(self.request)
buy_mall_product.apply_async(
kwargs={
'token': token,
'amount_source': amount_source,
'payback_source': payback_source,
'user': user_id,
'device_type': device['device_type']
})
return HttpResponse(renderers.JSONRenderer().render(
{'status': '1'}, 'application/json'))
except Exception, e:
logger.debug('buy mall product failed with {}!\n'.format(
e.message))
return HttpResponse(renderers.JSONRenderer().render(
{
'status': '0',
'msg': 'args error! ' + e.message
}, 'application/json'))
def post(self, request):
trade_id = request.POST.get('tradeId')
user_id = request.POST.get('userId')
product_id = request.POST.get('productId')
token = request.POST.get('token')
amount = request.POST.get('amount')
amount_source = request.POST.get('sourceAmount')
red_packet = request.POST.get('redPacketAmount')
red_packet_type = request.POST.get('isRedPacket')
period = request.POST.get('period', 1)
# 使用的红包id
red_packet_id = request.POST.get('RedPacketId', 0)
try:
user = User.objects.get(pk=user_id)
product, status = MonthProduct.objects.get_or_create(
user=user,
product_id=product_id,
trade_id=trade_id,
token=token,
amount=amount,
amount_source=amount_source,
red_packet=red_packet,
cancel_status=False,
trade_status='NEW',
red_packet_type=red_packet_type,
)
device = utils.split_ua(self.request)
buy_month_product.apply_async(kwargs={
'token': token,
'red_packet_id': red_packet_id,
'amount_source': amount_source,
'user': user_id,
'device': device,
'period': period
},
queue='celery_ylb')
return HttpResponse(renderers.JSONRenderer().render(
{'status': '1'}, 'application/json'))
except Exception, e:
logger.debug('buy month product failed with {}!\n'.format(
e.message))
return HttpResponse(renderers.JSONRenderer().render(
{
'status': '0',
'msg': 'args error! ' + e.message
}, 'application/json'))
def post(self, request):
size = request.DATA.get('size', '').strip()
device = split_ua(request)
device_type = device['device_type']
if not device_type or not size:
return Response({'ret_code': 20001, 'message': u'信息输入不完整'})
if device_type != 'ios' or int(size) not in (x for x in range(1, 9)):
return Response({'ret_code': 20002, 'message': u'参数不合法'})
if int(size) in (x for x in range(5, 9)):
size = str(int(size) - 4)
device_type = 'act_score_iso'
size = self.SIZE_MAP[size]
# activate_query = AppActivate.objects.filter(Q(is_used=True), Q(device=self.DEVICE_MAP[device_type]))
# activate = activate_query.filter(Q(is_long_used=False) & Q(start_at__lte=timezone.now()) & Q(end_at__gte=timezone.now())).order_by('-priority').first()
# if not activate:
# activate = activate_query.filter(Q(is_long_used=True)).order_by('-priority').first()
activate = AppActivate.objects.filter(
Q(is_used=True), Q(device=self.DEVICE_MAP[device_type]),
Q(is_long_used=True) |
(Q(is_long_used=False) & Q(start_at__lte=timezone.now())
& Q(end_at__gte=timezone.now()))).first()
if activate:
if size == 'img_one':
img_url = activate.img_one
elif size == 'img_two':
img_url = activate.img_two
elif size == 'img_three':
img_url = activate.img_three
elif size == 'img_four':
img_url = activate.img_four
else:
img_url = ''
if img_url:
img_url = '{host}/media/{url}'.format(
host=settings.CALLBACK_HOST, url=img_url)
return Response({
'ret_code': 0,
'message': 'ok',
'image': img_url,
})
return Response({'ret_code': 20003, 'message': 'fail'})
def _is_version_satisfied(request):
# return {"device_type":device_type, "app_version":arr[0],
# "channel_id":arr[2], "model":arr[1],
# "os_version":arr[3], "network
# ":arr[4]}
device = split_ua(request)
print(11111111111111111111)
print('trade request device %s' % device)
if device['device_type'] == 'ios' and _above_version(
device['app_version'], '2.6.0'):
# 2.6.0版本起，支持交易密码
return True
if device['device_type'] == 'android' and _above_version(
device['app_version'], '2.6.0'):
#2.6.0版本起，支持交易密码
return True
# no trade_pwd for pc first pay
if device['device_type'] == 'pc' and PayInfo.objects.filter(
user=request.user, status=PayInfo.SUCCESS).exists():
return True
return False
def post(self, request):
result = third_pay.withdraw(request)
# 短信通知添加用户名
user = request.user
try:
device = split_ua(request)
except:
device = {'device_type': 'pc'}
name = user.wanglibaouserprofile.name or u'用户'
if not result['ret_code']:
withdraw_submit_ok.apply_async(
kwargs={
"user_id": user.id,
"user_name": name,
"phone": request.user.wanglibaouserprofile.phone,
"amount": result['amount'],
"bank_name": result['bank_name'],
"order_id": result['order_id'],
"device": device
})
return Response(result)
def get(self, request):
device = utils.split_ua(request)
result = []
device_t = "mobile"
# if device['device_type'] == "ios":
# dic = Misc.objects.filter(key="ios_hide_banner_version").first()
# try:
# dataver = dic.value.split(",")
# appver = device['app_version']
# if appver in dataver:
# return Response({"ret_code": 1, "results": result})
# except Exception, e:
# pass
# elif device['device_type'] == "pc":
# device_t = "PC_2"
# device_t = "mobile"
# bans = Banner.objects.filter(device=device_t)
now = timezone.now()
bans = Banner.objects.filter(device=device_t, type='banner', is_used=True)\
.filter(Q(is_long_used=True) | Q(start_at__lt=now, end_at__gt=now)).order_by('-priority')[:3]
for x in bans:
obj = {
"id": x.id,
"image": str(x.image),
"link": x.link,
"name": x.name,
"priority": x.priority,
"type": x.type
}
if device_t == "mobile":
if not x.alt:
result.append(obj)
elif 'channel_id' in device and x.alt == device['channel_id']:
result.append(obj)
else:
result.append(obj)
return Response({"ret_code": 0, "results": result})
def bind_pay_dynnum(request):
""" 根据银行设置的支付渠道进行支付渠道的支付
1、确认支付功能
"""
logger.error(request.DATA)
user = request.user
order_id = request.DATA.get("order_id", "").strip()
token = request.DATA.get("token", "").strip()
vcode = request.DATA.get("vcode", "").strip()
input_phone = request.DATA.get("phone", "").strip()
set_the_one_card = request.DATA.get('set_the_one_card', '').strip()
device = split_ua(request)
ip = util.get_client_ip(request)
mode = request.DATA.get('mode', '').strip()
if not order_id.isdigit():
return {"ret_code": 20125, "message": "订单号错误"}
if not order_id or not token:
return {"ret_code": 20120, "message": "请重新获取验证码"}
pay_info = PayInfo.objects.filter(order_id=order_id).first()
if not pay_info or pay_info.status == PayInfo.SUCCESS:
return {"ret_code": 20121, "message": "订单不存在或已支付成功"}
card_no = pay_info.card_no
if len(card_no) == 10:
card = Card.objects.filter(user=user,
no__startswith=card_no[:6],
no__endswith=card_no[-4:]).first()
else:
card = Card.objects.filter(no=card_no, user=user).first()
if not card:
# res = {"ret_code": 20002, "message": "银行卡未绑定"}
channel = pay_info.channel
else:
channel = card.bank.channel
if channel == 'huifu':
res = {'ret_code': 20003, 'message': '汇付天下请选择快捷支付渠道'}
elif channel == 'yeepay':
res = YeeShortPay().dynnum_bind_pay(request)
elif channel == 'kuaipay':
res = KuaiShortPay().dynnum_bind_pay(user,
vcode,
order_id,
token,
input_phone,
device,
ip,
request,
mode=mode)
elif channel == 'baopay':
res = BaoPayInterface(user, ip,
device).dynnum_bind_pay(order_id, vcode, mode,
request)
else:
res = {"ret_code": 20004, "message": "请对银行绑定支付渠道"}
if not card:
# 宝付这个时候卡才生产，在调用dynnum_bind_pay之前是没卡的
card = Card.objects.get(no=pay_info.card_no)
if res.get('ret_code') == 0:
if set_the_one_card:
TheOneCard(request.user).set(card.id)
# # Modify by hb on 2015-12-24 : 如果ret_code返回非0, 还需进一步判断card是否有绑定记录, 因为有可能出现充值失败但绑卡成功的情况
# try:
# bind_flag = 0
# if (card.bank.channel == 'kuaipay' and res.get('ret_code') == 0) or (
# card.bank.channel == 'yeepay' and 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))
process_for_bind_card(user, card, res, request)
return res
def pre_pay(self, request):
""" 获取验证码支付还是直接支付
长卡号获取验证码
短卡号直接支付
"""
if not request.user.wanglibaouserprofile.id_is_valid:
return {"ret_code": 20111, "message": "请先进行实名认证"}
amount = request.DATA.get("amount", "").strip()
card_no = request.DATA.get("card_no", "").strip()
input_phone = request.DATA.get("phone", "").strip()
gate_id = request.DATA.get("gate_id", "").strip()
device_type = split_ua(request)['device_type']
if not amount or not card_no:
return {"ret_code": 20112, 'message': '信息输入不完整'}
if len(card_no) > 10 and (not input_phone or not gate_id):
return {"ret_code": 20113, 'message': '卡号格式不正确'}
try:
float(amount)
except:
return {"ret_code": 20114, 'message': '金额格式错误'}
amount = util.fmt_two_amount(amount)
# if amount < 10 or len(str(amount)) > 20:
# return {"ret_code": 20115, 'message': '充值须大于等于10元'}
if len(str(amount)) > 20:
return {"ret_code": 20115, 'message': '充值金额太大'}
if amount < 0.009:
# 涉及到小数精度，不能用0.01
return {"ret_code": 20115, 'message': '充值金额太小（至少0.01元）'}
user = request.user
profile = user.wanglibaouserprofile
card, bank = None, None
if gate_id:
bank = Bank.objects.filter(gate_id=gate_id).first()
if not bank or not bank.yee_bind_code.strip():
return {"ret_code": 201116, "message": "不支持该银行"}
if len(card_no) == 10:
card = Card.objects.filter(user=user, no__startswith=card_no[:6], no__endswith=card_no[-4:],
is_bind_yee=True).first()
else:
#card = Card.objects.filter(no=card_no, user=user).first()
card = Card.objects.filter(no=card_no, user=user, bank=bank).first()
pay_record = PayInfo.objects.filter(card_no=card_no, user=user, bank=bank)
if pay_record.filter(error_message__icontains='不匹配'):
return {"ret_code":200118, "message":"银行卡与银行不匹配"}
if not card:
card = self.add_card_unbind(user, card_no, bank, request)
if not card and not bank:
return {'ret_code': 200117, 'message': '卡号不存在或银行不存在'}
#if bank and card and bank != card.bank:
#return {"ret_code": 200118, "message": "银行卡与银行不匹配"}
# 商户生成的唯一绑卡请求号，最长50位
request_id = '{phone}{time}'.format(phone=profile.phone, time=timezone.now().strftime("%Y%m%d%H%M%S"))
if len(card_no) != 10:
# 未绑定银行卡，需要先绑定银行卡获取验证码，然后在确认支付
try:
# 请求绑定银行卡
res = self._bind_card_request(request, input_phone, card_no, request_id)
if res['ret_code'] != 0:
# 600326已绑定，600302绑卡数超限
if res['ret_code'] in ['600326', '600302']:
self.sync_bind_card(user)
return {'ret_code': '20119', 'message': '银行卡已绑定，请返回使用快捷充值'}
else:
# logger.error(res)
return res
except Exception, e:
logger.error(e.message)
return {"ret_code": "20120", "message": '绑定银行卡失败'}
def post(self, request):
user = request.user
days = request.POST.get('days', '').strip()
# days = request.GET.get('days', '').strip()
if not days or not days.isdigit():
return Response({'ret_code': -1, 'message': u'参数错误'})
days = int(days)
today = datetime.date.today()
# yesterday = (datetime.datetime.now() - datetime.timedelta(days=1)).date()
sign_record = UserDailyActionRecord.objects.filter(
user=user, create_date=today, action_type=u'sign_in').first()
if not sign_record or not sign_record.status:
return Response({'ret_code': -1, 'message': u'不符合领取条件'})
activities = SeriesActionActivity.objects.filter(
action_type=u'sign_in',
is_stopped=False,
start_at__lte=timezone.now(),
end_at__gte=timezone.now()).all()
current_activity = None
for activity in activities:
if activity.days == days:
current_activity = activity
if not current_activity:
return Response({'ret_code': -1, 'message': u'不符合领取条件'})
length = len(activities)
maxDayNote = activities[length - 1].days
if sign_record.continue_days < maxDayNote:
recycle_continue_days = sign_record.continue_days
elif sign_record.continue_days % maxDayNote == 0:
recycle_continue_days = maxDayNote
else:
recycle_continue_days = sign_record.continue_days % maxDayNote
# recycle_continue_days = sign_record.continue_days % (maxDayNote + 1)
if recycle_continue_days != days:
return Response({'ret_code': -1, 'message': u'不符合领取条件'})
reward_record, create = ActivityRewardRecord.objects.get_or_create(
activity_code=current_activity.code, create_date=today, user=user)
if reward_record.status:
return Response({'ret_code': -1, 'message': u'奖励已经领取过了'})
device = split_ua(self.request)
user_agent = request.META['HTTP_USER_AGENT']
is_weixin = False
if "MicroMessenger" in user_agent:
is_weixin = True
device_type = device['device_type']
events = []
records = []
experience_events = []
rewards = []
redpack_txts = []
redpack_record_ids = ""
experience_record_ids = ""
with transaction.atomic():
reward_record = ActivityRewardRecord.objects.select_for_update(
).filter(activity_code=current_activity.code,
create_date=today,
user=user).first()
if reward_record.status:
return Response({'ret_code': -1, 'message': u'奖励已经领取过了'})
rules = SeriesActionActivityRule.objects.filter(
activity=current_activity, is_used=True)
for rule in rules:
sub_redpack_record_ids, sub_experience_record_ids = self.giveReward(
user, rule, events, experience_events, records,
redpack_txts, device_type)
if isinstance(sub_redpack_record_ids, Response):
return sub_redpack_record_ids
if isinstance(sub_experience_record_ids, Response):
return sub_experience_record_ids
redpack_record_ids += sub_redpack_record_ids
experience_record_ids += sub_experience_record_ids
if rule.gift_type == "reward":
reward = None
reward_list = rule.reward.split(",")
for reward_type in reward_list:
now = timezone.now()
reward = Reward.objects.filter(
type=reward_type, is_used=False,
end_time__gte=now).first()
if reward:
break
if reward:
reward.is_used = True
reward.save()
# 记录奖品发放流水
description = '=>'.join([rule.rule_name, reward.type])
has_reward_record = _keep_reward_record(
user, reward, description)
reward_content = reward.content
end_date = timezone.localtime(
reward.end_time).strftime("%Y年%m月%d日")
name = reward.type
context = Context({
# 'mobile': safe_phone_str(user.wanglibaouserprofile.phone),
'reward': reward_content,
'end_date': end_date,
'name': name,
})
if has_reward_record:
rewards.append(reward)
redpack_txts.append(name)
if rule.msg_template:
msg = Template(rule.msg_template)
content = msg.render(context)
_send_message_template(user, rule.rule_name,
content)
else:
sub_redpack_record_ids, sub_experience_record_ids = self.giveReward(
user,
rule,
events,
experience_events,
records,
redpack_txts,
device_type,
is_addition=True)
if isinstance(sub_redpack_record_ids, Response):
return sub_redpack_record_ids
if isinstance(sub_experience_record_ids, Response):
return sub_experience_record_ids
redpack_record_ids += sub_redpack_record_ids
experience_record_ids += sub_experience_record_ids
reward_record.redpack_record_ids = redpack_record_ids
reward_record.experience_record_ids = experience_record_ids
reward_record.activity_code_time = timezone.now()
reward_record.status = True
reward_record.activity_desc = u'用户领取连续%s天签到奖励' % days
reward_record.save()
try:
w_user = WeixinUser.objects.filter(user=user).first()
for idx, event in enumerate(events):
record = records[idx]
start_time, end_time = get_start_end_time(
event.auto_extension, event.auto_extension_days,
record.created_at, event.available_at,
event.unavailable_at)
_send_message_for_hby(request.user, event, end_time)
if is_weixin and w_user:
sentCustomerMsg.apply_async(
kwargs={
"txt":
"恭喜您获得连续%s天签到奖励\n签到奖励：%s\n有效期至：%s\n快去我的账户－理财券页面查看吧！"
% (days, getattr(event, "desc_text", "优惠券"),
end_time.strftime('%Y年%m月%d日')), #\n兑换码:%s
"openid":
w_user.openid,
},
queue='celery02')
if is_weixin and w_user:
for reward in rewards:
sentCustomerMsg.apply_async(
kwargs={
"txt":
"恭喜您获得连续%s天签到奖励\n签到奖励：%s\n有效期至：%s\n兑换码：%s\n天天签到不要停，快去兑换吧！"
% (days, reward.type,
timezone.localtime(
reward.end_time).strftime("%Y年%m月%d日"),
reward.content), #\n兑换码:%s
"openid":
w_user.openid,
},
queue='celery02')
if is_weixin and w_user:
for experience_event in experience_events:
sentCustomerMsg.apply_async(kwargs={
"txt":
"恭喜您获得连续%s天签到奖励\n签到奖励：%s\n快去我的账户－体验金页面查看吧！" %
(days, getattr(experience_event, "desc_text", "体验金")),
"openid":
w_user.openid,
},
queue='celery02')
except Exception, e:
logger.debug(traceback.format_exc())
def bind_pay_deposit(request):
""" 根据银行设置的支付渠道进行支付渠道的支付
1、获取验证码
2、快捷支付功能
"""
logger.error(request.DATA)
card_no = request.DATA.get("card_no", "").strip()
gate_id = request.DATA.get("gate_id", "").strip()
input_phone = request.DATA.get("phone", "").strip()
device_type = split_ua(request)['device_type']
ip = util.get_client_ip(request)
mode = request.DATA.get('mode', '').strip()
user = request.user
if user.wanglibaouserprofile.utype == '3':
return {"ret_code": 30059, "message": u"企业用户无法请求该接口"}
if not user.wanglibaouserprofile.id_is_valid:
return {"ret_code": 20111, "message": "请先进行实名认证"}
if not card_no and not gate_id:
return {"ret_code": 20001, 'message': '信息输入不完整'}
if len(card_no) > 10 and (not input_phone or not gate_id):
return {"ret_code": 20112, 'message': '信息输入不完整'}
user_bind_cards = Card.objects.filter(
user=user).filter(Q(is_bind_kuai=True) | Q(is_bind_yee=True))
if len(card_no) > 10 and user_bind_cards.filter(no=card_no).count() == 0 and \
user_bind_cards.filter(~Q(no=card_no)).count() > 0:
# 只允许绑一张
return {"ret_code": 20113, 'message': '为确保账户安全，资金同卡进出，不能再绑卡'}
if gate_id:
bank = Bank.objects.filter(gate_id=gate_id).first()
else:
if len(card_no) == 10:
card = Card.objects.filter(user=user,
no__startswith=card_no[:6],
no__endswith=card_no[-4:]).first()
else:
card = Card.objects.filter(no=card_no, user=user).first()
if not card:
return {"ret_code": 20001, 'message': '信息输入不完整'}
bank = card.bank
if not bank:
return {"ret_code": 20002, "message": "银行ID不正确"}
#验证银行卡和银行匹配
if len(card_no) != 10 and bank.cards_info:
cardinfo = check_bank_carkinfo(card_no, bank)
#返回ret_code为20075的话表示银行卡和银行不匹配
if cardinfo['ret_code'] == 20075:
return cardinfo
amount = request.DATA.get('amount', '').strip()
try:
amount = float(amount)
amount = util.fmt_two_amount(amount)
if amount < 0:
raise ValueError()
except:
return {"ret_code": 20114, 'message': '金额格式错误'}
if bank.channel == 'huifu':
result = HuifuShortPay().pre_pay(request)
return result
elif bank.channel == 'yeepay':
result = YeeShortPay().pre_pay(request)
return result
elif bank.channel == 'baopay':
res = BaoPayInterface(user, ip,
device_type).pre_pay(card_no, amount,
input_phone, gate_id,
request)
return res
elif bank.channel == 'kuaipay':
stop_no_sms_channel = Misc.objects.filter(
key='kuai_qpay_stop_no_sms_channel').first()
if stop_no_sms_channel and stop_no_sms_channel.value == '1' and \
len(card_no) == 10 and not request.DATA.get('mode'):
# mode != vcode_for_qpay
# Modify by hb on 2016-04-28
#return {'ret_code': 201183,
return {'ret_code': 201181, 'message': u'该银行支付升级，请更新App版本'}
result = KuaiShortPay().pre_pay(user,
amount,
card_no,
input_phone,
gate_id,
device_type,
ip,
request,
mode=mode)
return result
else:
return {"ret_code": 20004, "message": "请选择支付渠道"}
if params['status'] == 1:
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
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 = 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": orderId})
except:
pass
OrderHelper.update_order(pay_info.order, pay_info.user, pay_info=model_to_dict(pay_info), status=pay_info.status)
return rs
def pre_pay(self, request):
self.app_pay(request)
class YeeShortPay:
""" 易宝快捷支付 """
def post(self, request):
user = request.user
now = timezone.now()
start_dt = local_to_utc(datetime(2016, 6, 7), 'min')
user_joined = user.date_joined # 用户注册时间
device = split_ua(request)
device_type = decide_device(device['device_type'])
purchase_code = 'experience_purchase'
experience_product = ExperienceProduct.objects.filter(
isvalid=True).first()
if not experience_product:
return Response({'ret_code': 30001, 'message': u'体验标有误,请重试'})
total_amount = 0
total_amount_tmp = 0
# 查询用户符合条件的理财金记录
with transaction.atomic(savepoint=True):
# 锁表,主要用来锁定体验金投资时的动作
purchase_lock_record = ExperiencePurchaseLockRecord.objects.select_for_update().\
filter(user=user, purchase_code=purchase_code).first()
if not purchase_lock_record:
# 没有记录时创建一条
try:
purchase_lock_record = ExperiencePurchaseLockRecord.objects.create(
user=user,
purchase_code=purchase_code,
purchase_times=0)
except Exception:
logger.exception(
"Error: experience purchase err, user: %s, phone: %s" %
(user.id, user.wanglibaouserprofile.phone))
return Response({
'ret_code': 30003,
'message': u'体验金投资失败,请重试'
})
experience_record = ExperienceEventRecord.objects.filter(user=user, apply=False) \
.filter(event__invalid=False, event__available_at__lt=now, event__unavailable_at__gt=now)\
.select_related('event')
records_ids = ''
if experience_record:
catalog = u'购买体验标'
for i in experience_record:
total_amount_tmp += i.event.amount
buy_p2p = P2PRecord.objects.filter(user_id=user.id).exists()
buy_count = MarginRecord.objects.filter(
user_id=user.id, catalog=catalog).count()
if not buy_p2p:
if user_joined > start_dt:
# 如果查询到已经购买过至少 1 次体验标,则不再检测账户余额
if buy_count == 0:
if total_amount_tmp >= 28888 and user.margin.margin < 1:
return Response({
'ret_code': 30009,
'message': u'账户余额不足,请先充值'
})
for record in experience_record:
event = record.event
total_amount += event.amount
records_ids += str(record.id) + ','
record.apply = True
record.apply_amount = event.amount
record.apply_at = timezone.now()
record.apply_platform = device_type
record.save()
terms = get_amortization_plan(u'日计息一次性还本付息').generate(
total_amount,
experience_product.expected_earning_rate / 100.0,
timezone.now(), experience_product.period)
for index, term in enumerate(terms['terms']):
amortization = ExperienceAmortization()
amortization.product = experience_product
amortization.user = user
amortization.principal = term[1] # 本金
amortization.interest = term[2] # 利息
amortization.term = index + 1 # 期数
amortization.description = u'第%d期' % (index + 1)
amortization.term_date = term[6] - timedelta(days=1)
amortization.save()
# 从账户中扣除 1 元 (没有购买过体验标的情况)
if not buy_p2p:
if user_joined > start_dt:
if total_amount >= 28888 and buy_count == 0:
amount = 1.00
order_id = OrderHelper.place_order(
user, order_type=catalog, status=u'新建').id
margin_keeper = MarginKeeper(user=user,
order_id=order_id)
margin_keeper.reduce_margin_common(
amount, catalog=catalog, description=catalog)
# 更新当前的一组流水id
purchase_lock_record.purchase_times += 1
purchase_lock_record.description = records_ids
purchase_lock_record.save()
term_date = amortization.term_date
interest = amortization.interest
return Response({
'ret_code': 0,
'data': {
'amount': total_amount,
'term_date': term_date.strftime("%Y-%m-%d"),
'interest': interest
}
})
else:
return Response({
'ret_code': 30002,
'message': u'没有体验金记录,无法购买体验标'
})
def post(self, request, *args, **kwargs):
#result, message = verify_captcha(request.POST)
#if not result:
# return self.render_to_response({
# 'result': message
# })
user = request.user
if not user.wanglibaouserprofile.id_is_valid:
return self.render_to_response({'result': u'请先进行实名认证'})
if user.wanglibaouserprofile.frozen:
return self.render_to_response(
{'result': u'账户已冻结!请联系网利宝客服:4008-588-066'})
phone = user.wanglibaouserprofile.phone
code = request.POST.get('validate_code', '')
status, message = validate_validation_code(phone, code)
if status != 200:
return self.render_to_response({
# Modify by hb on 2015-12-02
#'result': u'短信验证码输入错误'
'result': message
})
result = PayResult.WITHDRAW_SUCCESS
try:
card_id = request.POST.get('card_id', '')
card = Card.objects.get(pk=card_id, user=user)
card_no = card.no
# 检测银行卡是否在黑名单中
black_list = BlackListCard.objects.filter(card_no=card_no).first()
if black_list and black_list.user != user:
raise AbnormalCardException
# 检查白名单
white_list = WhiteListCard.objects.filter(user=user,
card_no=card_no).first()
if not white_list:
# 增加银行卡号检测功能,检测多张卡
card_count = Card.objects.filter(no=card_no).count()
if card_count > 1:
raise ManyCardException
# 检测银行卡在以前的提现记录中是否为同一个用户
payinfo_record = PayInfo.objects.filter(
card_no=card_no).order_by('-create_time').first()
if payinfo_record:
if payinfo_record.user != user:
raise AbnormalCardException
amount_str = request.POST.get('amount', '')
amount = decimal.Decimal(amount_str). \
quantize(TWO_PLACES, context=decimal.Context(traps=[decimal.Inexact]))
margin = user.margin.margin # 账户余额
uninvested = user.margin.uninvested # 充值未投资金额
# 获取费率配置
fee_misc = WithdrawFee()
fee_config = fee_misc.get_withdraw_fee_config()
# 计算提现费用 手续费 + 资金管理费
# 提现最大最小金额判断
if amount > fee_config.get('max_amount') or amount <= 0:
raise decimal.DecimalException
if amount < fee_config.get('min_amount'):
if amount != margin:
raise decimal.DecimalException
# 获取计算后的费率
fee, management_fee, management_amount = fee_misc.get_withdraw_fee(
user, amount, margin, uninvested)
actual_amount = amount - fee - management_fee # 实际到账金额
if actual_amount <= 0:
raise decimal.DecimalException
# 检测个别银行的单笔提现限额,如民生银行
bank_limit = util.handle_withdraw_limit(card.bank.withdraw_limit)
bank_max_amount = bank_limit.get('bank_max_amount', 0)
if bank_max_amount:
if amount > bank_max_amount:
raise decimal.DecimalException
pay_info = PayInfo()
pay_info.amount = actual_amount
pay_info.fee = fee
pay_info.management_fee = management_fee
pay_info.management_amount = management_amount
pay_info.total_amount = amount
pay_info.type = PayInfo.WITHDRAW
pay_info.user = user
pay_info.card_no = card.no
pay_info.account_name = user.wanglibaouserprofile.name
pay_info.bank = card.bank
pay_info.request_ip = get_client_ip(request)
pay_info.status = PayInfo.ACCEPTED
order = OrderHelper.place_order(user,
Order.WITHDRAW_ORDER,
pay_info.status,
pay_info=model_to_dict(pay_info))
pay_info.order = order
keeper = MarginKeeper(user, pay_info.order.pk)
margin_record = keeper.withdraw_pre_freeze(
amount, uninvested=management_amount)
pay_info.margin_record = margin_record
pay_info.save()
try:
device = split_ua(request)
except:
device = {'device_type': 'pc'}
name = user.wanglibaouserprofile.name or u'用户'
withdraw_submit_ok.apply_async(
kwargs={
"user_id": user.id,
"user_name": name,
"phone": user.wanglibaouserprofile.phone,
"amount": amount,
"bank_name": card.bank.name,
"order_id": order.id,
"device": device
})
except decimal.DecimalException:
result = u'提款金额在0～{}之间'.format(fee_config.get('max_amount'))
except Card.DoesNotExist:
result = u'请选择有效的银行卡'
except ManyCardException:
result = u'银行卡号存在重复，请尝试其他银行卡号码，如非本人操作请联系客服'
except AbnormalCardException:
result = u'银行卡号与身份信息存在异常, 如非本人操作请联系客服'
except MarginLack as e:
result = u'余额不足'
pay_info.error_message = str(e)
pay_info.status = PayInfo.FAIL
pay_info.save()
# return self.render_to_response({
# 'result': result
# })
return HttpResponseRedirect(
reverse('withdraw-complete-result', kwargs={'result': result}))
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 post(self, request):
size = request.DATA.get('size', '').strip()
device = split_ua(request)
device_type = device['device_type']
if not device_type or not size:
return Response({'ret_code': 20001, 'message': u'信息输入不完整'})
if device_type not in ('ios', 'android') or int(size) not in (
x for x in range(1, 9)):
return Response({'ret_code': 20002, 'message': u'参数不合法'})
if int(size) in (x for x in range(5, 9)):
size = str(int(size) - 4)
if device_type == 'ios': device_type = 'act_iso'
if device_type == 'android': device_type = 'act_android'
size = self.SIZE_MAP[size]
activate_query = AppActivate.objects.filter(
Q(is_used=True), Q(device=self.DEVICE_MAP[device_type]))
activate = activate_query.filter(
Q(is_long_used=False) & Q(start_at__lte=timezone.now())
& Q(end_at__gte=timezone.now())).order_by('-priority').first()
if not activate:
activate = activate_query.filter(
Q(is_long_used=True)).order_by('-priority').first()
# activate = AppActivate.objects.filter(Q(is_used=True), Q(device=self.DEVICE_MAP[device_type]), Q(is_long_used=True) | (Q(is_long_used=False) & Q(start_at__lte=timezone.now()) & Q(end_at__gte=timezone.now()))).first()
if activate:
if size == 'img_one':
img_url = activate.img_one
elif size == 'img_two':
img_url = activate.img_two
elif size == 'img_three':
img_url = activate.img_three
elif size == 'img_four':
img_url = activate.img_four
else:
img_url = ''
jump_state = activate.jump_state
link_dest = activate.link_dest
if img_url:
if self.DEVICE_MAP[device_type] in ("act_iso", 'act_android'):
if request.user.is_authenticated():
invest_flag = P2PRecord.objects.filter(
user=request.user, catalog='申购').exists()
if activate.user_invest_limit == '-1' or (
activate.user_invest_limit == '0' and
not invest_flag) or (activate.user_invest_limit
== '1' and invest_flag):
img_url = '{host}/media/{url}'.format(
host=settings.CALLBACK_HOST, url=img_url)
return Response({
'ret_code':
0,
'message':
'ok',
'image':
img_url,
'jump_state':
jump_state,
'link_dest':
link_dest,
'link_dest_url':
activate.link_dest_h5_url,
})
else:
img_url = '{host}/media/{url}'.format(
host=settings.CALLBACK_HOST, url=img_url)
return Response({
'ret_code': 0,
'message': 'ok',
'image': img_url,
'jump_state': jump_state,
'link_dest': link_dest,
'link_dest_url': activate.link_dest_h5_url,
})
return Response({'ret_code': 20003, 'message': 'fail'})
def pre_pay(self, request, bank=None):
""" 汇付天下直接进行邦卡支付，不能够获取验证码 """
if not request.user.wanglibaouserprofile.id_is_valid:
return {"ret_code": 20111, "message": "请先进行实名认证"}
amount = request.DATA.get("amount", "").strip()
card_no = request.DATA.get("card_no", "").strip()
input_phone = request.DATA.get("phone", "").strip()
gate_id = request.DATA.get("gate_id", "").strip()
if not amount or not card_no or not gate_id:
return {"ret_code": 20112, 'message': '信息输入不完整'}
if len(card_no) > 10 and not input_phone:
return {"ret_code": 20112, 'message': '信息输入不完整'}
if card_no and len(card_no) == 10:
return {'ret_code': 20013, 'message': '卡号格式不正确'}
try:
float(amount)
except:
return {"ret_code": 20114, 'message': '金额格式错误'}
amount = fmt_two_amount(amount)
user = request.user
profile = user.wanglibaouserprofile
bank = Bank.objects.filter(gate_id=gate_id).first()
if not bank or not bank.huifu_bind_code.strip():
return {"ret_code": 201151, "message": "不支持该银行"}
if len(card_no) == 10:
card = Card.objects.filter(user=user, no__startswith=card_no[:6], no__endswith=card_no[-4:]).first()
card_no = card.no
else:
card = Card.objects.filter(no=card_no, user=user).first()
if not card:
card = self.bind_card_wlbk(user, card_no, bank, request)
if not card:
return {"ret_code": -1, "message": '银行卡不存在'}
if bank and card and bank != card.bank:
return {"ret_code": 201153, "message": "银行卡与银行不匹配"}
if card and not card.is_bind_huifu:
res = self.open_bind_card(user, bank, card)
if res['ret_code'] != 0:
return res
card.is_bind_huifu = True
card.save()
try:
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 = user
pay_info.channel = "huifu_bind"
pay_info.request_ip = get_client_ip(request)
order = OrderHelper.place_order(user, Order.PAY_ORDER, pay_info.status, pay_info=model_to_dict(pay_info))
pay_info.order = order
if card:
pay_info.bank = card.bank
pay_info.card_no = card.no
else:
pay_info.bank = bank
pay_info.card_no = card_no
pay_info.status = PayInfo.PROCESSING
pay_info.account_name = profile.name
pay_info.save()
OrderHelper.update_order(order, user, pay_info=model_to_dict(pay_info), status=pay_info.status)
# 充值
req, res = self._card_pay_huifu(user=user, amount=pay_info.amount, card_no=card_no)
pay_info.error_code = res['RespCode']
pay_info.error_message = res['ErrMsg']
pay_info.request = req
pay_info.response = res
pay_info.response_ip = get_client_ip(request)
if res['RespCode'] != u'000000':
pay_info.save()
return {"ret_code": -3, "message": res['ErrMsg']}
else:
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()
rs = {"ret_code": 0, "message": "success", "amount": amount, "margin": margin_record.margin_current}
if rs['ret_code'] == 0:
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": order.id})
except:
pass
# 充值成功后，更新本次银行使用的时间
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
except Exception, 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)
return {"ret_code": "20119", "message": message}
def post(self, request):
amount = request.DATA.get("amount", "")
bank_id = request.DATA.get("bank_id", "")
card_id = request.DATA.get("card_id", "")
device = rest_utils.split_ua(request)
device_type = rest_utils.decide_device(device['device_type'])
try:
app_version = device['app_version']
except KeyError:
app_version = ''
if not amount:
return Response({"ret_code": 30131, "message": u"请输入金额"})
if device_type == 'pc':
if not card_id:
return Response({"ret_code": 30141, "message": u"银行卡选择错误"})
else:
if not bank_id:
if device_type == 'ios' or device_type == 'android':
if app_version and app_version < "2.6.3":
pass
else:
return Response({
"ret_code": 30137,
"message": u"银行卡选择错误"
})
try:
float(amount)
except:
return Response({"ret_code": 30132, 'message': u'金额格式错误'})
if amount <= 0:
return Response({"ret_code": 30131, "message": u"请输入金额"})
amount = util.fmt_two_amount(amount)
# 计算提现费用 手续费 + 资金管理费
user = request.user
margin = user.margin.margin # 账户余额
uninvested = user.margin.uninvested # 充值未投资金额
if amount > margin:
return Response({"ret_code": 30139, "message": u"提现金额超出账户可用余额"})
# 获取费率配置
fee_misc = WithdrawFee()
fee_config = fee_misc.get_withdraw_fee_config()
# 检测提现最大最小金额
max_amount = fee_config.get('max_amount')
min_amount = fee_config.get('min_amount')
if amount > max_amount:
return Response({"ret_code": 30133, 'message': u'提现金额超出最大提现限额'})
if amount < min_amount:
if margin > min_amount:
return Response({
"ret_code": 30134,
'message': u'提现金额必须大于{}元'.format(min_amount)
})
else:
if amount != margin:
return Response({
"ret_code":
30138,
'message':
u'账户余额小于{}元时须一次性提完'.format(min_amount)
})
# 检测银行的单笔最大提现限额,如民生银行
withdraw_limit = ''
if bank_id and card_id:
bank = Bank.objects.filter(code=bank_id.upper()).first()
try:
card = Card.objects.get(pk=card_id)
except Card.DoesNotExist:
card = None
if bank.id != card.bank.id:
return Response({"ret_code": 30140, 'message': u'银行选择错误'})
else:
if card:
withdraw_limit = card.bank.withdraw_limit
elif bank and bank.withdraw_limit:
withdraw_limit = bank.withdraw_limit
elif card_id and not bank_id:
try:
card = Card.objects.get(pk=card_id)
withdraw_limit = card.bank.withdraw_limit
except Card.DoesNotExist:
pass
elif bank_id and not card_id:
bank = Bank.objects.filter(code=bank_id.upper()).first()
if bank and bank.withdraw_limit:
withdraw_limit = bank.withdraw_limit
if withdraw_limit:
bank_limit = util.handle_withdraw_limit(withdraw_limit)
bank_max_amount = bank_limit.get('bank_max_amount', 0)
if bank_max_amount:
if amount > bank_max_amount:
return Response({
"ret_code": 30135,
'message': u'提现金额超出银行最大提现限额'
})
# 获取计算后的费率
fee, management_fee, management_amount = fee_misc.get_withdraw_fee(
user, amount, margin, uninvested)
actual_amount = amount - fee - management_fee # 实际到账金额
if actual_amount <= 0:
return Response({"ret_code": 30136, "message": u'余额不足，提现失败'})
if device_type == 'ios' or device_type == 'android':
if app_version and app_version < "2.6.3":
fee = fee + management_fee
return Response({
"ret_code": 0,
"actual_amount": actual_amount,
"fee": fee, # 手续费
"management_fee": management_fee, # 管理费
"management_amount": management_amount, # 计算管理费的金额
})
