async def get(self):
rucounts = collections.defaultdict(int)
async for dudoc in domain.get_multi_user(domain_id=self.domain_id,
role={'$gte': ''},
fields={'uid': 1, 'role': 1}):
if 'role' in dudoc:
rucounts[dudoc['role']] += 1
roles = sorted(list(self.domain['roles'].keys()))
self.render('domain_manage_role.html', rucounts=rucounts, roles=roles)
async def get(self):
rucounts = collections.defaultdict(int)
async for dudoc in domain.get_multi_user(domain_id=self.domain_id,
role={'$gte': ''},
fields={'uid': 1, 'role': 1}):
if 'role' in dudoc:
rucounts[dudoc['role']] += 1
# built-in roles are displayed additionally so that we don't need to use get_all_roles() here
roles = sorted(list(self.domain['roles'].keys()))
self.render('domain_manage_role.html', rucounts=rucounts, roles=roles)
async def get(self, *, page: int = 1):
udocs, uucount, ucount = await pagination.paginate(
domain.get_multi_user(domain_id=self.domain_id).sort([
('rank', 1)
]), page, self.USERS_PER_PAGE)
for udoc in udocs:
udoc['info'] = await user.get_by_uid(udoc['uid'])
self.render('domain_ranking.html',
page=page,
uucount=uucount,
ucount=ucount,
udocs=udocs)
async def get(self):
rucounts = collections.defaultdict(int)
async for dudoc in domain.get_multi_user(domain_id=self.domain_id,
role={'$gte': ''},
fields={
'uid': 1,
'role': 1
}):
if 'role' in dudoc:
rucounts[dudoc['role']] += 1
# built-in roles are displayed additionally so that we don't need to use get_all_roles() here
roles = sorted(list(self.domain['roles'].keys()))
self.render('domain_manage_role.html', rucounts=rucounts, roles=roles)
async def get(self):
uids = [self.domain['owner_uid']]
rudocs = collections.defaultdict(list)
async for dudoc in domain.get_multi_user(domain_id=self.domain_id,
role={'$gte': ''},
fields={'uid': 1, 'role': 1}):
if 'role' in dudoc:
uids.append(dudoc['uid'])
rudocs[dudoc['role']].append(dudoc)
roles = sorted(list(self.domain['roles'].keys()))
roles_with_text = [(role, role) for role in roles]
udict = await user.get_dict(uids)
self.render('domain_manage_user.html', roles=roles, roles_with_text=roles_with_text,
rudocs=rudocs, udict=udict)
async def get(self):
uids = []
rudocs = collections.defaultdict(list)
async for dudoc in domain.get_multi_user(domain_id=self.domain_id,
role={'$gte': ''},
fields={'uid': 1, 'role': 1, 'display_name': 1}):
if 'role' in dudoc:
uids.append(dudoc['uid'])
rudocs[dudoc['role']].append(dudoc)
roles = sorted(list(domain.get_all_roles(self.domain).keys()))
roles_with_text = [(role, role) for role in roles]
udict = await user.get_dict(uids)
self.render('domain_manage_user.html', roles=roles, roles_with_text=roles_with_text,
rudocs=rudocs, udict=udict)
async def run(domain_id: str, keyword: str='rp', rank_field: str='rank', level_field: str='level'):
_logger.info('Ranking')
dudocs = domain.get_multi_user(domain_id=domain_id, fields={'_id': 1, 'uid': 1, keyword: 1}) \
.sort(keyword, -1)
last_dudoc = {keyword: None}
rank = 0
count = 0
user_coll = db.coll('domain.user')
user_bulk = user_coll.initialize_unordered_bulk_op()
async for dudoc in dudocs:
count += 1
if keyword not in dudoc:
dudoc[keyword] = None
if dudoc[keyword] != last_dudoc[keyword]:
rank = count
user_bulk.find({'_id': dudoc['_id']}).update_one({'$set': {rank_field: rank}})
last_dudoc = dudoc
# progress
if count % 1000 == 0:
_logger.info('#{0}: Rank {1}'.format(count, rank))
if count > 0:
_logger.info('Committing')
await user_bulk.execute()
if rank == 0:
_logger.warn('No one has {0}'.format(keyword))
return
if level_field:
level_ranks = sorted([(level, round(int(count * perc / 100)))
for level, perc in builtin.LEVELS.items()],
key=lambda i: i[1], reverse=True)
assert level_ranks[0][1] == count
user_bulk = user_coll.initialize_unordered_bulk_op()
for i in range(len(level_ranks) - 1):
_logger.info('Updating users levelled {0}'.format(level_ranks[i][0]))
(user_bulk.find({'domain_id': domain_id,
'$and': [{rank_field: {'$lte': level_ranks[i][1]}},
{rank_field: {'$gt': level_ranks[i + 1][1]}}]})
.update({'$set': {level_field: level_ranks[i][0]}}))
i = len(level_ranks) - 1
_logger.info('Updating users levelled {0}'.format(level_ranks[i][0]))
(user_bulk.find({'domain_id': domain_id, rank_field: {'$lte': level_ranks[i][1]}})
.update({'$set': {level_field: level_ranks[i][0]}}))
_logger.info('Committing')
await user_bulk.execute()
async def run(domain_id: str,
keyword: str = 'rp',
rank_field: str = 'rank',
level_field: str = 'level'):
_logger.info('Ranking')
dudocs = domain.get_multi_user(domain_id=domain_id, fields={'_id': 1, 'uid': 1, keyword: 1}) \
.sort(keyword, -1)
last_dudoc = {keyword: None}
rank = 0
count = 0
user_coll = db.coll('domain.user')
user_bulk = user_coll.initialize_unordered_bulk_op()
async for dudoc in dudocs:
count += 1
if keyword not in dudoc:
dudoc[keyword] = None
if dudoc[keyword] != last_dudoc[keyword]:
rank = count
user_bulk.find({
'_id': dudoc['_id']
}).update_one({'$set': {
rank_field: rank
}})
last_dudoc = dudoc
# progress
if count % 1000 == 0:
_logger.info('#{0}: Rank {1}'.format(count, rank))
if count > 0:
_logger.info('Committing')
await user_bulk.execute()
if rank == 0:
_logger.warn('No one has {0}'.format(keyword))
return
if level_field:
level_ranks = sorted([(level, round(int(count * perc / 100)))
for level, perc in builtin.LEVELS.items()],
key=lambda i: i[1],
reverse=True)
assert level_ranks[0][1] == count
user_bulk = user_coll.initialize_unordered_bulk_op()
for i in range(len(level_ranks) - 1):
_logger.info('Updating users levelled {0}'.format(
level_ranks[i][0]))
(user_bulk.find({
'domain_id':
domain_id,
'$and': [{
rank_field: {
'$lte': level_ranks[i][1]
}
}, {
rank_field: {
'$gt': level_ranks[i + 1][1]
}
}]
}).update({'$set': {
level_field: level_ranks[i][0]
}}))
i = len(level_ranks) - 1
_logger.info('Updating users levelled {0}'.format(level_ranks[i][0]))
(user_bulk.find({
'domain_id': domain_id,
rank_field: {
'$lte': level_ranks[i][1]
}
}).update({'$set': {
level_field: level_ranks[i][0]
}}))
_logger.info('Committing')
await user_bulk.execute()
async def get(self, *, page: int=1):
dudocs, dupcount, _ = await pagination.paginate(
domain.get_multi_user(domain_id=self.domain_id, rp={'$gt': 0.0}).sort([('rank', 1)]),
page, self.USERS_PER_PAGE)
udict = await user.get_dict(dudoc['uid'] for dudoc in dudocs)
self.render('ranking_main.html', page=page, dupcount=dupcount, dudocs=dudocs, udict=udict)
