def do_benefit_save(redis, session):
""" 救济金设置接口 """
lang = getLang()
fields = ('save_money', 'save_times', 'save_min_money')
for field in fields:
exec('%s = request.forms.get("%s","")' % (field, field))
try:
log_debug('[try do_fish_setting] share_coin[%s] exchange_shop[%s]' %
(save_money, save_times))
except:
return {'code': -300, 'msg': '接口参数错误!'}
if not save_times.isdigit():
return {'code': 1, 'msg': '领取次数必须设置为整数'}
if not save_money.isdigit():
return {'code': 1, 'msg': '领取金额必须设置为整数'}
if not save_min_money.isdigit():
return {'code': 1, 'msg': '用户最低领取金额必须设置为整数'}
update_info = {
'save_money': convert_util.to_int(save_money),
'save_times': convert_util.to_int(save_times),
'save_min_money': convert_util.to_int(save_min_money)
}
redis.hmset(FISH_CONSTS_CONFIG, update_info)
return {'code': 1, 'msg': '更新成功'}
def get_fish_sys_datas(redis,start_date,end_date):
"""
获取捕鱼系统统计数据
params: redis, start_date,end_date
"""
start_date = convert_util.to_datetime(start_date)
end_date = convert_util.to_datetime(end_date)
one_day = timedelta(1)
now_date = datetime.now()
total_members = convert_util.to_int(redis.scard(ACCOUNT4WEIXIN_SET4FISH))
total_recharge = convert_util.to_int(redis.get(FISH_SYSTEM_RECHARGE_TOTAL))
data_list = []
while end_date >= start_date:
if end_date > now_date:
end_date-=one_day
continue
today = convert_util.to_dateStr(end_date)
today_reg = redis.scard(FORMAT_REG_DATE_TABLE4FISH%(today))
today_active = convert_util.to_int(redis.scard(FORMAT_LOGIN_DATE_TABLE4FISH%(today)))
today_sys_user_total,today_sys_coin_total = redis.hmget(FISH_SYSTEM_DATE_RECHARGE_TOTAL%(today),('recharge_user_total','recharge_coin_total'))
today_sys_user_total = convert_util.to_int(today_sys_user_total)
today_sys_coin_total = convert_util.to_float(today_sys_coin_total)
try:
average_val = round(today_sys_coin_total/today_active,2)
except:
average_val = 0.00
data_list.append({
'today' : today,
'today_reg' : today_reg,
'today_active' : today_active,
'today_sys_user_total' : today_sys_user_total,
'today_sys_coin_total' : today_sys_coin_total,
'average_val' : average_val,
'money_total' : string_util.format_credit(total_recharge),
})
end_date-=one_day
# 查詢奖池情况
jackpot = redis.hgetall("fish:room:jackpot:hesh")
if not jackpot:
jackpot = {}
__swit = {
"5000": "十炮场",
"5001": "百炮场",
"5002": "千炮场",
"5003": "万炮场"
}
result = []
for gameId, value in jackpot.items():
result.append({
"name": __swit[gameId],
"gameId": gameId,
"value": value
})
timestamp = time.strftime("%Y-%m-%d", time.localtime())
number = redis.get("fish:redpick:fish:%s:number" % timestamp) or 0
return {'data':data_list, "water": result, "fishRedPick": number}
def get_login_list(redis,agentId,reg_date,isdel_none = False):
"""
获取某个时间段注册人数详情
params:
[ reg_date ] : 某一天
"""
registMemberList = redis.smembers(FORMAT_LOGIN_DATE_TABLE%(reg_date))
if not registMemberList:
return []
adminTable = AGENT_TABLE%(agentId)
agent_type, aId =redis.hmget(adminTable, ('type', 'id'))
agent_type = convert_util.to_int(agent_type)
type2getMemberIds = {
0 : getSystemMemberIds,
1 : getAgentAllMemberIds
}
memberIds = None
if agent_type == 1:
memberIds = type2getMemberIds[agent_type](redis,agentId)
if not memberIds:
return []
elif agent_type > 1 :
memberTable = FORMAT_ADMIN_ACCOUNT_MEMBER_TABLE%(agentId)
memberIds = redis.smembers(memberTable)
if not memberIds:
return []
res = []
member_id_keys = []
for member in registMemberList:
account2user_table = FORMAT_ACCOUNT2USER_TABLE%(member)
member_id_keys.append(account2user_table)
#获取会员ID
member_id_lists = [user_id.split(":")[1] for user_id in redis.mget(member_id_keys)]
for member_id in member_id_lists:
if memberIds and (member_id not in memberIds) or (member_id.strip() == 'robot'):
continue
use_count = redis.hget(PLAYER_DAY_DATA%(member_id,reg_date),'roomCard')
use_count = convert_util.to_int(use_count)
if isdel_none and not use_count:
continue
table = FORMAT_USER_TABLE%(member_id) #从账号获得账号信息，和旧系统一样
parentAg = \
redis.hget(table,'parentAg')
memberInfo = {
'id' : member_id,
'parentAg' : parentAg,
'use_count' : use_count,
}
if parentAg:
parent_id = redis.hget(AGENT_TABLE%parentAg, 'parent_id')
memberInfo['top_parent_ag'] = parent_id
res.append(memberInfo)
return res
def get_removeCard(redis, session, remove_type="cards"):
"""
移除会员的钻石
"""
curTime = datetime.now()
lang = getLang()
memberId = request.GET.get('id', '').strip()
pageNumber = request.GET.get('cur_page', '').strip()
if not memberId:
return {'code': '1', 'msg': '非法操作!'}
if not pageNumber:
pageNumber = 1
else:
pageNumber = convert_util.to_int(pageNumber)
if remove_type == 'cards':
""" 移除钻石操作 """
page_title = '移除会员(%s)钻石' % (memberId)
parentAg = redis.hget(FORMAT_USER_TABLE % (memberId), 'parentAg')
room_card = redis.get(USER4AGENT_CARD % (parentAg, memberId))
back_url = BACK_PRE + '/member/list?pageNumber={}'.format(pageNumber)
else:
""" 移除金币操作 """
page_title = '移除会员[%s]金币' % (memberId)
room_card = redis.hget(FORMAT_USER_TABLE % (memberId), 'coin')
room_card = convert_util.to_int(room_card)
back_url = BACK_PRE + '/fish/member/list?pageNumber={}'.format(
pageNumber)
memberInfo = {
'title':
page_title,
'backUrl':
back_url,
'agentId':
parentAg if remove_type == 'cards' else '',
'memberId':
memberId,
'submitUrl':
BACK_PRE + '/member/removeCard/{}/{}'.format(pageNumber, remove_type),
'roomcard':
room_card,
'STATIC_LAYUI_PATH':
STATIC_LAYUI_PATH,
'STATIC_ADMIN_PATH':
STATIC_ADMIN_PATH
}
return template('admin_member_removeCard',
page=remove_type,
info=memberInfo,
lang=lang,
RES_VERSION=RES_VERSION)
def test_to_int(self):
self.assertEqual(convert_util.to_int('1'), 1)
self.assertEqual(convert_util.to_int('1.0'), 0)
self.assertEqual(convert_util.to_int('1a'), 0)
self.assertEqual(convert_util.to_int('aaa'), 0)
self.assertEqual(convert_util.to_int(''), 0)
self.assertEqual(convert_util.to_int(None), 0)
self.assertEqual(convert_util.to_int('-1'), -1)
self.assertEqual(convert_util.to_int(10), 10)
self.assertEqual(convert_util.to_int(-10), -10)
self.assertEqual(convert_util.to_int0('1'), 1)
self.assertEqual(convert_util.to_int0('1.0'), 0)
self.assertEqual(convert_util.to_int0('1a'), 0)
self.assertEqual(convert_util.to_int0('aaa'), 0)
self.assertEqual(convert_util.to_int0(''), 0)
self.assertEqual(convert_util.to_int0(None), 0)
self.assertEqual(convert_util.to_int0('-1'), 0)
self.assertEqual(convert_util.to_int0(10), 10)
self.assertEqual(convert_util.to_int0(-10), 0)
self.assertEqual(convert_util.to_int1('1'), 1)
self.assertEqual(convert_util.to_int1('1.0'), 1)
self.assertEqual(convert_util.to_int1('1a'), 1)
self.assertEqual(convert_util.to_int1('aaa'), 1)
self.assertEqual(convert_util.to_int1(''), 1)
self.assertEqual(convert_util.to_int1(None), 1)
self.assertEqual(convert_util.to_int1('-1'), 1)
self.assertEqual(convert_util.to_int1(10), 10)
self.assertEqual(convert_util.to_int1(-10), 1)
def get_room_list(redis,searchId=False,op=False):
"""
获取捕鱼房间列表1
params: redis,searchId(是否查询指定列表)
"""
room_ids = redis.lrange(FISH_ROOM_LIST,0,-1)
room_list = []
log_debug('[try get_room_list] room_ids[%s]'%(room_ids))
trans2IntList = ('min_coin','max_coin','base_coin','max_base_coin','step_base_coin','max_player_count')
for room_id in room_ids:
room_info = redis.hgetall(FISH_ROOM_TABLE%(room_id))
room_info['room_id'] = int(room_id)
room_info['need_coin'] = room_info['need_coin'] if 'need_coin' in room_info.keys() else 0
room_info['coin_value'] = room_info['coin_value'] if 'coin_value' in room_info.keys() else 0
ft = room_info.get('field_type')
if ft:
room_info['field_type'] = int(ft)
for transkey in trans2IntList:
if room_info[transkey]:
room_info[transkey] = convert_util.to_int(room_info[transkey])
if op:
room_info['op'] = FISH_OP_LIST
room_list.append(room_info)
room_list = sorted(room_list, key=itemgetter('room_id'))
if not op:
return room_list
count = len(room_list)
log_debug('[try get_room_list] dataLen[%s] room_list[%s]'%(count,room_list))
return {'data':room_list,'count':count}
def do_pay_record(redis, user_id, user_table, coin, price):
"""
捕鱼支付统计
:params redis实例
:params user_id 用户ID
:params coin 支付金币
"""
today = convert_util.to_dateStr(datetime.now())
coin = convert_util.to_int(coin)
pipe = redis.pipeline()
try:
pipe.hincrby(user_table, 'coin', coin)
try:
pipe.hincrbyfloat(user_table, 'recharge_coin_total',
int(price) * 0.01)
except:
pipe.hincrbyfloat(user_table, 'recharge_coin_total',
float(price) * 0.01)
pipe.incrbyfloat(FISH_SYSTEM_RECHARGE_TOTAL, price)
pipe.hincrbyfloat(FISH_SYSTEM_DATE_RECHARGE_TOTAL % (today),
'recharge_coin_total',
int(price) * 0.01)
if not redis.sismember(FISH_RECHARGE_USER_DAY_IDS, user_id):
pipe.hincrby(FISH_SYSTEM_DATE_RECHARGE_TOTAL % (today),
'recharge_user_total', 1)
pipe.sadd(FISH_RECHARGE_USER_DAY_IDS, user_id)
except Exception, e:
log_util.error(
'[FUNC do_pay_record] Error userId[%s] coin[%s] reason[%s]' %
(user_id, coin, e), True)
return None
def get_exchange_infos(redis,start_date,end_date,user_id,sort_name,sort_method,pageSize,pageNumber):
'''
获取玩家兑换信息列表
'''
if user_id:
total = redis.llen(FISH_USER_EXCHANGE_LIST%(user_id))
exchange_ids = redis.lrange(FISH_USER_EXCHANGE_LIST%(user_id),0,-1)
else:
total = redis.llen(FISH_EXCHANGE_LIST)
exchange_ids = redis.lrange(FISH_EXCHANGE_LIST,0,-1)
exchange_id_keys = [FISH_EXCHANGE_TABLE%(exchange_id) for exchange_id in exchange_ids]
exchange_details = [exchange_detail for exchange_detail in redis.mget(exchange_id_keys)]
exchange_info = []
for exchange_detail in exchange_details:
exchange_detail = eval(exchange_detail)
if int(exchange_detail['exchange_reward_status']) == 1:
exchange_detail['op'] = []
else:
exchange_detail['op'] = FISH_EXCHANGE_LIST_OP
exchange_info.append(exchange_detail)
exchange_info = sorted(exchange_info, key=itemgetter(sort_name),reverse=sort_method)
#分页渲染
exchange_info = web_util.get_server_pagination(exchange_info,pageSize,pageNumber)
#exchange_info = sorted(exchange_info, key=itemgetter(sort_name),reverse=True)
return {'data':exchange_info,'count':convert_util.to_int(total)}
def get_agent_by_date(redis, agentId, agent_ids, date):
count = 0
for agent_id in agent_ids:
nums = redis.get(DAY_AG_LOGIN_COUNT % (agent_id, date))
count += convert_util.to_int(nums)
return count
def do_add_yesterday_data(redis, yesterday):
print yesterday
yesterday = convert_util.to_int(
redis.scard(FORMAT_LOGIN_DATE_TABLE4FISH % (yesterday)))
total = redis.incr("fish:login:per:day:total", yesterday)
print 'do_add_yesterday_data[%s]' % (total)
def get_game_info(redis,group_id,isRefresh=False):
""" 获取游戏信息 """
group_id_games = AGENT_OWN_GAME%(group_id)
try:
game_id_sets = redis.smembers(group_id_games)
except:
game_id_sets = redis.lrange(group_id_games, 0, -1)
defaultGameSet = redis.smembers(GAME_DEFAULT_BIND)
#增加绑定游戏
if not defaultGameSet:
defaultGameSet = []
game_id_sets,defaultGameSet = list(game_id_sets),list(defaultGameSet)
game_id_sets.extend(defaultGameSet)
game_id_sets = set(game_id_sets)
game_list = {}
for game_id in game_id_sets:
game_table = GAME_TABLE%(game_id)
if not redis.exists(game_table):
continue
name, webTag, version,packName,game_sort = redis.hmget(game_table, ('name', 'web_tag', 'version','pack_name','game_sort'))
game_list[game_id] = {
'id' : game_id,
'name' : name,
'web_tag' : webTag,
'version' : version,
'downloadUrl' : packName,
'sort' : convert_util.to_int(game_sort)
}
game_list = sorted(game_list.iteritems(),key=lambda d:d[1]['sort'])
if isRefresh:
game_list = {int(game[0]):game[1] for game in game_list}
return game_list
def get_member_list(redis,session):
"""
获取会员列表接口
"""
lang = getLang()
curTime = datetime.now()
fields = ('isList','startDate','endDate','pageSize','pageNumber','searchId','sort_name','sort_method')
for field in fields:
exec("%s = request.GET.get('%s','').strip()"%(field,field))
selfUid = session['id']
if not pageNumber:
pageNumber = 1
else:
pageNumber = convert_util.to_int(pageNumber)
if isList:
res = getMemberList(redis,session,selfUid,searchId,lang,pageSize,pageNumber,sort_name,sort_method)
return json.dumps(res)
else:
info = {
'title' : lang.MEMBER_LIST_TITLE_TXT,
'listUrl' : BACK_PRE+'/member/list?isList=1&pageNumber={}&pageSize={}'.format(pageNumber,pageSize),
'searchTxt' : lang.MEMBER_INPUT_TXT,
'sort_bar' : True,#开启排序
'member_page' : True,#开启排序
'cur_page' : pageNumber,
'cur_size' : pageSize,
'STATIC_LAYUI_PATH' : STATIC_LAYUI_PATH,
'remove_type' : 'cards',
'STATIC_ADMIN_PATH' : STATIC_ADMIN_PATH
}
return template('admin_member_list',info=info,lang=lang,RES_VERSION=RES_VERSION)
def do_create_total(redis):
count = 0
for key in redis.keys(FORMAT_LOGIN_DATE_TABLE4FISH%('*')):
count+=convert_util.to_int(redis.scard(key))
print 'do_create_total total[%s]'%(count)
redis.set("fish:login:per:day:total",count)
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 get_fish_cal_data(redis):
"""
获取捕鱼的每日数据更新
"""
curTime = convert_util.to_dateStr(datetime.now())
log_per_day = convert_util.to_int(redis.scard(FORMAT_LOGIN_DATE_TABLE4FISH%(curTime)))
reg_per_day = convert_util.to_int(redis.scard(FORMAT_REG_DATE_TABLE4FISH%(curTime)))
total_member = convert_util.to_int(redis.scard(ACCOUNT4WEIXIN_SET4FISH))
login_per_rate = convert_util.to_int(redis.get("fish:per:login:rate"))
recharge_per_rate = convert_util.to_int(redis.get("fish:per:recharge:rate"))
share_per_day = convert_util.to_int(redis.scard(FISH_FIRST_SHARE_PER_DAY_SET))
total_share = convert_util.to_int(redis.get(FISH_SHARE_TOTAL))
log_util.debug('[get_fish_cal_data] log_per_day[%s] reg_per_day[%s] total_member[%s] login_per_rate[%s] recharge_per_rate[%s]'\
%(log_per_day,reg_per_day,total_member,login_per_rate,recharge_per_rate))
return {
'log_per_day' : log_per_day,
'reg_per_day' : reg_per_day,
'total_member' : total_member,
'login_per_rate' : login_per_rate,
'recharge_per_rate' : recharge_per_rate,
'share_per_day' : share_per_day,
'total_share' : total_share
}
def do_auto_charge(redis,session):
"""
奖品发货状态变更接口
"""
curTime = datetime.now()
fields = ('exchange_id','exchangeIds')
for field in fields:
exec("%s=request.forms.get('%s','').strip()"%(field,field))
if exchangeIds:
""" 批量发货设置 """
batch_ids = exchangeIds.split(',')
pipe = redis.pipeline()
for batch_id in batch_ids:
exchange_table = FISH_EXCHANGE_TABLE%(batch_id)
exchange_info = eval(redis.get(exchange_table))
exchange_info['exchange_reward_status'] = convert_util.to_int(exchange_info['exchange_reward_status'])
if exchange_info['exchange_reward_status'] == 0:
exchange_info['exchange_reward_status'] = 1
pipe.set(exchange_table,exchange_info)
else:
pass
pipe.execute()
return {'code':0,'msg':'批量发货成功,请注意商品状态!','jumpUrl':BACK_PRE+'/goods/reward/exchange/list'}
else:
""" 单个商品发货 """
if not exchange_id:
return {'code':1,'msg':'参数错误'}
exchange_table = FISH_EXCHANGE_TABLE%(exchange_id)
exchange_info = eval(redis.get(exchange_table))
exchange_info['exchange_reward_status'] = convert_util.to_int(exchange_info['exchange_reward_status'])
log_debug('[exchange_info][%s]'%(exchange_info))
pipe = redis.pipeline()
#auto_charge_set = redis.smembers(FISH_REWARD_AUTO_CHARGE)
if exchange_info['exchange_reward_status'] == 0:
exchange_info['exchange_reward_status'] = 1
pipe.set(exchange_table,exchange_info)
else:
return {'code':1,'msg':'该奖品已经发货'}
#pipe.lrem(FISH_REWARD_ON_SHOP_LIST,exchange_id)
pipe.execute()
return {'code':0,'msg':'兑换ID为[%s]的商品发货状态更改成功'%(exchange_id),'jumpUrl':BACK_PRE+'/goods/reward/exchange/list'}
def do_create_recharge_total(redis):
""" 统计所有的充值总数 """
count = 0
for key in redis.keys(FISH_SYSTEM_DATE_RECHARGE_TOTAL%('*')):
print key
count+=convert_util.to_int(redis.hget(key,'recharge_coin_total'))
print 'do_create_recharge_total total[%s]'%(count)
redis.set(FISH_SYSTEM_RECHARGE_TOTAL,count)
def get_agent_active(redis, agentId, startDate, endDate):
"""
获取直属下级代理活跃数
"""
self_child_table = AGENT_CHILD_TABLE % (agentId)
self_child_ids = redis.smembers(self_child_table)
god_id = redis.get('god:id')
if agentId == god_id:
self_child_ids = []
for aid in redis.smembers('sysadmin:id:set'):
self_child_table = AGENT_CHILD_TABLE % (aid)
self_child_ids += list(redis.smembers(self_child_table))
self_child_ids = set(self_child_ids)
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)
res = []
now_date = datetime.now()
while endDate >= startDate:
if endDate > now_date:
endDate -= deltaTime
continue
for child_id in self_child_ids:
agentInfo = {}
agentInfo['id'] = child_id
agentInfo['date'] = endDate.strftime('%Y-%m-%d')
count = convert_util.to_int(
redis.get(DAY_AG_LOGIN_COUNT % (child_id, agentInfo['date'])))
parentTable = AGENT_CHILD_TABLE % (child_id)
agent_ids = redis.smembers(parentTable)
count = get_agent_by_date(redis, child_id, agent_ids,
agentInfo['date'])
agentInfo['active'] = count
agentInfo['roomcard'] = getAgentRoomByDay(redis, child_id,
agentInfo['date']),
agentInfo['members'] = getAgentAllMembers(redis, child_id),
pid, type = redis.hmget('agents:id:%s' % agentInfo['id'],
'parent_id', 'type')
agentInfo['gid'] = pid
if type == '2':
agentInfo['gid'] = redis.hget('agents:id:%s' % pid,
'parent_id')
res.append(agentInfo)
endDate -= deltaTime
res = sorted(res, key=itemgetter('date', 'active', 'id'), reverse=True)
return {'data': res, 'count': len(res)}
def do_memberRechargeCoin(redis, session):
"""
代理给会员充值金币接口
"""
selfUid = session['id']
fields = ('memberId', 'cardNums', 'passwd', 'token')
for field in fields:
exec('%s = request.forms.get("%s",' ').strip()' % (field, field))
if session.get('recharge_token') == None:
log_debug('session[%s]' % (session['recharge_token']))
return {'code': 1, 'msg': '非法提交订单'}
if token != session['recharge_token']:
log_debug(
'[try do_memberRecharge] token is not match. submit_token[%s] session_token[%s]'
% (token, session['recharge_token']))
return {
'code': 0,
'msg': '不能重复确认订单.',
'jumpUrl': BACK_PRE + '/member/search'
}
user_table = FORMAT_USER_TABLE % (memberId)
agent_table = AGENT_TABLE % (selfUid)
selfPasswd = redis.hget(agent_table, 'passwd')
info = {'title': '会员金币充值', 'backUrl': BACK_PRE + '/fish/member/list'}
checkNullFields = [{
'field': cardNums,
'msg': '充值金币数不能为空'
}, {
'field': passwd,
'msg': '请输入你的密码'
}]
for check in checkNullFields:
if not check['field']:
return {'code': 1, 'msg': check['msg']}
if selfPasswd != encrypt_util.to_sha256(passwd):
return {'code': 1, 'msg': '您的密码不正确'}
pipe = redis.pipeline()
try:
cardNums = convert_util.to_int(cardNums)
pipe.hincrby(user_table, 'coin', cardNums)
except Exception, e:
log_util.debug(
'[try do_memberRechargeCoin] ERROR. memberId[%s] reason[%s]' %
(memberId, e))
return {'code': 1, 'msg': '充值失败'}
def getAgentList(redis, session):
"""
代理列表
"""
lang = getLang()
#fields = ('isList','id','searchId','start_date','end_date')
fields = ('isList', 'id', 'searchId', 'start_date', 'end_date')
for field in fields:
exec(GET_FORMS % (field, field))
if not id:
id = session['id']
adminTable = AGENT_TABLE % (id)
creatAgUrl = BACK_PRE + '/agent/create'
#搜索条件
condition = {
'start_date': start_date,
'end_date': end_date,
'searchId': searchId
}
create_auth, aType = redis.hmget(adminTable, ('create_auth', 'type'))
create_auth = convert_util.to_int(create_auth)
if redis.sismember(AGENT2ACCESSBAN % (id), creatAgUrl):
createAg = '0'
else:
createAg = '1'
if isList:
res = getAgListInfos(redis, session, id, condition, lang)
return json.dumps(res)
else:
info = {
'title':
'下线代理列表(%s)' % (lang.TYPE_2_ADMINTYPE[str(int(aType) + 1)]),
'showPlus': 'true' if aType in ['0', '1'] else 'false',
"agent_id": id,
'createAccess': createAg,
'atype': aType,
'searchTxt': '公会/代理ID',
'createUrl': BACK_PRE + '/agent/create',
'listUrl': BACK_PRE + '/agent/list?isList=1',
'create_auth': create_auth,
'show_date_search': True,
'STATIC_LAYUI_PATH': STATIC_LAYUI_PATH,
'STATIC_ADMIN_PATH': STATIC_ADMIN_PATH
}
return template('admin_agent_list',
PAGE_LIST=PAGE_LIST,
info=info,
lang=lang,
RES_VERSION=RES_VERSION)
def do_auto_charge(redis,session):
"""
奖品上架接口
"""
curTime = datetime.now()
fields = ('reward_id',)
for field in fields:
exec("%s=request.forms.get('%s','').strip()"%(field,field))
if not reward_id:
return {'code':1,'msg':'参数错误'}
checkDesc = {
1 : '奖品ID为[%s]的商品下架成功',
0 : '奖品ID为[%s]的商品上架成功'
}
reward_table = FISH_REWARD_TABLE%(reward_id)
reward_status,reward_now_nums,reward_nums,reward_type = redis.hmget(reward_table,('reward_status','reward_now_nums','reward_nums','reward_type'))
reward_status = convert_util.to_int(reward_status)
reward_now_nums = convert_util.to_int(reward_now_nums)
reward_nums = convert_util.to_int(reward_nums)
pipe = redis.pipeline()
#auto_charge_set = redis.smembers(FISH_REWARD_AUTO_CHARGE)
if reward_status == 1:
pipe.hset(reward_table,'reward_status',0)
pipe.lrem(FISH_REWARD_ON_SHOP_LIST,reward_id)
pipe.lrem(FISH_REWARD_ON_SHOP_TYPE_LIST%(reward_type),reward_id)
else:
if reward_now_nums > reward_nums:
return web_util.do_response(1,'该奖品期数已过期,不能上架!')
pipe.hset(reward_table,'reward_status',1)
pipe.lpush(FISH_REWARD_ON_SHOP_LIST,reward_id)
pipe.lpush(FISH_REWARD_ON_SHOP_TYPE_LIST%(reward_type),reward_id)
#更新版本号
pipe.hincrby(FISH_CONSTS_CONFIG,'exchange_shop_ver',1)
pipe.execute()
return {'code':0,'msg':checkDesc[reward_status]%(reward_id),'jumpUrl':BACK_PRE+'/goods/fish/reward/list'}
def calc_per_recharge():
if not redis.exists(FISH_SYSTEM_RECHARGE_TOTAL):
do_create_recharge_total(redis)
else:
already_create_day = len(redis.keys(FISH_SYSTEM_DATE_RECHARGE_TOTAL%('*')))
already_recharge_total = convert_util.to_int(redis.get(FISH_SYSTEM_RECHARGE_TOTAL))
result = already_recharge_total/already_create_day
print 'already_create_day[%s] already_recharge[%s] result[%s]'%(already_create_day,already_recharge_total,result)
redis.set("fish:per:recharge:rate",result)
#删除当天充值人数统计
redis.delete(FISH_RECHARGE_USER_DAY_IDS)
def do_add_fishcoin_2_members(redis, transNo):
"""
捕鱼玩家增加金币,收到微信支付成功通知后回调
:params redis 数据库连接实例
:params transNo 订单号
"""
curTime = datetime.now()
orderTable = ORDER_TABLE4FISH % (transNo)
if not redis.exists(orderTable):
log_util.debug('[%s][wechatPay][error] orderNo[%s] is not exists.' %
(curTime, params['out_trade_no']))
return False
cardNums, present_card = redis.hmget(orderTable,
('roomCards', 'presentCards'))
cardNums = convert_util.to_int(cardNums)
present_card = convert_util.to_int(present_card)
rType, memberAccount, order_money = redis.hmget(
orderTable, ('num', 'account', 'money'))
#chargeNums = TYPE_2_CARS[rType]
account2user_table = FORMAT_ACCOUNT2USER_TABLE % (memberAccount
) #从账号获得账号信息，和旧系统一样
userTable = redis.get(account2user_table)
groupId, ori_coin = redis.hmget(userTable, 'parentAg', 'coin')
log_util.debug(
'[func addCoin2Member4fish] ori_coin[%s] recharge_coin[%s] present_coin[%s] order_money[%s]'
% (ori_coin, cardNums, present_card, order_money))
pipe = redis.pipeline()
pipe.hincrby(userTable, 'coin', cardNums + present_card)
#记录今日充值数
do_pay_record(redis,
userTable.split(":")[1], userTable, cardNums, order_money)
log_util.debug(
'[%s][wechatPay] recharge roomcards[%s] to account[%s] success' %
(curTime, cardNums, memberAccount))
pipe.execute()
return
def get_fish_sys_datas(redis,start_date,end_date):
"""
获取捕鱼系统统计数据
params: redis, start_date,end_date
"""
start_date = convert_util.to_datetime(start_date)
end_date = convert_util.to_datetime(end_date)
one_day = timedelta(1)
now_date = datetime.now()
total_members = convert_util.to_int(redis.scard(ACCOUNT4WEIXIN_SET4FISH))
total_recharge = convert_util.to_int(redis.get(FISH_SYSTEM_RECHARGE_TOTAL))
data_list = []
while end_date >= start_date:
if end_date > now_date:
end_date-=one_day
continue
today = convert_util.to_dateStr(end_date)
today_reg = redis.scard(FORMAT_REG_DATE_TABLE4FISH%(today))
today_active = convert_util.to_int(redis.scard(FORMAT_LOGIN_DATE_TABLE4FISH%(today)))
today_sys_user_total,today_sys_coin_total = redis.hmget(FISH_SYSTEM_DATE_RECHARGE_TOTAL%(today),('recharge_user_total','recharge_coin_total'))
today_sys_user_total = convert_util.to_int(today_sys_user_total)
today_sys_coin_total = convert_util.to_float(today_sys_coin_total)
try:
average_val = round(today_sys_coin_total/today_active,2)
except:
average_val = 0.00
data_list.append({
'today' : today,
'today_reg' : today_reg,
'today_active' : today_active,
'today_sys_user_total' : today_sys_user_total,
'today_sys_coin_total' : today_sys_coin_total,
'average_val' : average_val,
'money_total' : string_util.format_credit(total_recharge),
})
end_date-=one_day
return {'data':data_list}
def calc_per_login():
if not redis.exists("fish:login:per:day:total"):
do_create_total(redis)
else:
today = date.today()
do_add_yesterday_data(redis,today-timeDelt)
already_create_day = len(redis.keys(FORMAT_LOGIN_DATE_TABLE4FISH%('*')))
already_login_total = convert_util.to_int(redis.get("fish:login:per:day:total"))
result = already_login_total/already_create_day
print 'already_create_day[%s] already_login_total[%s] result[%s]'%(already_create_day,already_login_total,result)
redis.set("fish:per:login:rate",result)
def do_removeCard(redis,session,page=1,remove_type="cards"):
"""
移除会员的钻石接口
page:当前是操作第几页
"""
curTime = datetime.now()
lang = getLang()
fields = ('roomcard','agentId','remove','memberId')
for field in fields:
exec("%s = request.forms.get('%s','').strip()"%(field,field))
if not remove:
return {'code':1,'msg':lang.MEMBER_DIOMAN_INPUT_TXT}
if isinstance(remove,float):
return {'code':1,'msg':lang.MEMBER_DIOMAN_INPUT_NUM_TXT}
remove = convert_util.to_int(remove)
roomcard = convert_util.to_int(roomcard)
if remove > roomcard:
return {'code':1,'msg':lang.MEMBER_DIOMAN_GT_TXT}
try:
if remove_type == 'cards':
jump_url = "/admin/member/list?&pageNumber={}".format(page)
success_msg = lang.MEMBER_DIOMAN_REMOVE_SUCCESS
redis.incrby(USER4AGENT_CARD%(agentId, memberId),-remove)
else:
jump_url = "/admin/fish/member/list?&pageNumber={}".format(page)
success_msg = lang.MEMBER_COIN_REMOVE_SUCCESS
redis.hincrby(FORMAT_USER_TABLE%(memberId),'coin',-remove)
logInfo = {'datetime':curTime.strftime('%Y-%m-%d %H:%M:%S'),\
'ip':request.remote_addr,'desc':lang.AGENT_OP_LOG_TYPE['removeRoomCard']%(memberId,remove)}
writeAgentOpLog(redis,agentId,logInfo)
except Exception,e:
log_util.debug('[try do_removeCard] remove Exception reason[%s]'%(e))
return {'code':1,'msg':'移除失败'}
def do_addCard(redis,session,page=1,remove_type="cards"):
"""
增加会员钻石接口
"""
curTime = datetime.now()
lang = getLang()
fields = ('roomcard','agentId','add','memberId')
for field in fields:
exec("%s = request.forms.get('%s','').strip()"%(field,field))
selfUid = session['id']
if not add:
return {'code':1,'msg':lang.MEMBER_DIOMAN_INPUT_TXT}
if isinstance(add,float):
return {'code':1,'msg':lang.MEMBER_DIOMAN_INPUT_NUM_TXT}
add = convert_util.to_int(add)
roomcard = convert_util.to_int(roomcard)
if add <= 0 :
return {'code':1,'msg':lang.MEMBER_DIOMAN_LT_TXT}
try :
if remove_type == 'cards':
jump_url = "/admin/member/list?&pageNumber={}".format(page)
#提示成功
success_msg = lang.MEMBER_DIOMAN_ADD_SUCCESS
redis.incrby(USER4AGENT_CARD%(agentId, memberId),add)
else:
jump_url = "/admin/fish/member/list?&pageNumber={}".format(page)
success_msg = lang.MEMBER_COIN_ADD_SUCCESS
redis.hincrby(FORMAT_USER_TABLE%(memberId),'coin',add)
logInfo = {'datetime':curTime.strftime('%Y-%m-%d %H:%M:%S'),\
'ip':request.remote_addr,'desc':lang.AGENT_OP_LOG_TYPE['addRoomCard']%(memberId,add)}
writeAgentOpLog(redis,agentId,logInfo)
except Exception,e:
return {'code':1,'msg':lang.MEMBER_DIOMAN_INPUT_NUM_TXT}
def get_reward_shop_api_data(redis,on_shop_field):
"""
获取商城数据（大厅接口1）
"""
lang = getLang()
def index2dic(des_type):
return lang.REWARD_TYPE_2_DESC[des_type]
on_shop_lists = get_reward_shop_data(redis,on_shop_field)
on_shop_dic = {0:[],1:[],2:[],3:[],4:[]}
on_shop_type = on_shop_dic.keys()
for on_shop in on_shop_lists:
on_shop['reward_type'] = lang.REWARD_TYPE_2_DESC[convert_util.to_int(on_shop['reward_type'])]
log_util.debug('[try get_reward_shop_api_data] on_shop[%s]'%(on_shop_lists))
return map(index2dic,[0,1,2,3,4]),on_shop_lists
def get_index_page(redis, session, action='HALL'):
lang = getLang()
my_accesses = eval(session['access'])
datas = {
'STATIC_ADMIN_PATH': STATIC_ADMIN_PATH,
'ADMIN_DEFAULT_PAGE': '/admin/home?sys={}'.format(action),
'agent_id': session['id'],
'show_data_url': BACK_PRE + '/getHomePageData?sys={}'.format(action),
}
#初始化后台菜单
# if action == 'HALL':
# """ 棋牌大厅数据生成 """
hall_fields = ('type', 'parent_id', 'roomCard', 'open_auth')
agent_type, agent_parentAg, agent_cards, agent_openAuth = redis.hmget(
AGENT_TABLE % (session['id']), hall_fields)
access_modules = access_module.MENU_MODULES
if int(agent_type) in [SYSTEM_ADMIN]:
roomcard = '无限制'
else:
roomcard = agent_cards
open_auth = convert_util.to_int(agent_openAuth)
datas['room_card'] = roomcard
datas['agent_type'] = agent_type
datas['open_auth'] = open_auth
datas['show_card_bar'] = True
datas['open_auth_text'] = OPENAUTH_2_TXT[open_auth]
datas['link_fish_txt'] = ''
#datas['link_fish_url'] = BACK_PRE+'/FISH'
datas['link_fish_url'] = ''
# else:
# """ 捕鱼大厅数据生成 """
# fish_fields = ('type','parent_id')
# agent_type,agent_parentAg = redis.hmget(AGENT_TABLE%(session['id']),fish_fields)
# access_modules = access_module.FISH_MENU_MODULES
# #数据绑定
# datas['agent_type'] = agent_type
# datas['link_fish_txt'] = '棋牌系统后台'
# datas['link_fish_url'] = BACK_PRE+'/HALL'
#生成菜单数据
menus = menu_util.init_menus(lang, my_accesses, access_modules)
return template('admin_base',datas=datas,RES_VERSION=RES_VERSION,lang=lang,\
session=session,TYPE2TXT=lang.TYPE_2_ADMINTYPE,mainModules=menus)
def pushNotices(redis,session,action='hall'):
"""
将消息放进玩家的信息列表
"""
type2Msg = {'0':'推送','1':'取消推送'}
action = action.upper()
timeStr = convert_util.to_dateStr(datetime.now())
agentId = session['id']
active_id = request.GET.get('active_id','').strip()
pipe = redis.pipeline()
#超级管理员发的公告需要塞到所有玩家的信息盒子
active_table = FORMAT_GAMEHALL_ACTIVE_TABEL%(active_id)
senderId = redis.hget(active_table,'groupId')
if not senderId:
senderId = 1
if action == 'HALL':
memberIdList = getAgentAllMemberIds(redis,senderId)
user_msg_table_list = FORMAT_USER_ACTIVE_LIST
else:
userIdKey = []
memberIds = redis.smembers(ACCOUNT4WEIXIN_SET4FISH)
for memberId in memberIds:
table = FORMAT_ACCOUNT2USER_TABLE%(memberId) #从账号获得账号信息，和旧系统一样
userIdKey.append(table)
memberIdList = [userId.split(":")[1] for userId in redis.mget(userIdKey)]
user_msg_table_list = FORMAT_USER_ACTIVE_FISH_LIST
#推送所有公告
status = convert_util.to_int(redis.hget(active_table,'status'))
log_util.debug('[try pushNotices] agentId[%s] memberIds[%s] status[%s] action[%s]'%(agentId,memberIdList,status,action))
try:
if status == 0:
for memberId in memberIdList:
pipe.hset(FORMAT_GAMEHALL_ACTIVE_TABEL%(active_id),'time',timeStr)
pipe.lpush(user_msg_table_list%(memberId),active_id)
pipe.hset(active_table,'status',1)
else:
for memberId in memberIdList:
pipe.lrem(user_msg_table_list%(memberId),active_id)
pipe.srem(FORMAT_ACT_READ_SET%(active_id),memberId)
pipe.hset(active_table,'status',0)
except Exception,e:
log_util.debug('[try pushNotices] ERROR agentId[%s] reason[%s]'%(agentId,e))
return {'code':1,'msg':type2Msg[str(status)]+'失败.'}
