def friend_applys(self, msgtype, body):
p = self.player
rsp = poem_pb.ApplysList()
applys = p.friend_applys or {}
fields = [
'entityID', 'name', 'prototypeID', 'level', 'credits', "borderID"
]
now = int(time.time())
pending = []
rs = Player.batch_load(applys.keys(), fields)
for each in rs:
info = {}
applytime = applys.get(each.entityID, {}).get('applytime', 0)
if applytime and now > applytime + FRIEND_APPLY_CD:
pending.append(each.entityID)
continue
for f in fields:
info[f] = getattr(each, f)
info['id'] = info['entityID']
info['time'] = applytime
info['vip'] = get_vip(info['credits'] or 0)
rsp.applys.add(**info)
if pending:
for i in pending:
del p.friend_applys[i]
p.save()
p.sync()
logger.debug(rsp)
return success_msg(msgtype, rsp)
def friend_invite_list(self, msgtype, body):
p = self.player
if not p.factionID:
return success_msg(msgtype, "")
req = poem_pb.InviteFriendList()
req.ParseFromString(body)
logger.debug(req)
try:
ownerID, fbID = simple_load_friendfb(req.friendfbID, 'ownerID',
'fbID')
except DoesNotExistsException:
return fail_msg(msgtype,
msgTips.FAIL_MSG_FRIENDFB_ALREADY_DISAPPEARED)
if p.entityID != ownerID:
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
invitees = load_friendfb_invitees(req.friendfbID)
# invitees 起码会有发现者
assert invitees, "impossible"
fields = ['entityID', 'name', 'prototypeID', 'level', "borderID"]
# 过滤已经邀请的好友(2016-02-18 改会公会成员)
f = Faction.simple_load(p.factionID, ["memberset"])
rs = Player.batch_load(list(set(f.memberset) - invitees), fields)
rsp = poem_pb.InviteFriendListResponse()
config = get_config(FriendfbConfig)[fbID]
for each in rs:
info = {}
if each.level < config.openlv:
continue
for f in fields:
info[f] = getattr(each, f)
info['id'] = info['entityID']
rsp.friends.add(**info)
return success_msg(msgtype, rsp)
def friend_list(self, msgtype, body):
p = self.player
# 推荐好友
if p.friend_count < p.friend_max_count:
recommend(p.entityID)
rsp = poem_pb.FriendList()
fields = [
'entityID', 'name', 'prototypeID', 'level', 'credits', 'lastlogin',
"groupID", "borderID"
]
rs = Player.batch_load(list(p.friendset), fields)
for each in rs:
info = {}
for f in fields:
info[f] = getattr(each, f)
info['id'] = info['entityID']
if info['lastlogin']:
info['time'] = time.mktime(info['lastlogin'].timetuple())
else:
info['time'] = 0
info['gifted'] = info['id'] in p.friendgiftedset
info['vip'] = get_vip(info['credits'] or 0)
info["messages_count"] = len(
p.friend_messages.get(info['entityID'], []))
rsp.friends.add(**info)
logger.debug(rsp)
return success_msg(msgtype, rsp)
def friend_recommends(self, msgtype, body):
p = self.player
rsp = poem_pb.RecommendsList()
recommends = getrecommends(p, count=10)
fields = [
'entityID', 'name', 'prototypeID', 'level', 'credits',
'friend_applys', 'lastlogin', "borderID"
]
rs = Player.batch_load(recommends, fields)
for each in rs:
if not each:
continue
each.friend_applys.load()
if p.entityID in each.friend_applys:
continue
info = {}
for f in fields:
info[f] = getattr(each, f)
info['id'] = info['entityID']
info['vip'] = get_vip(info['credits'] or 0)
if info['lastlogin']:
info['time'] = int(time.mktime(info['lastlogin'].timetuple()))
rsp.recommends.add(**info)
logger.debug(rsp)
return success_msg(msgtype, rsp)
def query_player():
value = request.POST.getone('value')
type = request.POST.getone('type')
regionID = int(request.GET['regionID'])
if not type or not value:
return FAILURE
import settings
from player.model import Player
from yy.entity.index import UniqueIndexing
from user.model import User, UsernameIndexing
if type == 'playername':
indexing = UniqueIndexing('index_p_name{%d}' % regionID,
settings.REDISES['index'])
entityID = indexing.get_pk(value)
if entityID:
entityIDs = [indexing.get_pk(value)]
else:
entityIDs = []
elif type == 'username':
userID = UsernameIndexing.get_pk(value)
u = User.load(userID)
entityIDs = u.roles[regionID]
elif type == 'entityID':
entityIDs = [int(value)]
attrs = [
'entityID', 'username', 'name', 'sex', 'career', 'level', 'userID'
]
header = ['ID', u'用户名', u'名称', u'性别', u'职业', u'等级', u"用户ID"]
rows = []
players = Player.batch_load(entityIDs, attrs)
for player in players:
ll = [getdisplayattr(player, s) for s in attrs]
rows.append(ll)
return dict(rows=rows, header=header)
def backup_extras(type, ranking, backup_key, count=30):
extra_key = backup_key + EXTRA_POSTFIX
entityIDs = ranking.get_by_range(0, count)
extras = {}
for p in Player.batch_load(entityIDs, RANKING_EXTRA_KEYS[type]):
if p is None:
continue
extras[p.entityID] = ranking_extra_encode(p, type)
ranking.pool.execute_pipeline(
('del', extra_key),
['hmset', extra_key] + list(convert_dict_to_list(extras)),
)
def get_players_info(self, playerIDs, attrs):
objs = []
pending = []
playerIDs = list(playerIDs)
for playerID in list(playerIDs):
p = self.get_player(playerID)
if p:
objs.append(p)
else:
pending.append(playerID)
from player.model import Player
objs.extend(filter(lambda s: s, Player.batch_load(pending, Player.expend_fields(attrs))))
result = []
for p in objs:
result.append({n: getattr(p, n) for n in attrs})
return sorted(result, key=lambda s: playerIDs.index(s['entityID']))
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 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 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 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)