def user_info(self, params):
module = "account"
method = "user_account"
user_account = {}
with get_rpc_conn(module) as proxy:
try:
user_account = proxy.call(method, params)
except:
logger.error(traceback.format_exc())
raise ews.EwsError(ews.STATUS_USER_ACCOUNT_FAIL)
user_account = ujson.loads(user_account)
module = "user"
method = "user_info"
user_info = {}
with get_rpc_conn(module) as proxy:
try:
user_info = proxy.call(method, params)
user_info = ujson.loads(user_info)
except:
logger.error(traceback.format_exc())
raise ews.EwsError(ews.STATUS_USER_INFO_FAIL)
ret = {}
ret.update(user_account)
ret.update(user_info)
return ret
def user_recharge(ret, *args, **kwargs):
params = args[0].json_args
request = args[0].request
route_path = args[0].route_path
#ret = ujson.loads(ret)
#if ret.get("status") == "100":
#区分不同充值渠道
try:
recharge_channel = route_path.split('/')[1]
msg = {"paychannel": recharge_channel}
module = "account"
method = "search_recharge_order"
orderinfo = {}
if recharge_channel == 'jiuzhao':
if ret == "success":
oid = params.get("outTradeNo")
with get_rpc_conn(module) as proxy:
try:
orderinfo = proxy.call(method, {"oid": oid})
orderinfo = ujson.loads(orderinfo)
except:
logger.error(traceback.format_exc())
msg.update({
"oid": oid,
"uid": orderinfo.get("f_uid", ""),
"platform": orderinfo.get("f_platform", ""),
"realMoney": params.get("amount", ""),
"rechargeMoney": params.get("amount", ""),
"paytime": params.get("thirdPayTime", "")
})
MQ.send_msg('recharge_suc', msg)
else:
pass
elif recharge_channel == 'lianlian':
if ret.get("ret_code") == "0000":
oid = params.get("no_order")
with get_rpc_conn(module) as proxy:
try:
orderinfo = proxy.call(method, {"oid": oid})
orderinfo = ujson.loads(orderinfo)
except:
logger.error(traceback.format_exc())
msg.update({
"oid": oid,
"uid": orderinfo.get("f_uid", ""),
"platform": orderinfo.get("f_platform", ""),
"realMoney": params.get("money_order", ""),
"rechargeMoney": params.get("money_order", "")
})
MQ.send_msg('recharge_suc', msg)
else:
pass
else:
pass
except:
logger.error(traceback.format_exc())
def comfirm_withdraw():
"""
审核提款
:return:
"""
module = "account"
method = "get_obligation_order"
params = {"orderstatus": define.WITHDRAW_STATUS_CHECK}
orders = []
with get_rpc_conn(module) as proxy:
try:
orders = proxy.call(method, params)
except:
logger.error(traceback.format_exc())
send_textcard_message(msgtype="提款异常",
servicename="nncp-job",
exceptinfo="获取待支付失败")
raise
orders = ujson.loads(orders)
for order in orders:
module = "user"
method = "user_info"
uid = order.get("f_uid")
user_info = {}
with get_rpc_conn(module) as proxy:
try:
user_info = proxy.call(method, {"uid": uid})
user_info = ujson.loads(user_info)
except:
logger.error(traceback.format_exc())
uid = order.get("f_uid")
oid = order.get("f_oid")
money = order.get("f_money")
card_no = order.get("f_card_no")
acct_name = user_info.get("realname")
#todo 订单状态检查，防止重复
resp = lianlian.query_withdraw_order(oid)
logger.info("lianlian.query_withdraw_order %s", resp)
if resp.get("ret_code") == "0000":
continue
try:
status = lianlian.withdraw(oid, money, card_no, acct_name)
except:
logger.info(traceback.format_exc())
logger.info("withdraw %s", status)
def user_password_modify(self, mobile, code, checksum, oldpassword,
newpassword):
if checksum != hashlib.md5(
str(mobile) + str(code) + define.DEFIND_SMS_SALT).hexdigest():
raise ews.EwsError(ews.STATUS_USER_MOBILE_VERIFY_ERROR)
if oldpassword == newpassword:
raise ews.EwsError(ews.STATUS_USER_PASSWORD_MODIFY_SAMEPWD)
params = {
"mobile":
mobile,
"oldpassword":
hashlib.md5(oldpassword + define.DEFIND_LOGIN_SALT).hexdigest(),
"newpassword":
hashlib.md5(newpassword + define.DEFIND_LOGIN_SALT).hexdigest()
}
module = "user"
method = "password_modify"
with get_rpc_conn(module) as proxy:
status = 0
try:
status = proxy.call(method, params)
except:
logger.error(traceback.format_exc())
raise ews.EwsError(ews.STATUS_USER_PASSWORD_MODIFY_FAIL)
if status < 1:
raise ews.EwsError(ews.STATUS_USER_LOGIN_PASSWORD_ERROR)
return status
raise ews.EwsError(ews.STATUS_USER_PASSWORD_MODIFY_FAIL)
def trade(handler, *args, **kwargs):
ck = handler.json_args.get("ck", "")
uid = session.get_by_ck(ck).get('uid')
params = handler.json_args
params.update({"uid": uid})
pid = None
try:
# 账户检查
paymoney = UserBean().check_account(params)
# 下单
with get_rpc_conn("trade") as proxy:
try:
resp = proxy.call("place_order", params)
except RpcException as ex:
raise ews.EwsError(ews.STATUS_RPC_TRADE_ERROR, ex.message)
except:
logger.error(traceback.format_exc())
raise
account = UserBean().user_account({"uid": uid})
ret = {
"pid": resp.get("pid"),
"balance": Decimal(account.get("balance")) - Decimal(paymoney),
"balance_draw": account.get("balance_draw")
}
return handler.ok(ret)
def place_order(self, params):
module = "account"
method = "recharge_order"
oid = None
with get_rpc_conn(module) as proxy:
try:
oid = proxy.call(method, params)
except:
logger.error(traceback.format_exc())
raise ews.EwsError(ews.STATUS_USER_ACCOUNT_FAIL)
if not oid:
raise
paychannel = params.get("paychannel")
params.update({"oid": oid})
if paychannel == "1001":
path = build_unifiedorder(params)
return {"url": path}
elif paychannel == "1002":
ret = self.order_lianlian_web(params)
return ret
elif paychannel in ["1003", "1004"]:
ret = self.order_lianlian_web(params)
return ret
elif paychannel == "1004":
ret = self.order_lianlian_sdk(params)
return ret
return
def check_account(self, params):
with get_rpc_conn("account") as proxy:
payinfo = proxy.call("check_account", params)
payinfo = ujson.loads(payinfo)
paystatus = payinfo.get("paystatus")
paymoney = payinfo.get("paymoney")
if paystatus != define.ORDER_PAY_STATUS_SUCC:
raise ews.EwsError(ews.STATUS_RPC_TRADE_ERROR,
define.PAY_STATUS_REMARK[paystatus])
return paymoney
def cal_prize_ssq():
"""双色球算奖
"""
try:
rds = db_pool.get_redis("main")
expect = rds.get(rediskey.REDIS_OPENCODE_EXPECT.format("ssq"))
with get_rpc_conn("ticket") as proxy:
proxy.call("Jprize", {"lotid": 3, "expect": expect})
except:
logger.error(traceback.format_exc())
def user_account_detail(self, params):
module = "account"
method = "user_account_detail"
account_detail = {}
with get_rpc_conn(module) as proxy:
try:
account_detail = proxy.call(method, params)
except:
logger.error(traceback.format_exc())
raise ews.EwsError(ews.STATUS_USER_ACCOUNT_FAIL)
account_detail = ujson.loads(account_detail)
details = account_detail.get("details", [])
count = account_detail.get("count", 0)
user_list = []
#:"f_crtime":1520666344,"f_pid":57,"f_inout":1,"f_money":32.0,"f_id":23,"f_uptime":1520666344,"f_lotid":28,"f_uid":1,"f_balance":9648.0
for detail in details:
inout = int(detail.get("f_inout"))
if inout == define.ACCOUNT_LOG_TYPE_PAID:
continue
user_list.append({
"crtime":
detail.get("f_crtime"),
"pid":
detail.get("f_oid"),
"inout":
detail.get("f_inout"),
"money":
detail.get("f_money"),
"desc":
define.ACCOUNT_LOG_DESC.get(inout),
"id":
detail.get("f_id"),
"balance":
float(detail.get("f_balance_recharge")) +
float(detail.get("f_balance_draw")),
"lotid":
detail.get("f_lotid")
})
ret = {}
pageno = params.get("pageno")
pagesize = params.get("pagesize")
ret.update({
"list": user_list,
"count": count,
"all_page": (count / int(pagesize)) + 1,
"curr_page": pageno
})
return ret
def modify_password(self, params):
module = "user"
method = "modify_password"
ret = {}
with get_rpc_conn(module) as proxy:
try:
ret = proxy.call(method, params)
except:
logger.error(traceback.format_exc())
raise ews.EwsError(ews.STATUS_USER_ACCOUNT_FAIL)
return
def withdraw_fail():
"""
审核提款
:return:
"""
module = "account"
method = "get_obligation_order"
params = {"orderstatus": define.WITHDRAW_STATUS_FAIL}
orders = []
with get_rpc_conn(module) as proxy:
try:
orders = proxy.call(method, params)
except:
logger.error(traceback.format_exc())
send_textcard_message(msgtype="提款异常",
servicename="nncp-job",
exceptinfo="获取待支付失败")
raise
orders = ujson.loads(orders)
for order in orders:
module = "account"
method = "withdraw_refund"
status = False
oid = order.get("f_oid")
uid = order.get("f_uid")
with get_rpc_conn(module) as proxy:
try:
status = proxy.call(method, {"oid": oid})
except:
logger.error(traceback.format_exc())
send_textcard_message(
msgtype="提款提款异常",
servicename="nncp-job",
exceptinfo="提款退款异常,需要人工操作 uid:%s oid: %s" % (uid, oid))
if not status:
pass
def check_split_tickets(self, params):
try:
#调用拆票服务
with get_rpc_conn("ticket") as proxy:
try:
params.update({'checksplit':True})
tickets = proxy.call("split_tickets", params)
except:
logger.error(traceback.format_exc())
raise ews.EwsError(ews.STATUS_LOTTOCHECK_ERROR, '投注金额错误')
except:
logger.error(traceback.format_exc())
raise ews.EwsError(ews.STATUS_LOTTOCHECK_ERROR, '投注金额错误')
def get_user_info_by_mobile(self, mobile):
module = "user"
method = "user_info_by_mobile"
params = {"mobile": mobile}
user_info = {}
with get_rpc_conn(module) as proxy:
try:
user_info = proxy.call(method, params)
except:
logger.error(traceback.format_exc())
raise ews.EwsError(ews.STATUS_USER_INFO_FAIL)
return user_info
raise ews.EwsError(ews.STATUS_USER_INFO_FAIL)
def chasecancel(handler, *args, **kwargs):
ck = handler.json_args.get("ck")
uid = session.get_by_ck(ck).get('uid')
cid = handler.json_args.get("cid")
try:
with get_rpc_conn("trade") as proxy:
try:
params = {"uid": uid, "cid": cid}
resp = proxy.call("cancel_chasenumber", params)
except RpcException as ex:
raise ews.EwsError(ews.STATUS_RPC_TRADE_ERROR, ex.message)
except:
logger.error(traceback.format_exc())
raise
return handler.ok(resp)
def user_password_reset(self, mobile, code, checksum, password):
if checksum != hashlib.md5(
str(mobile) + str(code) + define.DEFIND_SMS_SALT).hexdigest():
raise ews.EwsError(ews.STATUS_USER_MOBILE_VERIFY_ERROR)
password = hashlib.md5(password + define.DEFIND_LOGIN_SALT).hexdigest()
params = {"mobile": mobile, "password": password}
module = "user"
method = "password_reset"
with get_rpc_conn(module) as proxy:
status = 0
try:
status = proxy.call(method, params)
except:
logger.error(traceback.format_exc())
raise ews.EwsError(ews.STATUS_USER_PASSWORD_RESET_FAIL)
return status
raise ews.EwsError(ews.STATUS_USER_PASSWORD_RESET_FAIL)
def jiuzhao_recharge_notice(self, params):
"""
充值入账
:return:
"""
amount = params.get("amount")
mchId = params.get("mchId")
oid = params.get("outTradeNo")
tradeno = params.get("outOrderId")
paytime = params.get("thirdPayTime")
status = params.get("orderStatus")
sign = params.get("sign")
is_verify = jz_verify(params)
if is_verify:
module = "account"
method = "search_recharge_order"
orderinfo = {}
with get_rpc_conn(module) as proxy:
try:
orderinfo = proxy.call(method, params)
orderinfo = ujson.loads(orderinfo)
except:
logger.error(traceback.format_exc())
raise ews.EwsError(ews.STATUS_USER_ACCOUNT_FAIL)
if not orderinfo:
logger.error("order not found %s", oid)
return "fail"
logger.info("orderinfo:%s", orderinfo)
orderstatus = str(orderinfo.get("f_orderstatus", "-1"))
_money = orderinfo.get("f_rechargemoney")
if orderstatus == "1":
logger.info("already recharge %s", oid)
return "fail"
amount = round(int(amount) / 100.0, 2)
if float(_money) != float(amount):
logger.info("notice money nq amount")
return "fail"
elif orderstatus == "0" and status == "00":
params = {
"uid": orderinfo.get("f_uid"),
"oid": oid,
"tradeno": tradeno,
"money": amount
}
status = proxy.call("recharge_notify", params)
if status:
return "success"
else:
return "fail"
else:
send_textcard_message(msgtype="充值异常告警",
servicename="nncp-api",
exceptinfo="充值入账异常")
else:
# raise #todo 验签失败
send_textcard_message(msgtype="充值异常告警",
servicename="nncp-api",
exceptinfo="充值验签错误")
return "fail"
def order_lianlian_sdk(self, params):
'''连连sdk充值
:param
ck
truename: 实名认证的用户名
idcard： 身份证号
card_no： 身份证号
no_agree： 绑定临时银行卡
bank_code: 银行编码
no_agree: 协议号
'''
platform = params.get("platform", "android")
# 绑定临时银行卡
no_agree = params.get('no_agree', None)
card_no = params.get('card_no', None)
module = "user"
method = "user_info"
user_info = {}
with get_rpc_conn(module) as proxy:
try:
user_info = proxy.call(method, params)
user_info = ujson.loads(user_info)
except:
logger.error(traceback.format_exc())
raise ews.EwsError(ews.STATUS_USER_INFO_FAIL)
# 获取实名信息接口
if not user_info.get("realname", ""):
# 没有实名认证
raise ews.EwsError(ews.STATUS_USER_NOT_AUTH)
if (not params.get("no_agree")) and params.get("card_no"):
req = {
'username': "",
'orderid': "",
'cardno': params.get("card_no"),
'truename': "",
'idcode': "",
'channel': "",
}
# 快捷绑定
pass
bank_code = params.get("bank_code", "")
if params.get("card_no") and not bank_code:
bank_code_info = lianlian.bank_card_test(params.get("card_no"))
print bank_code_info
bank_code = bank_code_info.get("bank_code") if bank_code_info.get(
"bank_code") else ""
data = {
'acct_name': user_info.get("realname"),
'bank_code': bank_code,
'busi_partner': "101001",
'card_no': params.get("card_no"),
'dt_order': time.strftime('%Y%m%d%H%M%S'),
'flag_modify': '1',
'id_no': user_info.get("idcard"),
'id_type': "0",
'money_order': params.get("money"),
"name_goods": "充值",
'no_order': params.get("oid"),
'notify_url': lianlian.notify_url_web,
'oid_partner': lianlian.partner_num_web,
'sign_type': 'RSA',
'url_return': params.get("callback_url", ""),
'user_id': str(params.get("uid")),
'valid_order': '1440',
'version': "1.0",
"no_agree": params.get("no_agree"),
"timestamp": time.strftime('%Y%m%d%H%M%S'),
"info_order": "nncp"
}
data = dict((k, v) for k, v in data.items() if v) # 空值过滤掉
reg_time = lianlian.to_format_datatime(user_info.get("crtime", ""))
risk_item = lianlian.lianlian_make_risk_item(data["user_id"], reg_time,
data["acct_name"],
data["id_no"],
params.get("bind_mobile"))
data["risk_item"] = ujson.dumps(risk_item)
data['sign'] = lianlian.esun_sign_wap(data)
return data
def lianlian_withdraw_notice(self, checked_args):
'''连连web/sdk充值异步入账
'''
logger.debug("=========checked_args")
logger.info("lianlian_withdraw_notice： %s", checked_args)
# {
# "oid_partner": "201103171000000000",
# "dt_order": "20130515094018",
# "no_order": "2013051500005",
# "oid_paybill": "2013051613121201",
# "money_order": "200.01",
# "result_pay": "SUCCESS",
# "settle_date": "20130627",
# "sign_type ": "RSA",
# "sign": "ZPZULntRpJwFmGNIVKwjLEF2Tze7bqs60rxQ22CqT5J1UlvGo575QK9z/
# + p + 7E9cOoRoWzqR6xHZ6WVv3dloyGKDR0btvrdqPgUAoeaX / YOWzTh00vwcQ + HBtXE + vP
# TfAqjCTxiiSJEOY7ATCF1q7iP3sfQxhS0nDUug1LP3OLk = "
# }
amount = checked_args.get("money_order")
oid = checked_args.get("no_order")
tradeno = checked_args.get("oid_paybill")
result_pay = checked_args.get("result_pay")
sign = checked_args.get("sign")
if not sign:
return {'ret_code': '8888', 'ret_msg': '参数异常'}
res = lianlian.lian_verify(checked_args, checked_args['sign'])
if not res:
logger.info("===lianlian verify fail===")
logger.info(checked_args)
return {'ret_code': '1111', 'ret_msg': '验签失败'}
if checked_args['result_pay'] != 'SUCCESS':
logger.info("===lianlian result_pay status fail ===")
# return {'ret_code': '2222', 'ret_msg': 'result_pay： ' + checked_args['result_pay']}
module = "account"
method = "search_withdraw_order"
orderinfo = {}
with get_rpc_conn(module) as proxy:
try:
orderinfo = proxy.call(method, {"oid": oid})
orderinfo = ujson.loads(orderinfo)
except:
logger.error(traceback.format_exc())
raise ews.EwsError(ews.STATUS_USER_ACCOUNT_FAIL)
if not orderinfo:
logger.error("order not found %s", oid)
return {'ret_code': '3333', 'ret_msg': 'order not found'}
logger.info("orderinfo:%s", orderinfo)
orderstatus = str(orderinfo.get("f_orderstatus", "-1"))
_money = orderinfo.get("f_money")
if orderstatus == "2":
logger.info("already deal %s", oid)
return {'ret_code': '0000', 'ret_msg': 'already deal'}
if float(_money) != float(amount):
logger.info("notice money nq amount")
return {
'ret_code': '5555',
'ret_msg': 'notice money nq amount'
}
elif orderstatus == "1":
if result_pay == "SUCCESS":
status = define.WITHDRAW_STATUS_SUC
else:
status = define.WITHDRAW_STATUS_FAIL
params = {
"oid": oid,
"orderstatus": status,
"tradeno": tradeno
}
module = "account"
method = "update_withdraw_orderstatus"
status = False
with get_rpc_conn(module) as proxy:
try:
status = proxy.call(method, params)
except:
logger.error(traceback.format_exc())
if status:
ret = {'ret_code': '0000', 'ret_msg': '交易成功'}
return ret
else:
return {'ret_code': '6666', 'ret_msg': 'fail'}
return {'ret_code': '6666', 'ret_msg': 'fail'}
def lianlian_recharge_notice(self, checked_args):
'''连连web/sdk充值异步入账
'''
logger.debug("=========checked_args")
logger.debug(checked_args)
amount = checked_args.get("money_order")
oid = checked_args.get("no_order")
tradeno = checked_args.get("oid_paybill")
status = checked_args.get("result_pay")
sign = checked_args.get("sign")
# {
# "oid_partner": "201103171000000000",
# "dt_order": "20130515094013",
# "no_order": "2013051500001",
# "oid_paybill": "2013051613121201",
# "money_order": "10",
# "result_pay": "SUCCESS",
# "settle_date": "20130516",
# "info_order": "用户13958069593购买了3桶羽毛球",
# "pay_type": "2",
# "bank_code": "01020000",
# "sign_type": "RSA",
# "sign": "ZPZULntRpJwFmGNIVKwjLEF2Tze7bqs60rxQ22CqT5J1UlvGo575QK9z/
# + p + 7E9cOoRoWzqR6xHZ6WVv3dloyGKDR0btvrdqPgUAoeaX / YOWzTh00vwcQ + HBtX
# E + vPTfAqjCTxiiSJEOY7ATCF1q7iP3sfQxhS0nDUug1LP3OLk = "
# }
res = lianlian.lian_verify(checked_args, checked_args['sign'])
if not res:
logger.info("===lianlian verify fail===")
logger.info(checked_args)
return {'ret_code': '1111', 'ret_msg': '验签失败'}
if checked_args['result_pay'] != 'SUCCESS':
return {
'ret_code': '2222',
'ret_msg': 'result_pay： ' + checked_args['result_pay']
}
module = "account"
method = "search_recharge_order"
orderinfo = {}
with get_rpc_conn(module) as proxy:
try:
orderinfo = proxy.call(method, {"oid": oid})
orderinfo = ujson.loads(orderinfo)
except:
logger.error(traceback.format_exc())
raise ews.EwsError(ews.STATUS_USER_ACCOUNT_FAIL)
if not orderinfo:
logger.error("order not found %s", oid)
return {'ret_code': '3333', 'ret_msg': 'order not found'}
logger.info("orderinfo:%s", orderinfo)
orderstatus = str(orderinfo.get("f_orderstatus", "-1"))
_money = orderinfo.get("f_rechargemoney")
if orderstatus == "1":
logger.info("already recharge %s", oid)
return {'ret_code': '0000', 'ret_msg': 'already recharge'}
if float(_money) != float(amount):
logger.info("notice money nq amount")
return {
'ret_code': '5555',
'ret_msg': 'notice money nq amount'
}
elif orderstatus == "0" and status == "SUCCESS":
params = {
"uid": orderinfo.get("f_uid"),
"oid": oid,
"tradeno": tradeno,
"money": amount
}
status = proxy.call("recharge_notify", params)
if status:
ret = {'ret_code': '0000', 'ret_msg': '交易成功'}
# req = {
# 'agree_no': checked_args['no_agree'],
# 'bank_code': checked_args['bank_code'],
# 'card_type': checked_args['pay_type'],
# 'id_code': checked_args.get('id_no', '')
# }
# if checked_args['no_agree']:
# pass
return ret
else:
return {'ret_code': '6666', 'ret_msg': 'fail'}
return {'ret_code': '6666', 'ret_msg': 'fail'}
def lianlian_withdraw(self, params):
money = params.get("money")
if float(money) < 1:
raise ews.EwsError(ews.STATUS_WITHDRAW_MONEY_LIMIT)
module = "user"
method = "user_info"
user_info = {}
with get_rpc_conn(module) as proxy:
try:
user_info = proxy.call(method, params)
user_info = ujson.loads(user_info)
except:
logger.error(traceback.format_exc())
raise ews.EwsError(ews.STATUS_USER_INFO_FAIL)
# 获取实名信息接口
if not user_info.get("realname", ""):
# 实名认证
raise ews.EwsError(ews.STATUS_USER_NOT_AUTH)
card_no = user_info.get("cardno", "")
if not user_info.get("cardno", ""):
raise ews.EwsError(ews.STATUS_NOT_BIND_CARD)
params.update({"card_no": card_no})
rds = db_pool.get_redis('main')
mobile = user_info.get("mobile")
code = params.get("code", "")
uid = params.get("uid")
_code = rds.get(
rediskey.REDIS_USER_MOBILE_SMS_CODE.format(mobile=mobile))
limit_count = rds.incr(
rediskey.REDIS_USER_MOBILE_SMS_CODE_VERIFY_LIMIT.format(
mobile=mobile))
rds.expire(
rediskey.REDIS_USER_MOBILE_SMS_CODE_VERIFY_LIMIT.format(
mobile=mobile), 6 * 60 * 60)
if limit_count >= 6:
raise ews.EwsError(ews.STATUS_USER_VERIDFY_CODE_LIMIT_ERROR)
if not _code or _code != code:
raise ews.EwsError(ews.STATUS_USER_SMS_CODE_ERROR)
rds.delete(
rediskey.REDIS_USER_MOBILE_SMS_CODE_VERIFY_LIMIT.format(
mobile=mobile))
module = "account"
method = "recharge_withdraw"
oid = None
with get_rpc_conn(module) as proxy:
try:
oid = proxy.call(method, params)
except RpcException as ex:
raise ews.EwsError(ews.STATUS_RPC_ERROR, ex.message)
except:
logger.error(traceback.format_exc())
send_textcard_message(msgtype="提款下单异常",
servicename="nncp-api",
exceptinfo="提款下单错误 uid:%s" % (uid))
raise ews.EwsError(ews.STATUS_USER_WITHDRAW_PLACEORDER_FAIL)
if not oid:
send_textcard_message(msgtype="提款下单异常",
servicename="nncp-api",
exceptinfo="提款下单错误 uid:%s" % (uid))
raise ews.EwsError(ews.STATUS_USER_WITHDRAW_PLACEORDER_FAIL)
return {}
def trade_follow(handler, *args, **kwargs):
ck = handler.json_args.get("ck", "")
uid = session.get_by_ck(ck).get('uid')
pid = handler.json_args.get("pid")
lotid = handler.json_args.get("lotid", 47)
allmoney = handler.json_args.get("allmoney")
beishu = handler.json_args.get("beishu")
params = handler.json_args
params.update({"uid": uid, "couponid": 0})
try:
module = "trade"
method = "proj_detail"
proj_detail = {}
with get_rpc_conn(module) as proxy:
proj_detail = proxy.call(method, params)
proj_detail = ujson.loads(proj_detail)
if not proj_detail:
raise ews.EwsError(ews.STATUS_PROJ_NOT_FOUND)
ptype = proj_detail.get("f_ptype")
if str(ptype) != "1":
raise ews.EwsError(ews.STATUS_PROJ_FORBID_FOLLOW)
orderstatus = proj_detail.get("f_orderstatus")
if orderstatus in [2, 4]:
raise ews.EwsError(ews.STATUS_PROJ_FORBID_FOLLOW)
firsttime = proj_detail.get("f_firsttime")
if firsttime < time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()):
raise ews.EwsError(ews.STATUS_PROJ_DEADLINE)
_allmoney = proj_detail.get("f_allmoney")
_beishu = proj_detail.get("f_beishu")
# 下单
if int(beishu) > 10000:
raise ews.EwsError(ews.STATUS_PROJ_ALLMONEY_ERROR)
single = int(float(_allmoney)) / int(_beishu)
if allmoney != str(single * int(beishu)):
raise ews.EwsError(ews.STATUS_PROJ_ALLMONEY_ERROR)
# 账户检查
paymoney = UserBean().check_account(params)
params = {
'lotid': lotid,
'wtype': proj_detail.get("f_wtype"),
'beishu': beishu,
'zhushu': proj_detail.get("f_zhushu"),
'ggtype': proj_detail.get("f_ggtype"),
'allmoney': allmoney,
'couponid': proj_detail.get("f_couponid"),
'isquchu': proj_detail.get("f_isquchu"),
'danma': proj_detail.get("f_danma"),
'rqlist': proj_detail.get("f_rqlist"),
'ratelist': proj_detail.get("f_ratelist"),
'fileorcode': proj_detail.get("f_fileorcode"),
'uid': uid,
'fid': pid,
'ptype': '-1',
'firsttime': proj_detail.get("f_firsttime"),
'lasttime': proj_detail.get("f_lasttime")
}
with get_rpc_conn("trade") as proxy:
try:
resp = proxy.call("place_order", params)
except RpcException as ex:
raise ews.EwsError(ews.STATUS_RPC_TRADE_ERROR, ex.message)
except:
logger.error(traceback.format_exc())
raise
account = UserBean().user_account({"uid": uid})
ret = {
"pid": resp.get("pid"),
"balance": Decimal(account.get("balance")) - Decimal(paymoney),
"balance_draw": account.get("balance_draw")
}
return handler.ok(ret)
def coupon_list(self, params):
coupons = {}
with get_rpc_conn("account") as proxy:
try:
coupons = proxy.call("coupon_list", params)
except:
logger.error(traceback.format_exc())
raise ews.EwsError(ews.STATUS_COUPON_LIST_FAIL)
coupons = ujson.loads(coupons)
count = coupons.get("count", 0)
coupons = coupons.get("coupons")
#排序规则
lotid = params.get("lotid")
allmoney = params.get("allmoney")
if int(lotid) > 0 and int(allmoney) > 0:
coupons = sorted(coupons,
key=lambda x: float(x["f_couponmoney"]),
reverse=True)
coupons = sorted(coupons, key=lambda x: x["f_expiretime"])
else:
coupons = sorted(coupons, key=lambda x: x["f_expiretime"])
coupons = sorted(coupons, key=lambda x: float(x["f_couponmoney"]))
lst = []
for coupon in coupons:
# lotid定向过滤
lotids = coupon.get("f_lotids")
if lotids != "0":
lotids = lotids.split(",")
logger.debug(lotid)
if int(lotid) > 0 and str(lotid) not in lotids:
continue
else:
lotids = []
# 优惠券跳转
weekday = datetime.datetime.today().weekday() + 1
if weekday in [1, 3, 6]:
if not lotids or str(define.LOTTE_DLT_ID) in lotids:
jumplotid = str(define.LOTTE_DLT_ID)
else:
jumplotid = lotids[0]
elif weekday in [2, 4, 7]:
if not lotids or str(define.LOTTE_SSQ_ID) in lotids:
jumplotid = str(define.LOTTE_SSQ_ID)
else:
jumplotid = lotids[0]
else:
jumplotid = lotids[0] if lotids else str(
define.LOTTE_GX11X5_ID)
lst.append({
"cid": coupon.get("f_cid"),
"uid": coupon.get("f_uid"),
"pid": coupon.get("f_pid"),
"lotids": lotids,
"jumplotid": jumplotid,
"couponstatus": coupon.get("f_couponstatus"),
"couponmoney": coupon.get("f_couponmoney"),
"requiremoney": coupon.get("f_requiremoney"),
"crtime": coupon.get("f_crtime"),
"activedays": coupon.get("f_activedays"),
"activetime": coupon.get("f_activetime"),
"expiretime": coupon.get("f_expiretime")
})
pageno = params.get("pageno")
pagesize = params.get("pagesize")
ret = {
"list": lst,
"count": count,
"all_page": (count / int(pagesize)) + 1,
"curr_page": pageno
}
return ret
def bankcardverify(self, params):
cardno = params.get("cardno")
bank_code_info = lianlian.bank_card_test(cardno)
ret_code = bank_code_info.get("ret_code")
if ret_code != "0000":
raise ews.EwsError(ews.STATUS_BIND_CARD_FAIL)
bank_code = bank_code_info.get("bank_code") if bank_code_info.get(
"bank_code") else ""
bank_name = bank_code_info.get("bank_name") if bank_code_info.get(
"bank_name") else ""
params.update({"bank_main": bank_name, "bank_sub": bank_code})
module = "user"
method = "user_info"
user_info = {}
with get_rpc_conn(module) as proxy:
try:
user_info = proxy.call(method, params)
user_info = ujson.loads(user_info)
except:
logger.error(traceback.format_exc())
raise ews.EwsError(ews.STATUS_USER_INFO_FAIL)
# 获取实名信息接口
if user_info.get("cardno", ""):
#已经绑定银行卡
raise ews.EwsError(ews.STATUS_ALREADY_BIND_CARD)
if not user_info.get("realname", ""):
# 没有实名认证
raise ews.EwsError(ews.STATUS_USER_NOT_AUTH)
url = "http://jisubank2.market.alicloudapi.com/bankcardverify/verify?bankcard={bankcard}&realname={realname}"
realname = user_info.get("realname", "")
url = url.format(bankcard=cardno, realname=realname)
header = {
'Authorization': 'APPCODE ' + "dc384ff70f79452dac4b3a7f5b107c5d"
}
r = requests.get(url, headers=header)
# {
# "status": "0",
# "msg": "ok",
# "result": {
# "bankcard": "6228480402564881235",
# "realname": "张先生",
# "verifystatus": "1",
# "verifymsg": "抱歉，银行卡号校验不一致！"
# }
# }
logger.info(r.content)
if r.status_code != 200:
raise ews.EwsError(ews.STATUS_BIND_CARD_FAIL)
resp = ujson.loads(r.content)
result = resp.get("result")
status = resp.get("status")
verifystatus = result.get("verifystatus")
if status == "0":
module = "user"
method = "bind_bankcard"
user_info = {}
with get_rpc_conn(module) as proxy:
try:
status = proxy.call(method, params)
except:
logger.error(traceback.format_exc())
raise ews.EwsError(ews.STATUS_USER_INFO_FAIL)
if not status:
raise ews.EwsError(ews.STATUS_USER_INFO_FAIL)
return True
raise ews.EwsError(ews.STATUS_REALNAME_NOT_MATCHING_BANKCARD)
def realname_auth(self, params):
"""
实名认证
:param params:
:return:
"""
idcard = params.get("idcard")
truename = params.get("realname")
code = params.get("code")
rds = db_pool.get_redis("main")
self.__check_auth_idcard(idcard, truename)
module = "user"
method = "user_info"
user_info = {}
with get_rpc_conn(module) as proxy:
try:
user_info = proxy.call(method, params)
user_info = ujson.loads(user_info)
except:
logger.error(traceback.format_exc())
raise ews.EwsError(ews.STATUS_USER_INFO_FAIL)
# 获取实名信息接口
if user_info.get("realname", ""):
# 实名认证
raise ews.EwsError(ews.STATUS_ALREADY_TRUENAME)
mobile = user_info.get("mobile")
_code = rds.get(
rediskey.REDIS_USER_MOBILE_SMS_CODE.format(mobile=mobile))
limit_count = rds.incr(
rediskey.REDIS_USER_MOBILE_SMS_CODE_VERIFY_LIMIT.format(
mobile=mobile))
rds.expire(
rediskey.REDIS_USER_MOBILE_SMS_CODE_VERIFY_LIMIT.format(
mobile=mobile), 6 * 60 * 60)
if limit_count >= 6:
logger.error(
'Mobile sms code verify limit! mobile=%s|count=%s|key=%s',
mobile, limit_count,
rediskey.REDIS_USER_MOBILE_SMS_CODE_VERIFY_LIMIT)
raise ews.EwsError(ews.STATUS_USER_VERIDFY_CODE_LIMIT_ERROR)
if _code != code:
raise ews.EwsError(ews.STATUS_USER_SMS_CODE_ERROR)
rds.delete(
rediskey.REDIS_USER_MOBILE_SMS_CODE_VERIFY_LIMIT.format(
mobile=mobile))
status = self.verifyIdcard(idcard, truename)
if not status:
raise ews.EwsError(ews.STATUS_AUTH_TRUENAME_FAIL)
module = "user"
method = "realname_auth"
ret = {}
with get_rpc_conn(module) as proxy:
try:
ret = proxy.call(method, params)
except:
logger.error(traceback.format_exc())
raise ews.EwsError(ews.STATUS_AUTH_TRUENAME_FAIL)
return
def user_mobile_reg(self, params):
password = params.get("password")
password = hashlib.md5(password + define.DEFIND_LOGIN_SALT).hexdigest()
mobile = params.get("mobile")
idfa = params.get("idfa")
code = params.get("code")
rds = db_pool.get_redis("main")
if not re.match(PATTERN, mobile):
# 手机号非法
key = rediskey.REDIS_MOBILE_LOGIN_COUNT_LIMIT.format(deviceid=idfa)
rds.incr(key, 1)
raise ews.EwsError(ews.STATUS_USER_MOBILE_FORMAT_ERROR)
params.update({"password": password})
userinfo = self.get_user_info_by_mobile(mobile)
if userinfo:
raise ews.EwsError(ews.STATUS_USER_MOBILE_ALREAD_REG)
else:
_code = rds.get(
rediskey.REDIS_USER_MOBILE_SMS_CODE.format(mobile=mobile))
limit_count = rds.incr(
rediskey.REDIS_USER_MOBILE_SMS_CODE_VERIFY_LIMIT.format(
mobile=mobile))
rds.expire(
rediskey.REDIS_USER_MOBILE_SMS_CODE_VERIFY_LIMIT.format(
mobile=mobile), 6 * 60 * 60)
if limit_count >= 6:
logger.error(
'Mobile sms code verify limit! mobile=%s|count=%s|key=%s',
mobile, limit_count,
rediskey.REDIS_USER_MOBILE_SMS_CODE_VERIFY_LIMIT)
raise ews.EwsError(ews.STATUS_USER_VERIDFY_CODE_LIMIT_ERROR)
if _code != code:
raise ews.EwsError(ews.STATUS_USER_SMS_CODE_ERROR)
#注册
module = "user"
method = "mobile_reg"
uid = 0
with get_rpc_conn(module) as proxy:
try:
uid = proxy.call(method, params)
except:
logger.error(traceback.format_exc())
raise ews.EwsError(ews.STATUS_USER_REG_FAIL)
#登录日志
params.update({"uid": uid})
proxy.call("login_log", params)
#写ck
ck = session.make_ck(uid)
session.set_ck_to_redis(ck, uid, ttl=7 * 24 * 60 * 60)
rds.delete(
rediskey.REDIS_USER_MOBILE_SMS_CODE_VERIFY_LIMIT.format(
mobile=mobile))
return {"uid": uid, "ck": ck}
def user_login(self, params):
origin_params = params
login_type = params.get("login_type", "mobile")
mobile = params.get("mobile", "")
password = params.get("password", "")
verifycode = params.get("verifycode", "")
deviceid = params.get("mbimei")
rds = db_pool.get_redis('main')
if login_type == define.DEFIND_USER_LOGIN_TYPE:
if not re.match(PATTERN, mobile):
# 手机号非法
key = rediskey.REDIS_MOBILE_LOGIN_COUNT_LIMIT.format(
deviceid=deviceid)
rds.incr(key, 1)
raise ews.EwsError(ews.STATUS_USER_MOBILE_FORMAT_ERROR)
login_password = hashlib.md5(password +
define.DEFIND_LOGIN_SALT).hexdigest()
verify = self.verify_img_code(verifycode, deviceid)
if not verify:
raise ews.EwsError(ews.STATUS_USER_IMG_CODE_ERROR)
module = "user"
method = "login"
params = {
"mobile": mobile,
"password": password,
"logintype": login_type
}
user_info = {}
with get_rpc_conn(module) as proxy:
user_info = proxy.call(method, params)
if not user_info:
raise ews.EwsError(ews.STATUS_LOGIN_NOT_REG)
# 用户没有注册
loginpwd = user_info.get("f_loginpwd")
if login_password != loginpwd:
key = rediskey.REDIS_MOBILE_LOGIN_COUNT_LIMIT.format(
deviceid=deviceid)
rds.incr(key, 1)
raise ews.EwsError(ews.STATUS_USER_LOGIN_PASSWORD_ERROR)
#todo 登录日志
origin_params.update({"uid": user_info.get("f_uid")})
proxy.call("login_log", origin_params)
uid = user_info.get("f_uid")
username = user_info.get("f_username")
nickname = user_info.get("f_nickname")
mobile = user_info.get("f_mobile")
truename = user_info.get("f_truename")
idcard = user_info.get("f_idcard")
ck = session.make_ck(uid)
session.set_ck_to_redis(ck, uid, ttl=24 * 60 * 60)
module = "account"
method = "user_account"
params = {"uid": uid}
user_account = {}
with get_rpc_conn(module) as proxy:
try:
user_account = proxy.call(method, params)
except:
logger.error(traceback.format_exc())
raise ews.EwsError(ews.STATUS_LOGIN_FAIL)
user_account = ujson.loads(user_account)
ret = {
"uid": uid,
"ck": ck,
"mobile": mobile,
"truename": truename,
"idcard": idcard,
"username": username,
"nickname": nickname
}
ret.update(user_account)
key = rediskey.REDIS_MOBILE_LOGIN_COUNT_LIMIT.format(
deviceid=deviceid)
rds.delete(key)
return ret
else:
raise ews.EwsError(ews.STATUS_LOGIN_FAIL)
