def __create_event(cls, **kwargs):
fields = dict(
create_time=kwargs['create_time'],
uid=kwargs['uid'],
order_id=kwargs['order_id'],
ref_id=kwargs['ref_id'],
)
return OrderEvent.add_model(fields, merchant=kwargs['merchant'], date=kwargs['create_time'])
def get(self):
"""
订单修改日志
:return:
"""
if not request.args:
return ResponseSuccess(
message=
"参数规则：?merchant=test&date=20190901&order_id=123&uid=123&ref_id=xxx&export=1，"
"必填参数：merchant，"
"可选参数：date，order_id，uid，ref_id，export，"
"当不填写date时，默认查询当天所有的数据").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()
q_params = dict()
order_id = request.args.get('order_id')
try:
order_id = OrderUtils.parse_tx_id(order_id)
except:
pass
if order_id:
q_params['order_id'] = order_id
uid = request.args.get('uid')
if uid:
q_params['uid'] = uid
ref_id = request.args.get('ref_id')
if ref_id:
q_params['ref_id'] = ref_id
if not q_params:
return ResponseSuccess(
message="必须输入 order_id/uid/ref_id 其中一个或多个参数").as_response()
events = OrderEvent.query_model(query_fields=q_params, date=date)
rst = list()
for event in events:
rst.append(
dict(
create_time=event.create_time,
order_id=event.order_id,
uid=event.uid,
ref_id=event.ref_id,
data_before=event.data_before,
data_after=event.data_after,
))
rst = sorted(rst, key=lambda x: x['create_time'], reverse=True)
for x in rst:
x['create_time'] = DateTimeKit.datetime_to_str(x['create_time'])
if rst and request.args.get('export'):
filename = 'order_events_%s.csv' % DateTimeKit.datetime_to_str(
date, DateTimeFormatEnum.TIGHT_DAY_FORMAT)
return CsvKit.send_csv(rst,
filename=filename,
fields=rst[0].keys())
return ResponseSuccess(bs_data=rst).as_response()
def __test_api_withdraw(self):
"""
1. 新建用户提现订单
:return:
"""
order_cls = OrderWithdraw
uid = 1000
channel_enum = ChannelConfigEnum.CHANNEL_1001
banks = [
PaymentBankEnum(int(bank))
for bank in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
]
proxy_channel = dict(fee=Decimal("2.5"),
fee_type=PaymentFeeTypeEnum.PERCENT_PER_ORDER,
limit_per_min=300,
limit_per_max=1000,
limit_day_max=0,
trade_begin_hour=0,
trade_begin_minute=0,
trade_end_hour=23,
trade_end_minute=59,
maintain_begin=DateTimeKit.str_to_datetime(
"2019-12-11 09:00:00",
DateTimeFormatEnum.SECONDS_FORMAT),
maintain_end=DateTimeKit.str_to_datetime(
"2025-12-20 23:00:00",
DateTimeFormatEnum.SECONDS_FORMAT),
state=ChannelStateEnum.TESTING,
banks=banks)
ProxyChannelConfig.update_channel(channel_enum, **proxy_channel)
merchant = MerchantEnum.TEST
# 准备配置数据
bank = BankCard.add_bank_card(
merchant,
uid=uid,
bank_name="中国工商银行",
bank_code="ICBC",
card_no="6212260405014627955",
account_name="张三",
branch="广东东莞东莞市长安镇支行",
province="广东省",
city="东莞市",
)
OrderMixes.add_one_channel_config(channel_enum)
OrderMixes.add_one_merchant_config(merchant,
channel_enum,
payment_way=PayTypeEnum.WITHDRAW)
channel_config = ChannelConfig.query_latest_one(
dict(channel_enum=channel_enum))
merchant_fee_config = MerchantFeeConfig.query_latest_one(
dict(
merchant=merchant,
payment_way=PayTypeEnum.WITHDRAW,
payment_method=channel_enum.conf.payment_method,
))
amount = Decimal("500")
fee = BalanceKit.round_4down_5up(
Decimal(merchant_fee_config.value) * amount / Decimal(100))
# 创建提现订单
params = dict(
uid=uid,
merchant=merchant,
channel_id=channel_config.channel_id,
mch_fee_id=merchant_fee_config.config_id,
source=OrderSourceEnum.TESTING,
order_type=PayTypeEnum.WITHDRAW,
in_type=InterfaceTypeEnum.CASHIER_H5,
amount=amount,
bank_id=bank.id,
fee=fee,
)
order, ref_id = OrderCreateCtl.create_order_event(**params)
event = OrderEvent.query_one(dict(ref_id=ref_id),
merchant=merchant,
date=order.create_time)
data = order_cls.query_by_order_id(order_id=event.order_id,
merchant=merchant)
begin_time, end_time = DateTimeKit.get_month_begin_end(
year=int(DateTimeKit.get_cur_datetime().year),
month=int(DateTimeKit.get_cur_datetime().month))
withdraw_params = dict(merchant_name="TEST",
page_size=10,
page_index=1,
begin_time=DateTimeKit.datetime_to_str(
begin_time,
DateTimeFormatEnum.SECONDS_FORMAT),
end_time=DateTimeKit.datetime_to_str(
end_time,
DateTimeFormatEnum.SECONDS_FORMAT),
state="0")
self.path = "/trade_manage/withdraw/list"
# 通过接口 查询提现订单
response = self.do_request(json_data=withdraw_params)
print(response.json, "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&")
self.assertEqual("1", response.json['data']['total'])
self.assertEqual("待认领", response.json['data']['entries'][0]['state'])
self.path = "/trade_manage/order/allowed"
# 通过接口， 认领订单
allowed_params = dict(order_id=order.id, merchant_name="TEST")
response = self.do_request(allowed_params)
self.assertEqual(ResponseSuccess.code, response.status_code)
self.assertEqual(ResponseSuccess.error_code,
response.json['error_code'])
# 查询当前订单状态是否已修改为已认领
data = order_cls.query_by_order_id(order_id=event.order_id,
merchant=merchant)
self.assertEqual(OrderStateEnum.ALLOC, data.state)
# 通过接口查询 审核列表 已有的认领订单为1
self.path = '/trade_manage/withdraw/review/list'
request_review_params = dict(
year=str(DateTimeKit.get_cur_datetime().year),
mouth=str(DateTimeKit.get_cur_datetime().month))
response = self.do_request(json_data=request_review_params)
self.assertEqual(1, len(response.json['data']['entries']))
self.assertEqual("已认领", response.json['data']['entries'][0]['state'])
# 通过接口查询 当前可用的 代付通道
proxy_channel_suppor = dict(bank_type=bank.bank_enum.name,
merchant_name="TEST",
amount=str(amount))
self.path = "/trade_manage/withdraw/available/channel"
response = self.do_request(json_data=proxy_channel_suppor)
self.assertEqual(WithdrawBankEntryResult.code, response.status_code)
self.assertEqual(WithdrawBankEntryResult.error_code,
response.json['error_code'])
self.assertEqual(
channel_enum.conf['provider'] + channel_enum.conf['mch_id'],
response.json['data']['entries'][0]['key'])
# 测试人工出款 处理订单
self.path = '/trade_manage/withdraw/person/execute'
execute_params = dict(order_id=order.order_id, merchant="Test")
response = self.do_request(json_data=execute_params)
self.assertEqual(ResponseSuccess.code, response.status_code)
self.assertEqual(ResponseSuccess.error_code,
response.json['error_code'])
data = order_cls.query_by_order_id(order_id=event.order_id,
merchant=merchant)
self.assertEqual(OrderStateEnum.DEALING, data.state)
# 测试人工出款 出款
self.path = "/trade_manage/withdraw/person/done"
done_params = dict(order_id=order.order_id,
merchant='TEST',
comment='测试',
fee='5')
response = self.do_request(json_data=done_params)
self.assertEqual(ResponseSuccess.code, response.status_code)
self.assertEqual(ResponseSuccess.error_code,
response.json['error_code'])
data = order_cls.query_by_order_id(order_id=event.order_id,
merchant=merchant)
self.assertEqual(OrderStateEnum.SUCCESS, data.state)
def __add_event(self, uid, merchant, channel_enum, order_type):
order_cls = OrderDeposit if order_type == PayTypeEnum.DEPOSIT else OrderWithdraw
channel_config = ChannelConfig.query_latest_one(
dict(channel_enum=channel_enum))
merchant_fee_config = MerchantFeeConfig.query_latest_one(
dict(
merchant=merchant,
payment_way=PayTypeEnum.DEPOSIT,
payment_method=channel_enum.conf.payment_method,
))
params = dict(
uid=uid,
merchant=merchant,
channel_id=channel_config.channel_id,
mch_fee_id=merchant_fee_config.config_id,
source=OrderSourceEnum.TESTING,
order_type=order_type,
in_type=InterfaceTypeEnum.CASHIER_H5,
amount=Decimal("500"),
comment='谢谢',
op_account='xxx',
bank_id=123,
fee=10 if order_type == PayTypeEnum.WITHDRAW else 0,
)
order, ref_id = OrderCreateCtl.create_order_event(**params)
self.assertIsNotNone(order)
event = OrderEvent.query_one(dict(ref_id=ref_id),
merchant=merchant,
date=order.create_time)
self.assertIsNotNone(event)
self.assertEqual(order.order_id, event.order_id)
self.assertEqual(order.uid, event.uid)
self.assertEqual(ref_id, event.ref_id)
order = order_cls.query_by_order_id(order_id=event.order_id,
merchant=merchant)
self.assertIsNotNone(order)
self.assertEqual(params['uid'], order.uid)
self.assertEqual(params['merchant'], order.merchant)
self.assertEqual(params['channel_id'], order.channel_id)
self.assertEqual(params['source'], order.source)
self.assertEqual(params['amount'], order.amount)
self.assertTrue(len(order.mch_tx_id) > 0)
self.assertTrue(len(order.sys_tx_id) > 0)
# 更新订单
order, ref_id = OrderUpdateCtl.update_order_event(
order_id=order.order_id,
uid=order.uid,
merchant=merchant,
state=OrderStateEnum.SUCCESS
if order_type == PayTypeEnum.DEPOSIT else OrderStateEnum.ALLOC,
tx_amount=Decimal("500.32"),
channel_tx_id='1232283838229929292',
settle=SettleStateEnum.DONE,
deliver=DeliverStateEnum.DONE,
channel_id=channel_config.channel_id,
mch_fee_id=merchant_fee_config.config_id,
op_account='xxxx',
comment='改了改了',
offer=Decimal('1.22'),
fee=Decimal('1.22'),
cost=Decimal('1.22'),
profit=Decimal('1.22'),
deliver_type=DeliverTypeEnum.PROXY,
alloc_time=DateTimeKit.get_cur_datetime(),
deal_time=DateTimeKit.get_cur_datetime(),
)
self.assertIsNotNone(order)
event = OrderEvent.query_one(dict(ref_id=ref_id),
merchant=merchant,
date=order.create_time)
self.assertEqual(order.order_id, event.order_id)
self.assertEqual(order.uid, event.uid)
self.assertEqual(ref_id, event.ref_id)
order3 = order_cls.query_by_order_id(order_id=event.order_id,
merchant=merchant)
self.assertIsNotNone(order3)
self.assertEqual(params['uid'], order3.uid)
self.assertEqual(params['merchant'], order3.merchant)
self.assertEqual(params['channel_id'], order3.channel_id)
self.assertEqual(params['source'], order3.source)
self.assertEqual(Decimal("500.32"), order3.tx_amount)
self.assertEqual(order.order_id, order3.order_id)
self.assertEqual(order.mch_tx_id, order3.mch_tx_id)
self.assertEqual(order.sys_tx_id, order3.sys_tx_id)
order3 = order_cls.query_by_tx_id(tx_id=order.sys_tx_id)
self.assertIsNotNone(order3)
self.assertEqual(params['uid'], order3.uid)
self.assertEqual(params['merchant'], order3.merchant)
self.assertEqual(params['channel_id'], order3.channel_id)
self.assertEqual(params['source'], order3.source)
self.assertEqual(Decimal("500.32"), order3.tx_amount)
self.assertEqual(order.order_id, order3.order_id)
self.assertEqual(order.mch_tx_id, order3.mch_tx_id)
self.assertEqual(order.sys_tx_id, order3.sys_tx_id)
order3 = order_cls.query_by_uid_someday(
merchant=merchant, uid=uid, someday=order.create_time).all()[0]
self.assertIsNotNone(order3)
self.assertEqual(params['uid'], order3.uid)
self.assertEqual(params['merchant'], order3.merchant)
self.assertEqual(params['channel_id'], order3.channel_id)
self.assertEqual(params['source'], order3.source)
self.assertEqual(Decimal("500.32"), order3.tx_amount)
self.assertEqual(order.order_id, order3.order_id)
self.assertEqual(order.mch_tx_id, order3.mch_tx_id)
self.assertEqual(order.sys_tx_id, order3.sys_tx_id)
begin_time, end_time = DateTimeKit.get_day_begin_end(order.create_time)
orders = order_cls.query_by_create_time(begin_time,
end_time,
merchant=merchant,
uid=uid).all()
order3 = orders[-1]
self.assertIsNotNone(order3)
self.assertFalse(order3.is_cold_table())
self.assertEqual(params['uid'], order3.uid)
self.assertEqual(params['merchant'], order3.merchant)
self.assertEqual(params['channel_id'], order3.channel_id)
self.assertEqual(params['source'], order3.source)
self.assertEqual(Decimal("500.32"), order3.tx_amount)
self.assertEqual(order.order_id, order3.order_id)
self.assertEqual(order.mch_tx_id, order3.mch_tx_id)
self.assertEqual(order.sys_tx_id, order3.sys_tx_id)
# 冷表查询测试
begin_time, end_time = DateTimeKit.get_day_begin_end(order.create_time)
clean_date = order_cls.get_clean_date()
if clean_date.month == begin_time.month:
begin_time = clean_date
orders = order_cls.query_by_create_time(begin_time,
end_time,
merchant=merchant,
uid=uid).all()
order3 = orders[-1]
self.assertIsNotNone(order3)
self.assertTrue(order3.is_cold_table())
self.assertEqual(params['uid'], order3.uid)
self.assertEqual(params['merchant'], order3.merchant)
self.assertEqual(params['channel_id'], order3.channel_id)
self.assertEqual(params['source'], order3.source)
self.assertEqual(Decimal("500.32"), order3.tx_amount)
self.assertEqual(order.order_id, order3.order_id)
self.assertEqual(order.mch_tx_id, order3.mch_tx_id)
self.assertEqual(order.sys_tx_id, order3.sys_tx_id)
def post(self):
"""
充值订单详情
:return:
"""
# form表单验证用提款的
form, error = WithDrawBankForm().request_validate()
if error:
return error.as_response()
# 取得订单id
order_id = form.order_id.data
# 根据订单id获取对应的商户 用户id
order_map = GlobalOrderId.query_global_id(order_id)
# 获取商户id
merchant = order_map.merchant
# 根据商户id 订单id查询具体的订单信息
entry = OrderDeposit.query_by_order_id(order_id=order_id,
merchant=merchant)
# 查询对应的订单详情表
detail = OrderDetailDeposit.query_by_order_id(merchant=merchant,
order_id=order_id)
# 拼接返回数据
detail_head = dict(
source=entry.source.desc,
create_time=entry.str_create_time,
done_time=detail.str_done_time,
mch_tx_id=entry.mch_tx_id,
sys_tx_id=entry.sys_tx_id,
state=entry.state.get_back_desc(PayTypeEnum.DEPOSIT),
settle=entry.settle.desc,
deliver=entry.deliver.desc,
amount=entry.amount,
)
order_merchant_info = dict(merchant_name=merchant.name,
offer=detail.offer,
fee=detail.fee,
cost=detail.cost,
profit=detail.profit)
deliver_info = None
if entry.channel_id:
proxy_entry = ChannelConfig.query_by_channel_id(entry.channel_id)
channel_enum = proxy_entry.channel_enum
deliver_info = dict(channel_name=channel_enum.desc,
mch_id=channel_enum.conf['mch_id'],
channel_tx_id=entry.channel_tx_id)
user_info = dict(
user_id=entry.uid,
ip=detail.ip,
location=GeoIpKit(detail.ip).location,
device="",
)
event_entries = OrderEvent.query_model(
query_fields=dict(order_id=entry.order_id), date=entry.create_time)
event_log_list = list()
for event in event_entries:
order_event = event.data_after[0]
order_event.update(event.data_after[1])
if 'state' in order_event:
state = list(order_event['state'].keys())[0]
event_log_list.append(
dict(
operate_type=OrderStateEnum.from_name(
state).get_back_desc(PayTypeEnum.DEPOSIT),
operator=order_event.get('op_account') or '',
result="成功",
operate_time=DateTimeKit.timestamp_to_datetime(
order_event['update_time']),
comment=order_event.get('comment') or '',
))
if 'deliver' in order_event:
deliver = list(order_event['deliver'].keys())[0]
event_log_list.append(
dict(
operate_type=DeliverStateEnum.from_name(deliver).desc,
operator=order_event.get('op_account') or '',
result="成功",
operate_time=DateTimeKit.timestamp_to_datetime(
order_event['update_time']),
comment=order_event.get('comment') or '',
))
return DepositOrderDetailResult(bs_data=dict(
detail_head=detail_head,
order_merchant_info=order_merchant_info,
deliver_info=deliver_info,
user_info=user_info,
event_log_list=event_log_list), ).as_response()
def post(self):
"""
提现订单详情
:return:
"""
form, error = WithDrawBankForm().request_validate()
if error:
return error.as_response()
order_id = form.order_id.data
order_map = GlobalOrderId.query_global_id(order_id)
merchant = order_map.merchant
entry = OrderWithdraw.query_by_order_id(order_id=order_id,
merchant=merchant)
detail = OrderDetailWithdraw.query_by_order_id(merchant=merchant,
order_id=order_id)
detail_head = dict(source=entry.source.desc,
op_account=detail.op_account,
deliver_type=detail.deliver_type.desc
if detail.deliver_type else None,
create_time=entry.str_create_time,
alloc_time=detail.str_alloc_time,
deal_time=detail.str_deal_time,
done_time=detail.str_done_time,
mch_tx_id=entry.mch_tx_id,
sys_tx_id=entry.sys_tx_id,
state=entry.state.get_back_desc(
PayTypeEnum.WITHDRAW),
settle=entry.settle.desc,
deliver=entry.deliver.desc,
amount=entry.amount)
order_merchant_info = dict(
merchant_name=merchant.name,
fee=detail.fee,
cost=detail.cost,
profit=detail.profit,
withdraw_type="测试" if merchant.is_test else "用户提现")
deliver_info = None
if entry.channel_id:
proxy_entry = ProxyChannelConfig.query_by_channel_id(
entry.channel_id)
channel_enum = proxy_entry.channel_enum
deliver_info = dict(channel_name=channel_enum.desc,
mch_id=channel_enum.conf['mch_id'],
channel_tx_id=entry.channel_tx_id)
user_info = dict(
user_id=entry.uid,
ip=detail.ip,
location=GeoIpKit(detail.ip).location,
device="",
)
event_entries = OrderEvent.query_model(
query_fields=dict(order_id=entry.order_id), date=entry.create_time)
event_log_list = list()
for event in event_entries:
order_event = event.data_after[0]
order_event.update(event.data_after[1])
if 'state' in order_event:
state = list(order_event['state'].keys())[0]
event_log_list.append(
dict(
operate_type=OrderStateEnum.from_name(
state).get_back_desc(PayTypeEnum.WITHDRAW),
operator=order_event.get('op_account') or '',
result="成功",
operate_time=DateTimeKit.timestamp_to_datetime(
order_event['update_time']),
comment=order_event.get('comment') or '',
))
if 'deliver' in order_event:
deliver = list(order_event['deliver'].keys())[0]
event_log_list.append(
dict(
operate_type=DeliverStateEnum.from_name(deliver).desc,
operator=order_event.get('op_account') or '',
result="成功",
operate_time=DateTimeKit.timestamp_to_datetime(
order_event['update_time']),
comment=order_event.get('comment') or '',
))
return WithdrawOrderDetailResult(
bs_data=dict(detail_head=detail_head,
order_merchant_info=order_merchant_info,
deliver_info=deliver_info,
user_info=user_info,
event_log_list=event_log_list)).as_response()