def __change_balance(self, data: dict, result: int, balance_check: dict):
"""
修改
:param data:
:param result:
:param balance_check:
:return:
"""
# 修改余额
data = copy.deepcopy(data)
ref_id = OrderUtils.gen_unique_ref_id()
data['ref_id'] = ref_id
data['tx_id'] = OrderUtils.gen_normal_tx_id(data['uid'])
rst, msg = UserBalanceEvent.update_user_balance(**data)
self.assertEqual(result, rst)
# 验证余额
balance = UserBalance.query_balance(data['uid'],
data['merchant']).first()
self.assertIsNotNone(balance)
self.assertEqual(balance_check['balance_available'],
balance.real_balance)
if rst != 0:
# 更新失败，就不用验证结果事件了
return rst
event = UserBalanceEvent.query_event(
uid=data['uid'],
merchant=balance.merchant,
date=DateTimeKit.get_cur_datetime(),
ref_id=ref_id).first()
value = data['value']
if data['ad_type'] == BalanceAdjustTypeEnum.MINUS:
# 做减法
value = -data['value']
self.assertEqual(data['uid'], event.uid)
self.assertEqual(data['merchant'], event.merchant)
self.assertEqual(data['source'], event.source)
self.assertEqual(data['bl_type'], event.bl_type)
self.assertEqual(data['ad_type'], event.ad_type)
self.assertEqual(value, event.value_real)
self.assertEqual(ref_id, event.ref_id)
if data['source'] == OrderSourceEnum.MANUALLY:
self.assertEqual(data['comment'], event.comment)
return rst
def add_balance_to_user(cls, account, value, register=True):
user = User.query_user(cls.merchant, account=account)
if not user:
if not register:
return -10, "用户未注册"
user = User.register_account(cls.merchant,
account=account,
ac_type=AccountTypeEnum.MOBILE,
login_pwd=cls.password)
data = dict(
uid=user.uid,
merchant=cls.merchant,
ref_id=OrderUtils.gen_unique_ref_id(),
source=OrderSourceEnum.MANUALLY,
order_type=PayTypeEnum.MANUALLY,
bl_type=BalanceTypeEnum.AVAILABLE,
ad_type=BalanceAdjustTypeEnum.PLUS,
tx_id=OrderUtils.gen_normal_tx_id(user.uid),
value=Decimal(str(value)),
comment="手动脚本修改用户可用余额",
)
rst, msg = UserBalanceEvent.update_user_balance(**data)
# print(rst, msg)
return rst, msg
def query_balance_event(cls, uid, merchant, date, order_type: PayTypeEnum):
"""
查询转账列表
:param uid:
:param merchant:
:param order_type:
:param date:
:return:
"""
return UserBalanceEvent.query_event(uid=uid,
order_type=order_type,
merchant=merchant,
date=date).all()
def query_multi_order_type_event(cls, uid, merchant, date):
"""
查询转账列表
:param uid:
:param merchant:
:param date:
:return:
"""
order_types = [
PayTypeEnum.TRANSFER, PayTypeEnum.MANUALLY, PayTypeEnum.REFUND
]
return UserBalanceEvent.query_by_order_types(uid=uid,
order_types=order_types,
merchant=merchant,
date=date).all()
def __check_event_params_error(self, uid, merchant):
###########################################################
# 余额修改,参数错误
###########################################################
ref_id = hashlib.md5('lakjdflasjfadl;kfja'.encode('utf8')).hexdigest()
data = dict(
uid=uid,
merchant=merchant,
ref_id=ref_id,
source=OrderSourceEnum.TESTING,
order_type=PayTypeEnum.DEPOSIT,
bl_type=BalanceTypeEnum.AVAILABLE,
ad_type=BalanceAdjustTypeEnum.PLUS,
tx_id=OrderUtils.gen_normal_tx_id(uid),
value=Decimal("0"),
comment="xxx",
)
# value是0
rst, msg = UserBalanceEvent.update_user_balance(**data)
self.assertEqual(rst, -1)
# value是负数
data['value'] = Decimal("-100")
rst, msg = UserBalanceEvent.update_user_balance(**data)
self.assertEqual(rst, -1)
# 提款不能用加法
data['value'] = Decimal("100")
data['source'] = OrderSourceEnum.TESTING
data['order_type'] = PayTypeEnum.WITHDRAW
data['ad_type'] = BalanceAdjustTypeEnum.PLUS
rst, msg = UserBalanceEvent.update_user_balance(**data)
self.assertEqual(rst, -3)
# 充值不能用减法
data['source'] = OrderSourceEnum.TESTING
data['order_type'] = PayTypeEnum.DEPOSIT
data['ad_type'] = BalanceAdjustTypeEnum.MINUS
rst, msg = UserBalanceEvent.update_user_balance(**data)
self.assertEqual(rst, -3)
# 人工操作时，必填调整类型
data['source'] = OrderSourceEnum.MANUALLY
data.pop('ad_type')
rst, msg = UserBalanceEvent.update_user_balance(**data)
self.assertEqual(rst, -4)
# 人工操作时，必填调整备注信息
data['ad_type'] = BalanceAdjustTypeEnum.MINUS
data.pop('comment')
rst, msg = UserBalanceEvent.update_user_balance(**data)
self.assertEqual(rst, -4)
def create_one_transfer_order(cls):
"""
创建一个失败的订单，最后退款
:return:
"""
amount = Decimal("100")
client_ip = '127.0.0.1'
# 判断余额是否足够
user = cls.get_user()
user2 = cls.get_user2()
# 执行转账动作
flag, msg = UserBalanceEvent.transfer(from_user=user,
to_user=user2,
merchant=cls.merchant,
amount=amount,
comment="转账备注")
def init_user2(cls):
user = cls.get_user2()
if not user:
user = User.register_account(cls.merchant,
account=cls.user_account2,
ac_type=AccountTypeEnum.MOBILE,
login_pwd=cls.password)
data = dict(
uid=user.uid,
merchant=cls.merchant,
ref_id=OrderUtils.gen_unique_ref_id(),
source=OrderSourceEnum.MANUALLY,
order_type=PayTypeEnum.MANUALLY,
bl_type=BalanceTypeEnum.AVAILABLE,
ad_type=BalanceAdjustTypeEnum.PLUS,
tx_id=OrderUtils.gen_normal_tx_id(user.uid),
value=Decimal("500000000"),
comment="手动脚本修改用户可用余额",
)
rst, msg = UserBalanceEvent.update_user_balance(**data)
# print(rst, msg)
# 写入数据库
if not cls.get_bank_card():
bank_card = BankCard.add_bank_card(
user.merchant,
uid=user.uid,
bank_name=PaymentBankEnum.ZHONGGUO.desc,
bank_code=PaymentBankEnum.ZHONGGUO.bank_code,
card_no=cls.bank_card_no2,
account_name="王小儿",
branch="深圳支行",
province="广东省",
city="深圳市",
)
def get(self):
"""
查询用户余额变更流水
:return:
"""
if not request.args:
return ResponseSuccess(
message=
"参数规则：?merchant=test&account=8618912341234&date=20190901&export=1"
).as_response()
try:
account = request.args.get('account')
if account:
account = '+' + account.strip('+').strip()
if not PhoneNumberParser.is_valid_number(account):
raise
except:
return ResponseSuccess(
message="请输入正确的用户手机号码，必须有完整区号，不填+号，如：8613812349999"
).as_response()
try:
merchant = MerchantEnum.from_name(request.args['merchant'])
except:
return ResponseSuccess(message="请输入正确的商户名称，有效的商户名称包括：%s" %
MerchantEnum.get_names()).as_response()
try:
date = request.args.get('date')
if date:
date = DateTimeKit.str_to_datetime(
date, DateTimeFormatEnum.TIGHT_DAY_FORMAT, to_date=True)
else:
date = DateTimeKit.get_cur_date()
except:
return ResponseSuccess(
message="请输入有效的查询日期，格式为：20190901").as_response()
rst = dict(
data=list(),
sum_value=0,
)
events = UserBalanceEvent.query_by_date(date,
merchant=merchant,
date=date)
if account:
user = User.query_user(merchant, account=account)
if not user:
return ResponseSuccess(message="用户不存在，请检查参数。商户：%s，手机号码：%s" %
(merchant.name, account))
user_balance = UserBalance.query_balance(user.uid,
merchant).first()
rst.update(user=dict(
account=user.account,
uid=user.uid,
user_balance=str(user_balance.real_balance),
))
events = events.filter_by(uid=user.uid)
rst['sql'] = str(events)
for event in events:
rst['sum_value'] += event.value_real
rst['data'].append(
dict(
create_time=event.create_time,
uid=event.uid,
ref_id=event.ref_id,
order_type=event.order_type.desc,
source=event.source.desc,
bl_type=event.bl_type.desc,
value=str(event.value_real),
ad_type=event.ad_type.desc,
tx_id=event.tx_id, # 大整数，转为字符串
comment=event.comment,
extra=event.raw_extra,
))
rst['data'] = sorted(rst['data'],
key=lambda x: x['create_time'],
reverse=True)
for x in rst['data']:
x['create_time'] = DateTimeKit.datetime_to_str(x['create_time'])
if rst['data'] and request.args.get('export'):
filename = 'user_balance_events_%s.csv' % DateTimeKit.datetime_to_str(
date, DateTimeFormatEnum.TIGHT_DAY_FORMAT)
return CsvKit.send_csv(rst['data'],
filename=filename,
fields=rst['data'][0].keys())
rst['sum_value'] = str(rst['sum_value'])
return ResponseSuccess(bs_data=rst).as_response()
def __test_api_withdraw(self):
"""
后台准备数据：
充值通道数据
代付通道数据
商户费率配置数据
钱包端：
1. 创建充值订单
2. 充值
3. 用户设置支付密码
4. 用户绑定银行卡
5. 获取充值配置信息(用户余额，充值最低最高限制)
发起提现请求：
:return:
"""
merchant = MerchantEnum.from_name("TEST")
info = dict(merchant=merchant,
account="+8618988888888",
auth_code="8888",
password="******",
trade_pwd="b943a52cc24dcdd12bf2ba3afda92351",
ac_type=AccountTypeEnum.MOBILE)
user = User.register_account(info['merchant'], info['account'],
info['ac_type'], info['password'])
self.path = '/auth/account/login'
login_data = dict(number=info['account'], password=info['password'])
response = self.do_request(login_data)
self.assertEqual(ResponseSuccessLogin.code, response.status_code)
self.assertEqual(ResponseSuccessLogin.error_code,
response.json['error_code'])
self.token = response.json['data']['token']
self.path = "/withdraw/banks/list"
# 1. 向数据库添加代付通道信息
withdraw_item = dict(fee="2.5",
fee_type=PaymentFeeTypeEnum(1),
limit_per_min="200",
limit_per_max="5000",
limit_day_max="50000",
trade_begin_hour="00",
trade_begin_minute="00",
trade_end_hour="23",
trade_end_minute="59",
maintain_begin=DateTimeKit.str_to_datetime(
"2019-09-27 00:00:00",
DateTimeFormatEnum.SECONDS_FORMAT),
maintain_end=DateTimeKit.str_to_datetime(
"2019-10-20 23:59:00",
DateTimeFormatEnum.SECONDS_FORMAT),
state=ChannelStateEnum(10),
banks=[
PaymentBankEnum(1),
PaymentBankEnum(2),
PaymentBankEnum(4),
PaymentBankEnum(3),
PaymentBankEnum(15)
])
ProxyChannelConfig.update_channel(ChannelConfigEnum.CHANNEL_1001,
**withdraw_item)
# 2. 向数据库插入 商户费率配置信息
# 充值费率设置
merchant_fee_dict = []
merchant_fee_dict.append(
dict(
merchant=MerchantEnum.from_name('TEST'),
payment_way=PayTypeEnum.DEPOSIT,
value="3.5",
fee_type=PaymentFeeTypeEnum.PERCENT_PER_ORDER,
payment_method=PayMethodEnum.ZHIFUBAO_SAOMA,
))
# 提现费率
merchant_fee_dict.append(
dict(
merchant=MerchantEnum.from_name('TEST'),
payment_way=PayTypeEnum.WITHDRAW,
value="3.5",
fee_type=PaymentFeeTypeEnum.PERCENT_PER_ORDER,
))
rst, error = MerchantFeeConfig.update_fee_config(
merchant, merchant_fee_dict)
self.assertEqual(True, rst)
# 3. 给用户和商户充值
uid = user.uid
ref_id = hashlib.md5('lakjdflasjfadl;kfja'.encode('utf8')).hexdigest()
data = dict(
uid=uid,
merchant=merchant,
ref_id=ref_id,
source=OrderSourceEnum.TESTING,
order_type=PayTypeEnum.DEPOSIT,
bl_type=BalanceTypeEnum.AVAILABLE,
ad_type=BalanceAdjustTypeEnum.PLUS,
tx_id=OrderUtils.gen_normal_tx_id(uid),
value=Decimal("10000.00"),
comment="xxx",
)
rst, msg = UserBalanceEvent.update_user_balance(**data)
self.assertEqual(0, rst)
balance = UserBalance.query_balance(data['uid'],
data['merchant']).first()
# 添加商户余额
data = dict(
merchant=MerchantEnum.TEST,
source=OrderSourceEnum.TESTING,
order_type=PayTypeEnum.DEPOSIT,
bl_type=BalanceTypeEnum.AVAILABLE,
ad_type=BalanceAdjustTypeEnum.PLUS,
tx_id=OrderUtils.gen_normal_tx_id(100),
value=Decimal("10000.00"),
comment=msg,
)
ref_id = hashlib.md5(
RandomString.gen_random_str(
length=128).encode('utf8')).hexdigest()
data['ref_id'] = ref_id
event_check = dict(total=1)
event_check.update(data)
rst, msg = MerchantBalanceEvent.update_balance(**data)
self.assertEqual(0, rst)
# 设置支付密码
flag = User.set_payment_password(merchant,
uid=uid,
trade_pwd=info["trade_pwd"])
self.assertEqual(True, flag)
# 绑定银行卡
bank_info = {
"payment_password": info['trade_pwd'],
"bank_name": "中国工商银行",
"bank_code": "ICBC",
"card_no": "6212260405014627955",
"account_name": "张三",
"branch": "广东东莞东莞市长安镇支行",
"province": "广东省",
"city": "东莞市"
}
flag = BankCard.add_bank_card(merchant,
uid=uid,
bank_name=bank_info['bank_name'],
bank_code=bank_info['bank_code'],
card_no=bank_info['card_no'],
account_name=bank_info['account_name'],
branch=bank_info['branch'],
province=bank_info['province'],
city=bank_info['city'])
self.assertEqual(bank_info['card_no'], flag.card_no)
self.path = "/withdraw/limit/config/get"
response = self.do_request()
self.assertEqual(ResponseBankWithdraw.code, response.status_code)
self.assertEqual(ResponseBankWithdraw.error_code,
response.json['error_code'])
self.assertEqual("10000", response.json['data']['balance'])
self.assertEqual("200", response.json['data']['limit_min'])
self.assertEqual("5000", response.json['data']['limit_max'])
self.path = "/withdraw/order/create"
create_data = dict(amount=1000.001,
user_bank=1,
trade_password=info['trade_pwd'])
# 测试小于 最低限额
create_data['amount'] = 100
response = self.do_request(json_data=create_data)
self.assertEqual(WithdrawOrderAmountInvalidError.code,
response.status_code)
self.assertEqual(WithdrawOrderAmountInvalidError.error_code,
response.json['error_code'])
create_data['amount'] = 6000
response = self.do_request(json_data=create_data)
self.assertEqual(WithdrawOrderAmountInvalidError.code,
response.status_code)
self.assertEqual(WithdrawOrderAmountInvalidError.error_code,
response.json['error_code'])
create_data['amount'] = str(500.56)
create_data['user_bank'] = 100
response = self.do_request(json_data=create_data)
self.assertEqual(WithdrawBankNoExistError.code, response.status_code)
self.assertEqual(WithdrawBankNoExistError.error_code,
response.json['error_code'], response.json['message'])
use_balance = UserBalance.query_balance(user.uid, merchant).first()
ori_merchant = MerchantInfo.query_merchant(merchant)
balance = ori_merchant.bl_ava - BalanceKit.round_4down_5up(
Decimal(create_data['amount'])) * 100 - BalanceKit.round_4down_5up(
Decimal(create_data['amount']) * Decimal(3.5))
merchant_balance = BalanceKit.round_4down_5up(
balance / Decimal(100)) * 100
u_balance = BalanceKit.round_4down_5up(
Decimal(use_balance.balance) / Decimal(100) -
Decimal(create_data['amount'])) * Decimal(100)
create_data['user_bank'] = 1
response = self.do_request(json_data=create_data)
self.assertEqual(ResponseSuccess.code, response.status_code)
self.assertEqual(ResponseSuccess.error_code,
response.json['error_code'])
cur_balance = UserBalance.query_balance(user.uid, merchant).first()
cur_merchant = MerchantInfo.query_merchant(merchant)
self.assertEqual(int(merchant_balance), int(cur_merchant.bl_ava))
self.assertEqual(int(u_balance), int(cur_balance.balance))
def order_create(cls,
user,
amount,
client_ip,
user_bank_id=None,
bank_info=None,
notify_url=None,
mch_tx_id=None,
extra=None):
"""
申请创建订单
:return:
"""
params = copy.deepcopy(locals())
params.pop('cls')
order = None
if not bank_info:
card_entry = BankCard.query_bankcard_by_id(card_id=user_bank_id)
if not card_entry:
msg = '%s, params: %s' % (WithdrawBankNoExistError.message,
params)
current_app.logger.error(msg)
return order, WithdrawBankNoExistError()
# 判断 金额是否在有效范围 获取代付系统当前最高最低交易金额
# limit_min, limit_max = ChannelLimitCacheCtl(PayTypeEnum.WITHDRAW).get_channel_limit()
# if amount < limit_min or amount > limit_max:
if ChannelListHelper.is_amount_out_of_range(
amount=amount,
merchant=user.merchant,
payment_way=PayTypeEnum.WITHDRAW,
client_ip=client_ip):
msg = '%s, params: %s' % (WithdrawOrderAmountInvalidError.message,
params)
current_app.logger.error(msg)
return order, WithdrawOrderAmountInvalidError()
# 商户配置信息
merchant_config = MerchantFeeConfig.query_latest_one(query_fields=dict(
merchant=user.merchant,
payment_way=PayTypeEnum.WITHDRAW,
))
# 手续费计算
fee_value = FeeCalculator.calc_fee(amount, merchant_config.fee_type,
merchant_config.value)
user_fee = merchant_fee = 0
if merchant_config.cost_type == CostTypeEnum.MERCHANT:
merchant_fee = fee_value
elif merchant_config.cost_type == CostTypeEnum.USER:
user_fee = fee_value
# 用户实际到账金额要减去手续费
amount -= user_fee
# 用户余额判断
if user.uid:
user_balance = UserBalance.query_balance(
uid=user.uid, merchant=user.merchant).first()
if user_balance.real_balance < amount + user_fee:
msg = '%s, params: %s' % ("用户余额不足", params)
current_app.logger.error(msg)
return order, AccountBalanceInsufficientError(message="用户余额不足")
# 判断商户余额是否充足
merchant_balance = MerchantInfo.query_merchant(m_name=user.merchant)
if merchant_balance.balance_available <= amount + merchant_fee:
msg = '%s, params: %s' % ("商户余额不足", params)
current_app.logger.error(msg)
return order, AccountBalanceInsufficientError(message="商户余额不足")
# 订单来源
source = OrderSourceEnum.TESTING if user.is_test_user else OrderSourceEnum.ONLINE
try:
# 创建提现订单/扣商户余额/扣用户余额，在同一个事务里面
with db.auto_commit():
order, ref_id = OrderCreateCtl.create_order_event(
uid=user.uid,
amount=amount,
merchant=user.merchant,
source=source,
order_type=PayTypeEnum.WITHDRAW,
in_type=InterfaceTypeEnum.CASHIER_H5,
bank_id=user_bank_id, # 提现时需要填入 银行卡信息
mch_fee_id=merchant_config.config_id,
mch_tx_id=mch_tx_id,
ip=client_ip,
fee=fee_value,
cost_type=merchant_config.cost_type,
notify_url=notify_url,
bank_info=bank_info,
extra=extra,
commit=False,
)
if not order:
msg = '%s, params: %s' % (WithdrawOrderCreateError.message,
params)
current_app.logger.error(msg)
raise WithdrawOrderCreateError()
# 扣提现金额
flag, msg = MerchantBalanceEvent.update_balance(
merchant=user.merchant,
ref_id=ref_id,
source=source,
order_type=PayTypeEnum.WITHDRAW,
bl_type=BalanceTypeEnum.AVAILABLE,
value=amount,
ad_type=BalanceAdjustTypeEnum.MINUS,
tx_id=order.sys_tx_id,
commit=False,
)
if flag < 0:
msg = '%s, params: %s' % ("扣商户余额失败, %s" % msg, params)
current_app.logger.error(msg)
raise DepositCallbackUserBalanceError(message="扣商户余额失败")
if merchant_fee:
# 扣商户手续费
flag, msg = MerchantBalanceEvent.update_balance(
merchant=user.merchant,
ref_id=OrderUtils.gen_unique_ref_id(),
source=source,
order_type=PayTypeEnum.FEE,
bl_type=BalanceTypeEnum.AVAILABLE,
value=merchant_fee,
ad_type=BalanceAdjustTypeEnum.MINUS,
tx_id=order.sys_tx_id,
commit=False,
)
if flag < 0:
msg = '%s, params: %s' % ("扣商户手续费失败, %s" % msg, params)
current_app.logger.error(msg)
raise DepositCallbackUserBalanceError(
message="扣商户手续费失败")
if user_fee:
# 扣除用户手续费
flag, msg = UserBalanceEvent.update_user_balance(
uid=user.uid,
merchant=user.merchant,
ref_id=OrderUtils.gen_unique_ref_id(),
source=source,
order_type=PayTypeEnum.FEE,
bl_type=BalanceTypeEnum.AVAILABLE,
value=user_fee,
ad_type=BalanceAdjustTypeEnum.MINUS,
tx_id=order.sys_tx_id,
commit=False,
)
if flag < 0:
msg = '%s, params: %s' % ("扣用户手续费失败, %s" % msg, params)
current_app.logger.error(msg)
raise DepositCallbackUserBalanceError(
message="扣用户手续费失败")
# 扣除用户余额
flag, msg = UserBalanceEvent.update_user_balance(
uid=user.uid,
merchant=user.merchant,
ref_id=ref_id,
source=source,
order_type=PayTypeEnum.WITHDRAW,
bl_type=BalanceTypeEnum.AVAILABLE,
value=amount,
ad_type=BalanceAdjustTypeEnum.MINUS,
tx_id=order.sys_tx_id,
commit=False,
)
if flag < 0:
msg = '%s, params: %s' % ("扣用户余额失败, %s" % msg, params)
current_app.logger.error(msg)
raise DepositCallbackUserBalanceError(message="扣用户余额失败")
except APIException as e:
current_app.logger.error(traceback.format_exc())
return order, e
return order, None
def manually_withdraw_failed(cls, admin_user, merchant, order_id):
"""
手动更新提款状态为失败
退款/审核拒绝
流程：
1. 获取创建订单时 扣除 用户及商户的费用
获取订单 withdrawOrderDetail 数据， 获取 手续费 提现金额
2. 给用户和商户新增费用
更新 UserBalance 表
更新 MerchantBalance表
3. 修改订单状态
更新 OrderUpdateCtl
:param admin_user:
:param merchant:
:param order_id:
:return:
"""
# 查询该笔订单是否存在
withdraw_entry = OrderWithdraw.query_by_order_id(merchant=merchant,
order_id=order_id)
# 判断是否存在
if not withdraw_entry:
return OrderInfoMissingError()
# 判断订单状态是否为 已认领 或 提现成功
if withdraw_entry.state not in [
OrderStateEnum.ALLOC, OrderStateEnum.SUCCESS
]:
return BankOrderStateError()
detail = OrderDetailWithdraw.query_by_order_id(
order_id=withdraw_entry.order_id,
merchant=merchant,
create_time=withdraw_entry.create_time)
if not detail:
return NosuchOrderDetailDataError()
# 提现订单 手续费 提现订单费用
fee = detail.fee
amount = detail.amount
comment = "出款失败" if withdraw_entry.state == OrderStateEnum.SUCCESS else "系统拒绝"
order_type = PayTypeEnum.REFUND if withdraw_entry.state == OrderStateEnum.SUCCESS else PayTypeEnum.MANUALLY
merchant_config = MerchantFeeConfig.query_by_config_id(
withdraw_entry.mch_fee_id)
# 更新订单状态
try:
with db.auto_commit():
order, ref_id = OrderUpdateCtl.update_order_event(
withdraw_entry.order_id,
uid=int(withdraw_entry.uid),
merchant=merchant,
state=OrderStateEnum.FAIL,
tx_amount=withdraw_entry.amount,
deliver_type=DeliverTypeEnum.MANUALLY,
op_account=admin_user.account,
commit=False)
if not order:
msg = WithdrawOrderStateChangeError.message
current_app.logger.error(msg)
raise WithdrawOrderStateChangeError()
# 加提现金额
flag, msg = MerchantBalanceEvent.update_balance(
merchant=merchant,
ref_id=ref_id,
order_type=order_type,
bl_type=BalanceTypeEnum.AVAILABLE,
value=amount,
ad_type=BalanceAdjustTypeEnum.PLUS,
tx_id=order.sys_tx_id,
source=OrderSourceEnum.MANUALLY,
comment=comment,
commit=False,
)
if flag < 0:
msg = '%s' % ("提现退回增加商户余额失败, %s" % msg)
current_app.logger.error(msg)
raise DepositCallbackUserBalanceError()
if merchant_config.cost_type == CostTypeEnum.MERCHANT:
# 给商户加手续费
flag, msg = MerchantBalanceEvent.update_balance(
merchant=merchant,
ref_id=OrderUtils.gen_unique_ref_id(),
order_type=PayTypeEnum.FEE,
bl_type=BalanceTypeEnum.AVAILABLE,
value=fee,
ad_type=BalanceAdjustTypeEnum.PLUS,
tx_id=order.sys_tx_id,
commit=False,
comment=comment,
source=OrderSourceEnum.MANUALLY)
if flag < 0:
msg = '%s' % ("提现退款增加商户手续费失败, %s" % msg)
current_app.logger.error(msg)
raise DepositCallbackUserBalanceError()
refund_fee = amount
if merchant_config.cost_type == CostTypeEnum.USER:
# 给用户退回手续费
refund_fee += fee
# 增加用户余额
flag, msg = UserBalanceEvent.update_user_balance(
uid=order.uid,
merchant=merchant,
ref_id=ref_id,
order_type=order_type,
bl_type=BalanceTypeEnum.AVAILABLE,
value=refund_fee,
ad_type=BalanceAdjustTypeEnum.PLUS,
tx_id=order.sys_tx_id,
commit=False,
comment=comment,
source=OrderSourceEnum.MANUALLY)
if flag < 0:
msg = '%s' % ("提现退款增加用户余额失败, %s" % msg)
current_app.logger.error(msg)
raise DepositCallbackUserBalanceError()
except APIException as e:
current_app.logger.error(traceback.format_exc())
return e
cls.do_notify(
order=order,
op_account=admin_user.account,
comment=comment,
)
return ResponseSuccess()
def order_fail(cls, order):
"""
订单失败处理
:return:
"""
params = copy.deepcopy(locals())
params.pop('cls')
params.pop('order')
params['tx_id'] = order.sys_tx_id
rst = dict(
code=0,
msg='',
)
# 手续费存在订单详情里面
order_detail = OrderDetailWithdraw.query_by_order_id(
order.merchant, order.order_id, order.create_time)
merchant_config = MerchantFeeConfig.query_by_config_id(
order.mch_fee_id)
try:
# 创建提现订单/扣商户余额/扣用户余额，在同一个事务里面
with db.auto_commit():
order, ref_id = OrderUpdateCtl.update_order_event(
order.order_id,
uid=order.uid,
merchant=order.merchant,
state=OrderStateEnum.FAIL,
commit=False,
)
if not order:
raise RuntimeError('提现订单修改失败状态失败, params: %s' % params)
# 给商户退回提现订单的发起金额
flag, msg = MerchantBalanceEvent.update_balance(
merchant=order.merchant,
ref_id=ref_id,
source=order.source,
order_type=PayTypeEnum.REFUND,
bl_type=BalanceTypeEnum.AVAILABLE,
# 订单发起金额
value=order.amount,
ad_type=BalanceAdjustTypeEnum.PLUS,
tx_id=order.sys_tx_id,
commit=False,
)
# print('update_balance', flag, msg)
if flag < 0:
raise RuntimeError(msg + ", params: %s" % params)
if merchant_config.cost_type == CostTypeEnum.MERCHANT:
# 给商户退回提手续费
flag, msg = MerchantBalanceEvent.update_balance(
merchant=order.merchant,
ref_id=OrderUtils.gen_unique_ref_id(),
tx_id=order.sys_tx_id,
source=order.source,
order_type=PayTypeEnum.FEE,
bl_type=BalanceTypeEnum.AVAILABLE,
# 收取商户的手续费
value=order_detail.fee,
ad_type=BalanceAdjustTypeEnum.PLUS,
commit=False,
)
# print('update_balance', flag, msg)
if flag < 0:
raise RuntimeError(msg + ", params: %s" % params)
refund_fee = order.amount
if merchant_config.cost_type == CostTypeEnum.USER:
# 给用户退回手续费
refund_fee += order_detail.fee
# 给用户退回发起金额
flag, msg = UserBalanceEvent.update_user_balance(
uid=order.uid,
merchant=order.merchant,
ref_id=ref_id,
source=order.source,
order_type=PayTypeEnum.REFUND,
bl_type=BalanceTypeEnum.AVAILABLE,
# 订单发起金额
value=refund_fee,
ad_type=BalanceAdjustTypeEnum.PLUS,
tx_id=order.sys_tx_id,
commit=False,
)
# print('update_user_balance', flag, msg)
if flag < 0:
raise RuntimeError(msg + ", params: %s" % params)
except APIException as e:
current_app.logger.error(traceback.format_exc())
return False
cls.do_notify(order=order)
return True
def success_order_process(cls,
order,
tx_amount,
channel_tx_id=None,
comment: str = '',
op_account=None,
commit=True):
"""
处理充值成功的订单
:param order:
:param tx_amount: 实际支付金额
:param channel_tx_id: 通道订单号
:param comment: 备注
:param op_account: 备注
:param commit: 是否立即提交事务
:return:
"""
params = copy.deepcopy(locals())
params.pop('cls')
params.pop('order')
params['tx_id'] = order.sys_tx_id
rst = dict(
code=0,
msg='',
)
# 计算一笔订单的各种费用
channel_config = ChannelConfig.query_by_channel_id(order.channel_id)
merchant_config = MerchantFeeConfig.query_by_config_id(
order.mch_fee_id)
order_fee = OrderFeeHelper.calc_order_fee(order, tx_amount,
channel_config,
merchant_config)
try:
with db.auto_commit(commit):
order, ref_id = OrderUpdateCtl.update_order_event(
order.order_id,
uid=order.uid,
merchant=order.merchant,
state=OrderStateEnum.SUCCESS,
channel_tx_id=channel_tx_id,
tx_amount=tx_amount,
offer=order_fee['offer'], # 优惠金额
fee=order_fee['merchant_fee'], # 手续费
cost=order_fee['channel_cost'], # 成本金额
profit=order_fee['profit'], # 利润（收入）金额
commit=False,
pay_method=channel_config.channel_enum.
conf['payment_method'],
comment=comment,
op_account=op_account,
)
if not order:
msg = '订单更新失败, params: %s' % params
raise RuntimeError(msg)
# 给用户充值
code, msg = UserBalanceEvent.update_user_balance(
uid=order.uid,
merchant=order.merchant,
ref_id=ref_id,
source=order.source,
order_type=order.order_type,
bl_type=BalanceTypeEnum.AVAILABLE,
value=order.amount,
ad_type=BalanceAdjustTypeEnum.PLUS,
comment=comment,
tx_id=order.sys_tx_id,
commit=False,
)
if code != 0:
raise RuntimeError(msg)
# 根据结算类型获取商户余额变更类型
balance_type = SettleHelper.get_balance_type_by_settle(
channel_config.settlement_type)
# 更新商户余额，加用户充值金额
code, msg = MerchantBalanceEvent.update_balance(
merchant=order.merchant,
ref_id=ref_id,
source=order.source,
order_type=order.order_type,
bl_type=balance_type,
value=order.amount,
ad_type=BalanceAdjustTypeEnum.PLUS,
tx_id=order.sys_tx_id,
comment=comment,
commit=False,
)
if code != 0:
raise RuntimeError(msg)
# 更新商户余额，扣手续费
ref_id = OrderUtils.gen_unique_ref_id()
code, msg = MerchantBalanceEvent.update_balance(
merchant=order.merchant,
ref_id=ref_id,
source=order.source,
order_type=PayTypeEnum.FEE,
bl_type=balance_type,
value=order_fee['merchant_fee'],
ad_type=BalanceAdjustTypeEnum.MINUS,
tx_id=order.sys_tx_id,
comment=comment,
commit=False,
)
if code != 0:
raise RuntimeError(msg)
except RuntimeError as e:
current_app.logger.error('An error occurred.', exc_info=True)
return False
# 累计当天通道充值额度
ChannelLimitCacheCtl.add_day_amount(channel_config.channel_enum,
order.amount)
cls.do_notify(order)
return True
def adjust_create(user,
source,
amount,
bl_type,
order_type,
ad_type,
comment,
tx_id=None,
ref_id=None):
params = copy.deepcopy(locals())
# params.pop('cls')
adjust_flag = True
try:
# 更新商户及用户余额
with db.auto_commit():
if not tx_id:
tx_id = OrderUtils.gen_normal_tx_id(user.uid)
if not ref_id:
ref_id = OrderUtils.gen_unique_ref_id()
# 更新用户余额
flag, msg = UserBalanceEvent.update_user_balance(
uid=user.uid,
merchant=user.merchant,
ref_id=ref_id,
source=source,
order_type=order_type,
bl_type=bl_type,
value=amount,
ad_type=ad_type,
tx_id=tx_id,
comment=comment,
commit=False,
)
if flag < 0:
msg = '%s, params: %s' % ("更新用户余额失败, %s" % msg, params)
current_app.logger.error(msg)
raise AdjustUserBalanceError(message="更新用户余额失败")
# 更新商户余额
flag, msg = MerchantBalanceEvent.update_balance(
merchant=user.merchant,
ref_id=ref_id,
source=source,
order_type=order_type,
bl_type=bl_type,
value=amount,
ad_type=ad_type,
tx_id=tx_id,
comment=comment,
commit=False,
)
if flag < 0:
msg = '%s, params: %s' % ("更新商户余额失败, %s" % msg, params)
current_app.logger.error(msg)
raise AdjustUserBalanceError(message="更新商户余额失败")
except APIException as e:
current_app.logger.error(traceback.format_exc())
adjust_flag = False
return adjust_flag, e
return adjust_flag, None
def post(self):
"""
转账
判断接受转账的用户是否存在
判断是否存在支付密码
校验老的支付密码
判断余额是否足够
执行转账操作
"""
form, error = TransferForm().request_validate()
if error:
return error.as_response()
# 从全局变量中取出用户ID,参考：verify_credential
uid = g.user.uid
if not g.user.has_permission(UserPermissionEnum.TRANSFER):
return UserPermissionDeniedError().as_response()
# 判断接受转账的用户是否存在
bind_user = UserBindInfo.query_bind(form.merchant.data,
form.number.data)
if not bind_user:
# 未绑定账号，验证手机号码是否正确
account = form.join_phone_number()
if not account:
return AccountNotExistError(message="您输入的账号不存在").as_response()
form.number.data = account
else:
# 使用绑定的手机号码
form.number.data = bind_user.account
user_info = User.query_user(form.merchant.data,
account=form.number.data)
if not user_info:
return AccountNotExistError(message="账号(%s)不存在" %
form.number.data).as_response()
no_transfer_limit = UserBindInfo.query_bind_by_uid(user_info.uid)
if not no_transfer_limit and form.amount.data > TRANSFER_AMOUNT_LIMIT:
# 非绑定用户转账限额检查
return UserPermissionDeniedError(
message="单次转账额度不能超过%s" % TRANSFER_AMOUNT_LIMIT).as_response()
# 判断是否是给自己转账
if uid == user_info.uid:
return TransferToMeError().as_response()
# 判断是否存在支付密码
user = User.query_user(form.merchant.data, uid)
if not user.trade_pwd:
return PaymentPwdNotExistError().as_response()
cache = UserPaymentPasswordLimitCache(uid=uid)
# 获取支付密码输入错误次数是否达到上限
if cache.is_limited():
return PaymentPasswordLimitedError().as_response()
# 校验支付密码
flag = User.verify_payment_password(
form.merchant.data, uid=uid, password=form.payment_password.data)
# 交易密码校验失败
if not flag:
cache.incr_times()
times = cache.get_left_times()
return PaymentPasswordError(message=PaymentPasswordError.message.
format(times)).as_response()
# 密码校验成功 删除密码输入错误记录
cache.delete_cache()
# 判断余额是否足够
balance = UserBalance.query_balance(uid=uid,
merchant=g.user.merchant).first()
if BalanceKit.divide_unit(balance.balance) < form.amount.data:
return AccountBalanceInsufficientError().as_response()
# 执行转账动作
flag, msg = UserBalanceEvent.transfer(from_user=g.user,
to_user=user_info,
merchant=form.merchant.data,
amount=form.amount.data,
comment=form.comment.data)
# 设置失败的情况
if not flag:
return NoSourceError().as_response()
return ResponseSuccess().as_response()