def get_rate_reports(redis, selfUid, startDate, endDate, agent_type):
"""
获取抽成的列表
"""
date_list = convert_util.to_week_list(startDate, endDate)
if agent_type == 0:
my_downline_agents = redis.smembers(AGENT_CHILD_TABLE % (selfUid))
elif agent_type > 0:
my_downline_agents = getAllChildAgentId(redis, selfUid)
else:
my_downline_agents = []
log_util.debug('my_downline_agents[%s]' % (my_downline_agents))
RateReportList = []
for date in date_list:
downline_reports = get_downline_rate(redis, date, my_downline_agents)
log_util.debug(
'[get_rate_reports] date[%s] selfId[%s] downline_reports[%s]' %
(date, selfUid, downline_reports))
if not downline_reports:
continue
RateReportList.extend(downline_reports)
log_util.debug('[agentRateTable1111] selfUid[%s] RateReportList[%s]' %
(selfUid, RateReportList))
return {'date': RateReportList}
def verfiyRcvDatas(redis, params):
"""
校验支付数据
"""
curTime = datetime.now()
orderTable = ORDER_TABLE % (params['out_trade_no'])
if not redis.exists(orderTable):
log_util.debug('[%s][wechatPay][error] orderNo[%s] is not exists.' %
(curTime, params['out_trade_no']))
return False
updateInfo = {
'money': params['total_fee'],
'endTime': params['time_end'],
'currency': params['fee_type'],
'orderNum': params['transaction_id'],
'type': 'successful',
}
pipe = redis.pipeline()
try:
log_util.debug('[%s][wechatPay][info] update orderInfo[%s] success.'\
%(curTime,updateInfo))
pipe.hmset(orderTable, updateInfo)
pipe.srem(PENDING_ORDER, orderTable)
pipe.sadd(SUCCEED_ORDER, orderTable)
pipe.persist(orderTable)
pipe.execute()
except:
log_util.debug('[%s][wechatPay][error] update orderInfo[%s] error.' %
(curTime, updateInfo))
return False
return True
def get_downline_rate(redis, date, my_downline_agents):
"""
获取下线抽成的列表(循环查询)
"""
RateReportList = []
for agent_id in my_downline_agents:
agentTable = AGENT_TABLE % (agent_id)
aType, parentId = redis.hmget(agentTable, ('type', 'parent_id'))
log_util.debug('agent_id[%s] aType[%s] parentId[%s]' %
(agent_id, aType, parentId))
if aType in ['2', '3']:
agentPerPriceList = redis.smembers(AGENT_ROOMCARD_PER_PRICE %
(parentId))
else:
agentPerPriceList = redis.smembers(AGENT_ROOMCARD_PER_PRICE %
(agent_id))
log_util.debug(
'----------------------------------------agentPerPriceList[%s]' %
(agentPerPriceList))
agentRateList = redis.smembers(AGENT_RATE_SET % (agent_id))
log_util.debug(
'----------------------------------------agentRateList[%s]' %
(agentRateList))
for price in agentPerPriceList:
for rate in agentRateList:
agentRateTable = AGENT_RATE_DATE % (agent_id, rate, price,
date)
if redis.exists(agentRateTable):
agentRate = redis.hgetall(agentRateTable)
agentRate['date'] = date
agentRate['id'] = agent_id
RateReportList.append(agentRate)
#log_util.debug('[RateReportList] agentTable[%s] RateReportList[%s]'%(agentTable,RateReportList))
return RateReportList
def addRoomCard2Member(redis, transNo):
"""
会员增加房卡
"""
curTime = datetime.now()
orderTable = ORDER_TABLE % (transNo)
if not redis.exists(orderTable):
log_util.debug('[%s][wechatPay][error] orderNo[%s] is not exists.' %
(curTime, params['out_trade_no']))
return False
goodid, memberAccount = redis.hmget(orderTable, ('num', 'account'))
rType = redis.hget(GOODS_TABLE % goodid, 'type')
rType = int(rType) if rType else None
if rType == 2:
addRoomCard2Member4Type2(redis, curTime, orderTable, memberAccount)
return
cardNums, present_card = redis.hmget(orderTable,
('roomCards', 'presentCards'))
if not present_card:
present_card = 0
try:
present_card = int(present_card)
except:
present_card = 0
#chargeNums = TYPE_2_CARS[rType]
account2user_table = FORMAT_ACCOUNT2USER_TABLE % (memberAccount
) #从账号获得账号信息，和旧系统一样
userTable = redis.get(account2user_table)
groupId = redis.hget(userTable, 'parentAg')
#会员ID
id = userTable.split(':')[1]
pipe = redis.pipeline()
pipe.incrby(USER4AGENT_CARD % (groupId, id),
(int(cardNums) + present_card))
#记录充值卡总额
if not redis.exists(USER4AGENT_RECHARGE % (groupId, id)):
pipe.set(USER4AGENT_RECHARGE % (groupId, id), 0)
pipe.incrby(USER4AGENT_RECHARGE % (groupId, id), int(cardNums))
CardMoney = getCardMoney(redis, groupId)
log_util.debug('[%s][wechatPay] recharge CardMoney[%s]' %
(curTime, CardMoney))
#计算分成金额
countRateOfAgent(redis, groupId, int(cardNums), CardMoney)
log_util.debug(
'[%s][wechatPay] recharge roomcards[%s] to account[%s] success' %
(curTime, cardNums, memberAccount))
roomCards = pipe.execute()[0]
pipe = redis.pipeline()
ymd = datetime.now().strftime("%Y-%m-%d")
useDatas = [int(cardNums), 4, roomCards]
useStr = ';'.join(map(str, useDatas))
pipe.lpush(PLAYER_DAY_USE_CARD % (id, ymd), useStr)
pipe.expire(PLAYER_DAY_USE_CARD % (id, ymd), SAVE_PLAYER_DAY_USE_CARD_TIME)
pipe.execute()
def get_jsapi_ticket(redis, access_token):
curTime = datetime.now()
url = 'https://api.weixin.qq.com/cgi-bin/ticket/getticket?access_token=%s&type=jsapi' % (
access_token)
message = getUrlMessage(url)
log_util.debug('[%s][getJsapiTicket][info] message [%s]' %
(curTime, message))
errMsg = ''
jsapi_ticket = ''
if message['errcode'] != 0:
log_util.debug(
'[%s][getJsapiTicket][info] ACCESS_TOKEN_JSAPI message:%s' %
(curTime, message))
errMsg = message['errmsg']
else:
pipe = redis.pipeline()
pipe.set(ACCESS_TOKEN_JSAPI, message['ticket'])
# pipe.expire(ACCESS_TOKEN_JSAPI, message['expires_in'])
pipe.expire(ACCESS_TOKEN_JSAPI, 6000)
pipe.execute()
jsapi_ticket = message['ticket']
return jsapi_ticket, errMsg
def getBroadcasts(redis, groupId, isNew=''):
"""
获取广播列表
"""
bIds = redis.lrange(HALL_BROADCAST_LIST, 0, -1)
broadInfos = []
groupIds = getGroupIds(redis, groupId)
groupIds.append(groupId)
log_util.debug('[groupIds][%s] bids[%s]' % (groupIds, bIds))
for bid in bIds:
if redis.exists(FORMAT_BROADCAST_TABLE % (bid)):
bInfos = redis.hgetall(FORMAT_BROADCAST_TABLE % (bid))
if bInfos['ag'] in groupIds:
broadInfos.append(bInfos)
else:
redis.lrem(FORMAT_BROADCAST_LIST_TABLE, '1', bid)
broadcasts = {'broadcasts': broadInfos}
if isNew:
broadcasts['isNew'] = isNew
return broadcasts
def get_notic_list(redis,session,action='HALL'):
lang = getLang()
action = action.upper()
fields = ('startDate','endDate','isList')
for field in fields:
exec('%s = request.GET.get("%s","").strip()'%(field,field))
log_util.debug('[get_notic_list] get params startDate[%s] endDate[%s] isList[%s] action[%s]'\
%(startDate,endDate,isList,action))
if isList:
noticList = getNoticsList(redis,session,lang,session['id'],action)
return json.dumps(noticList,cls=json_util.CJsonEncoder)
else:
info = {
'title' : lang.GAME_NOTIFY_LIST_TXT,
'tableUrl' : BACK_PRE+'/notic/list/{}?isList=1'.format(action),
'createUrl' : BACK_PRE+'/notice/create/{}'.format(action),
'STATIC_LAYUI_PATH' : STATIC_LAYUI_PATH,
'STATIC_ADMIN_PATH' : STATIC_ADMIN_PATH,
'back_pre' : BACK_PRE,
'addTitle' : lang.GAME_NOTIFY_CREATE_TXT
}
return template('admin_notice_list',info=info,lang=lang,RES_VERSION=RES_VERSION)
def check_session_verfiy(redis, api_name, SessionTable, account, sid,
verfiySid):
'''
验证session是否合法
return code,msg
'''
log_util.debug('[on refresh] account[%s] sid[%s]' % (account, sid))
if verfiySid and sid != verfiySid:
#session['member_account'],session['member_id'] = '',''
return -4, '账号已在其他地方登录', False, '1'
if redis.exists('kick:session:%s' % sid):
return -4, '账号已在其他地方登录', False, '1'
if not redis.exists(SessionTable):
return -3, 'sid 超时', False, '',
user_table = getUserByAccount(redis, account)
if not redis.exists(user_table):
return -5, '该用户不存在', False, ''
return 0, True, user_table, ''
def get_wechat_records(redis,session,action="HALL"):
"""
获取微信售钻记录接口
action通知是获取捕鱼还是棋牌
"""
lang = getLang()
action = action.upper()
fields = ('isList','startDate','endDate','memberId','orederNo')
for field in fields:
exec('%s = request.GET.get("%s","").strip()'%(field,field))
log_util.debug('[try get_wechat_records] get params isList[%s] startDate[%s] endDate[%s] memberId[%s] orderNo[%s] action[%s]'\
%(isList,startDate,endDate,memberId,orederNo,action))
if isList:
condition = {
'startDate' : startDate,
'endDate' : endDate,
'memberId' : memberId,
'orderNo' : orederNo
}
records = get_wechat_order_records(redis,session['id'],condition,action)
return json.dumps(records,cls=json_util.CJsonEncoder)
else:
params = 'isList=1&startDate=%s&endDate=%s'%(startDate,endDate)
info = {
'title' : lang.WECHAT_RECORD_TITLE if action =="HALL" else lang.WECHAT_FISH_RECORD_TITLE,
'tableUrl' : BACK_PRE+'/order/wechat/record/{}?{}'.format(action,params),
'searchUrl' : BACK_PRE+'/order/wechat/record/{}'.format(action),
'STATIC_LAYUI_PATH' : STATIC_LAYUI_PATH,
'STATIC_ADMIN_PATH' : STATIC_ADMIN_PATH,
'startDate' : startDate,
'action' : action,
'endDate' : endDate
}
return template('admin_wechat_record',info=info,lang=lang,RES_VERSION=RES_VERSION)
def run(self):
while True:
try:
# get task from finish que
task = self.que_manager.getQue(self.get_que_name)
if task is None:
time.sleep(0.5)
continue
log_util.debug("get one task from ingest queue: %s", task)
# ingest or delete image
task = json.loads(task.decode())
if task['ingest']:
# ingest image
im_type = 'jpg'
if image_util.is_gif(task['img_path']):
im_type = 'gif'
self.ingest_one(task['img_path'], im_type)
else:
# delete image
utils.remove_file(task['img_path'])
except Exception as e:
log_util.error("Ingestor run error: %s", str(e))
def get_betlist(redis,session):
"""
获取投注明细列表
"""
lang = getLang()
fields = ('isList','startDate','endDate','room_id','pageSize','pageNumber','sort_name','sort_method','user_id')
for field in fields:
exec('%s = request.GET.get("%s","").strip()'%(field,field))
log_util.debug('isList[%s] startDate[%s] [%s] [%s] [%s] [%s]'%(isList,startDate,endDate,room_id,pageSize,pageNumber))
page_info = { #分页数据
'page_size' : pageSize,
'page_number' : pageNumber
}
sort_info = { #排序数据
'sort_name' : sort_name,
'sort_method' : sort_method
}
if isList:
bet_records = get_bet_list(redis,startDate,endDate,room_id,user_id,page_info,sort_info)
return json.dumps(bet_records)
else:
info = {
'title' : '胜负统计',
'STATIC_LAYUI_PATH' : STATIC_LAYUI_PATH,
'STATIC_ADMIN_PATH' : STATIC_ADMIN_PATH,
'back_pre' : BACK_PRE,
'room_search' : True,#房间搜索
'user_search' : True,
'rooms' : get_room_list(redis),
'tableUrl' : BACK_PRE+'/fish/bet/list?isList=1'
}
return template('admin_fish_room_bet',PAGE_LIST=PAGE_LIST,info=info,lang=lang,RES_VERSION=RES_VERSION)
def getNoticeReadPage(redis,session):
"""
读取信息
"""
curTime = datetime.now()
lang = getLang()
msgType = request.GET.get('type','').strip()
msgId = request.GET.get('id','').strip()
agentId = request.GET.get('agentId','').strip()
memberId = request.GET.get('memberId','').strip()
action = request.GET.get('action','').strip()
#log
log_util.debug('[try getNoticeReadPage] msgId[%s] msgType[%s] agentId[%s] action[%s]'%(msgId,msgType,agentId,action))
noticeItem = FORMAT_GAMEHALL_NOTIC_TABLE%(msgId)
if not redis.exists(noticeItem):
return template('notice_not_exists')
noticeReads = FORMAT_MSG_READ_SET%(msgId)
readList = redis.smembers(noticeReads)
#设置消息为已读
if memberId not in readList:
redis.sadd(noticeReads,memberId)
title,content = redis.hmget(noticeItem,('title','content'))
bodyCorol = "#FFFFFF"
if action == "FISH":
bodyCorol = "#1874CD"
if msgType == MAIL_TYPE:
#setReward2User(msgId,userId)
deleteMsg(redis,msgId,memberId)
log_util.debug('[try getNoticeReadPage] RETURN msgId[%s] title[%s] content[%s] action[%s]'%(msgId,title,content,action))
return template('notice_content_page',content=content,title=title)
def do_delBroadsList(redis, session):
"""
广播删除
"""
lang = getLang()
fields = ('broadIds', 'broad_belone')
for field in fields:
exec('%s = request.forms.get("%s","").strip()' % (field, field))
if not broadIds:
return {'code': 1, 'msg': '参数错误'}
broadIds = broadIds.split(",")
log_util.debug('[try do_delBroadsList] broadIds[%s] broad_belone[%s]' %
(broadIds, broad_belone))
for broadId in broadIds:
try:
do_deleteBroads(redis, broadId, broad_belone)
except Exception, e:
log_util.debug(
'[try do_delBroadsList] error broadId[%s] reason[%s]' %
(broadId, e))
return {'code': 1, 'msg': '清楚广播失败.'}
def get_fish_data_query(redis, session):
"""
后台捕鱼数据查询接口
"""
lang = getLang()
fields = ('isList', 'start_date', 'end_date')
for field in fields:
exec('%s=request.GET.get("%s","").strip()' % (field, field))
log_util.debug(
'[try get_fish_data_query] isList[%s] start_date[%s] end_date[%s]' %
(isList, start_date, end_date))
if isList:
fish_system_datas = get_fish_sys_datas(redis, start_date, end_date)
return json.dumps(fish_system_datas)
else:
#统计数据
fish_static_datas = get_fish_cal_data(redis)
info = {
'title': lang.MENU_FISH_DATA_REAL_TXT,
'listUrl': BACK_PRE + '/fish/data/query?isList=1',
'STATIC_LAYUI_PATH': STATIC_LAYUI_PATH,
'STATIC_ADMIN_PATH': STATIC_ADMIN_PATH
}
return template(
'admin_fish_sys_data',
info=info,
log_per_day=fish_static_datas['log_per_day'],
reg_per_day=fish_static_datas['reg_per_day'],
total_member=fish_static_datas['total_member'],
login_per_rate=fish_static_datas['login_per_rate'],
recharge_per_rate=fish_static_datas['recharge_per_rate'],
share_per_day=fish_static_datas['share_per_day'],
total_share=fish_static_datas['total_share'],
lang=lang,
RES_VERSION=RES_VERSION)
def addRoomCard2Member(redis, transNo):
"""
会员增加房卡
"""
curTime = datetime.now()
orderTable = ORDER_TABLE % (transNo)
if not redis.exists(orderTable):
log_util.debug('[%s][wechatPay][error] orderNo[%s] is not exists.' %
(curTime, params['out_trade_no']))
return False
goodid, memberAccount = redis.hmget(orderTable, ('num', 'account'))
rType = redis.hget(GOODS_TABLE % goodid, 'type')
rType = int(rType) if rType else None
if rType == 2:
addRoomCard2Member4Type2(redis, curTime, orderTable, memberAccount)
return
cardNums, present_card = redis.hmget(orderTable,
('roomCards', 'presentCards'))
if not present_card:
present_card = 0
try:
present_card = int(present_card)
except:
present_card = 0
#chargeNums = TYPE_2_CARS[rType]
account2user_table = FORMAT_ACCOUNT2USER_TABLE % (memberAccount
) #从账号获得账号信息，和旧系统一样
userTable = redis.get(account2user_table)
groupId = redis.hget(userTable, 'parentAg')
try:
redis.hset(orderTable, 'groupId', groupId)
except Exception, error:
print '[addRoomCard2Member] [ERROR] %s' % (error)
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 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 get_fish_member_list(redis, session, selfUid, searchId, lang, pageSize,
pageNumber, sort_name, sort_method):
"""
获取捕鱼会员列表
:params redis redis链接实例
:params session 会话信息句柄
:params searchId 搜索的用户ID
:params lang 语言包实例
:params pageNumber 分页数
:params sort_name 排序名称
:params sort_method 排序方法
#捕鱼玩家信息列表
MEMBER_FISH_LIST_FIELDS = (
'name',
'parentAg',
'coin',
'nickname',
'headImgUrl',
'last_login_date',
'last_logout_date',
'valid',
'recharge_coin_total',
'exchange_ticket'
)
"""
adminTable = AGENT_TABLE % (selfUid)
aType, aId = redis.hmget(adminTable, ('type', 'id'))
type2getMemberIds = {0: getSystemMemberIds, 1: getAgentAllMemberIds}
if searchId and redis.exists(FORMAT_USER_TABLE % (searchId)): #如果搜索的话
memberIds = [searchId]
else: #管理员或者1及代理
memberIds = getSystemMemberIds(redis, selfUid, 'fish')
total_records = len(memberIds)
membersList, user_info_list = [], []
selfAccesses = eval(session['access'])
log_debug('=================startTime[%s]' % (datetime.now()))
memberInfos = []
if not searchId and redis.exists("agent:%s:fish:members:cache" %
(selfUid)): #直接从缓存读取
user_info_list = eval(
redis.get("agent:%s:fish:members:cache" % (selfUid)))
else:
for memberId in memberIds:
#获取所有用户信息
table = FORMAT_USER_TABLE % (memberId) #从账号获得账号信息，和旧系统一样
memberInfos = redis.hmget(table, MEMBER_FISH_LIST_FIELDS)
memberInfos.insert(0, memberId)
try:
memberInfos[3] = int(memberInfos[3])
except:
memberInfos[3] = 0
user_info_list.append(memberInfos)
if total_records >= LIST_CACHE_MAXNUM: #总记录数大于阈值的才需要缓存
redis.set("agent:%s:fish:members:cache" % (selfUid),
user_info_list)
redis.expire("agent:%s:fish:members:cache" % (selfUid),
LIST_CACHE_TTL)
if sort_name: #如果排序
log_util.debug('sorOrder[%s] sortName[%s]' % (sort_name, sort_method))
user_info_list = sorted(user_info_list,
key=itemgetter(SORT_2_INDEX[sort_name]),
reverse=FONT_CONFIG['STR_2_SORT'][sort_method])
#分页渲染
user_info_list = ServerPagination(user_info_list, pageSize, pageNumber)
for user_info in user_info_list:
#MEMBER_LIST_FIELDS = ('name','parentAg','roomCard','nickname','headImgUrl','last_login_date','last_logout_date','valid','open_auth')
memberInfo = {}
memberInfo['name'] = user_info[1]
memberInfo['id'] = user_info[0]
memberInfo['nickname'] = user_info[4]
memberInfo['headImgUrl'] = user_info[5]
memberInfo[
'last_login_date'] = user_info[6] if user_info[6] else '从未登录'
memberInfo[
'last_logout_date'] = user_info[7] if user_info[7] else '从未登录'
memberInfo['valid'] = user_info[8]
memberInfo['recharge_coin_total'] = user_info[9]
memberInfo['exchange_ticket'] = user_info[10] if user_info[10] else 0
memberInfo['coin'] = int(user_info[3]) if user_info[3] else 0
memberInfo['parentAg'] = user_info[2]
#memberInfo['rechargeTotal']= user_info[10]
memberInfo['op'] = []
for access in access_module.ACCESS_MEMBER_LIST:
if access.url[-4:] == 'kick' and int(aType) == 0:
continue
elif access.url[-6:] == 'freeze':
memberInfo['op'].append({'url':access.url+"/fish",'txt':'冻结' \
if user_info[8] == '1' else '解冻','method':access.method})
elif access.url[-10:] == 'removeCard':
memberInfo['op'].append({
'url': access.url,
'method': access.method,
'txt': '移除金币'
})
elif access.url[-7:] == 'addCard':
memberInfo['op'].append({
'url': access.url,
'method': access.method,
'txt': '补充金币'
})
else:
memberInfo['op'].append({
'url': access.url,
'method': access.method,
'txt': access.getTxt(lang)
})
membersList.append(memberInfo)
return {
'total': total_records,
'result': membersList,
'pageNumber': pageNumber
}
def do_reward_exchange(redis, session):
'''
玩家兑换奖品协议
@params:
sid : 玩家sesion
rewardId : 奖品ID
'''
curTime = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
dateStr = datetime.now().strftime('%Y-%m-%d')
fields = ('sid', 'rewardId', 'needTicket')
for field in fields:
exec(consts.FORMAT_PARAMS_POST_STR % (field, field))
try:
log_util.debug(
'[try do_reward_exchange] get params ticket[%s] sid[%s] rewardId[%s]'
% (needTicket, sid, rewardId))
except:
return {'code': -300, 'msg': '接口参数错误.'}
SessionTable, account, uid, verfiySid = getInfoBySid(redis, sid)
check_code, check_msg, user_table = check_session_verfiy(
redis, '/fish/doExchange/', 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 not redis.exists(FISH_REWARD_TABLE % (rewardId)):
return {'code': -4001, 'msg': '兑换商品不存在或已过期'}
reward_table = FISH_REWARD_TABLE % (rewardId)
user_addr_table = FORMAT_USER_ADDRESS_TABLE % (uid)
if not redis.exists(user_addr_table):
return {'code': -4004, 'msg': '请先设置奖品收货地址信息'}
user_exchange_ticket = convert_util.to_int(
redis.hget(user_table, 'exchange_ticket'))
needTicket = convert_util.to_int(needTicket)
#获取奖品对应信息
reward_need_ticket,reward_name,reward_per_stock,reward_img_path,reward_card_no,reward_card_pwd,reward_type,reward_coin,reward_status= \
redis.hmget(reward_table,('reward_need_ticket','reward_name','reward_per_stock','reward_img_path','reward_card_no','reward_card_pwd','reward_type','reward_coin','reward_status'))
reward_need_ticket = convert_util.to_int(reward_need_ticket)
reward_coin = convert_util.to_int(reward_coin)
reward_type = convert_util.to_int(reward_type)
reward_status = convert_util.to_int(reward_status)
reward_per_stock = convert_util.to_int(reward_per_stock)
if reward_status == consts.REWARD_OFFLINE:
return {'code': -4005, 'msg': '该奖品未上架'}
if reward_per_stock <= 0:
#根正数据错误
redis.hset(reward_table, 'reward_per_stock', 0)
return {
'code': 0,
'msg': '库存不足',
'type': 3,
'userTicket': user_exchange_ticket,
'needTicket': reward_need_ticket,
'rewardStock': 0
}
if needTicket != reward_need_ticket:
reward_per_stock = convert_util.to_int(
redis.hget(reward_table, 'reward_per_stock'))
return {
'code': 0,
'msg': '使用兑换卷和所需兑换卷不一致',
'type': 3,
'userTicket': user_exchange_ticket,
'needTicket': reward_need_ticket,
'rewardStock': reward_per_stock
}
if user_exchange_ticket < needTicket:
reward_per_stock = convert_util.to_int(
redis.hget(reward_table, 'reward_per_stock'))
log_util.debug(
'[try do_reward_exchange] needTicke[%s] user_exchange_ticket[%s]' %
(needTicket, user_exchange_ticket))
return {
'code': 0,
'msg': '兑换卷不足',
'type': 3,
'userTicket': user_exchange_ticket,
'needTicket': reward_need_ticket,
'rewardStock': reward_per_stock
}
#写入相应的兑换记录表
#减去玩家相应的兑换卷
#减去兑换奖品库存
user_addr_info = redis.hgetall(user_addr_table)
exchange_info = {
'user_id': uid,
'exchange_date': curTime,
'exchange_reward_id': rewardId,
'exchange_reward_name': reward_name,
'exchange_use_ticket': needTicket,
'exchange_type': reward_type,
'exchange_leave_ticket': user_exchange_ticket - needTicket,
'exchange_reward_img_path': reward_img_path,
'exchange_need_ticket': reward_need_ticket,
'exchange_card_no': reward_card_no if reward_card_no else '',
'exchange_card_pwd': reward_card_pwd if reward_card_pwd else '',
'exchange_reward_status': '0',
'exchange_user_name': user_addr_info['name'],
'exchange_user_phone': user_addr_info['phone'],
'exchange_user_addr':
user_addr_info['city'] + user_addr_info['address']
}
pipe = redis.pipeline()
try:
ori_exchange_id = redis.get(FISH_EXCHANGE_ID_COUNT)
exchange_id = redis.incr(FISH_EXCHANGE_ID_COUNT)
exchange_info['exchange_id'] = exchange_id
pipe.hincrby(user_table, 'exchange_ticket', -int(needTicket))
pipe.hincrby(reward_table, 'reward_per_stock', -1)
#设置兑换表
pipe.set(FISH_EXCHANGE_TABLE % (exchange_id), exchange_info)
#写入兑换记录列表
pipe.lpush(FISH_EXCHANGE_LIST, exchange_id)
#写入用户兑换记录表
pipe.lpush(FISH_USER_EXCHANGE_LIST % (uid), exchange_id)
#写入兑换记日期索引表
pipe.lpush(FISH_USER_EXCHANGE_DATE % (dateStr), exchange_id)
#写入状态索
pipe.lpush(FISH_USER_EXCHANGE_STATUS_LIST % (0), exchange_id)
except Exception, e:
redis.set(FISH_EXCHANGE_ID_COUNT, ori_exchange_id)
reward_per_stock = convert_util.to_int(
redis.hget(reward_table, 'reward_per_stock'))
log_util.debug('[try do_reward_exchange] exchange error reason[%s]' %
(e))
return {
'code': -4004,
'msg': '数据错误',
'needTicket': reward_need_ticket,
'rewardStock': reward_per_stock
}
pipe.lpush(FISH_USER_EXCHANGE_STATUS_LIST % (0), exchange_id)
except Exception, e:
redis.set(FISH_EXCHANGE_ID_COUNT, ori_exchange_id)
reward_per_stock = convert_util.to_int(
redis.hget(reward_table, 'reward_per_stock'))
log_util.debug('[try do_reward_exchange] exchange error reason[%s]' %
(e))
return {
'code': -4004,
'msg': '数据错误',
'needTicket': reward_need_ticket,
'rewardStock': reward_per_stock
}
log_util.debug(
'[try do_reward_exchange] return userTicket[%s] reward_per_stock[%s]' %
(exchange_info['exchange_leave_ticket'], reward_per_stock))
# if reward_type == consts.COIN_EXCHANGE: #金币兑换
# pipe.hincrby(user_table,'coin',reward_coin)
# exchange_info['exchange_reward_status'] = 1
# pipe.set(FISH_EXCHANGE_TABLE%(exchange_id),exchange_info)
# pipe.execute()
# #领取后的库存
# reward_per_stock = convert_util.to_int(redis.hget(reward_table,'reward_per_stock'))
# return {'code':0,'msg':'兑换成功,获得{}个金币'.format(reward_coin),'type':reward_type,'coin':reward_coin,'userTicket':exchange_info['exchange_leave_ticket'],'needTicket':reward_need_ticket,'rewardStock':reward_per_stock}
if reward_type == consts.CARD_EXCHANGE: #卡密兑换
exchange_info['exchange_reward_status'] = 1
pipe.set(FISH_EXCHANGE_TABLE % (exchange_id), exchange_info)
pipe.execute()
#领取后的库存
def do_HotUpdate(redis, session, action="HALL"):
"""
热更新配置
"""
action = action.upper()
curTime = datetime.now()
lang = getLang()
fields = (
'resVersion','minVersion','iosMinVersion',\
'downloadURL','IPAURL','apkSize','apkMD5',\
'hotUpdateURL','hotUpdateScriptsURL','updateAppStore1',\
'updateAppStore2','updateAndroid','updateYYB','packName'
)
for field in fields:
exec("%s=request.forms.get('%s','').strip()" % (field, field))
#log_debug
log_util.debug('[%s][hotUpDateSetting][info] resVersion[%s] minVersion[%s] iosMinVersion[%s] downloadURL[%s]'\
%(curTime,resVersion,minVersion,iosMinVersion,downloadURL))
checkNullField = [{
'field': resVersion,
'msg': 'resVersion不能为空'
}, {
'field': minVersion,
'msg': 'minVersion不能为空'
}, {
'field': iosMinVersion,
'msg': 'iosMinVersion不能为空'
}, {
'field': downloadURL,
'msg': 'downloadURL不能为空'
}, {
'field': IPAURL,
'msg': 'IPAURL不能为空'
}, {
'field': hotUpdateURL,
'msg': 'hotUpdateURL不能为空'
}, {
'field': hotUpdateScriptsURL,
'msg': 'hotUpdateScriptsURL不能为空'
}]
for check in checkNullField:
if not check['field']:
return {'code': 1, 'msg': check['msg']}
updateHostSettingInfo = {
'resVersion': resVersion,
'minVersion': minVersion,
'iosMinVersion': iosMinVersion,
'downloadURL': downloadURL,
'IPAURL': IPAURL,
'apkSize': apkSize,
'hotUpdateURL': hotUpdateURL,
'hotUpdateScriptsURL': hotUpdateScriptsURL,
'updateAppStore1': updateAppStore1,
'updateAppStore2': updateAppStore2,
'updateAndroid': updateAndroid,
'updateYYB': updateYYB,
'packName': packName,
'lastUpTime': curTime.strftime('%Y-%m-%d %H:%M:%S')
}
try:
saveHotUpDateSetting(redis, updateHostSettingInfo, action)
except:
log_debug('[%s][hotUpDateSetting][error] hotUpdateError reason[%s]' %
(curTime, e))
return {
'code': 0,
'msg': '保存配置成功',
'jumpUrl': BACK_PRE + '/setting/hotUpDateSetting?sys={}'.format(action)
}
import time
from common import log_util
import redis
import hashlib
def getInst(dbNum):
global redisdb
redisdb = redis.ConnectionPool(host="192.168.0.99",
port=6379,
db='1',
password='******')
return redis.Redis(connection_pool=redisdb)
if __name__ == '__main__':
redis = getInst(1)
pipe = redis.pipeline()
log_util.debug('[date] share table clearing............')
clear_tables = [
FISH_SHARE_NOT_TAKE_SETS, FISH_FIRST_SHARE_PER_DAY_SET,
FISH_SHARE_TAKE_SETS
]
for clear_table in clear_tables:
log_util.debug('clear table[%s]' % (clear_table))
pipe.delete(clear_table)
pipe.execute()
print 'Done......'
def get_fish_level_query(redis, session):
"""
后台鱼等级数据查询
"""
lang = getLang()
fields = ('isList', )
for field in fields:
exec('%s=request.GET.get("%s","").strip()' % (field, field))
log_util.debug('[try get_fish_level_query] isList[%s] ' % (isList))
if isList:
# fish_system_datas = get_fish_sys_datas(redis, start_date, end_date)
level_order_list = redis.smembers("fish:level:order:set")
result = []
if not level_order_list:
for i in range(1, 35):
order_data = dict(
modes_count_range=json.dumps({
0: "(1, 1)",
}),
order=i,
rate_appear=0,
limit_count=0,
rate_pick_range=(0.0045, 0.0045),
multiple_range=(20, 20),
speed_range=(54, 63), # (60,70),
dice_odds=0,
rot_range=(-5, 5),
rot_speed_range=(10, 10),
per_time_range=(3, 8),
times_count_range=(2, 4),
width=132,
height=118,
seq_offset=10,
min_limit_time=0,
max_limit_time=0,
max_together_count=0,
fishname='')
redis.hmset("fish:level:%s:hesh" % i, order_data)
redis.sadd("fish:level:order:set", i)
result.append({
"order":
int(order_data["order"]),
"name":
order_data["fishname"],
"op": [{
'url':
'/admin/fish/order/level/query_one?id=%s' %
order_data["order"],
'method':
'GET',
'txt':
'修改'
}]
})
else:
for order in level_order_list:
order_data = redis.hgetall("fish:level:%s:hesh" % order)
op = []
result.append({
"order":
int(order_data["order"]),
"name":
order_data["fishname"],
"op": [{
'url':
'/admin/fish/order/level/query_one?id=%s' %
order_data["order"],
'method':
'GET',
'txt':
'修改'
}]
})
result = sorted(result, key=lambda x: x["order"])
return json.dumps({"status": 200, "data": result})
else:
info = {
'title': lang.MENU_FISH_DATA_REAL_TXT,
'listUrl': BACK_PRE + '/fish/order/level/query_list?isList=1',
'STATIC_LAYUI_PATH': STATIC_LAYUI_PATH,
'STATIC_ADMIN_PATH': STATIC_ADMIN_PATH
}
return template("admin_fish_level_order",
info=info,
lang=lang,
RES_VERSION=RES_VERSION)
def do_createFishRoom(redis, session):
"""
创建捕鱼房间
"""
lang = getLang()
curTime = datetime.now()
#获取数据
for FIELDS in FISH_FIELDS:
exec(FORMART_POST_STR % (FIELDS, FIELDS))
log_debug('[try do_createFishRoom]')
checkNullFields = [{
'field': room_name,
'msg': lang.FISH_ROOM_NAME_EMPTY_TXT
}, {
'field': room_id,
'msg': lang.FISH_ROOM_ID_EMPTY_TXT
}, {
'field': base_coin,
'msg': lang.FISH_ROOM_BASE_EMPTY_TXT
}, {
'field': max_base_coin,
'msg': lang.FISH_ROOM_MAX_BASE_EMPTY_TXT
}, {
'field': step_base_coin,
'msg': lang.FISH_ROOM_STEP_BASE_EMPTY_TXT
}]
for check in checkNullFields:
if not check['field']:
return {'code': 1, 'msg': check['msg']}
fish_ids = redis.smembers(GAMEID_SET)
if room_id in fish_ids:
#房间ID不能重复
return {'code': 1, 'msg': '房间ID[%s]已经存在!' % (room_id)}
roomInfo = {
'room_id': room_id,
'room_name': room_name,
'min_coin': min_coin,
'max_coin': max_coin,
'ip_mask': ip_mask,
'max_player_count': max_player_count,
'base_coin': base_coin,
'max_base_coin': max_base_coin,
'step_base_coin': step_base_coin,
'status': 0,
'need_coin': need_coin if need_coin else 0,
'coin_value': coin_value if coin_value else 0,
'isTrail': isTrail,
'tax_rate': tax_rate if tax_rate else 0,
'get_rate': get_rate if get_rate else '',
'fish_limit_count': fish_limit_count if fish_limit_count else 0,
'fish_need_count': fish_need_count if fish_need_count else 0,
'max_add': max_add if max_add else 0,
'ticket_wait_time': ticket_wait_time if ticket_wait_time else '[]',
'max_ticket_count': max_ticket_count if max_ticket_count else 0,
}
try:
create_fish_room(redis, roomInfo)
log_util.debug(
'[try do_createFishRoom] room_id[%s] roomInfo[%s] create success.'
% (room_id, roomInfo))
except Exception, e:
return {'code': 2, 'msg': 'reason[%s]' % (e)}
"""
从玩家列表中移除
"""
userMsgBox = FORMAT_USER_MESSAGE_LIST % (memberId)
readList = redis.smembers(FORMAT_MSG_READ_SET % (msgId))
pipe = redis.pipeline()
try:
pipe.lrem(userMsgBox, msgId)
except Exception, e:
log_util.error(
'[try deleteMsg] ERROR msgId[%s] memberId[%s] errReason[%s]' %
(msgId, memberId, e))
return
log_util.debug('[try deleteMsg] msgId[%s] memberId[%s] ' %
(msgId, memberId))
pipe.execute()
def deleteAllMsg(redis, memberId):
"""
从玩家列表中清楚所有的消息
"""
log_debug('[FUNC][deleteAllMsg][info] memberId[%s]' % (memberId))
userMsgBox = FORMAT_USER_MESSAGE_LIST % (memberId)
pipe = redis.pipeline()
try:
pipe.delete(userMsgBox)
except Exception, e:
log_debug(
'[FUNC][deleteMsg][error] msgId[%s] memberId[%s] errReason[%s]' %
def do_login(redis,session):
"""
大厅登录接口
"""
tt = request.forms.get('tt', '').strip()
curTime = datetime.now()
ip = web_util.get_ip()
getIp = request['REMOTE_ADDR']
_account = request.forms.get('account', '').strip()
clientType = request.forms.get('clientType', '').strip()
intoGroupId = request.forms.get('groupId','').strip()
if not clientType:
clientType = 0
passwd = request.forms.get('passwd', '').strip()
login_type = request.forms.get('type', '').strip() #登录类型
login_type = int(login_type)
sid=0
log_util.debug("[ do_login ] account[%s] intoGroupid [%s] " % (_account, intoGroupId))
try:
log_util.debug('[on login]account[%s] clientType[%s] passwd[%s] type[%s]'%(_account, clientType, passwd, login_type))
except Exception as e:
print 'print error File', e
login_pools = redis.smembers(FORMAT_LOGIN_POOL_SET)
log_util.debug('[try do_login] account[%s] login_pools[%s]'%(_account,login_pools))
if _account in login_pools:
log_util.debug('[try do_login] account[%s] is already login.'%(_account))
return {'code':0}
dgid=DEFAULT_AGENT_ID
#dgid='407522'
DEFAULT_GID=DEFAULT_AGENT_ID # 默认公会暂不开放
#DEFAULT_GID='407522'#默认公会暂不开放
defaultgid=''
redis.sadd(FORMAT_LOGIN_POOL_SET,_account)
log_util.debug('[try do_login] account[%s] login_pools[%s]'%(_account,login_pools))
reAccount, rePasswd = onRegFish(redis, _account, passwd, login_type, ip)
if reAccount:
if login_type:
realAccount = redis.get(WEIXIN2ACCOUNT4FISH%(reAccount))
else:
realAccount = reAccount
#读取昵称和group_id
account2user_table = FORMAT_ACCOUNT2USER_TABLE%(realAccount)
userTable = redis.get(account2user_table)
id = userTable.split(':')[1]
if not redis.sismember(ACCOUNT4WEIXIN_SET4FISH, realAccount): #初次登录
redis.sadd(ACCOUNT4WEIXIN_SET4FISH, realAccount)
redis.sadd(FORMAT_REG_DATE_TABLE4FISH%(curTime.strftime("%Y-%m-%d")), realAccount)
# redis.hset(userTable, 'coin', consts.GIVE_COIN_FIRST_LOGIN)
account, name, groupId,loginIp, loginDate, picUrl, gender,valid, lockCount, ownAgent = \
redis.hmget(userTable, ('account', 'nickname', 'parentAg', 'lastLoginIp',\
'lastLoginDate', 'picUrl', 'gender','valid', 'lockCount', "ownAgent"))
if intoGroupId != '' and (groupId == DEFAULT_AGENT_ID or not groupId):
DEFAULT_GID = intoGroupId
topAgent = getTopAgentId(redis, groupId)
if not topAgent:
groupId = None
if not groupId or (intoGroupId != '' and (groupId == DEFAULT_AGENT_ID or not groupId)):
print(u"加入公会")
curTime=datetime.now()
pipe = redis.pipeline()
agValid, auto_check, groupType = redis.hmget(AGENT_TABLE%(DEFAULT_GID), ('valid', 'auto_check', 'type'))
if agValid == '1' and groupType != '1':
if not auto_check:
auto_check = CHECK_SUCCESS
# if auto_check == CHECK_SUCCESS:
pipe.hset(FORMAT_USER_TABLE%(id),'parentAg',DEFAULT_GID)
pipe.sadd(FORMAT_ADMIN_ACCOUNT_MEMBER_TABLE%(DEFAULT_GID), id)
pipe.lpush(JOIN_GROUP_LIST%(DEFAULT_GID), id)
pipe.set(JOIN_GROUP_RESULT%(id), '%s:%s:%s'%(DEFAULT_GID,auto_check,curTime.strftime('%Y-%m-%d %H:%M:%S')))
pipe.execute()
groupId = DEFAULT_GID
if not lockCount:
lockCount = 0
else:
lockCount = int(lockCount)
agentTable = AGENT_TABLE%(groupId)
isTrail, shop, parent_id = redis.hmget(agentTable,('isTrail','recharge', 'parent_id'))
if not isTrail:
isTrail = 0
level = 3
own_level = -1
topAgent = getTopAgentId(redis, groupId)
print(u"顶级公会ID：%s" % topAgent)
# if ownAgent:
# own_parent_id = redis.hget(AGENT_TABLE%(ownAgent), "parent_id")
# intOwn_parent_id = int(own_parent_id) if own_parent_id else 0
# if intOwn_parent_id == 1:
# level = 1
# elif intOwn_parent_id == 0:
# level = 3
# else:
# level = 2
# else:
# ownAgent = ''
topManager = redis.smembers("agent:%s:manager:member:set" % topAgent)
parentManager = redis.smembers("agent:%s:manager:member:set" % groupId)
if id in topManager:
level = 1
elif id in parentManager:
level = 2
else:
level = 3
exchangeIntoCode = redis.hget(EXCHANGE_AGENT_CODE, groupId)
if not exchangeIntoCode:
exchangeIntoCode = SecretKeysInto(redis, groupId)
#默认开放
shop = 1
shop = int(shop)
#会话信息
type2Sid = {
True : sid,
False : md5.new(str(id)+str(time.time())).hexdigest()
}
sid = type2Sid[login_type == 3]
SessionTable = FORMAT_USER_HALL_SESSION%(sid)
if redis.exists(SessionTable):
log_util.debug("[try do_login] account[%s] sid[%s] is existed."%(curTime,realAccount,sid))
redis.srem(FORMAT_LOGIN_POOL_SET,account)
return {'code':-1, 'msg':'链接超时'}
urlRes = urlparse(request.url)
serverIp = ''
serverPort = 0
gameid = 0
loginMsg = []
userInfo = {'name':name,'isTrail':int(isTrail),'shop':int(shop),
'agent_id':groupId,'account':reAccount,
"parent_id":parent_id,
'passwd':rePasswd,
"level": level,
"top_agent": topAgent,
"user_id": id,
"exchangeIntoCode": exchangeIntoCode
}
joinNum = ''
id = userTable.split(':')[1]
joinMessage = redis.get(JOIN_GROUP_RESULT%(id))
if joinMessage:
try:
joinMessage = joinMessage.split(':')
joinNum = int(joinMessage[0])
joinResult = int(joinMessage[1])
userInfo['applyId'] = joinNum
if joinResult == 1:
redis.delete(JOIN_GROUP_RESULT%(id))
except Exception as err:
print("ERROR joinMessage: %s, %s" % (JOIN_GROUP_RESULT%(id), err) )
key = redis.get(ACCOUNT2WAIT_JOIN_PARTY_TABLE%account)
# for key in redis.keys(WAIT_JOIN_PARTY_ROOM_PLAYERS%('*', '*', '*')):
if key:
if account in redis.lrange(key, 0, -1):
try:
gameId, serviceTag = redis.get('account:%s:wantServer'%account).split(',')
message = HEAD_SERVICE_PROTOCOL_NOT_JOIN_PARTY_ROOM%(account, ag)
redis.lpush(FORMAT_SERVICE_PROTOCOL_TABLE%(gameId, serviceTag), message)
except:
print '[account wantServer][%s]'%(redis.get('account:%s:wantServer'%account))
redis.lrem(key, account)
redis.srem(FORMAT_LOGIN_POOL_SET,_account)
return {'code':0, 'sid':sid, 'userInfo':userInfo, 'gameInfo':gameInfo, 'gameState':gameState}
else:
if joinNum:
redis.srem(FORMAT_LOGIN_POOL_SET,_account)
return {'code':0, 'sid':sid, 'userInfo':userInfo, 'joinResult':joinResult, 'loginMsg':loginMsg, }
redis.srem(FORMAT_LOGIN_POOL_SET,account)
return {'code':0, 'sid':sid, 'userInfo':userInfo, 'loginMsg':loginMsg}
else: #失败
redis.srem(FORMAT_LOGIN_POOL_SET,_account)
return {'code':101, 'msg':'账号或密码错误或者微信授权失败'}
def get_wechat_order_records(redis, groupId, condition, action="HALL"):
"""
获取微信支付订单记录
:params redis Redis实例
:params groupId 公会ID
:params condition 查询条件
:params action 查询 捕鱼FISH 或 棋牌HALL的订单
"""
deltaTime = timedelta(1)
orderList = []
roomCardCount, pendingMoney, successMoney, moneyCount = 0, 0, 0, 0
date_lists = convert_util.to_week_list(condition['startDate'],
condition['endDate'])
if action == "HALL":
date_table = DAY_ORDER
order_table = ORDER_TABLE
else:
date_table = DAY_ORDER4FISH
order_table = ORDER_TABLE4FISH
pipe = redis.pipeline()
for date in date_lists:
orders = redis.lrange(date_table % (date), 0, -1)
#roomCardCount+=len(orders)
for order in orders:
orderInfo = {}
if not order_table % (order):
pipe.lrem(ORDER_NUM_LIST, orders)
pipe.lrem(date_table % (date), order)
continue
orderDetail = redis.hgetall(order_table % (order))
if not orderDetail:
pipe.lrem(ORDER_NUM_LIST, orders)
pipe.lrem(date_table % (date), order)
continue
dateStr1 = time.strftime(
'%Y-%m-%d %H:%M:%S',
time.localtime(float(orderDetail['time'])))
log_util.debug('time[%s]' % (dateStr1))
moneyCount += round(float(orderDetail['money']), 2)
if orderDetail['type'] == 'pending':
pendingMoney += round(float(orderDetail['money']), 2)
else:
successMoney += round(float(orderDetail['money']), 2)
user_table = redis.get(FORMAT_ACCOUNT2USER_TABLE %
(orderDetail['account']))
group_id = redis.hget(user_table, 'parentAg')
orderInfo['orderNo'] = order
orderInfo['good_name'] = orderDetail['name']
orderInfo['good_money'] = round(
float(orderDetail['money']) * 0.01, 2)
orderInfo['order_paytime'] = dateStr1
orderInfo['good_count'] = orderDetail['roomCards']
orderInfo['order_type'] = orderDetail['type']
orderInfo['group_id'] = group_id if group_id else '-'
orderInfo['memberId'] = user_table.split(':')[1]
orderList.append(orderInfo)
pipe.execute()
return {
'data': orderList,
'orderCount': len(orderList),
'moneyCount': moneyCount * 0.01,
'pendingMoney': pendingMoney * 0.01,
'successMoney': successMoney * 0.01
}
def onRegFish_new(redis, account, passwd, type, ip, clientType,
session): #传入参数：账号，密码，类型
curTime = datetime.now()
log_util.debug('[try onReg] account[%s] passwd[%s] type[%s]' %
(account, passwd, type))
if type == 1: #微信code登录
tokenMessage = checkWeixinCode4fish(account)
if tokenMessage:
password = account
accessToken = tokenMessage["access_token"]
refreshToken = tokenMessage["refresh_token"]
openID = tokenMessage["openid"]
userData = getWeixinData(openID, accessToken)
unionid = userData['unionid']
if redis.exists(
WEIXIN2ACCOUNT %
(unionid)): # or redis.exists(WEIXIN2ACCOUNT%(unionid)):
realAccount = redis.get(WEIXIN2ACCOUNT % (unionid))
if not realAccount:
realAccount = redis.get(WEIXIN2ACCOUNT % (unionid))
account2user_table = FORMAT_ACCOUNT2USER_TABLE % (realAccount)
table = redis.get(account2user_table)
redis.hmset(
table, {
'accessToken': accessToken,
'refreshToken': refreshToken,
'password': md5.new(password).hexdigest()
})
else:
setOpenid2account4fish(openID, accessToken, refreshToken, ip,
redis, account)
redis.srem(FORMAT_LOGIN_POOL_SET, account)
return unionid, password
redis.srem(FORMAT_LOGIN_POOL_SET, account)
elif type == 2:
if redis.exists(
WEIXIN2ACCOUNT %
(account)): # or redis.exists(WEIXIN2ACCOUNT%(account)):
realAccount = redis.get(WEIXIN2ACCOUNT % (account))
if not realAccount:
realAccount = redis.get(WEIXIN2ACCOUNT % (account))
account2user_table = FORMAT_ACCOUNT2USER_TABLE % (realAccount)
table = redis.get(account2user_table)
truePassword, openID, accessToken = redis.hmget(
table, ('password', 'openid', 'accessToken'))
log_util.debug('type 2:passwd[%s] md5[%s] truePassword[%s]' %
(md5.new(passwd).hexdigest(), passwd, truePassword))
if truePassword == md5.new(passwd).hexdigest():
userData = getWeixinData(openID, accessToken)
log_util.debug('onReg for type 2, userData:%s' % (userData))
if userData:
redis.hmset(
table, {
'nickname': userData['nickname'],
'sex': userData['sex'],
'headImgUrl': userData['headimgurl']
})
redis.srem(FORMAT_LOGIN_POOL_SET, account)
return account, passwd
redis.srem(FORMAT_LOGIN_POOL_SET, account)
elif type == 3: #微信WEBcode登录
tokenMessage = checkWeixinCodeWEB(account)
if tokenMessage:
password = account
accessToken = tokenMessage["access_token"]
refreshToken = tokenMessage["refresh_token"]
openID = tokenMessage["openid"]
userData = getWeixinData(openID, accessToken)
unionid = userData['unionid']
if redis.exists(
WEIXIN2ACCOUNT %
(unionid)): # or redis.exists(WEIXIN2ACCOUNT%(unionid)):
realAccount = redis.get(WEIXIN2ACCOUNT % (unionid))
if not realAccount:
realAccount = redis.get(WEIXIN2ACCOUNT % (unionid))
account2user_table = FORMAT_ACCOUNT2USER_TABLE % (realAccount)
table = redis.get(account2user_table)
redis.hmset(
table, {
'accessToken': accessToken,
'refreshToken': refreshToken,
'password': md5.new(password).hexdigest()
})
else:
setOpenid2account4fish(openID, accessToken, refreshToken, ip,
redis, account)
redis.srem(FORMAT_LOGIN_POOL_SET, account)
return unionid, password
redis.srem(FORMAT_LOGIN_POOL_SET, account)
# 测试账号登录
elif type == 0:
account2user_table = FORMAT_ACCOUNT2USER_TABLE % (account)
if redis.exists(account2user_table):
table = redis.get(account2user_table)
truePassword, nickname = redis.hgmet(table, 'password', 'nickname')
return login_handler(redis, ip, nickname, passwd, login_type,
clientType, session)
redis.srem(FORMAT_LOGIN_POOL_SET, account)
return {'code': -3, 'msg': '账号不存在！'}
def get_bet_list(redis,startDate,endDate,room_id,user_id,page_info,sort_info,userId=None,groupId=None):
"""
获取捕鱼投注明细数据
params: reids,condition(查询条件列表)
"""
try:
startDate = datetime.strptime(startDate,'%Y-%m-%d')
endDate = datetime.strptime(endDate,'%Y-%m-%d')
except:
weekDelTime = timedelta(7)
weekBefore = datetime.now()-weekDelTime
startDate = weekBefore
endDate = datetime.now()
deltaTime = timedelta(1)
bet_table = ALL_FISH_BET_DATA_DETAIL
sum_table = ALL_FISH_BET_DATA4DAY
if user_id:#根据玩家ID搜索
bet_table = PLAYER_FISH_BET_DATA_DETAIL4DAY%(user_id,'%s')
sum_table= PLAYER_FISH_BET_DATA4DAY%(user_id,'%s')
elif room_id:#根据房间号查询
bet_table = FISH_BET_DATA_DETAIL4ROOM%(room_id,'%s')
sum_table = FISH_BET_DATA4DAY4ROOM%(room_id,'%s')
res,totalBetMoney,totalWinLostMoney,winLostRate,totalTickets = [],0,0,0,0
total_datas = []
now_time = datetime.now()
log_debug('[try get_bet_list] startDate->[%s]'%(datetime.now()))
while endDate >= startDate:
if endDate > now_time:#不查没有数据的时间
endDate-=deltaTime
continue
dateStr = endDate.strftime('%Y-%m-%d')
bet_records = redis.lrange(bet_table%(dateStr),0,-1)
#记录总投注额
betMoney,winLostMoney,ticket_total = redis.hmget(sum_table%(dateStr),('bet','profit','ticket'))
betMoney = convert_util.to_float(betMoney)
winLostMoney = convert_util.to_float(winLostMoney)
ticket_total = convert_util.to_float(ticket_total)
totalBetMoney+=betMoney
totalWinLostMoney+=winLostMoney
totalTickets+=ticket_total
#索引出所有数据
total_datas.extend(bet_records)
endDate -= deltaTime
total = len(total_datas)
for bet_record in total_datas:
bet_record = eval(bet_record)
bet_keys = bet_record.keys()
betInfo = {}
betInfo['win'] = bet_record['win']
betInfo['bet_id'] = bet_record['bet_id']
betInfo['room_id'] = bet_record['room_id']
betInfo['bet'] = bet_record['bet']
betInfo['uid'] = bet_record['uid']
betInfo['datetime'] = bet_record['datetime']
betInfo['init_coin'] = int(bet_record['init_coin']) if 'init_coin' in bet_keys else 0
betInfo['add_coin'] = bet_record['add_coin'] if 'add_coin' in bet_keys else 0
betInfo['login_time'] = bet_record['login_time'] if 'login_time' in bet_keys else '未知'
betInfo['add_ticket'] = bet_record['add_ticket'] if 'add_ticket' in bet_keys else 0
betInfo['op'] = []
betInfo['op'].append(BET_OP_LIST)
res.append(betInfo)
if totalWinLostMoney:
winLostRate = round(((totalBetMoney-totalWinLostMoney)/totalBetMoney)*100,2)
if winLostRate > 0.00:
winLostRate=-winLostRate
else:
winLostRate=abs(winLostRate)
if sort_info['sort_name']:
#如果排序
res = sorted(res, key=itemgetter(sort_info['sort_name']),reverse=FONT_CONFIG['STR_2_SORT'][sort_info['sort_method']])
#分页处理，客户端每次只渲染15条
res = ServerPagination(res,page_info['page_size'],page_info['page_number'])
log_util.debug('[try get_bet_list] endDtime->[%s]'%(datetime.now()))
return {'result':res,'count':total,'betTotal':totalBetMoney,'ticketTotal':totalTickets,'winLostTotal':totalWinLostMoney,'winLostRate':winLostRate}
def deleteMsg(redis,msgId,memberId):
"""
从玩家列表中移除
"""
userMsgBox = FORMAT_USER_MESSAGE_LIST%(memberId)
readList = redis.smembers(FORMAT_MSG_READ_SET%(msgId))
pipe = redis.pipeline()
try:
pipe.lrem(userMsgBox,msgId)
except Exception,e:
log_util.error('[try deleteMsg] ERROR msgId[%s] memberId[%s] errReason[%s]'%(msgId,memberId,e))
return
log_util.debug('[try deleteMsg] msgId[%s] memberId[%s] '%(msgId,memberId))
pipe.execute()
def deleteAllMsg(redis,memberId):
"""
从玩家列表中清楚所有的消息
"""
log_debug('[FUNC][deleteAllMsg][info] memberId[%s]'%(memberId))
userMsgBox = FORMAT_USER_MESSAGE_LIST%(memberId)
pipe = redis.pipeline()
try:
pipe.delete(userMsgBox)
except Exception,e:
log_debug('[FUNC][deleteMsg][error] msgId[%s] memberId[%s] errReason[%s]'%(msgId,memberId,e))
return
