def search_open_expect():
"""轮询开奖期号
"""
rds = db_pool.get_redis("main")
dlt_expect = dlt_logic.DltDraw().get_newest_opencode()
dlt_expect = dlt_expect.get("expect", None)
if dlt_expect:
rds.set(rediskey.REDIS_OPENCODE_EXPECT.format("dlt"),
dlt_expect,
ex=60)
logger.debug("Search opencode expect! lotname=dlt|expect=%s", dlt_expect)
gx11x5_expect = syxw_logic.SyxwDraw(44).get_newest_opencode()
gx11x5_expect = gx11x5_expect.get("expect", None)
if gx11x5_expect:
rds.set(rediskey.REDIS_OPENCODE_EXPECT.format("gx11x5"),
gx11x5_expect,
ex=60)
logger.debug("Search opencode expect! lotname=gx11x5|expect=%s",
gx11x5_expect)
ssq_expect = ssq_logic.SsqDraw().get_newest_opencode()
ssq_expect = ssq_expect.get("expect", None)
if ssq_expect:
rds.set(rediskey.REDIS_OPENCODE_EXPECT.format("ssq"),
ssq_expect,
ex=60)
logger.debug("Search opencode expect! lotname=ssq|expect=%s", ssq_expect)
def place_chasenumber(self, params):
#TODO 下单参数校验
lotid = params.get("lotid")
obj_order = Trade.get(int(lotid))
resp = obj_order.place_chasenumber(params) if obj_order else {}
#异步通知支付
if resp.get("cid"):
params = {
"lotid": resp.get("lotid"),
"oid": resp.get("cid"),
"msgtype": define.MSG_TYPE_CHASENUMBER_PLACED,
"msgcnt": ujson.dumps(resp)
}
try:
mid = MsgRecord().insert(params)
resp.update({"mid": mid})
except:
# 防止重复插入
logger.error(traceback.format_exc())
raise
else:
rds = db_pool.get_redis("msgbus")
rds.publish("TRADE#CHASENUMBER#PLACED", ujson.dumps(resp))
else:
raise RpcException("交易服务发起追号异常!lotid={}".format(lotid))
return {"cid": resp.get("cid", ""), "pid": resp.get("pid", "")}
def get_by_ck(ck, ss_err=True):
"""通过ck获取session信息
@param ck: 通过登录得到的ck串
@return: session内容，dict类型
"""
mc = db_pool.get_redis('session')
try:
uid = mc.get(MC_PREFIX_UID + str(ck))
if uid:
# 校验当前用户是否在其他设备多点登录
uid_ck = mc.get(MC_PREFIX_CK + str(uid))
if ck != uid_ck:
logger.debug('uid=%s^^^^^^ck=%s^^^^^uid_ck=%s', uid, ck, uid_ck)
mc.delete(MC_PREFIX_UID + str(ck))
raise ews.EwsError(ews.STATUS_MULTI_LOGIN_ERR)
# 刷新ck有效期并返回
set_ck_to_redis(ck, uid, refresh=True)
return {
'ck': ck,
'uid': uid,
'usertype': mc.get(MC_UT_PREFIX + str(ck)),
}
if ss_err:
logger.debug(detailtrace("DetailTrace:{}".format(ck)))
raise ews.EwsError(ews.STATUS_SESSION_ERR)
else:
return None
finally:
pass
def get_verify_code_img(self, params):
"""获取验证码图片
"""
deviceid = params.get("deviceid", "")
username = params.get("username", "")
vtype = params.get("vtype", define.VTYPE_LOGIN)
redis_opt = db_pool.get_redis("main")
code = ""
for i in range(4):
code += chr(random.randrange(ord('a'), ord('z') + 1))
vkey = deviceid # 默认的验证码key用设备码
if vtype == define.VTYPE_LOGIN:
# 登陆
vkey = deviceid
elif vtype == define.VTYPE_UNLOCK:
# 解锁
vkey = username
logger.debug(vkey)
rds_name = rediskey.CRAZY_VERIFY_CODE_PREFIX.format(vtype=vtype,
vkey=vkey)
redis_opt.set(rds_name, code, ex=5 * 60)
logger.info("rds_name=%s|code=%s|deviceid=%s|username=%s", rds_name,
code, deviceid, username)
img = get_img(code)
return img
def __init__(self):
self.conn_r = db_pool.get_mysql("nncp_ro")
self.conn_w = db_pool.get_mysql("nncp_wr")
self.conn = db_pool.get_mysql("nncp")
self.cursor = self.conn.cursor(MySQLdb.cursors.DictCursor)
self.rds = db_pool.get_redis("msgbus")
self.mongo = MongoDataModel()
def chasenumber_update_paid(channel,msg):
"""追号订单已支付，更新订单状态
"""
logger.debug('callback for [channel:%s]:[msg:%s]',channel,msg)
msg = ujson.loads(msg)
#校验订单数据
mid = msg.pop("mid")
lotid = int(msg.get("lotid", 0))
cid = msg.get("cid")
pid = msg.get("pid")
couponid = msg.get("couponid")
paymoney = msg.get("paymoney")
couponmoney = msg.get("couponmoney")
#更新订单状态
obj_order = Trade.get(lotid)
paystatus = msg.get("paystatus")
try:
params = {
"mid": mid,
"cid": cid,
"pid": pid,
"couponid": couponid,
"paymoney": paymoney,
"couponmoney": couponmoney,
"chase_originstatus": define.CHASE_STATUS_UNPAY,
"chase_targetstatus": define.CHASE_STATUS_SUCC if paystatus == define.ORDER_PAY_STATUS_SUCC else define.CHASE_STATUS_FAILPAY,
"order_originstatus": define.ORDER_STATUS_UNPAY,
"order_targetstatus": define.ORDER_STATUS_SUCC if paystatus == define.ORDER_PAY_STATUS_SUCC else define.ORDER_STATUS_FAILPAY,
"remark": define.PAY_STATUS_REMARK[paystatus]
}
obj_order.update_chasenumber_status(params)
except:
#更新订单状态异常处理, 告警+重试
logger.error(traceback.format_exc())
raise
else:
# 通知第一期订单成功支付
if paystatus == define.ORDER_PAY_STATUS_SUCC:
params = {
"lotid": lotid,
"oid": pid,
"msgtype": define.MSG_TYPE_ORDER_SUCCPAY,
"msgcnt": ujson.dumps(msg)
}
try:
mid = MsgRecord().insert(params)
msg.update({"mid": mid})
except:
# 防止重复插入
logger.error(traceback.format_exc())
else:
rds = db_pool.get_redis("msgbus")
rds.publish("TRADE#ORDER#SUCCPAY", ujson.dumps(msg))
else:
pass
def order_chasepay(channel, msg):
"""追号下单成功，直接扣款
"""
logger.debug('callback for [channel:%s]:[msg:%s]', channel, msg)
msg = ujson.loads(msg)
cid = msg.get("cid")
pid = msg.get("pid")
uid = msg.get("uid")
lotid = msg.get("lotid")
mid = msg.get("mid")
allmoney = float(msg.get("allmoney"))
couponid = int(msg.get("couponid"))
#直接扣款
params = {
"uid": uid,
"cid": cid,
"pid": pid,
"lotid": lotid,
"couponid": couponid,
"allmoney": allmoney,
"mid": mid
}
paystatus, paymoney, couponmoney = UserAccountLogic().order_chasepay(
params)
#异步通知支付状态
msg = {
"uid": uid,
"cid": cid,
"pid": pid,
"lotid": lotid,
"allmoney": allmoney,
"paymoney": paymoney,
"couponmoney": couponmoney,
"couponid": couponid,
"paystatus": paystatus
}
params = {
"oid": cid,
"lotid": lotid,
"msgtype": define.MSG_TYPE_CHASENUMBER_PAID,
"msgcnt": ujson.dumps(msg)
}
try:
mid = MsgRecord().insert(params)
msg.update({"mid": mid})
except:
# 防止重复插入
logger.error(traceback.format_exc())
raise
else:
rds = db_pool.get_redis("msgbus")
rds.publish("TRADE#CHASENUMBER#PAID", ujson.dumps(msg))
return
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 del_ck_from_redis(ck):
"""从redis删除ck
"""
if not ck:
raise ews.EwsError(ews.STATUS_SESSION_ERR)
uid_key = MC_PREFIX_UID + str(ck)
mc = db_pool.get_redis('session')
try:
mc.delete(uid_key)
except:
raise ews.EwsError(ews.STATUS_SESSION_ERR)
finally:
pass
def user_verify_code(handler):
json_args = handler.json_args
deviceid = json_args.get("mbimei", "")
rds = db_pool.get_redis('main')
key = rediskey.REDIS_MOBILE_LOGIN_COUNT_LIMIT.format(deviceid=deviceid)
login_times = rds.get(key)
iscode = "0"
if login_times and int(login_times) > 4:
iscode = "1"
ret = {"vcode_img_url": get_img_url(deviceid), "iscode": iscode}
return handler.ok(ret)
def get_wechat_access_token():
url = "https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid={corpid}&corpsecret={corpsecret}".format(
corpid=corpid, corpsecret=corpsecret)
r = db_pool.get_redis("main")
access_token = r.get("nncp:wechat:work:token")
if not access_token:
try:
req = requests.get(url, verify=False)
except:
req = requests.get(url, verify=False)
access_token = ujson.loads(req.content).get("access_token")
r.set("nncp:wechat:work:token", access_token, 60 * 60)
return access_token
else:
return access_token
def set_ck_to_redis(ck, uid, ttl=7 * 24 * 60 * 60, refresh=False):
"""设置memcached值
"""
if not ck or not uid:
raise ews.EwsError(ews.STATUS_SESSION_ERR)
uid_key = MC_PREFIX_UID + str(ck)
ck_key = MC_PREFIX_CK + str(uid)
logger.debug('uid=%s^^^^^^ck=%s^^^^^uid_key=%s^^^^^^^^ck_key=%s', uid, ck, uid_key, ck_key)
mc = db_pool.get_redis('session')
try:
mc.setex(uid_key, uid, ttl)
mc.setex(ck_key, ck, ttl)
except:
raise ews.EwsError(ews.STATUS_SESSION_ERR)
finally:
pass
def user_verify_code_img(handler):
"""图片验证码
"""
json_args = handler.json_args
deviceid = json_args.get("deviceid", "")
vtype = json_args.get("vtype", define.VTYPE_LOGIN)
redis_opt = db_pool.get_redis("main")
code = ""
for i in range(4):
code += chr(random.randrange(ord('a'), ord('z') + 1))
rds_name = rediskey.CRAZY_VERIFY_CODE_PREFIX.format(vtype=vtype,
vkey=deviceid)
redis_opt.set(rds_name, code, ex=5 * 60)
handler.set_header('Content-Type', 'image/png')
out = get_img(code)
return handler.ok(out, extd="verifycode")
def apply_data_token(dt_type):
"""申请一个data_token
"""
rds = db_pool.get_redis('main')
for i in range(4):
dt_key = hashlib.md5(str(random.random())).hexdigest()
dt_secret = hashlib.md5(str(random.random())).hexdigest()
if rds.setnx(DATA_TOKEN_PREFIX + dt_key, dt_secret) <= 0:
continue
rds.expire(DATA_TOKEN_PREFIX + dt_key, DATA_TOKEN_TTL)
return {
'key': dt_key,
'secret': dt_secret,
'ttl': DATA_TOKEN_TTL,
'type': dt_type,
}
else:
raise ews.EwsError(ews.STATUS_STATUS_BUSY)
def verify_img_code(self, verifycode, deviceid):
"""验证图片验证码
"""
rds = db_pool.get_redis('main')
key = rediskey.REDIS_MOBILE_LOGIN_COUNT_LIMIT.format(deviceid=deviceid)
login_count = rds.get(key) or 0
logger.info("verifycode:%s, deviceid:%s", verifycode, deviceid)
if int(login_count) <= 4:
return True
rds_name = rediskey.CRAZY_VERIFY_CODE_PREFIX.format(
vtype=define.VTYPE_LOGIN, vkey=deviceid)
code = rds.get(rds_name)
if code.lower() == verifycode.lower():
return True
return False
def user_verify_sms(self, mobile, code):
pt = re.compile('^0\d{2,3}\d{ 7,8}$|^1[3456789]\d{9}$|^147\d{8}')
phonematch = pt.match(mobile)
if not phonematch:
raise ews.EwsError(ews.STATUS_USER_MOBILE_FORMAT_ERROR)
if not code:
raise ews.EwsError(ews.STATUS_USER_MOBILE_CODE_EMPTY)
rds = db_pool.get_redis('main')
_code = rds.get(
rediskey.REDIS_USER_MOBILE_SMS_CODE.format(mobile=mobile)) or ""
if not _code:
raise ews.EwsError(ews.STATUS_USER_MOBILE_CODE_EXPIRE)
if str(_code) != str(code):
raise ews.EwsError(ews.STATUS_USER_MOBILE_CODE_ERROR)
checksum = hashlib.md5(
str(mobile) + str(code) + define.DEFIND_SMS_SALT).hexdigest()
return {"checksum": checksum, "code": code, "mobile": mobile}
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)
def get_ck_by_uid(uid):
mc = db_pool.get_redis('session')
return mc.get(MC_PREFIX_CK + str(uid))
def broadcast(channel, msg):
"""广播
"""
r = db_pool.get_redis('main')
r.publish(channel, msg)
def send(mq, msg):
"""发消息
"""
r = db_pool.get_redis('main')
r.rpush(mq, msg)
def __init__(self):
self.rds = db_pool.get_redis('main')
def project_prize(channel,msg):
"""校验中奖金额,执行派奖
"""
logger.debug('callback for [channel:%s]:[msg:%s]',channel,msg)
try:
unpack = ujson.loads(msg)
lotid = unpack.get("lotid")
pid = unpack.get("pid")
uid = unpack.get("uid")
obj_ticket = Ticket.get(int(lotid))
prj_tickets_status = obj_ticket.get_tickets_status_by_project(pid)
ticketnum = sum(ts["cnt"] for ts in prj_tickets_status)
prj_tickets_status = {ts["status"]:{"cnt":ts["cnt"],
"allmoney": ts["allmoney"],
"calgetmoney": ts["calgetmoney"],
"getmoney": ts["getmoney"]} for ts in prj_tickets_status}
rds = db_pool.get_redis("msgbus")
obj_order = Trade.get(int(lotid))
order = obj_order.get_project_by_pid(pid)
getmoney = Decimal(0)
if order.get("f_isjprize") == define.ORDER_JPRIZE_PRIZED:
logger.warning("彩种lotid=%s方案pid=%s重复派奖拦截", lotid, pid)
AlertMoniter().add_alert_msg("[重要]彩种lotid={}方案pid={}重复派奖拦截".format(lotid, pid))
else:
# 全部出票
if define.TICKET_STATUS_SAVED not in prj_tickets_status:
# 全部算奖
if define.TICKET_STATUS_PRINTED not in prj_tickets_status:
if define.TICKET_STATUS_PRIZED in prj_tickets_status:
calgetmoney = prj_tickets_status[define.TICKET_STATUS_PRIZED].get("calgetmoney")
getmoney = prj_tickets_status[define.TICKET_STATUS_PRIZED].get("getmoney")
cancelmoney = Decimal(0)
#if calgetmoney != getmoney:
if False: #TODO 暂时屏蔽奖金校验
logger.debug("彩种lotid=%s方案pid=%s派奖失败[算奖金额不匹配]", lotid, pid)
AlertMoniter().add_alert_msg("[重要]彩种lotid={}方案pid={}派奖失败[算奖金额不匹配]".format(lotid, pid))
else:
#部分撤单
if define.TICKET_STATUS_CANCEL in prj_tickets_status:
cancelmoney = prj_tickets_status[define.TICKET_STATUS_CANCEL].get("allmoney")
logger.debug("彩种lotid=%s方案pid=%s派奖完成[中奖%s元撤单%s元]", lotid, pid, getmoney, cancelmoney)
else:
logger.debug("彩种lotid=%s方案pid=%s派奖完成[中奖%s元]", lotid, pid, getmoney)
rds.publish("TRADE#ORDER#PRIZED", ujson.dumps({"lotid":lotid,
"pid":pid,
"uid":uid,
"allmoney":order.get("f_allmoney"),
"couponmoney":order.get("f_couponmoney"),
"cid": order.get("f_chaseid", 0) or 0, #竞篮竞足没有chaseid
"fid": order.get("f_fid", 0) or 0,
"getmoney":getmoney,
"cancelmoney":cancelmoney}))
elif define.TICKET_STATUS_CANCEL in prj_tickets_status:
cancelmoney = prj_tickets_status[define.TICKET_STATUS_CANCEL].get("allmoney")
logger.debug("彩种lotid=%s方案pid=%s派奖完成[撤单%s元]", lotid, pid, cancelmoney)
rds.publish("TRADE#ORDER#PRIZED", ujson.dumps({"lotid":lotid,
"pid":pid,
"uid":uid,
"allmoney":order.get("f_allmoney"),
"couponmoney":order.get("f_couponmoney"),
"cid": order.get("f_chaseid", 0) or 0, #竞篮竞足没有chaseid
"fid": order.get("f_fid", 0) or 0,
"getmoney": Decimal(0),
"cancelmoney":cancelmoney}))
else:
logger.debug("彩种lotid=%s方案pid=%s派奖完成[未中奖]", lotid, pid)
# 活动消息: [方案派奖成功]
activity_msg = {
"uid": order.get("f_uid"),
"pid": order.get("f_pid"),
"lotid": order.get("f_lotid"),
"wtype": order.get("f_wtype"),
"zhushu": order.get("f_zhushu"),
"beishu": order.get("f_beishu"),
"allmoney": order.get("f_allmoney"),
"couponmoney": order.get("f_couponmoney"),
"returnmoney": order.get("f_cancelmoney"),
"prize": order.get("f_getmoney"),
"buytime": order.get("f_crtime"),
"firsttime": order.get("f_firsttime", "") or "",
"lasttime": order.get("f_lasttime", "") or "",
"fadan": order.get("f_ptype", 0) or 0,
"followpid": order.get("f_fid", 0) or 0,
"orderstatus": order.get("f_orderstatus"),
"isjprize": order.get("f_isjprize"),
"platform": order.get("f_platform")
}
MQ.send_msg('prize_suc', activity_msg)
# 追号方案继续追号
chaseid = order.get("f_chaseid", 0)
if chaseid > 0:
params = {
'cid': chaseid,
'getmoney': getmoney
}
resp = obj_order.continue_chasenumber(params)
#异步通知拆票
if resp.get("pid", ""):
params = {
"lotid": resp.get("lotid"),
"oid": resp.get("pid"),
"msgtype": define.MSG_TYPE_ORDER_SUCCPAY,
"msgcnt": ujson.dumps(resp)
}
try:
mid = MsgRecord().insert(params)
unpack.update({"mid": mid,
"pid": resp.get("pid"),
"paystatus": define.ORDER_PAY_STATUS_SUCC}) #更新为新订单的pid
except:
# 防止重复插入
logger.error(traceback.format_exc())
else:
rds = db_pool.get_redis("msgbus")
rds.publish("TRADE#ORDER#SUCCPAY", ujson.dumps(unpack))
else:
logger.debug("彩种lotid=%s方案pid=%s派奖失败[未全部算奖]", lotid, pid)
else:
logger.debug("彩种lotid=%s方案pid=%s派奖失败[未全部出票]", lotid, pid)
except:
logger.error(traceback.format_exc())
AlertMoniter().add_alert_msg("[重要]派奖或追号异常! info={}".format(msg))
def order_update_paid(channel,msg):
"""投注订单已支付，更新订单状态
"""
logger.debug('callback for [channel:%s]:[msg:%s]',channel,msg)
msg = ujson.loads(msg)
#校验订单数据
mid = msg.pop("mid")
lotid = int(msg.get("lotid", 0))
pid = msg.get("pid")
uid = msg.get("uid")
couponid = msg.get("couponid")
paymoney = msg.get("paymoney")
couponmoney = msg.get("couponmoney")
#更新订单状态
obj_order = Trade.get(lotid)
paystatus = msg.get("paystatus")
try:
params = {
"mid": mid,
"pid": pid,
"couponid": couponid,
"paymoney": paymoney,
"couponmoney": couponmoney,
"originstatus": define.ORDER_STATUS_UNPAY,
"targetstatus": define.ORDER_STATUS_SUCC if paystatus == define.ORDER_PAY_STATUS_SUCC else define.ORDER_STATUS_FAILPAY,
"remark": define.PAY_STATUS_REMARK[paystatus]
}
obj_order.update_order_status(params)
except:
#更新订单状态异常处理, 告警+重试
logger.error(traceback.format_exc())
raise
else:
if paystatus == define.ORDER_PAY_STATUS_SUCC:
params = {
"lotid": lotid,
"oid": pid,
"msgtype": define.MSG_TYPE_ORDER_SUCCPAY,
"msgcnt": ujson.dumps(msg)
}
try:
mid = MsgRecord().insert(params)
msg.update({"mid": mid})
except:
# 防止重复插入
logger.error(traceback.format_exc())
else:
rds = db_pool.get_redis("msgbus")
rds.publish("TRADE#ORDER#SUCCPAY", ujson.dumps(msg))
# 活动消息: [用户购买成功]
order = obj_order.get_project_by_pid(pid)
activity_msg = {
"uid": order.get("f_uid"),
"pid": order.get("f_pid"),
"lotid": order.get("f_lotid"),
"wtype": order.get("f_wtype"),
"zhushu": order.get("f_zhushu"),
"beishu": order.get("f_beishu"),
"allmoney": order.get("f_allmoney"),
"couponmoney": order.get("f_couponmoney"),
"returnmoney": order.get("f_cancelmoney"),
"prize": order.get("f_getmoney"),
"buytime": order.get("f_crtime"),
"firsttime": order.get("f_firsttime", "") or "",
"lasttime": order.get("f_lasttime", "") or "",
"fadan": order.get("f_ptype", 0) or 0,
"followpid": order.get("f_fid", 0) or 0,
"orderstatus": order.get("f_orderstatus"),
"isjprize": order.get("f_isjprize"),
"platform": order.get("f_platform")
}
MQ.send_msg('buy_suc', activity_msg)
else:
pass
def tickets_update_project(lotid, pid, uid):
obj_ticket = Ticket.get(int(lotid))
prj_tickets_status = obj_ticket.get_tickets_status_by_project(pid)
ticketnum = sum(ts["cnt"] for ts in prj_tickets_status)
prj_tickets_status = {ts["status"]:ts["cnt"] for ts in prj_tickets_status}
logger.debug("prj_tickets_status=%s", prj_tickets_status)
orderstatus = isjprize = None
rds = db_pool.get_redis("msgbus")
# 全部出票
if define.TICKET_STATUS_SAVED not in prj_tickets_status:
# 全部算奖
if define.TICKET_STATUS_PRINTED not in prj_tickets_status:
# 全部未中奖
if define.TICKET_STATUS_PRIZED not in prj_tickets_status:
# 全部撤单
if define.TICKET_STAUTS_LOSE not in prj_tickets_status:
orderstatus = define.ORDER_STATUS_CANCEL
isjprize = define.ORDER_JPRIZE_UNCAL
else:
if define.TICKET_STATUS_CANCEL in prj_tickets_status:
orderstatus = define.ORDER_STATUS_PRINT_PART
else:
orderstatus = define.ORDER_STATUS_PRINT_ALL
isjprize = define.ORDER_JPRIZE_LOSE
else:
#部分撤单
if define.TICKET_STATUS_CANCEL in prj_tickets_status:
orderstatus = define.ORDER_STATUS_PRINT_PART
else:
orderstatus = define.ORDER_STATUS_PRINT_ALL
isjprize = define.ORDER_JPRIZE_PRIZE
#全部票已经算奖或者撤单, 触发派奖
#票状态入库与消息推送异步，此处会有重复消息
rds.publish("TRADE#ORDER#PRIZE", ujson.dumps({"lotid": lotid, "pid": pid, "uid": uid}))
else:
if define.TICKET_STATUS_CANCEL in prj_tickets_status:
orderstatus = define.ORDER_STATUS_PRINT_PART
else:
orderstatus = define.ORDER_STATUS_PRINT_ALL
isjprize = define.ORDER_JPRIZE_UNCAL
obj_order = Trade.get(int(lotid))
order = None
try:
obj_order.tickets_update_project(pid, orderstatus, isjprize)
order = obj_order.get_project_by_pid(pid)
# 活动消息: [方案出票成功]
if orderstatus in [define.ORDER_STATUS_PRINT_PART, define.ORDER_STATUS_PRINT_ALL]:
activity_msg = {
"uid": order.get("f_uid"),
"pid": order.get("f_pid"),
"lotid": order.get("f_lotid"),
"wtype": order.get("f_wtype"),
"zhushu": order.get("f_zhushu"),
"beishu": order.get("f_beishu"),
"allmoney": order.get("f_allmoney"),
"couponmoney": order.get("f_couponmoney"),
"returnmoney": order.get("f_cancelmoney"),
"prize": order.get("f_getmoney"),
"buytime": order.get("f_crtime"),
"firsttime": order.get("f_firsttime", "") or "",
"lasttime": order.get("f_lasttime", "") or "",
"fadan": order.get("f_ptype", 0) or 0,
"followpid": order.get("f_fid", 0) or 0,
"orderstatus": order.get("f_orderstatus"),
"isjprize": order.get("f_isjprize"),
"platform": order.get("f_platform")
}
MQ.send_msg('print_suc', activity_msg)
except:
pass
else:
#非追号订单， 通知解冻扣款
if order.get("f_chaseid", 0) == 0:
msg = {
"lotid": lotid,
"pid": pid,
"uid": uid
}
params = {
"lotid": lotid,
"oid": pid,
"msgtype": define.MSG_TYPE_TICKET_PRINTED,
"msgcnt": ujson.dumps(msg)
}
try:
mid = MsgRecord().insert(params)
msg.update({"mid": mid})
except:
pass
# 防止重复插入
#logger.error(traceback.format_exc())
else:
rds.publish("TRADE#ORDER#PRINTED", ujson.dumps(msg))
else:
pass
else:
pass
return orderstatus, isjprize
def user_send_sms(self, mobile, vtype):
"""
:param mobile:
:param vtype:
:return:
"""
pt = re.compile('^0\d{2,3}\d{6,7,8}$|^1[3456789]\d{9}$|^147\d{8}')
phonematch = pt.match(mobile)
if not phonematch:
raise ews.EwsError(ews.STATUS_USER_MOBILE_FORMAT_ERROR)
#
userinfo = self.get_user_info_by_mobile(mobile)
if vtype == "reg":
if userinfo:
raise ews.EwsError(ews.STATUS_USER_MOBILE_ALREAD_REG)
elif vtype == "auth":
if not userinfo:
raise ews.EwsError(ews.STATUS_USER_MOBILE_ACCOUNT_NOT_FOUND)
if userinfo.get("realname"):
raise ews.EwsError(ews.STATUS_ALREADY_TRUENAME)
else:
if not userinfo:
raise ews.EwsError(ews.STATUS_USER_MOBILE_ACCOUNT_NOT_FOUND)
rds = db_pool.get_redis('main')
data = {}
# 短信服务发送验证码(频率限制)
time_limit_key = rediskey.REDIS_USER_MOBILE_SEND_SMS_TIME_LIMIT.format(
mobile=mobile, vtype=vtype)
timestamp = rds.get(time_limit_key)
if timestamp:
data['timeleft'] = 60 - (int(time.time()) - int(timestamp))
return data
tday = datetime.datetime.now().weekday()
key = rediskey.REDIS_USER_MOBILE_SEND_SMS_COUNT_LIMIT.format(
mobile=mobile, tday=tday)
days_code = rds.get(key)
# TODO 测试屏蔽
if days_code:
if int(days_code) >= 20:
raise ews.EwsError(ews.STATUS_AUTH_MOBILE_CODE_MULNUM)
# 发送验证码
codelist = ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9')
code = sample(codelist, 4)
code = ''.join([str(i) for i in code])
logger.info("mobile %s code:%s", vtype, code)
params = {"code": code}
SMS_TPL = {
'reg': 'SMS_127035066',
'pwd': 'SMS_127035065',
'auth': 'SMS_127035069',
'withdraw': 'SMS_133270931'
}
resp = sms.send_sms(uuid.uuid1(), mobile, "小牛",
SMS_TPL.get(vtype, 'SMS_127035066'),
ujson.dumps(params))
resp = ujson.loads(resp)
resp_code = resp.get("Code")
if resp_code != "OK":
logger.debug(resp)
raise ews.EwsError(ews.STATUS_USER_SEND_SMS_FAIL)
rds.setex(rediskey.REDIS_USER_MOBILE_SMS_CODE.format(mobile=mobile),
code, 300) # 验证码有效期5分钟
rds.setex(time_limit_key, int(time.time()), 60) # 频率限制1分钟
rds.incr(key, 1)
rds.expire(key, 24 * 60 * 60)
data['lefttime'] = 60
data['expired'] = 300
return data
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 get_data_token(dt_key):
"""获取data_token
"""
rds = db_pool.get_redis('main')
return rds.get(DATA_TOKEN_PREFIX + dt_key)
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 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}
