def unbind_bankcard(user_id, bankcard_id):
try:
bankcard.unbind_bankcard(user_id, bankcard_id)
response.success()
except Exception as e:
logger.exception(e)
response.fail()
def preprepaid():
data = request.values
channel = request.channel
order_id = data.get('order_id')
to_user_id = data['to_user_id']
to_domain_name = data.get('to_domain_name')
amount = data['amount']
client_callback_url = data['callback_url']
client_notify_url = data['notify_url']
if not to_domain_name:
to_user_map = channel.get_user_map(to_user_id)
to_domain_name = channel.user_domain.name
else:
# 指定不同的to用户域
to_domain = get_user_domain_by_name(to_domain_name)
if to_domain is None:
return response.fail(
msg="domain [{0}] not exists.".format(to_domain_name))
to_user_map = to_domain.get_user_map(to_user_id)
if to_user_map is None:
return response.fail(
msg="to with domain [{0}] user [{1}] not exists.".format(
to_domain_name, to_user_id))
try:
prepaid_record = create_prepaid(channel, order_id,
to_user_map.account_user_id, amount,
client_callback_url, client_notify_url)
return prepaid_record.tx
except Exception as e:
logger.exception(e)
return response.fail(code=1, msg=e.message)
def prepay():
data = request.values
channel = request.channel
payer_user_id = data['payer_user_id']
payee_user_id = data['payee_user_id']
payee_domain_name = data.get('payee_domain_name')
order_id = data['order_id']
product_name = data['product_name']
product_category = data['product_category']
product_desc = data['product_desc']
amount = data['amount']
client_callback_url = data['callback_url']
client_notify_url = data['notify_url']
payment_type = data['payment_type']
# check
if payment_type not in [PaymentType.DIRECT, PaymentType.GUARANTEE]:
return response.fail(
msg="payment_type [{0}] not supported.".format(payment_type))
payer_user_map = channel.get_add_user_map(payer_user_id)
if not payee_domain_name:
# 默认payee用户域和payer是一致的
payee_user_map = channel.get_add_user_map(payee_user_id)
else:
# 指定不同的payee用户域
payee_domain = get_user_domain_by_name(payee_domain_name)
if payee_domain is None:
return response.fail(
msg="domain [{0}] not exists.".format(payee_domain_name))
payee_user_map = payee_domain.get_user_map(payee_user_id)
if payee_user_map is None:
return response.fail(
msg="payee with domain [{0}] user [{1}] not exists.".format(
payee_domain_name, payee_user_id))
try:
payment_record = pay.find_or_create_payment(
channel, payment_type, payer_user_map.account_user_id,
payee_user_map.account_user_id, order_id, product_name,
product_category, product_desc, amount, client_callback_url,
client_notify_url)
return payment_record.tx
except AlreadyPaidError as e:
logger.exception(e)
return response.fail(msg=e.message)
except Exception as e:
logger.exception(e)
return response.fail(code=1, msg=e.message)
def prepay_channel_order(order_channel, order_id):
"""超级支付接口"""
channel = get_channel_by_name(order_channel)
if channel is None:
return response.refused('bad channel: [{0}]'.format(order_channel))
try:
payment_record = pay.find_payment(channel, order_id)
return payment_record.tx
except AlreadyPaidError as e:
logger.exception(e)
return response.fail(msg=e.message)
except Exception as e:
logger.exception(e)
return response.fail(code=1, msg=e.message)
def prepare_params(tx, payment_scene, vas_name, extra_params=None):
from api_x.zyt.user_mapping.auth import vas_payment_is_enabled
from api_x.zyt.evas.payment import params
# TODO: log to db.
logger.info("[PAYMENT PARAMS] {0}, {1}, {2}, {3}, {4}".format(
payment_scene, vas_name, tx.type, tx.sn, extra_params))
if tx.state != PaymentTxState.CREATED:
return response.processed()
payment_entity = gen_payment_entity(tx)
if payment_entity is None:
return response.bad_request()
# 目前暂时用来控制zyt余额支付仅限于lvye_pay_site.
if not vas_payment_is_enabled(payment_entity, vas_name):
return response.refused(msg='[{0}] is not allowed for [{1}]'.format(
vas_name, tx.channel_name))
try:
payment_type, prepared_params = params.prepare(
payment_scene, vas_name, payment_entity, extra_params=extra_params)
return response.success(params=prepared_params,
vas_name=vas_name,
payment_type=payment_type)
except Exception as e:
logger.exception(e)
return response.fail(msg=e.message)
def draw_cheque(user_id):
data = request.values
channel = request.channel
order_id = data.get('order_id')
amount = data['amount']
valid_seconds = data.get('valid_seconds', 30)
cheque_type = data.get('cheque_type', ChequeType.INSTANT)
info = data.get('info', '')
client_notify_url = data.get('notify_url', '')
user_map = channel.get_user_map(user_id)
if user_map is None:
return response.bad_request(
msg='user not exists: [{0}]'.format(user_id))
from_id = user_map.account_user_id
try:
cheque_record = cheque.draw_cheque(channel, from_id, amount, order_id,
valid_seconds, cheque_type, info,
client_notify_url)
return response.success(sn=cheque_record.sn,
cash_token=cheque_record.cash_token,
amount=cheque_record.amount)
except Exception as e:
logger.exception(e)
return response.fail(code=1, msg=e.message)
def withdraw(user_id):
data = request.values
channel = request.channel
order_id = data.get('order_id')
bankcard_id = data['bankcard_id']
amount = data['amount']
client_notify_url = data.get('notify_url', '')
user_map = channel.get_user_map(user_id)
if user_map is None:
return response.bad_request(
msg='user not exists: [{0}]'.format(user_id))
from_user_id = user_map.account_user_id
try:
amount_value = Decimal(amount)
except Exception as e:
logger.error('bad amount value: [{0}]: {1}'.format(amount, e.message))
return response.bad_request(
msg='amount value error: [{0}]'.format(amount))
fee = calc_user_withdraw_fee(from_user_id, amount_value)
try:
bankcard = dba.query_bankcard_by_id(bankcard_id)
if bankcard is None:
return response.fail(
msg='bankcard not found: [{0}]'.format(bankcard_id))
if bankcard.user_id != from_user_id:
return response.fail(
msg='bankcard [{0}] is not bound to user [{1}]'.format(
bankcard_id, from_user_id))
withdraw_record = apply_to_withdraw(channel, order_id, from_user_id,
bankcard, amount_value, fee,
client_notify_url, data)
log_user_withdraw(from_user_id, withdraw_record.sn, bankcard_id,
withdraw_record.amount,
withdraw_record.actual_amount, withdraw_record.fee)
return response.success(sn=withdraw_record.sn,
actual_amount=withdraw_record.actual_amount,
fee=withdraw_record.fee)
except Exception as e:
logger.exception(e)
return response.fail(code=1, msg=e.message)
def wrapper(*args, **kwargs):
try:
params = {}
params.update(request.values.items())
params.update(request.view_args)
logger.info("[{0}] {1}: {2}".format(entry_path, request.url, params))
# check perm
channel_name = params.get('channel_name')
if channel_name is None:
return response.fail(msg='channel_name is needed.')
channel = get_channel_by_name(channel_name)
if channel is None:
msg = 'channel not exits: [{0}]'.format(channel_name)
return response.fail(msg=msg)
try:
_verify_channel_perm(channel, entry_path)
except EntryAuthError as e:
return response.refused(msg=e.message)
# verify sign
sign_type = params['sign_type']
# 这里的主要作用是验签, 只需要channel_pub_key或md5_key
try:
signer = Signer('key', 'sign', channel.md5_key, None, channel.public_key)
if not signer.verify(params, sign_type):
logger.warn('sign verify error: [{0}]'.format(params))
msg = 'sign error.'
return response.refused(msg=msg)
except Exception as e:
logger.exception(e)
msg = 'sign error.'
return response.refused(msg=msg)
except Exception as e:
logger.exception(e)
return response.bad_request(msg=e.message)
logger.info("[{0}] verify done.".format(entry_path))
request.__dict__['channel'] = channel
request.__dict__['params'] = params
return f(*args, **kwargs)
def cancel_cheque(user_id):
data = request.values
channel = request.channel
sn = data['sn']
user_map = channel.get_user_map(user_id)
if user_map is None:
return response.bad_request(
msg='user not exists: [{0}]'.format(user_id))
try:
cheque.cancel_cheque(channel, user_map.account_user_id, sn)
return response.success()
except Exception as e:
logger.exception(e)
return response.fail(code=1, msg=e.message)
def transfer(user_id):
data = request.values
channel = request.channel
to_user_domain_name = data['to_user_domain_name']
to_user_id = data['to_user_id']
order_id = data.get('order_id')
amount = data['amount']
info = data['info']
try:
tx = transfer_biz.apply_to_transfer(channel, order_id,
channel.user_domain.name, user_id,
to_user_domain_name, to_user_id,
amount, info)
return response.success(sn=tx.sn)
except Exception as e:
logger.exception(e)
return response.fail(code=1, msg=e.message)
def apply_to_refund():
data = request.params
channel = request.channel
order_id = data['order_id']
amount = data['amount']
client_notify_url = data['notify_url']
logger.info('receive refund: {0}'.format({k: v for k, v in data.items()}))
try:
refund_record = refund.apply_to_refund(channel,
order_id,
amount,
client_notify_url,
data=data)
return response.success(sn=refund_record.sn)
except Exception as e:
logger.exception(e)
return response.fail(code=1, msg=e.message)
def cash_cheque(user_id):
data = request.values
channel = request.channel
cash_token = data['cash_token']
user_map = channel.get_user_map(user_id)
if user_map is None:
return response.bad_request(
msg='user not exists: [{0}]'.format(user_id))
to_id = user_map.account_user_id
try:
cheque_record = cheque.cash_cheque(channel, to_id, cash_token)
return response.success(sn=cheque_record.sn,
amount=cheque_record.amount)
except Exception as e:
logger.exception(e)
return response.fail(code=1, msg=e.message)
def query_info(tx, payment_scene, extra_params=None):
from api_x.zyt.evas.payment import infos
# TODO: log to db.
logger.info("[PAYMENT INFO] {0}, {1}, {2}, {3}".format(
payment_scene, tx.type, tx.sn, extra_params))
payment_entity = gen_payment_entity(tx)
if payment_entity is None:
return response.bad_request()
try:
data, evases, vas_infos = infos.prepare(payment_scene,
payment_entity,
extra_params=extra_params)
return response.success(info=data,
activated_evas=evases,
vas_infos=vas_infos)
except Exception as e:
logger.exception(e)
return response.fail(msg=e.message)
def list_cheque(user_id):
data = request.values
channel = request.channel
user_map = channel.get_user_map(user_id)
if user_map is None:
return response.bad_request(
msg='user not exists: [{0}]'.format(user_id))
try:
cheque_records = cheque.list_cheque(channel, user_map.account_user_id)
return response.success(cheques=[{
'sn': cr.sn,
'info': cr.info,
'type': cr.type,
'amount': cr.amount,
'cash_token': cr.cash_token,
'expired_at': cr.expired_at,
'created_on': cr.created_on
} for cr in cheque_records])
except Exception as e:
logger.exception(e)
return response.fail(code=1, msg=e.message)
