def load_friendfb(friendfbID):
now = int(time.time())
if if_boss(friendfbID):
friendfb = {}
campaign = get_boss_campaign(friendfbID)
if campaign:
friendfb.update(**{
'friendfbID': friendfbID,
'ownerID': 0, # 发现者
'fbID': campaign.config.fbID,
'owner': '',
'activists': [],
'createtime': now,
'remain': max(campaign.config.end - now, 0),
'desc': campaign.config.desc,
})
friendfb.update(**campaign.get_boss())
else:
rs = convert_list_to_dict(pool.execute("HGETALL", friendfbID))
logger.debug("%r", rs)
if not rs:
return rs
friendfb = {k: decode(v) for k, v in rs.items()}
friendfb.setdefault('friendfbID', friendfbID)
friendfb['activists'] = load_friendfb_activists(friendfbID)
friendfb['invitees'] = load_friendfb_invitees(friendfbID)
logger.debug("%r", friendfb)
friendfb['remain'] = \
FRIENDFB_INTERVAL - (now - friendfb['createtime'])
friendfb['hp'] = max(friendfb['hp'], 0)
return friendfb
def give_reward(self):
ranking = CityDungeonSelfRanking.get_range_by_score(
"-inf", "+inf", withscores=True)
configs = get_config(CityDungeonRewardConfig)
from campaign.manager import g_campaignManager
start_time = g_campaignManager.city_dungeon_campaign.get_start_time()
final_time = g_campaignManager.city_dungeon_campaign.get_final_time()
for rank, (entityID, score) in enumerate(
convert_list_to_dict(ranking, dictcls=OrderedDict).items(), 1):
if not rank:
continue
for c in configs.values():
start, end = c.range
if start:
if start > rank:
continue
if end:
if end < rank:
continue
config = c
if not config:
continue
title, content, ID = get_mail("CityDungeon")
content = content.format(rank)
rewards = parse_reward(config.rewards)
key = "CityDungeon{%d}{%d}" % (start_time, final_time)
try:
proxy.city_send_mail(
entityID, title, content, rewards, key, ID)
except AttributeError:
pass
def give_reward(self, date=None):
if not date:
now = int(time.time())
tm = date = datedate.fromtimestamp(now).strftime("%Y-%m-%d")
else:
tm = date
ranking = get_ranking_backup(self.type)
key = ranking.key
ll = get_config(RankingCampaignRewardByGroupConfig).get(
self.config.group, [])
configs = get_config(RankingCampaignRewardConfig)
configs = [configs[i.id] for i in ll]
key = "%s{%s}" % (key, tm)
limit = get_ranking_limit(self.type)
if limit is not None:
rankers = ranking.get_range_by_score(limit,
"+inf",
withscores=True)
else:
rankers = ranking.get_range_by_score("-inf",
"+inf",
withscores=True)
rankers = convert_list_to_dict(rankers, dictcls=OrderedDict).items()
for rank, (entityID, score) in enumerate(rankers, 1):
config = None
for c in configs:
start, end = c.range
if start:
if start > rank:
continue
if end:
if end < rank:
continue
config = c
if not config:
continue
title, content, ID = get_mail("RankingReward")
content = content.format(self.config.day, self.config.title, rank)
if self.type in get_faction_types():
f = Faction.simple_load(entityID, ["leaderID", "memberset"])
for i in set(f.memberset):
if i == f.leaderID:
rewards = parse_reward(config.rewards)
else:
rewards = parse_reward(config.rewards2)
try:
proxy.ranking_send_mail(i, title, content, rewards,
key, ID)
except AttributeError:
pass
else:
rewards = parse_reward(config.rewards)
try:
proxy.ranking_send_mail(entityID, title, content, rewards,
key, ID)
except AttributeError:
pass
def reload_top_three(self):
self.top_three = []
rankers = convert_list_to_dict(index_pool.execute(
"HGETALL", DailyTopThreeBackup))
result = []
for k, v in sorted(rankers.items()):
result.append(cPickle.loads(v))
self.top_three = result
return self.top_three
def get_payment(orderid):
pool = settings.REDISES["payment"]
key = "payment{%s}" % orderid
with pool.ctx() as conn:
rs = conn.execute("HGETALL", key)
if not rs:
return dict()
payment = convert_list_to_dict(rs)
return payment
def get_panel(self, p, rsp):
rsp.faction_rank = CityDungeonKillRanking.get_rank(p.factionID)
rsp.self_rank = CityDungeonSelfRanking.get_rank(p.entityID)
faction_rankers = convert_list_to_dict(
CityDungeonKillRanking.get_range_by_score(
"-inf", "+inf", count=10, withscores=True),
dictcls=OrderedDict)
factions = Faction.batch_load(
faction_rankers.keys(),
["entityID", "name", "level"])
for faction in factions:
if not faction:
continue
score = faction_rankers[faction.entityID]
faction_rankers[faction.entityID] = {
"name": faction.name,
"score": score,
"level": FactionRankRanking.get_score(faction.factionID) or 1,
}
player_rankers = convert_list_to_dict(
CityDungeonSelfRanking.get_range_by_score(
"-inf", "+inf", count=10, withscores=True),
dictcls=OrderedDict)
players = Player.batch_load(
player_rankers.keys(),
["entityID", "name", "faction_name", "level"])
for player in players:
score = player_rankers[player.entityID]
player_rankers[player.entityID] = {
"name": player.name,
"score": score,
"level": player.level,
"name2": player.faction_name,
}
rsp.faction_ranking = sorted(
faction_rankers.values(), key=lambda s: s["score"], reverse=True)
rsp.self_ranking = sorted(
player_rankers.values(), key=lambda s: s["score"], reverse=True)
rsp.top_prototypeID = p.prototypeID
rsp.current_info = self.get_current_info(p)
rsp.top_member_info = self.get_top_member_info(p)
rsp.reds = g_redManager.get_red_messages(
module=RedModuleType.CityDungeon)
def use_key(player, key):
sdk = username2sdk(player.username)
key = key.lower()
with _pool.ctx() as conn:
info = convert_list_to_dict(
conn.execute("HGETALL", "giftkey{%s}" % key))
if not info:
raise InvalidGiftkeyError
giftID_key = info["giftID"] # player.giftkeys 的 key需要是字符串
info["giftID"] = giftID = int(info["giftID"])
info["used"] = int(info.get("used") or 0)
info["channels"] = filter(lambda s: s,
info.get("channels", "").split(","))
info["servers"] = map(
int, filter(lambda s: s,
info.get("servers", "").split(",")))
configs = get_config(GiftkeyConfig)
config = configs.get(giftID)
if not config:
raise InvalidGiftkeyError
# 区服限制
if info["servers"] and settings.REGION["ID"] not in info["servers"]:
raise InvalidGiftkeyError
# 渠道限制
if info["channels"] and sdk not in info["channels"]:
raise InvalidGiftkeyError
# 同组的只能领取一次
groups = set()
for i in player.giftkeys.keys():
c = configs.get(int(i))
if c:
groups.add(c.group)
if config.group in groups:
if giftID_key not in player.giftkeys:
raise ExceedUseCountError
# 单个玩家次数限制
each_used = player.giftkeys.get(giftID_key, 0)
if config.each_use_count != -1: # -1表示不限制
if each_used >= config.each_use_count:
raise ExceedUseCountError
now = int(time.time())
# 时间限制
if config.start_time and now < config.start_time:
raise ExceedDeallineError
if config.end_time and now >= config.end_time:
raise ExceedDeallineError
used = conn.execute("HINCRBY", "giftkey{%s}" % key, "used", 1)
# 使用总次数限制
if config.use_count != -1: # -1表示不限制
if used > config.use_count:
conn.execute("HINCRBY", "giftkey{%s}" % key, "used", -1)
raise ExceedUseCountError
player.giftkeys[giftID_key] = player.giftkeys.get(giftID_key, 0) + 1
player.save()
return giftID
def load_ranks(friendfbID):
if if_boss(friendfbID):
bc = get_boss_campaign(friendfbID)
if not bc:
return []
return bc.load_ranks()
else:
key = "%s_ranklist" % friendfbID
with pool.ctx() as conn:
rs = convert_list_to_dict(conn.execute("HGETALL", key))
rs = map(decode, rs.values())
rs = sorted(rs, key=lambda s: s['damage'], reverse=True)
return rs
def __init__(self, id):
self.id = id
self.key = "config_files.{}".format(id)
self.pool = get_index_pool()
self.md5_prefix = '_md5'
self.files = RedisFetcher(
"HGETALL",
self.key,
formatter=lambda s: {
k: v
for k, v in convert_list_to_dict(s).items()
if not k.endswith("_md5")
},
pool=self.pool)
def get_red(self, red):
info = convert_list_to_dict(index_pool.execute("HGETALL", red))
if not info:
return
info["count"] = int(info["count"])
info["prototypeID"] = int(info["prototypeID"])
info["borderID"] = int(info["borderID"])
info["type"] = int(info["type"])
info["module"] = int(info["module"])
info["drop"] = int(info["drop"])
if info.get("time"):
info["time"] = int(info["time"])
info["cd"] = max(int(info["time"] - time.time()), 0)
return info
def faction_rank(self, msgtype, body):
req = poem_pb.RequestFactionRankList()
req.ParseFromString(body)
rsp = poem_pb.FactionInfos()
rank = 0
if req.type == poem_pb.RequestFactionRankList.Self:
if self.player.factionID:
rank = FactionRankRanking.get_rank(self.player.factionID)
count = 50
page = req.index
if rank <= count:
start = '-inf'
end = '+inf'
offset = count * page
rankscores = FactionRankRanking.get_range_by_score(
start,
end,
count=count + 1, # 多取一条，用于判断是否有下一页
offset=offset,
withscores=True,
)
infos = convert_list_to_dict(rankscores)
rankers = [c for i, c in enumerate(rankscores) if i % 2 == 0]
offset += 1
else:
start = max(rank - 1 + count * page, 0)
end = start + count
rankers = FactionRankRanking.get_by_range(
start,
end + 1, # 多取一条，用于判断是否有下一页
)
offset = start - 1
scores = FactionRankRanking.get_scores(rankers)
infos = dict(zip(rankers, scores))
thumbs = []
for i in rankers:
thumb = get_faction_thumb(i)
if not thumb:
continue
thumbs.append(thumb)
for thumb in thumbs[:count]:
thumb['rank'] = rankers.index(thumb['factionID']) + offset
thumb['level'] = infos.get(thumb['factionID'], 1)
rsp.infos.add(**thumb)
thumbs.sort(key=lambda s: s['rank'])
if len(thumbs) > count:
rsp.hasnext = True
else:
rsp.hasnext = False
return success_msg(msgtype, rsp)
def update(self, *args, **kwargs):
dict.update(self, *args, **kwargs)
data = {}
if args:
e = args[0]
if hasattr(e, 'items'):
data = e
else:
data = convert_list_to_dict(e)
data.update(kwargs)
for k, v in data.items():
data[k] = self.encoder(v)
values = convert_dict_to_list(data)
self.entity.push_command('HMSET', self.store_key, *values)
self.touch_handler()
def get_short_ranking(self):
from yy.utils import convert_list_to_dict
from collections import OrderedDict
rankers = convert_list_to_dict(self.handsel_ranking.get_range_by_score(
"-inf", "+inf", count=5, withscores=True),
dictcls=OrderedDict)
from player.model import Player
players = Player.batch_load(rankers.keys(), ["entityID", "name"])
for player in players:
score = rankers[player.entityID]
rankers[player.entityID] = {
"name": player.name,
"score": score,
}
return rankers
def backup(self):
rankers = convert_list_to_dict(
PlayerDailyRankRanking.get_range_by_score(
"-inf", "+inf", count=3, withscores=True))
result = []
sorted_rankers = sorted(
rankers.items(),
key=operator.itemgetter(1),
reverse=True)
index_pool.execute("DEL", DailyTopThreeBackup)
for rank, (i, daily_max_win_count) in enumerate(sorted_rankers, 1):
detail = get_opponent_detail(i)
detail["daily_max_win_count"] = daily_max_win_count
result.append(detail)
index_pool.execute(
"HSET", DailyTopThreeBackup, rank, cPickle.dumps(detail))
self.reload_top_three()
return result
def get_faction_ranking(self, ranking):
faction_rankers = convert_list_to_dict(
ranking.get_range_by_score(
"-inf", "+inf", count=10, withscores=True),
dictcls=OrderedDict)
factions = Faction.batch_load(
faction_rankers.keys(),
["entityID", "name", "level"])
for faction in factions:
score = faction_rankers[faction.entityID]
faction_rankers[faction.entityID] = {
"name": faction.name,
"score": score,
"level": FactionRankRanking.get_score(faction.factionID) or 1,
}
faction_rankers = sorted(
faction_rankers.values(), key=lambda s: s["score"], reverse=True)
return faction_rankers
def load_best_clearances(fbID=None):
pool = settings.REDISES["index"]
if fbID:
with pool.ctx() as conn:
rs = conn.execute("HGET", get_best_clearances_key(), fbID)
if rs:
rs = [fbID, rs]
else:
rs = []
else:
with pool.ctx() as conn:
rs = conn.execute("HGETALL", get_best_clearances_key())
dd = convert_list_to_dict(rs)
result = {}
for k, v in dd.items():
if v:
result[int(k)] = msgpack.loads(v)
return result
def get_rankers(self, count=50):
from campaign.manager import g_campaignManager
opened = g_campaignManager.dailypvp_campaign.is_open()
if opened:
rankers = convert_list_to_dict(
PlayerDailyRankRanking.get_range_by_score(
"-inf", "+inf", count=count, withscores=True))
result = []
sorted_rankers = sorted(
rankers.items(),
key=operator.itemgetter(1),
reverse=True)
for i, daily_max_win_count in sorted_rankers:
detail = get_opponent_detail(i)
detail["daily_max_win_count"] = daily_max_win_count
result.append(detail)
else:
result = self.get_backup_top_three()
return result
def get_player_ranking(self, ranking):
player_rankers = convert_list_to_dict(
ranking.get_range_by_score(
"-inf", "+inf", count=10, withscores=True),
dictcls=OrderedDict)
players = Player.batch_load(
player_rankers.keys(),
["entityID", "name", "faction_name",
"level", "city_contend_total_treasure"])
for player in players:
score = player_rankers[player.entityID]
player_rankers[player.entityID] = {
"name": player.name,
"score": score,
"level": player.level,
"name2": player.faction_name,
"score2": player.city_contend_total_treasure,
}
player_rankers = sorted(
player_rankers.values(), key=lambda s: (
s["score"], s["score2"]), reverse=True)
return player_rankers
def get_rank_list(self, rank, page=0, count=50):
if rank <= count:
start = '-inf'
end = '+inf'
offset = count * page
rankscores = PlayerRankRanking.get_range_by_score(
start,
end,
count=count + 1, # 多取一条，用于判断是否有下一页
offset=offset,
withscores=True,
)
infos = convert_list_to_dict(rankscores)
rankers = [c for i, c in enumerate(rankscores) if i % 2 == 0]
offset += 1
else:
start = max(rank + count * page, 0)
end = start + count
rankers = PlayerRankRanking.get_by_range(
start,
end + 1, # 多取一条，用于判断是否有下一页
)
offset = start
scores = PlayerRankRanking.get_scores(rankers)
infos = dict(zip(rankers, scores))
needs = [
'entityID', 'name', 'level', 'career', 'prototypeID', 'totalbp',
'rank_win_count', "factionID"
]
thumbs = g_entityManager.get_players_info(rankers, needs)
for thumb in thumbs:
thumb['pvprank'] = rankers.index(thumb['entityID']) + offset
thumb['totalbp'] = infos.get(thumb['entityID'], 0)
detail = get_opponent_detail_all(thumb["entityID"])
thumb.update(detail)
thumbs.sort(key=lambda s: s['pvprank'])
return thumbs
def sync_looted_mats(player):
mats = convert_list_to_dict(cost_looted_mats(player.entityID))
for k, v in mats.items():
player.cost_mats([[k, int(v)]])
player.save()
player.sync()
def hgetall(self):
return convert_list_to_dict(self.pool.execute('hgetall', self.key))
# coding:utf-8
import json
from yy.utils import convert_list_to_dict
import settings
pool = settings.REDISES['user']
keys = pool.execute('keys', 'u{*}')
for key in keys:
key = "roles_%s" % key
cmds = ["HMSET", key]
roles = convert_list_to_dict(pool.execute("HGETALL", key))
for regionID, roleID in roles.items():
roleID = json.loads(roleID)
if not isinstance(roleID, list):
cmds.extend([regionID, json.dumps([int(roleID)])])
if len(cmds) == 2:
continue
print cmds
pool.execute(*cmds)
def view(platform):
pool = create_pool(POOLS[platform])
print convert_list_to_dict(pool.execute('hgetall', REGIONS_KEY))
print convert_list_to_dict(pool.execute('smembers', WHITELIST_REGIONS_KEY))
def load_rewards(self):
self.rewards = {}
pool = settings.REDISES["index"]
data = convert_list_to_dict(pool.execute("HGETALL", SWAPRANK_REWARDS))
for k, v in data.items():
self.rewards[k] = ujson.loads(v)
def ranking_list(self, msgtype, body):
req = poem_pb.RankingListRequest()
req.ParseFromString(body)
p = self.player
backup = False
if req.from_campaign:
campaign = g_rankingCampaignManager.campaigns.get(req.type)
if campaign and campaign.is_open():
ranking = get_ranking(req.type)
else:
ranking = get_ranking_backup(req.type)
backup = True
else:
ranking = get_ranking(req.type)
if not ranking:
return fail_msg(msgtype, reason="没有这个排行榜")
rankers = convert_list_to_dict(ranking.get_range_by_score(
"-inf", "+inf", count=30, withscores=True),
dictcls=OrderedDict).items()
extras = {}
key = get_ranking_backup_key(req.type)
if req.type in RANKING_EXTRA_KEYS:
entityIDs = [
int(entityID) for entityID, _ in rankers if entityID
]
if p.entityID not in entityIDs:
entityIDs.append(p.entityID)
if entityIDs:
if backup:
extra_key = key + EXTRA_POSTFIX
extras.update(
zip(entityIDs, ranking.pool.execute(
'hmget', extra_key, *entityIDs)))
else:
for obj in Player.batch_load(
entityIDs, RANKING_EXTRA_KEYS[req.type]):
if obj:
extras[obj.entityID] = ranking_extra_encode(
obj, req.type)
rsp = poem_pb.RankingList()
faction_types = get_faction_types()
self_rank = None
for rank, (entityID, score) in enumerate(rankers, 1):
entityID = int(entityID)
score = int(float(score))
if not score:
continue
item = rsp.items.add(rank=rank, score=score)
item.extra = extras.get(entityID)
if req.type not in faction_types:
self.build_player_item(entityID, item)
if entityID == p.entityID:
self_rank = rsp.self = item
else:
self.build_faction_item(entityID, item)
if entityID == p.factionID:
self_rank = rsp.self = item
if not self_rank:
if req.type not in faction_types:
rank = ranking.get_rank(p.entityID)
if rank:
item = rsp.self
item.rank = rank
item.score = ranking.get_score(p.entityID)
item.extra = extras.get(p.entityID)
self.build_player_item(p.entityID, item)
else:
rank = ranking.get_rank(p.factionID)
if rank:
item = rsp.self
item.rank = rank
item.score = ranking.get_score(p.factionID)
self.build_faction_item(p.factionID, item)
return success_msg(msgtype, rsp)
