def get_user_data():
""" Returns JSON about active and recently active users, as well as info
about user agents, etc. """
# first, do the user agent popularity contest, since that's simple
results = utils.mdb.users.group(['latest_user_agent'],
{'latest_user_agent': {
'$exists': True
}}, {"count": 0},
"function(o, p){p.count++}")
sorted_list = sorted(results, key=lambda k: k["count"], reverse=True)
for i in sorted_list:
i["value"] = i['latest_user_agent']
i["count"] = int(i["count"])
ua_data = sorted_list[:25]
# next, get active/recent users
recent_user_cutoff = datetime.now() - timedelta(
hours=utils.settings.get("application", "recent_user_horizon"))
recent_users = utils.mdb.users.find({
"latest_activity": {
"$gte": recent_user_cutoff
}
}).sort("latest_activity", -1)
active_user_count = 0
recent_user_count = 0
final_user_output = []
for u in recent_users:
u['age'] = utils.get_time_elapsed_since(u['created_on'], 'age')
u['latest_activity_age'] = utils.get_time_elapsed_since(
u['latest_activity'], 'age')
if u["latest_activity"] > (datetime.now() -
timedelta(minutes=utils.settings.get(
'application', 'active_user_horizon'))):
active_user_count += 1
u['is_active'] = True
else:
recent_user_count += 1
u['is_active'] = False
final_user_output.append(u)
# create the final output dictionary
d = {
"meta": {
"active_user_horizon":
utils.settings.get("application", "active_user_horizon"),
"active_user_count":
active_user_count,
"recent_user_horizon":
utils.settings.get("application", "recent_user_horizon"),
"recent_user_count":
recent_user_count,
},
"user_agent_stats": ua_data,
"user_info": final_user_output,
}
# and return it as json
return json.dumps(d, default=json_util.default)
def get_settlement_data():
""" Returns JSON about recently updated settlements. Also serializes those
settlements and gets their event_log. """
recent_cutoff = datetime.now() - timedelta(
hours=settings.get("application", "recent_user_horizon"))
ids = utils.mdb.settlements.find({
'last_accessed': {
'$gte': recent_cutoff
}
}).distinct('_id')
sorting_hat = {}
for s_id in ids:
last_updated = utils.mdb.settlement_events.find({
'settlement_id': s_id
}).limit(1).sort("created_on", -1)[0]['created_on']
sorting_hat[last_updated] = s_id
sorted_ids = []
for timestamp in sorted(sorting_hat.keys(), reverse=True):
sorted_ids.append(sorting_hat[timestamp])
recent_settlements = []
for s in utils.mdb.settlements.find({"_id": {"$in": sorted_ids}}):
s['creator_email'] = utils.mdb.users.find_one({'_id': s['created_by']
})['login']
s['age'] = utils.get_time_elapsed_since(s['created_on'], 'age')
s['players'] = utils.mdb.survivors.find({
"settlement": s['_id']
}).distinct('email')
recent_settlements.append(s)
return json.dumps(recent_settlements, default=json_util.default)
def latest_settlement(self):
""" Get the latest settlement and punch it up with some additional info,
since JSON consumers don't have MDB access and can't get it otherwise.
"""
# s = self.get_eligible_documents(collection="settlements", limit=1)
try:
s = utils.mdb.settlements.find(
{"name": {
"$nin": self.ineligible_names
}},
sort=[("created_on", -1)])[0]
except IndexError:
self.logger.error(
"No settlements in mdb match the 'latest_settlement' criteria! Returning None..."
)
return None
S = settlements_models.Settlement(_id=s["_id"])
s["campaign"] = S.get_campaign("name")
s["expansions"] = S.get_expansions("pretty")
s["player_count"] = S.get_players("count")
s["age"] = utils.get_time_elapsed_since(s["created_on"], 'age')
for k in [
'timeline',
]:
if k in s.keys():
s[k] = "REDACTED"
return s
def get_patron_attributes(self):
""" Returns a dictionary of patronage information. """
if 'patron' not in self.user.keys():
return {'level': 0}
self.user['patron'].update({'age': utils.get_time_elapsed_since(self.user['patron']['created_on'], 'age')})
return self.user['patron']
def get_latest_activity(self, return_type=None):
""" Returns the user's latest activity in a number of ways. Leave the
'return_type' kwarg blank for a datetime stamp.
"""
la = self.user["latest_activity"]
if return_type is not None:
return utils.get_time_elapsed_since(la, return_type)
return la
def dump(self):
""" Dump a summary of the user to the CLI. """
U_serialized = self.User.serialize(dict)['user']
mini_repr = OrderedDict()
if 'admin' in self.User.user.keys():
mini_repr['admin'] = self.User.user['admin']
for time_attr in ['created_on','latest_sign_in', 'latest_activity']:
mini_repr[time_attr] = utils.get_time_elapsed_since(U_serialized[time_attr], 'age')
for attr in ['settlements_created','survivors_created']:
mini_repr[attr] = U_serialized[attr]
dump_doc_to_cli(mini_repr, gap_spaces=25)
if self.User.user['preferences'] != {}:
print(' User Preferences:')
dump_doc_to_cli(self.User.user['preferences'], gap_spaces=35)
def pretty_survivor(self, survivor):
""" Clean a survivor up and make it 'shippable' as part of the world
JSON. This initializes the survivor and will normalize it. """
# init
S = survivors_models.Survivor(_id=survivor["_id"],
normalize_on_init=False)
survivor["epithets"] = S.get_epithets("pretty")
survivor["age"] = utils.get_time_elapsed_since(survivor["created_on"],
"age")
# redact/remove
survivor["attribute_detail"] = 'REDACTED'
# add settlement info
settlement = utils.mdb.settlements.find_one(
{"_id": survivor["settlement"]})
survivor["settlement_name"] = settlement["name"]
return survivor
def get_age(self, return_type="years"):
""" Returns the user's age. """
return utils.get_time_elapsed_since(self.user["created_on"], 'age')
