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)