def get(self):
"""
测试外网访问，正向代理是否正常
:return:
"""
try:
tx_id = request.args['tx_id']
except:
return ResponseSuccess(message="必填交易ID").as_response()
order = OrderDeposit.query_by_tx_id(tx_id)
if not order:
return ResponseSuccess(message="订单不存在，请确认交易号是否正确: %s" %
tx_id).as_response()
state_before = OrderConstraint.query_by_order_id(order.order_id).state
with db.auto_commit():
OrderConstraint.revoke_order_state(order.order_id, order.state)
state_after = OrderConstraint.query_by_order_id(order.order_id).state
return ResponseSuccess(bs_data=dict(
order_id=order.order_id,
sys_tx_id=order.sys_tx_id,
order_state=order.state.desc,
state_before=state_before.desc,
state_after=state_after.desc,
)).as_response()
def get(self):
"""
后台管理员操作日志
:return:
"""
if not request.args:
return ResponseSuccess(
message="参数规则：?account=panda&date=20190901&export=1"
).as_response()
account = request.args['account']
if account:
user = AdminUser.query_user(account=account)
if not user:
return ResponseSuccess(message="用户不存在，请检查参数。account：%s" %
account).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()
events = AdminLog.query_by_date(date)
if account:
events = events.filter_by(account=account)
rst = list()
for event in events:
rst.append(
dict(
create_time=event.create_time,
account=event.account,
url=event.url,
ip=event.ip,
module=event.module.desc,
model=event.model,
model_id=event.model_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 = 'admin_log_%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 get(self):
"""
商户配置查询
:return:
"""
if not request.args:
return ResponseSuccess(message="参数规则：?merchant=test").as_response()
try:
merchant = MerchantEnum.from_name(request.args['merchant'])
except:
return ResponseSuccess(message="请输入正确的商户名称，有效的商户名称包括：%s" %
MerchantEnum.get_names()).as_response()
merchant_info = MerchantInfo.query_merchant(merchant)
if not merchant_info:
return ResponseSuccess(message="未创建商户").as_response()
bs_data = dict(
balance=dict(
balance_total=str(merchant_info.balance_total),
balance_available=str(merchant_info.balance_available),
balance_income=str(merchant_info.balance_income),
balance_frozen=str(merchant_info.balance_frozen),
),
merchant=merchant.name,
domains=MerchantDomainConfig.get_domains(merchant),
# db=DBEnum(merchant.name).get_db_name(),
)
deposit_fees = MerchantFeeConfig.query_active_configs(
query_fields=dict(
merchant=merchant,
payment_way=PayTypeEnum.DEPOSIT,
))
deposit_fees = MerchantFeeConfig.filter_latest_items(deposit_fees)
if not deposit_fees:
return MerchantConfigDepositError(bs_data=bs_data).as_response()
bs_data['deposit_fees'] = [x.short_description for x in deposit_fees]
withdraw_fees = MerchantFeeConfig.query_latest_one(query_fields=dict(
merchant=merchant,
payment_way=PayTypeEnum.WITHDRAW,
))
if not withdraw_fees:
return MerchantConfigWithdrawError(bs_data=bs_data).as_response()
bs_data['withdraw_fees'] = withdraw_fees.short_description
channels = ChannelListHelper.get_available_channels(
merchant, PayTypeEnum.DEPOSIT)
bs_data['deposit_channels'] = [x.short_description for x in channels]
channels = ChannelListHelper.get_available_channels(
merchant, PayTypeEnum.WITHDRAW)
bs_data['withdraw_channels'] = [x.short_description for x in channels]
return ResponseSuccess(bs_data=bs_data).as_response()
def get(self):
"""
查询可用的通道
:return:
"""
if not request.args:
return ResponseSuccess(
message="参数规则：?tx_id=xxxx，交易ID，必填").as_response()
try:
tx_id = request.args['tx_id']
except:
return ResponseSuccess(message="必填交易ID").as_response()
order = OrderDeposit.query_by_tx_id(tx_id)
if not order:
return ResponseSuccess(message="订单不存在，请确认交易号是否正确: %s" %
tx_id).as_response()
order_detail = OrderDetailDeposit.query_by_tx_id(tx_id)
channel = ChannelConfig.query_by_channel_id(order.channel_id)
fee_config = MerchantFeeConfig.query_by_config_id(order.mch_fee_id)
order_info = dict(
order_id=order.order_id,
create_time=order.str_create_time,
uid=order.uid,
sys_tx_id=order.sys_tx_id,
mch_tx_id=order.mch_tx_id,
channel_tx_id=order.channel_tx_id,
amount=str(order.amount),
tx_amount=str(order.tx_amount),
source=order.source.desc,
pay_method=order.pay_method.desc,
state=order.state.desc,
settle=order.settle.desc,
deliver=order.deliver.desc,
channel_id=order.channel_id,
channel=channel.short_description,
mch_fee_id=order.mch_fee_id,
mch_fee=fee_config.short_description,
in_type=order_detail.in_type.desc,
offer=str(order_detail.offer),
fee=str(order_detail.fee),
cost=str(order_detail.cost),
profit=str(order_detail.profit),
ip=order_detail.ip,
)
return ResponseSuccess(bs_data=order_info).as_response()
def post(self):
"""
best pay 交易通知
:return:
"""
form, error = BestPayNotifyForm().request_validate()
if error:
return error.as_response()
# 判断订单号是否存在 不存在 或状态不为Init 则返回无效的订单号
order_id = form.tx_id.data
order = DepositTransactionCtl.get_order_by_order_id(order_id=order_id)
if not order or order.state.name != OrderStateEnum.INIT.name:
return InvalidOrderIdError().as_response()
# 收款银行卡号
# 发起人姓名
# 充值金额
# 备注
# 充值时间
# 状态
if not OrderTransferLog.insert_transfer_log(
order_id=order_id,
amount='{:.2f}'.format(float(form.amount.data)),
in_account=form.card_number.data,
out_name=form.user_name.data):
return InvalidOrderIdError(message="新增转账信息有误").as_response()
return ResponseSuccess().as_response()
def post(self):
"""
用户余额调整
:return:
"""
form, error = UserBalanceEditForm.request_validate()
if error:
return error.as_response()
uid = form.uid.data
# 判断该用户id是否存在
user = User.query.filter_by(**dict(id=uid)).first()
if not user:
return AdjustUserBalanceError(message="系统找不到该用户").as_response()
ad_type = BalanceAdjustTypeEnum.PLUS
# 当调整状态为 减少时 需要判断 当前用户余额和商户余额值
amount = BalanceKit.round_4down_5up(Decimal(form.amount.data))
if form.adjust_type.data == BalanceAdjustTypeEnum.MINUS:
ad_type = BalanceAdjustTypeEnum.MINUS
# 获取用户余额 并判断
user_balance_info = UserBalance.query.filter(
UserBalance.id == uid).first()
if not user_balance_info:
return UserBalanceNoFoundError().as_response()
user_balance = user_balance_info.real_balance
if Decimal(user_balance) - amount < 0:
print("用户没有足够的金额", user_balance, amount)
return AdjustUserBalanceError(
message="用户没有足够的金额").as_response()
# 获取商户余额 并判断
merchant_balance_info = MerchantInfo.query.filter_by(**dict(
_merchant=user_balance_info.merchant.value)).first()
if not merchant_balance_info:
return AdjustUserBalanceError(message="该商户信息不存在").as_response()
bl_ava = merchant_balance_info.balance_available
if Decimal(bl_ava) - amount < 0:
print("商户没有足够的余额", bl_ava, amount)
return AdjustUserBalanceError(
message="商户没有足够的余额").as_response()
# 调整用户及商户余额
flag, error = AdjustTransactionCtl.adjust_create(
user=user,
source=OrderSourceEnum.MANUALLY,
amount=amount,
order_type=PayTypeEnum.MANUALLY,
bl_type=BalanceTypeEnum.AVAILABLE,
ad_type=ad_type,
comment=form.comment.data)
if not flag:
return AdjustUserBalanceError(message="余额调整失败").as_response()
return ResponseSuccess().as_response()
class UserBankDelete(Resource):
method_decorators = admin_decorators
@ns.expect(UserBankInfo)
@ns.marshal_with(ResponseSuccess.gen_doc(api))
def post(self):
"""
用户银行信息编辑
"""
form, error = UserBankDeleteForm().request_validate()
if error:
return error.as_response()
print(form.card_id, "****************", form.card_id.data)
card_id = form.card_id.data
# 判断该用户银行卡 信息是否存在
card_entry = BankCard.query.filter_by(
**dict(id=card_id, valid=1)).first()
if not card_entry:
return AdjustUserBalanceError(message="card_id 不存在").as_response()
BankCard.delete_bankcard_by_card_id(card_id=card_id)
return ResponseSuccess().as_response()
class ResetPassword(Resource):
method_decorators = admin_decorators
# 请求数据格式
@ns.expect(AdminResetPassword)
# 相应数据格式
@ns.marshal_with(ResponseSuccess.gen_doc(api))
def post(self):
"""
修改登录密码
:return:
"""
# 格式验证
form, error = ResetWordForm().request_validate()
if error:
return error.as_response()
# 获取用户ID
uid = g.user.uid
if not AdminUser.verify_password(uid=uid, password=form.ori_password.data):
return PasswordError().as_response()
if AdminUser.verify_password(uid=uid, password=form.new_password.data):
return RePasswordError().as_response()
flag = AdminUser.reset_password(
uid=uid,
login_pwd=form.new_password.data
)
if not flag:
return NoSourceError().as_response()
return ResponseSuccess().as_response()
def manually_withdraw(cls, admin_user, merchant, 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 != OrderStateEnum.ALLOC:
return BankOrderStateError()
# 更新订单状态
order, ref_id = OrderUpdateCtl.update_order_event(
withdraw_entry.order_id,
uid=int(withdraw_entry.uid),
merchant=merchant,
state=OrderStateEnum.DEALING,
tx_amount=withdraw_entry.amount,
deliver_type=DeliverTypeEnum.MANUALLY,
deal_time=DateTimeKit.get_cur_datetime(),
op_account=admin_user.account,
mch_fee_id=withdraw_entry.mch_fee_id,
commit=True)
if not order:
return WithdrawOrderStateChangeError()
return ResponseSuccess()
class ForgetPasswordVerifyAuth(Resource):
method_decorators = [
limiter.limit("1/second"),
]
# 请求数据格式
@ns.expect(MobileAuthCode)
# 相应数据格式
@ns.marshal_with(ResponseSuccess.gen_doc(api))
def post(self):
"""
忘记密码 --验证验证码
:return:
"""
# 用户手机号格式验证
form, error = AuthCodeTrueForm().request_validate()
if error:
return error.as_response()
# 判断验证码是否过期
if AuthCodeGenerator(form.number.data).is_expired(form.auth_code.data):
return AuthCodeExpiredError().as_response()
# 判断验证码是否正确
if not AuthCodeGenerator(form.number.data).verify_code(
form.auth_code.data):
return AuthCodeError().as_response()
return ResponseSuccess().as_response()
def post(self):
"""
忘记密码 --设置新密码
:return:
"""
# 用户手机号格式验证
form, error = PasswordTrueForm().request_validate()
if error:
return error.as_response()
# 判断验证码是否过期
if AuthCodeGenerator(form.number.data).is_expired(form.auth_code.data):
return AuthCodeExpiredError().as_response()
# 判断验证码是否正确
if not AuthCodeGenerator(form.number.data).verify_code(
form.auth_code.data):
return AuthCodeError().as_response()
User.reset_password(form.merchant.data,
account=form.number.data,
login_pwd=form.password.data)
UserPasswordLimitCache(form.number.data).delete_cache()
User.update_user_state(merchant=form.merchant.data,
account=form.number.data,
state=AccountStateEnum.ACTIVE)
return ResponseSuccess().as_response()
def post(self):
"""
忘记密码 --验证手机号，获取验证码
:return:
"""
# 用户手机号格式验证
form, error = MobileRegisterTrueCheckForm().request_validate()
if error:
return error.as_response()
# 首先获取当日是否已发送过验证码
if AuthCodeLimiter(form.number.data).is_limited():
return AuthCodeTimesLimitError().as_response()
# 生成验证码
code = AuthCodeGenerator(form.number.data).generate_code()
current_app.logger.info('code generated success, code: %s', code)
# print('code: %s' % code)
# 将验证码以短信方式发送到用户手机
try:
if not current_app.config['DEBUG']:
from app.services.celery.sms import async_send_auth_code
async_send_auth_code.delay(phone=form.number.data, code=code)
except:
current_app.config['SENTRY_DSN'] and current_app.logger.fatal(
traceback.format_exc())
# 验证码发送成功后，发送次数+1
AuthCodeLimiter(form.number.data).incr_times()
return ResponseSuccess().as_response()
class OrderManuallyDone(Resource):
method_decorators = admin_decorators
@ns.expect(OrderIdCommentDoc)
@ns.marshal_with(ResponseSuccess.gen_doc(api))
def post(self):
"""
人工完成充值订单
:return:
"""
form, error = OrderIdCommentForm().request_validate()
if error:
return error.as_response()
order_id = form.order_id.data
g_order_id = GlobalOrderId.query_global_id(order_id)
order = OrderDeposit.query_by_order_id(merchant=g_order_id.merchant,
order_id=order_id)
if DepositTransactionCtl.success_order_process(
order,
order.amount,
comment=form.comment.data,
op_account=g.user.account):
return ResponseSuccess(message="处理成功")
else:
return ResponseSuccess(message="处理失败")
def post(self):
"""
给商户发通知
:return:
"""
form, error = OrderStateNotifyFrom().request_validate()
if error:
return error.as_response()
order_id = form.order_id.data
order_type = form.order_type.data
if order_type == PayTypeEnum.WITHDRAW:
order = WithdrawTransactionCtl.get_order_by_order_id(order_id)
rst = WithdrawTransactionCtl.do_notify(
order=order,
op_account=g.user.account,
comment="后台人工状态通知",
)
else:
order = DepositTransactionCtl.get_order_by_order_id(order_id)
rst = DepositTransactionCtl.do_notify(
order=order,
op_account=g.user.account,
comment="后台人工状态通知",
)
return ResponseSuccess(message=rst['msg'])
class WithdrawPersonDone(Resource):
method_decorators = admin_decorators
@ns.expect(WithDrawPersonExecuteDoneParams)
@ns.marshal_with(ResponseSuccess.gen_doc(api), as_list=True)
def post(self):
"""
运营确定出款成功
:return:
"""
form, error = WithDrawPersonExecutedDoneForm().request_validate()
if error:
return error.as_response()
fee = form.fee.data if form.fee.data else "0"
comment = form.comment.data
rsp = WithdrawTransactionCtl.manually_withdraw_success(
admin_user=g.user,
merchant=form.merchant.data,
order_id=form.order_id.data,
channel_cost=fee,
comment=comment,
)
return rsp.as_response()
def post(self):
"""
设置支付密码
"""
"""
判断密码是否是6位纯数字
判断密码是否是连续的
判断是否存在支付密码
写入支付密码到数据库
"""
form, error = SetPaymentPassword().request_validate()
if error:
return error.as_response()
# 从全局变量中取出用户ID,参考：verify_credential
uid = g.user.uid
# 判断是否存在支付密码
user = User.query_user(form.merchant.data, uid)
if user.trade_pwd:
return PaymentPwdNotExistError().as_response()
# 设置支付密码
flag = User.set_payment_password(form.merchant.data,
uid=uid,
trade_pwd=form.payment_password.data)
# 设置失败的情况
if not flag:
return NoSourceError().as_response()
return ResponseSuccess().as_response()
def order_alloc(cls, admin_account, order_id, merchant):
"""
认领分配订单
:return:
"""
params = copy.deepcopy(locals())
params.pop('cls')
order = OrderWithdraw.query_by_order_id(merchant, order_id)
if not order:
msg = '%s, params: %s' % (NoSuchWithdrawOrderError.message, params)
current_app.logger.error(msg)
return NoSuchWithdrawOrderError()
if order.state != OrderStateEnum.INIT:
msg = '%s, params: %s' % (DoNotAllowedOrderError.message, params)
current_app.logger.error(msg)
return DoNotAllowedOrderError()
order, ref_id = OrderUpdateCtl.update_order_event(
order.order_id,
uid=order.uid,
merchant=merchant,
state=OrderStateEnum.ALLOC,
op_account=admin_account,
alloc_time=DateTimeKit.get_cur_datetime(),
)
if not order:
msg = '%s, params: %s' % (AllowedOrderError.message, params)
current_app.logger.error(msg)
return AllowedOrderError()
return ResponseSuccess()
class AuthUsername(Resource):
method_decorators = [
limiter.limit("1/second"),
]
@ns.expect(MobileNumber)
@ns.marshal_with(ResponseSuccess.gen_doc(api))
def post(self):
"""
检查手机号是否已经注册
"""
form, error = MobileRegisterCheckForm().request_validate()
if error:
return error.as_response()
if not MerchantFeeConfig.query_latest_one(query_fields=dict(
merchant=form.merchant.data,
payment_way=PayTypeEnum.DEPOSIT,
)):
return MerchantConfigDepositError().as_response()
if not MerchantFeeConfig.query_latest_one(query_fields=dict(
merchant=form.merchant.data,
payment_way=PayTypeEnum.WITHDRAW,
)):
return MerchantConfigWithdrawError().as_response()
return ResponseSuccess().as_response()
class OrderStateNotifyResource(Resource):
method_decorators = merchant_decorators
@ns.expect(OrderStateNotifyDoc)
@ns.marshal_with(ResponseSuccess.gen_doc(api))
def post(self):
"""
给商户发通知
:return:
"""
form, error = OrderStateNotifyFrom().request_validate()
if error:
return error.as_response()
order_id = str(form.order_id.data)
if form.type.data == PayTypeEnum.WITHDRAW:
order = WithdrawTransactionCtl.get_order(order_id)
rst = WithdrawTransactionCtl.do_notify(order=order,
op_account=g.user.account,
comment="商户后台手动通知")
elif form.type.data == PayTypeEnum.DEPOSIT:
order = DepositTransactionCtl.get_order(order_id)
rst = DepositTransactionCtl.do_notify(
order=order,
op_account=g.user.account,
comment="商户后台手动通知",
)
return ResponseSuccess(message=rst['msg'])
def post(self):
"""
修改密码
:return:
"""
# 用户手机号格式验证
form, error = ResetWordForm().request_validate()
if error:
return error.as_response()
# 从全局变量中取出用户ID,参考：verify_credential
uid = g.user.uid
if not User.verify_password(merchant=form.merchant.data,
uid=uid,
password=form.ori_password.data):
return PasswordError().as_response()
if User.verify_password(merchant=form.merchant.data,
uid=uid,
password=form.new_password.data):
return RePasswordError().as_response()
flag = User.reset_password(form.merchant.data,
uid=uid,
login_pwd=form.new_password.data)
if not flag:
return NoSourceError().as_response()
return ResponseSuccess().as_response()
def post(self):
"""
修改登录密码
:return:
"""
# 格式验证
form, error = ResetWordForm().request_validate()
if error:
return error.as_response()
# 获取用户ID
uid = g.user.uid
if not AdminUser.verify_password(uid=uid, password=form.ori_password.data):
return PasswordError().as_response()
if AdminUser.verify_password(uid=uid, password=form.new_password.data):
return RePasswordError().as_response()
flag = AdminUser.reset_password(
uid=uid,
login_pwd=form.new_password.data
)
if not flag:
return NoSourceError().as_response()
return ResponseSuccess().as_response()
def post(self):
"""
发货通知，由商户实现
:return:
"""
if not EnvironEnum.is_local_evn(current_app.config['FLASK_ENV']):
# 无论如何都记录一条log
current_app.logger.info('path: %s, ip: %s, args: %s, data: %s',
url_for("gateway_demo_notify"), IpKit.get_remote_ip(), request.args,
request.json)
form, error = DepositNotifyForm.request_validate()
if error:
return error.as_response()
checker = GatewayFormChecker(form.merchant_id.data)
# 1. IP白名单校验
if not checker.verify_ip(form.client_ip.data):
current_app.logger.error('msg: %s, ip: %s, white ips: %s', GatewayIPError.message, IpKit.get_remote_ip(),
checker.get_white_ips())
return GatewayIPError().as_response()
# 2. 签名校验
sign_fields = form.get_sign_fields()
if not checker.verify_sign(form.sign.data, sign_fields):
current_app.logger.error('msg: %s, sign: %s, fields: %s, sign_str: %s',
GatewaySignError.message, form.sign.data, sign_fields,
checker.get_sign_str(sign_fields))
return GatewaySignError().as_response()
# 商户自己的业务逻辑处理
current_app.logger.info('notify success: %s', form.json_data)
return ResponseSuccess().as_response()
class SMSCodeAuthentication(Resource):
method_decorators = [limiter.limit("1/second"), ]
# 期待客户端请求的数据模型,使用expect来装饰
@ns.expect(MobileAuthCode)
# 给客户端返回的的响应数据模型，使用marshal_with来装饰
@ns.marshal_with(ResponseSuccess.gen_doc(api))
def post(self):
"""
验证短信动态验证码
"""
# 验证表单手机号及验证码格式验证
form, error = AuthCodeForm.request_validate()
if error:
return error.as_response()
# 判断验证码是否过期
if AuthCodeGenerator(form.number.data).is_expired(form.auth_code.data):
return AuthCodeExpiredError().as_response()
# 判断验证码是否正确
if not AuthCodeGenerator(form.number.data).verify_code(form.auth_code.data):
return AuthCodeError().as_response()
return ResponseSuccess().as_response()
class PaymentPasswordForgetSet(Resource):
method_decorators = cashier_decorators
# 期待客户端请求数据模型， 用response 来装饰
@ns.expect(SetForgetPaymentPassword)
# 相应数据格式
@ns.marshal_with(ResponseSuccess.gen_doc(api))
def post(self):
"""
忘记支付密码，重置支付密码
"""
"""
检查验证码
判断是否存在支付密码
设置新的支付密码
"""
form, error = SetForgetPaymentPasswordForm().request_validate()
if error:
return error.as_response()
# 判断验证码是否过期
if AuthCodeGenerator(form.number.data).is_expired(form.auth_code.data):
return AuthCodeExpiredError().as_response()
# 判断验证码是否正确
if not AuthCodeGenerator(form.number.data).verify_code(
form.auth_code.data):
return AuthCodeError().as_response()
# 从全局变量中取出用户ID,参考：verify_credential
uid = g.user.uid
# 判断是否存在支付密码
user = User.query_user(form.merchant.data, uid)
if not user.trade_pwd:
return PaymentPwdNotExistError().as_response()
# 设置新的支付密码
flag = User.set_payment_password(
form.merchant.data,
uid=uid,
trade_pwd=form.new_payment_password.data)
# 设置失败的情况
if not flag:
return NoSourceError().as_response()
try:
# 清理掉支付密码输入错误的次数记录
cache = UserPaymentPasswordLimitCache(uid=uid)
# 密码设置成功 删除密码输入错误记录
cache.delete_cache()
except:
pass
return ResponseSuccess().as_response()
def get(self):
"""
检查热表数据
:return:
"""
if not request.args:
return ResponseSuccess(
message="参数规则：?merchant=test&date=20190901").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()
kwargs = dict(
date=date,
merchant=merchant,
only_hot=request.args.get('only_hot'),
only_cold=request.args.get('only_cold'),
)
rst = dict(
OrderDeposit=OrderDeposit.query_by_date(date, **kwargs).count(),
OrderWithdraw=OrderWithdraw.query_by_date(date, **kwargs).count(),
OrderDetailDeposit=OrderDetailDeposit.query_by_date(
date, **kwargs).count(),
OrderDetailWithdraw=OrderDetailWithdraw.query_by_date(
date, **kwargs).count(),
)
kwargs['merchant'] = merchant.name
kwargs['date'] = DateTimeKit.datetime_to_str(date)
rst['kwargs'] = kwargs
return ResponseSuccess(bs_data=rst).as_response()
def get(self):
"""
测试查询订单
:return:
"""
count = OrderDepositTst.count_all_records()
return ResponseSuccess(bs_data=dict(
count=count,
)).as_response()
def get(self):
"""
测试创建订单
:return:
"""
rst = OrderDepositTst.create_order()
return ResponseSuccess(bs_data=dict(
code=rst['code'],
msg=rst['msg'],
)).as_response()
def get(self):
"""
联通性测试
:return:
"""
from scripts.admin_user import init_admin_user
if not request.args:
return ResponseSuccess(message="参数规则：?account=panda").as_response()
try:
account = request.args['account']
except:
return ResponseSuccess(message="请输入admin账号名称").as_response()
account, password = init_admin_user(account, None)
return ResponseSuccess(
bs_data=dict(account=account, password=password)).as_response()
def get(self):
"""
删除某个手机号码的短信发送次数限制
:return:
"""
try:
account = request.args.get('account')
if account:
account = '+' + account.strip('+').strip()
if not PhoneNumberParser.is_valid_number(account):
raise
else:
raise
except:
return ResponseSuccess(
message="请输入正确的用户手机号码，必须有完整区号，不填+号，如：8613812349999"
).as_response()
AuthCodeLimiter(account).cache.delete()
accounts = list()
for key in AuthCodeLimiterCache.scan_iter(
AuthCodeLimiterCache.KEY_PREFIX):
accounts.append(
AuthCodeLimiterCache.split_key(key=key.decode('utf8'))[-1])
if account in accounts:
return ResponseSuccess(message="删除失败，accounts: %s" %
accounts).as_response()
codes = list()
for account in accounts:
cache = AuthCodeLimiter(account)
codes.append(
dict(
account=account,
sent_times=cache.get_times(),
is_limited=cache.is_limited(),
ttl=cache.cache.get_ttl(),
))
return ResponseSuccess(message="删除成功",
bs_data=dict(codes=codes, )).as_response()
def post(self):
client_ip = IpKit.get_remote_ip()
third_config = ThirdPayConfig.EpayTong_PAY_DEPOSIT.value
if not EnvironEnum.is_local_evn(current_app.config['FLASK_ENV']):
# 无论如何都记录一条log
current_app.logger.info(
'epaytong deposit callback, ip: %s, data: %s',
IpKit.get_remote_ip(), request.form)
if not CallbackEpayTong.check_ip(client_ip):
current_app.logger.fatal(
'ip not allow, client_ip: %s, data: %s, body: %s', client_ip,
request.args, request.form)
return BaseResponse('FAIlURE')
sys_tx_id = request.form['order_no']
order = DepositTransactionCtl.get_order(sys_tx_id)
if not order:
current_app.logger.error('epaytong: no found order, order id: %s' %
(sys_tx_id))
return BaseResponse('FAILURE')
no_need_field = ['signType', 'sign']
sorted_fields = sorted([k for k in request.form.keys()])
request_str = "&".join([
"{}={}".format(k, request.form[k]) for k in sorted_fields
if (request.form[k] == 0 or request.form[k] == "0"
or request.form[k]) and k not in no_need_field
])
sign = request.form['sign']
sign_str = request_str + third_config['secret_key']
flag = CallbackEpayTong.check_sign(sign, sign_str)
if not flag:
current_app.logger.fatal(
'invalid sign, client_ip: %s, data: %s, body: %s', client_ip,
request.args, request_str)
return ResponseSuccess(code=500, message='签名错误').as_response()
tx_amount = request.form['price']
pwTradeId = request.form['notify_id']
status = request.form['is_success']
trade = request.form['trade_status']
if status == 'T' and trade == "TRADE_FINISHED":
if not DepositTransactionCtl.success_order_process(
order, decimal.Decimal(tx_amount), pwTradeId):
return BaseResponse('FAIlURE')
else:
if not DepositTransactionCtl.failed_order_process(
order, decimal.Decimal(tx_amount), pwTradeId):
return BaseResponse('FAIlURE')
return BaseResponse('success')