def get_hall_broad(redis, session):
"""
获取大厅播放广播
级别优先级: 全服维护广播>全服循环广播>地区维护广播>地区循环广播
先播放优先级高的一条
"""
fields = ('sid', )
for field in fields:
exec('%s = request.forms.get("%s","").strip()' % (field, field))
try:
log_debug('[try get_hall_broad] sid[%s]' % (sid))
except:
return {'code': -300, 'msg': '接口参数错误!'}
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
check_code, check_msg, user_table, osid = check_session_verfiy(
redis, '/fish/getBroadcast/', SessionTable, account, sid, verfiySid)
log_debug('[try do_refresh] check_code[%s] check_msg[%s]' %
(check_code, check_msg))
if int(check_code) < 0:
if check_code == -4:
return {'code': check_code, 'msg': check_msg, 'osid': osid}
return {'code': check_code, 'msg': check_msg}
broadInfo = getHallBroadInfo(redis, 1, FISH_BRO_CONTAIN_ALL_LIST, 'FISH')
if not broadInfo:
return {'code': 0, 'broadcasts': [], 'requestPerSec': 10}
return {'code': 0, 'broadcasts': broadInfo, 'requestPerSec': 10}
def setQuestionStart(redis, session):
""""
点击了开始答题
"""
log_debug('点击了开始答题')
curTime = datetime.now()
curDate = curTime.strftime('%Y-%m-%d')
log_debug('点击了开始答题2')
try:
sid = request.forms.get('sid', '').strip()
except Exception as err:
return {'code': 1, 'msg': '参数错误'}
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
if not redis.exists(SessionTable):
return {'code': -3, 'msg': 'sid超时'}
# 检查是否到活动时间
isIntime, info = check_spring_time(redis, 4)
if not isIntime:
return {'code': 1, 'msg': info}
# 设置为已经答题
redis.hset(ACTIVICE_QUESTION_START, account, curDate)
return {'code': 0, 'msg': '开始答题'}
def do_inner(redis, session):
"""
获得附件
"""
eid = request.forms.get('eid', '').strip()
sid = request.forms.get('sid', '').strip()
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
attach = redis.hget('fish:mail:%s' % eid, 'attach')
if attach:
for c in eval(attach):
if int(c['id']) == 1:
coin = redis.hincrby('users:%s' % uid, 'coin', int(c['num']))
elif int(c['id']) == 2:
redis.hincrby('users:%s' % uid, 'warhead', int(c['num']))
# 领取后删除邮件
if redis.hget('fish:mail:%s' % eid, 'type') == '0':
mail_set = 'user:%s:system:mails'
else:
mail_set = 'user:%s:player:mails'
redis.srem(mail_set % uid, eid)
redis.delete('fish:mail:%s' % eid)
return {'code': 0, 'msg': 'ok'}
else:
return {'code': 1, 'msg': '领取失败！'}
def do_inner(redis, session):
'''
获取好友申请列表
'''
sid = request.GET.get("sid", "").strip()
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
reqs = redis.lrange('user:%s:friend:req:list' % uid, 0, -1)
data = []
for req in reqs:
uid = req.split('|')[0]
today = str(datetime.now())[:10]
today_fish = redis.get('user:%s:gain:fish:date:%s' % (uid, today))
today_coins = redis.get('user:%s:gain:coins:date:%s' % (uid, today))
today_warheads = redis.get('user:%s:gain:warheads:date:%s' %
(uid, today))
dic = redis.hgetall('friend:invite:%s' % req)
dic['invite_id'] = req
dic['comment'] = redis.hget('users:%s' % uid,
'comment') or '这个人很懒，还没有备注。'
dic['today_fish'] = today_fish or 0
dic['today_coins'] = today_coins or 0
dic['today_warheads'] = today_warheads or 0
data.append(dic)
return {'code': 0, 'data': data}
def get_benefit_info(redis,session):
fields = ('sid',)
for field in fields:
exec(consts.FORMAT_PARAMS_POST_STR%(field,field))
SessionTable,account,uid,verfiySid = getInfoBySid(redis,sid)
check_code,check_msg,user_table,osid = check_session_verfiy(redis,'/fish/getRewardInfo/',SessionTable,account,sid,verfiySid)
log_util.debug('[try do_refresh] check_code[%s] check_msg[%s]'%(check_code,check_msg))
if int(check_code)<0:
if check_code == -4:
return {'code':check_code,'msg':check_msg,'osid':osid}
return {'code':check_code,'msg':check_msg}
#判断是否能领取救济金
code, _,benefit= can_take_benefit(redis,uid,user_table)
if code < 0:
canTakeBenefit = 0
else:
canTakeBenefit = 1
benefitInfo = {
'minCoin': benefit['min_coin'],
'benefitCoin': benefit['benefit_coin'],
'benefitCount': benefit['take_count'],
'userCount': benefit['user_take_count'],
'canTakeBenefit': canTakeBenefit
}
token = encrypt_util.to_md5(str(time.time())+sid)
redis.set(USER_BENEFIT_TOKEN%(uid),token)
log_util.info('[getBenefitInfo] uid[%s] token[%s]'%(uid,token))
return {'code':0,'benefitInfo':benefitInfo,'token':token}
def do_inner(redis, session):
'''
好友列表
'''
sid = request.GET.get("sid", "").strip()
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
friends = redis.smembers('user:%s:friend:set' % uid)
data = []
for friend in friends:
uid = friend
today = str(datetime.now())[:10]
today_fish = redis.get('user:%s:gain:fish:date:%s' % (uid, today))
today_coins = redis.get('user:%s:gain:coins:date:%s' % (uid, today))
today_warheads = redis.get('user:%s:gain:warheads:date:%s' %
(uid, today))
headImgUrl, nickname, last_login_date, comment = redis.hmget(
'users:%s' % friend, 'headImgUrl', 'nickname', 'last_login_date',
'comment')
dic = {
"uid": friend,
"headImgUrl": headImgUrl,
"nickname": nickname,
"last_login_date": last_login_date,
"comment": comment or '这个人很懒，还没有备注。',
"today_fish": today_fish or 0,
"today_coins": today_coins or 0,
"today_warheads": today_warheads or 0,
}
data.append(dic)
return {'code': 0, 'data': data}
def do_gain_exchange_ticket(redis, session):
"""
获取捕鱼奖品兑换卷接口
"""
fields = ('sid', 'tickets')
for field in fields:
exec(consts.FORMAT_PARAMS_POST_STR % (field, field))
try:
log_util.debug('[try do_gain_exchange_ticket] sid[%s] tickets[%s]' %
(sid, tickets))
except:
return {'code': -300, 'msg': '接口请求参数错误'}
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
check_code, check_msg, user_table = check_session_verfiy(
redis, '/fish/getRewardInfo/', SessionTable, account, sid, verfiySid)
log_util.debug('[try do_refresh] check_code[%s] check_msg[%s]' %
(check_code, check_msg))
if int(check_code) < 0:
if check_code == -4:
return {'code': check_code, 'msg': check_msg, 'osid': sid}
return {'code': check_code, 'msg': check_msg}
if int(tickets) < 0:
return {'code': -5001, 'msg': '奖券数据错误'}
#测试
exchange_ticket = redis.hincrby(user_table, 'exchange_ticket',
int(tickets))
return {'code': 0, 'userTickets': exchange_ticket}
def refresh_reward_stock(redis, session):
"""
刷新所有商品的库存接口
:params sid 返回最新库存的ID和库存
"""
onshop_fields = ('reward_per_stock', )
fields = ('sid', )
for field in fields:
exec('%s = request.forms.get("%s","").strip()' % (field, field))
try:
log_util.debug('[try refresh_reward_stock] sid[%s]' % (sid))
except:
return {'code': -300, 'msg': '接口参数请求错误!'}
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
check_code, check_msg, user_table = check_session_verfiy(
redis, '/fish/getRewardInfo/', SessionTable, account, sid, verfiySid)
log_util.debug('[try do_refresh] check_code[%s] check_msg[%s]' %
(check_code, check_msg))
if int(check_code) < 0:
if check_code == -4:
return {'code': check_code, 'msg': check_msg, 'osid': sid}
return {'code': check_code, 'msg': check_msg}
reward_info = get_reward_shop_data(redis, onshop_fields)
log_util.debug('[try refresh_reward_stock] sid[%s] goodsInfo[%s] ' %
(sid, reward_info))
return {'code': 0, 'rewardInfo': reward_info}
def do_inner(redis, session):
'''
房间发送邀请
'''
sid = request.forms.get("sid", "").strip()
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
invite_uid = request.forms.get("invite_uid", "").strip()
game_id = request.forms.get("game_id", "").strip()
room_no = request.forms.get("room_no", "").strip()
redis.setex('user:%s:invited:room:no' % room_no, room_no, 30)
if redis.llen('user:%s:invited:req' % invite_uid) > 3:
redis.rpop('user:%s:invited:req' % invite_uid)
nickname, headImgUrl = redis.hget('users:%s' % uid, 'nickname',
'headImgUrl')
info = json.dumps({
"uid": uid,
"nickname": nickname,
"headImgUrl": headImgUrl,
"game_id": game_id
})
redis.lpush('user:%s:invited:req' % invite_uid, info)
return {"code": 0, "msg": "ok!"}
def do_getBroadcast(redis, session):
"""
捕鱼大厅广播
"""
curTime = datetime.now()
fields = ('sid', )
for field in fields:
exec('%s = request.forms.get("%s","").strip()' % (field, field))
try:
log_debug('[try do_getBroadcast] sid[%s]' % (field))
except:
return {'code': -300, 'msg': '接口参数错误'}
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
check_code, check_msg, user_table, osid = check_session_verfiy(
redis, '/fish/getBroadcast/', SessionTable, account, sid, verfiySid)
log_debug('[try do_refresh] check_code[%s] check_msg[%s]' %
(check_code, check_msg))
if int(check_code) < 0:
if check_code == -4:
return {'code': check_code, 'msg': check_msg, 'osid': osid}
return {'code': check_code, 'msg': check_msg}
groupId = redis.hget(user_table, 'parentAg')
if redis.exists(FORMAT_BROADCAST_LIST_TABLE):
broadcasts = getBroadcasts(redis, groupId)
else:
broadcasts = {'broadcasts': {}}
return {'code': 0, 'data': broadcasts}
def do_take_sign_reward(redis,session):
""" 领取签到奖励接口 """
fields = ('sid','signDay','isRetake')
for field in fields:
exec(consts.FORMAT_PARAMS_POST_STR%(field,field))
SessionTable,account,uid,verfiySid = getInfoBySid(redis,sid)
check_code,check_msg,user_table,osid = check_session_verfiy(redis,'/fish/doSign/',SessionTable,account,sid,verfiySid)
log_util.debug('[try do_refresh] check_code[%s] check_msg[%s]'%(check_code,check_msg))
if int(check_code)<0:
if check_code == -4:
return {'code':check_code,'msg':check_msg,'osid':osid}
return {'code':check_code,'msg':check_msg}
sign_id = redis.get(FISH_TABLE_NOW_RUN)
if not sign_id:
sign_id = 1
#检查领取是否有效
code,msg,sign_day_info= check_sign_valid(redis,uid,signDay,sign_id)
if code<0:
return {'code':code,'msg':msg}
weekTime = time.strftime("%Y-%m-%d:%W")
pipe = redis.pipeline()
message = ''
sign_type = convert_util.to_int(sign_day_info['give_type'])
if sign_type == consts.GIVE_COIN:
#领取的是金币的话
message = "金币{}".format(sign_day_info['coin'])
#pipe.hincrby(user_table,'coin',convert_util.to_int(sign_day_info['coin']))
# 改成领取1000000弹头
sign_warheads = get_should_sign_warheads(redis,uid)
pipe.hincrby(user_table,'warhead',sign_warheads)
# sign_day_info['taked'].append(uid)
pipe.hset(FISH_SIGN_TABLE%(sign_id), signDay, sign_day_info)
users = redis.hget(FISH_SIGN_TABLE_WEEK % (sign_id, weekTime), signDay)
if users:
users = eval(users)
else:
users = []
users.append(uid)
pipe.hset(FISH_SIGN_TABLE_WEEK % (sign_id, weekTime), signDay, users)
log_util.info('[do_take_sign_reward] uid[%s] do sign success.signDay[%s] coin[%s]'%(uid,signDay,sign_day_info['coin']))
month = time.strftime("%Y-%m")
number = redis.hget(FISH_SIGN_TABLE_USER_NUMBER % month, account)
if number:
number = int(number)
redis.hincrby(FISH_SIGN_TABLE_USER_NUMBER % month, account, 1)
number += 1
else:
redis.hset(FISH_SIGN_TABLE_USER_NUMBER % month, account, 1)
number = 1
pipe.hset("users:%s"%uid,"last_sign_date",str(datetime.now())[:10])
pipe.execute()
#return {'code':0,'msg':'签到成功,获取{}'.format(message), "number": number}
return {'code':0,'msg':'签到成功,获取{}'.format(sign_warheads), "number": number}
def do_inner(redis, session):
"""
选择附件
"""
sid = request.forms.get('sid', '').strip()
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
coin, warhead = redis.hmget('users:%s' % uid, 'coin', 'warhead')
warhead = int(warhead or 0)
return {'code': 0, 'data': {'2': warhead}}
def do_inner(redis, session):
'''
修改或添加备注
'''
sid = request.forms.get("sid", "").strip()
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
comment = request.forms.get("comment", "").strip()
redis.hset('users:%s' % uid, 'comment', comment)
return {'code': 0, 'msg': 'ok'}
def do_inner(redis, session):
'''
拒绝好友申请
'''
sid = request.forms.get("sid", "").strip()
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
invite_id = request.forms.get("invite_id", "").strip()
redis.lrem('user:%s:friend:req:list' % uid, invite_id)
redis.delete('friend:invite:%s' % invite_id)
return {'code': 0, 'msg': 'ok！'}
def do_inner(redis, session):
'''
删除好友
'''
sid = request.forms.get("sid", "").strip()
del_uid = request.forms.get("del_uid", "").strip()
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
redis.srem('user:%s:friend:set' % del_uid, uid)
redis.srem('user:%s:friend:set' % uid, del_uid)
return {'code': 0, 'msg': '删除成功！'}
def do_mailRefresh(redis, session):
"""
捕鱼邮件轮询接口
"""
fields = ('sid', )
for field in fields:
exec('%s = request.forms.get("%s","").strip()' % (field, field))
try:
log_debug('[try do_getBroadcast] sid[%s]' % (field))
except:
return {'code': -300, 'msg': '接口参数错误'}
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
check_code, check_msg, user_table, osid = check_session_verfiy(
redis, '/fish/getBroadcast/', SessionTable, account, sid, verfiySid)
log_debug('[try do_refresh] check_code[%s] check_msg[%s]' %
(check_code, check_msg))
if int(check_code) < 0:
if check_code == -4:
return {'code': check_code, 'msg': check_msg, 'osid': osid}
return {'code': check_code, 'msg': check_msg}
userMailList = []
unReadMailList = []
userMailTable = FORMAT_USER_MSG_FISH_LIST % (uid)
mail_ids = redis.lrange(userMailTable, 0, -1)
for mail_id in mail_ids:
mailTable = FORMAT_GAMEHALL_NOTIC_TABLE % (mail_id)
if not redis.exists(mailTable) or mail_id == '':
continue
readList = redis.smembers(FORMAT_MSG_READ_SET % (mail_id))
mailInfo = redis.hgetall(mailTable)
if uid in readList:
mailInfo['read'] = '1'
else:
mailInfo['read'] = '0'
if mailInfo['read'] == '1':
userMailList.append(mailInfo)
else:
unReadMailList.append(mailInfo)
log_util.debug('[mailRefresh] mail_id[%s] mailInfo[%s] readList[%s]' %
(mail_id, mailInfo, readList))
#合并消息
userMailList = unReadMailList + userMailList
return {
'code': 0,
'mailList': userMailList,
'unReadNums': len(unReadMailList)
}
def do_inner(redis, session):
'''
发送好友请求
'''
msg = request.forms.get("msg", "").strip()
sid = request.forms.get("sid", "").strip()
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
nickname = redis.hget('users:%s' % uid, 'nickname')
to_uid = request.forms.get("to_uid", "").strip()
if uid == to_uid:
return {'code': 1, 'msg': '您不能添加自己为好友！'}
if uid in redis.smembers('user:%s:friend:set' % to_uid):
return {'code': 1, 'msg': '您已是对方好友，不能重复发送好友请求！'}
if to_uid in redis.smembers('user:%s:friend:set' % uid):
return {'code': 1, 'msg': '对方好友已是您好友，不能重复发送好友请求！'}
if int(redis.scard('user:%s:friend:set' % uid) or 0) > 30:
return {'code': 1, 'msg': '您的好友已达到上限,无法添加好友！'}
if int(redis.scard('user:%s:friend:set' % to_uid) or 0) > 30:
return {'code': 1, 'msg': '对方好友已达到上限,无法添加好友！'}
account = redis.hget('users:%s' % to_uid, 'account')
#if account not in redis.smembers('account4weixin:set'):
# return {'code':1,'msg':'用户不存在！'}
#检验对方好友申请中是否存在
iids = redis.lrange('user:%s:friend:req:list' % to_uid, 0, -1)
for iid in iids:
if iid.split('|')[0] == uid:
return {'code': 1, 'msg': '您已发送过好友请求，不可重复发送！'}
send_time = str(datetime.now())[:19]
invite_id = uid + "|" + str(int(time.time()))
if redis.llen('user:%s:friend:req:list' % to_uid) > 30:
reids.rpop('user:%s:friend:req:list' % to_uid)
redis.lpush('user:%s:friend:req:list' % to_uid, invite_id)
redis.hmset('friend:invite:%s' % invite_id, {
"uid": uid,
"msg": msg,
"send_time": send_time,
"nickname": nickname,
})
return {'code': 0, 'msg': '发送成功！'}
def do_address(redis, session):
'''
玩家操作收获地址接口
@params:
sid
phone
province
city
address
name
'''
fields = ('sid', 'name', 'phone', 'city', 'address', 'action')
for field in fields:
exec(consts.FORMAT_PARAMS_POST_STR % (field, field))
try:
log_util.debug(
'[try do_address] get parasm sid[%s] name[%s] phone[%s] city[%s] addr[%s]'
% (sid, name, phone, city, address))
except:
return {'code': -300, 'msg': '接口参数错误'}
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
check_code, check_msg, user_table = check_session_verfiy(
redis, '/fish/getRewardInfo/', SessionTable, account, sid, verfiySid)
log_util.debug('[try do_refresh] check_code[%s] check_msg[%s]' %
(check_code, check_msg))
if int(check_code) < 0:
if check_code == -4:
return {'code': check_code, 'msg': check_msg, 'osid': sid}
return {'code': check_code, 'msg': check_msg}
if action not in ['add', 'modify', 'delete']:
return {'code': -2001, 'msg': '不被允许的操作,请重试.'}
address_info = {
'name': name,
'phone': phone,
'city': city,
'address': address
}
action_2_fun = {
'add': do_user_modify_addr,
'modify': do_user_modify_addr,
'delete': do_user_del_addr
}
op_result = action_2_fun[action](redis, uid, address_info)
log_util.debug('[try do_address] sid[%s] action[%s] op_result[%s]' %
(sid, action, op_result))
return {'code': 0, 'msg': '操作成功'}
def do_inner(redis, session):
"""
删除邮件
"""
eid = request.forms.get('eid', '').strip()
sid = request.forms.get('sid', '').strip()
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
if redis.hget('fish:mail:%s' % eid, 'type') == '0':
mail_set = 'user:%s:system:mails'
else:
mail_set = 'user:%s:player:mails'
redis.srem(mail_set % uid, eid)
redis.delete('fish:mail:%s' % eid)
return {'code': 0, 'msg': '删除成功!'}
def doSignMonth(redis, session):
"领取"
fields = ('sid', 'day')
for field in fields:
exec (consts.FORMAT_PARAMS_POST_STR % (field, field))
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
check_code,check_msg,user_table,osid = check_session_verfiy(redis,'/fish/getRewardInfo/',SessionTable,account,sid,verfiySid)
log_util.debug('[try do_refresh] check_code[%s] check_msg[%s]'%(check_code,check_msg))
if int(check_code)<0:
if check_code == -4:
return {'code':check_code,'msg':check_msg,'osid':osid}
return {'code':check_code,'msg':check_msg}
account2user_table = FORMAT_ACCOUNT2USER_TABLE % (account)
userTable = redis.get(account2user_table)
receiveMoney = json.loads(json.dumps({
5: 100000,
10: 250000,
15: 500000,
20: 1000000
}))
month = time.strftime("%Y-%m")
# 获取领取表格
receive = redis.hget(FISH_SIGN_TABLE_USER_RECEIVE % month, account)
number = redis.hget(FISH_SIGN_TABLE_USER_NUMBER % month, account)
number = int(number) if number else 0
if not receive:
receive = json.loads(json.dumps({5: 0, 10:0, 15:0, 20:0}))
else:
receive = json.loads(receive)
if int(day) <= number:
print(u"传进来的天数:%s" % day)
if day not in receive.keys():
return {"code": 1, "msg": "不存在这一天"}
money = receiveMoney[day]
print(u"天数：%s 金钱：%s " % (day, money))
if receive[day] == 0:
redis.hincrby(userTable, 'coin', money)
receive[day] = 1
redis.hset(FISH_SIGN_TABLE_USER_RECEIVE % month, account, json.dumps(receive))
else:
return {"code": 1, "msg": "你已经领取过了"}
#return {"code": 0, "msg": "成功", 'receive': receive, "money": money}
return {"code": 0, "msg": "成功", 'receive': '1000000', "money": 1000000}
else:
return {"code": 1, "msg": "暂时还不能领取"}
def do_take_benefit(redis,session):
""" 救济金补领接口 """
fields = ('sid','token')
for field in fields:
exec(consts.FORMAT_PARAMS_POST_STR%(field,field))
SessionTable,account,uid,verfiySid = getInfoBySid(redis,sid)
check_code,check_msg,user_table,osid = check_session_verfiy(redis,'/fish/getRewardInfo/',SessionTable,account,sid,verfiySid)
# ----------暂时可无限领取弹头救济金-----------------
'''
warhead = redis.hget('users:%s'%uid,'warhead')
warhead = int(warhead or 0)
if warhead < 1000:
redis.hincrby('users:%s'%uid,20000)
sendProtocol2AllGameService(redis, HEAD_SERVICE_PROTOCOL_MEMBER_REFRESH%(account),game="FISH")
return {'code':0,'msg':'领取救济金成功'}
'''
# ----------暂时可无限领取弹头救济金-----------------
log_util.debug('[try do_refresh] check_code[%s] check_msg[%s]'%(check_code,check_msg))
if int(check_code)<0:
if check_code == -4:
return {'code':check_code,'msg':check_msg,'osid':osid}
return {'code':check_code,'msg':check_msg}
server_token = redis.get(USER_BENEFIT_TOKEN%(uid))
if token != server_token:
log_util.info('[do_take_benefit] client_token[%s] server_token[%s]'%(token,server_token))
return {'code':-9003,'msg':'不能重复领取!'}
code,msg,benefit_info = can_take_benefit(redis,uid,user_table)
if code < 0:
log_util.debug('[do_take_benefit] can\'t take benefit code[%s] msg[%s]'%(code,msg))
return {'code':code,'msg':msg}
_datetime = time.strftime("%Y-%m-%d", time.localtime())
try:
#领取救济金
pipe = redis.pipeline()
pipe.hincrby(FISH_BENEFIT_COIN_TABLE % _datetime ,uid,1)
pipe.hincrby(user_table,'coin',benefit_info['benefit_coin'])
except Exception,e:
log_util.error('[do_take_benefit] take benefit error[%s]'%(e))
return {'code':-9000,'msg':'领取救济金失败!'}
def do_buyCoin(redis, session):
"""
测试购买金币接口
:params sid 用户sid
:params cards 购买金币数
"""
fields = ('sid', 'cards', 'price', 'goodId')
for field in fields:
exec('%s = request.forms.get("%s","").strip()' % (field, field))
try:
log_util.debug('[try do_buyCoin] sid[%s] cardNums[%s] price[%s]' %
(sid, cards, price))
if not price:
return {'code': -300, 'msg': '接口参数请求错误'}
except:
return {'code': -300, 'msg': '接口参数请求错误'}
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
check_code, check_msg, user_table = check_session_verfiy(
redis, '/fish/buyCoin/', SessionTable, account, sid, verfiySid)
if int(check_code) < 0:
if check_code == -4:
return {'code': check_code, 'msg': check_msg, 'osid': sid}
return {'code': check_code, 'msg': check_msg}
_wechatHandler = fish_pay_func.test_WeChatPay(redis, goodId, user_table)
if not _wechatHandler:
return {'code': -6001, 'msg': '购买金币失败'}
#统计金币
_handler = fish_pay_func.do_pay_record(redis, uid, user_table, cards,
price)
if not _handler:
return {'code': -6000, 'msg': '购买金币失败.'}
coin = redis.hget(user_table, 'coin')
log_util.debug('[try buyCoin] return coin[%s]' % (coin))
redis.hincrby(user_table, 'warhead', int(cards))
print '=' * 66
print '=' * 66
print 'cards:'
print cards
print '=' * 66
print '=' * 66
return {'code': 0, 'msg': '购买金币成功', 'coin': coin}
def getQuestion(redis, session):
"""
答题题目接口
"""
curTime = datetime.now()
curDate = curTime.strftime('%Y-%m-%d')
try:
sid = request.forms.get('sid', '').strip()
except Exception as err:
return {'code': 1, 'msg': '参数错误'}
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
if not redis.exists(SessionTable):
return {'code': -3, 'msg': 'sid超时'}
# 检查是否到活动时间
isIntime, info = check_spring_time(redis, 4)
if not isIntime:
return {'code': 1, 'msg': info}
#检查是否答过题
answer = redis.hget(ACTIVICE_QUESTION_ANSWER, account)
isStart = redis.hget(ACTIVICE_QUESTION_START, account)
if answer == curDate or isStart == curDate:
return {'code': 1, 'msg': '你已经答过题了'}
#获取题目
questions = redis.hkeys(ACTIVICE_QUESTION_ALL_HESH)
selectCount = min(ACTIVICE_QUESTION_SELECT, len(questions))
selectKeys = random.sample(questions, selectCount)
selectQuestion = []
for key in selectKeys:
q = redis.hget(ACTIVICE_QUESTION_ALL_HESH, key)
selectQuestion.append(json.loads(q))
data = {
'list': selectQuestion,
'title': ACTIVICE_QUESTION_TITLE,
'desc': ACTIVICE_QUESTION_DESC,
'timeLimit': ACTIVICE_QUESTION_TIME,
'route': {
'method': 'POST',
'url': '/fish/question/answer',
"params": {}
}
}
return {'code': 0, 'msg': '获取题库成功', 'data': data}
def do_inner(redis, session):
"""
查看邮件
"""
sid = request.GET.get('sid', '').strip()
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
eids = list(redis.smembers('user:%s:system:mails' % uid)) + list(
redis.smembers('user:%s:player:mails' % uid))
# 超过三十天则删除
for eid in eids:
now_ts = int(time.time())
send_ts = int(eid.split('|')[1])
if now_ts - send_ts > 3600 * 24 * 30:
if redis.hget('fish:mail:%s' % eid, 'type') == "0":
mail_set = 'user:%s:system:mails'
else:
mail_set = 'user:%s:player:mails'
redis.delete('fish:mail:%s' % eid)
redis.srem(mail_set % uid, eid)
# 获取未过期的所有邮件
eids = list(redis.smembers('user:%s:system:mails' % uid)) + list(
redis.smembers('user:%s:player:mails' % uid))
data_not_read = []
data_is_read = []
if eids:
for eid in eids:
dic = redis.hgetall('fish:mail:%s' % eid)
dic['attach'] = eval(dic['attach'])
if redis.hget('fish:mail:%s' % eid, 'isRead') == '0':
data_not_read.append(dic)
else:
data_is_read.append(dic)
data_not_read = sorted(data_not_read,
key=lambda x: int(x['timestamp']),
reverse=True)
data_is_read = sorted(data_is_read,
key=lambda x: int(x['timestamp']),
reverse=True)
data = data_not_read + data_is_read
return {'code': 0, 'data': data}
def do_inner(redis, session):
'''
寻找列表
'''
sid = request.GET.get("sid", "").strip()
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
cur_day = datetime.now()
day7ago = cur_day - timedelta(7)
uids = []
while cur_day >= day7ago:
date_str = str(cur_day)[:10]
uids += list(redis.smembers('active:users:date:%s' % date_str))
cur_day -= timedelta(1)
uids = list(set(uids))
find_uids = get_find_uids(redis, uids, uid)
data = []
for friend in find_uids:
uid = friend
today = str(datetime.now())[:10]
today_fish = redis.get('user:%s:gain:fish:date:%s' % (uid, today))
today_coins = redis.get('user:%s:gain:coins:date:%s' % (uid, today))
today_warheads = redis.get('user:%s:gain:warheads:date:%s' %
(uid, today))
headImgUrl, nickname, last_login_date, comment = redis.hmget(
'users:%s' % friend, 'headImgUrl', 'nickname', 'last_login_date',
'comment')
if not comment:
comment = "这个人很懒，还没有备注。"
dic = {
"uid": friend,
"headImgUrl": headImgUrl,
"nickname": nickname,
"last_login_date": last_login_date,
"comment": comment,
"today_fish": today_fish or 0,
"today_coins": today_coins or 0,
"today_warheads": today_warheads or 0,
}
data.append(dic)
return {'code': 0, 'data': data}
def getQuestion(redis, session):
"""
问卷调查接口
"""
curTime = datetime.now()
curDate = curTime.strftime('%Y-%m-%d')
try:
sid = request.forms.get('sid', '').strip()
data = request.forms.get('data', '').strip()
anwser = json.loads(data)
except Exception as err:
return {'code': 1, 'msg': '参数错误'}
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
if not redis.exists(SessionTable):
return {'code': -3, 'msg': 'sid超时'}
# 检查是否答过题
isAnswer = redis.sismember(ACTIVICE_SURVER_ANSWER % SURVER_NUMBER, account)
if isAnswer:
return {'code': 1, 'msg': '你已经回答过问卷了'}
account2user_table = FORMAT_ACCOUNT2USER_TABLE % (account)
userTable = redis.get(account2user_table)
#记录数据
pipe = redis.pipeline()
for tid, ans in anwser.items():
for aid in ans:
pipe.hincrby(ACTIVICE_SURVER_RESULT % (SURVER_NUMBER, tid),
str(aid), 1)
#送出奖励
goldTotal = SURVER_SEND_GOLD
pipe.hincrby(userTable, "coin", goldTotal)
# 记录金币数
pipe.hincrby(ACTIVICE_SEND_SURVER_GOLD_COUNT % SURVER_NUMBER, curDate,
goldTotal)
#记录已答题
pipe.sadd(ACTIVICE_SURVER_ANSWER % SURVER_NUMBER, account)
pipe.execute()
return {
'code': 0,
'msg': '感谢您完成问卷，谢谢您的大力支持！\n获得{0}金币'.format(goldTotal),
'data': ''
}
def get_user_reward_record(redis, session):
"""
玩家兑换记录接口
"""
fields = ('sid', 'pageNum')
exchange_fields = ( # 兑换记录需要的字段
'exchange_reward_name', 'exchange_card_no', 'exchange_card_pwd',
'exchange_date', 'exchange_reward_status')
for field in fields:
exec(consts.FORMAT_PARAMS_POST_STR % (field, field))
try:
log_util.debug(
'[try get_user_reward_record] get params sid[%s] pageNum[%s]' %
(sid, pageNum))
if not pageNum:
pageNum = 1
except:
return {'code': -300, 'msg': '接口参数错误'}
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
check_code, check_msg, user_table = check_session_verfiy(
redis, '/fish/getRewardInfo/', SessionTable, account, sid, verfiySid)
log_util.debug('[try do_refresh] check_code[%s] check_msg[%s]' %
(check_code, check_msg))
if int(check_code) < 0:
if check_code == -4:
return {'code': check_code, 'msg': check_msg, 'osid': sid}
return {'code': check_code, 'msg': check_msg}
pageNum = convert_util.to_int(pageNum)
user_exchange_list, user_total_record = get_user_exchange_list(
redis, uid, exchange_fields, pageNum, consts.NUMS_PER_PAGE)
log_util.debug(
'[try get_user_reward_record] sid[%s] user_exchange_list[%s]' %
(sid, user_exchange_list))
return {
'code': 0,
'userExchangeInfo': user_exchange_list,
'totalRecords': user_total_record
}
def do_checkOrder(redis, session):
"""
检查微信支付是否成功接口
"""
curTime = datetime.now()
orderSwitch = convert_util.to_int(
redis.hget(FISH_CONSTS_CONFIG, 'wechat_switch'))
outTradeNo = request.forms.get('outTradeNo', '').strip()
sid = request.forms.get('sid', '').strip()
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
check_code, check_msg, user_table = check_session_verfiy(
redis, '/fish/checkOrder/', SessionTable, account, sid, verfiySid)
log_util.debug('[try checkOrder] check_code[%s] check_msg[%s]' %
(check_code, check_msg))
if int(check_code) < 0:
if check_code == -4:
return {'code': check_code, 'msg': check_msg, 'osid': sid}
return {'code': check_code, 'msg': check_msg}
if not outTradeNo:
return {'code': -1, 'msg': 'outTradeNo不存在'}
orderTable = ORDER_TABLE4FISH % (outTradeNo)
if not redis.exists(SUCCEED_ORDER4FISH) or not redis.sismember(
SUCCEED_ORDER4FISH, orderTable):
return {'code': -9}
if not orderTable:
return {'code': -1, 'msg': 'orderTable不存在'}
roomCards = redis.hget(orderTable, ('roomCards'))
checkNum = redis.hincrby(orderTable, 'CheckNum', 1)
groupId = redis.hget(user_table, 'parentAg')
redis.hset(orderTable, 'groupId', groupId)
# roomCard = redis.get(USER4AGENT_CARD%(groupId, id))
roomCard = redis.hget(user_table, 'coin')
return {'code': 0, 'roomCard': roomCard}
def do_inner(redis, session):
'''
接受好友申请
'''
sid = request.forms.get("sid", "").strip()
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
from_uid = request.forms.get("from_uid", "").strip()
invite_id = request.forms.get("invite_id", "").strip()
if int(redis.scard('user:%s:friend:set' % uid) or 0) > 30:
return {'code': 1, 'msg': '添加失败，您的好友已达到上限！'}
if int(redis.scard('user:%s:friend:set' % from_uid) or 0) > 30:
return {'code': 1, 'msg': '添加失败，对方好友已达到上限！'}
redis.sadd('user:%s:friend:set' % uid, from_uid)
redis.sadd('user:%s:friend:set' % from_uid, uid)
redis.delete('friend:invite:%s' % invite_id)
redis.lrem('user:%s:friend:req:list' % uid, invite_id)
return {'code': 0, 'msg': '添加成功！'}
def get_fish_goods_info(redis, session):
'''
捕鱼获取商城商品接口
:params sid 用户登录session
:params ver 当前商城的ver
:return rewardInfo:[{},{}],addressInfo:{}
'''
fields = ('sid', 'rewardType', 'ver')
onshop_fields = ('reward_name', 'reward_per_stock', 'reward_img_path',
'reward_need_ticket', 'reward_pos', 'reward_type')
for field in fields:
exec(consts.FORMAT_PARAMS_POST_STR % (field, field))
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
check_code, check_msg, user_table = check_session_verfiy(
redis, '/fish/getRewardInfo/', SessionTable, account, sid, verfiySid)
log_util.debug('[try do_refresh] check_code[%s] check_msg[%s]' %
(check_code, check_msg))
if int(check_code) < 0:
if check_code == -4:
return {'code': check_code, 'msg': check_msg, 'osid': sid}
return {'code': check_code, 'msg': check_msg}
user_addr_table = FORMAT_USER_ADDRESS_TABLE % (uid)
if not redis.exists(user_addr_table):
address_info = {}
else:
address_info = redis.hgetall(user_addr_table)
#获取奖品列表
reward_type_info, reward_goods_info = get_reward_shop_api_data(
redis, onshop_fields)
log_util.debug(
'[try get_fish_goods_info] sid[%s] goodsInfo[%s] address_info[%s] ' %
(sid, reward_goods_info, address_info))
return {
'code': 0,
'typeInfo': reward_type_info,
'rewardInfo': reward_goods_info,
'addressInfo': address_info
}
