def rooms_dict():
out = dict({})
rooms = list(flask_redis.smembers("forresthill-rooms"))
rooms.sort()
for room in rooms:
out[room] = flask_redis.hget(room, "name")
return out
def get_friend_rooms():
rooms = map(lambda name: flask_redis.hgetall(name),
flask_redis.smembers("forresthill-rooms"))
rooms.sort(key=lambda x: x['key'])
friends = set()
if current_user.is_authenticated:
for room in rooms:
room_machines = flask_redis.lrange(room['key'] + "-machines", 0,
-1)
for machineName in room_machines:
machine = flask_redis.hgetall(machineName)
if current_user.has_friend(machine['user']):
uun = current_user.get_friend(machine['user'])
friends.add((uun, room['key'], room['name']))
friends = list(friends)
# uun -> name
names = ldap.get_names([f[0] for f in friends])
for i in range(len(friends)):
uun, b, c = friends[i]
if uun in names:
friends[i] = {
'uun': uun,
'name': names[uun],
'room_key': b,
'room_name': c
}
friends.sort(key=lambda x: x['name'])
return friends
def rooms_list():
rooms = list(flask_redis.smembers("forresthill-rooms"))
rooms.sort()
for i in range(len(rooms)):
room = rooms[i]
rooms[i] = (room, flask_redis.hget(room, "name"))
return rooms
def rooms_list():
"""Returns a tuple of (name, uun) (TODO: swap order)"""
rooms = list(flask_redis.smembers("forresthill-rooms"))
rooms.sort()
for i in range(len(rooms)):
room = rooms[i]
rooms[i] = (room, flask_redis.hget(room, "name"))
return rooms
def schema_reset(site):
siteKey = site + "-rooms"
pipe = flask_redis.pipeline()
for room in flask_redis.smembers(siteKey):
schema_reset_room(pipe, site, room)
pipe.delete(site)
pipe.srem("mapp.sites", site)
pipe.execute()
def get_friend(self, friend_hash):
import hashlib
from config import CRYPTO_SECRET as secret
from map import flask_redis
all_friends = flask_redis.smembers(self.get_id() + '-friends')
for friend in all_friends:
hasher = hashlib.sha512()
hasher.update(friend + str(secret))
if hasher.hexdigest() == friend_hash:
return friend
return ""
def map_routine(which_room):
room = flask_redis.hgetall(str(which_room))
room_machines = flask_redis.lrange(room['key'] + "-machines", 0, -1)
machines = {m: flask_redis.hgetall(m) for m in room_machines}
num_rows = max([int(machines[m]['row']) for m in machines])
num_cols = max([int(machines[m]['col']) for m in machines])
num_machines = len(machines.keys())
num_used = 0
rows = []
for r in xrange(0, num_rows+1):
unsorted_cells = []
for c in xrange(0, num_cols+1):
default_cell = {'hostname': None, 'col': c, 'row': r}
cell = [v for (k, v) in machines.iteritems() if int(v['row']) == r and int(v['col']) == c]
if not cell:
cell = default_cell
else:
cell = cell[0]
try:
if cell['user'] is not "":
num_used += 1
except Exception:
pass
unsorted_cells.append(cell)
cells = unsorted_cells
rows.append(cells)
num_free = num_machines - num_used
reserved = flask_redis.smembers('reserved-machines')
low_availability = num_free <= 0.3 * num_machines
date_format = "%Y-%m-%dT%H:%M:%S.%f"
last_update = datetime.strptime(flask_redis.get("last-update"),date_format)
last_update = last_update.strftime("%Y-%m-%d %H:%M:%S")
return {
"room" : room,
"rows" : rows,
"reserved" : reserved,
"num_free" : num_free,
"num_machines" : num_machines,
"low_availability" : low_availability,
"last_update" : last_update
}
def get_friends():
friends = flask_redis.smembers(current_user.get_username() + "-friends")
friends = list(friends)
with ldap.conn() as ldap_conn:
friend_names = ldap.get_names_bare(friends, ldap_conn)
for i in range(len(friends)):
uun = friends[i]
friend = uun
if uun in friend_names:
friend = friend_names[uun]
friends[i] = (friend, uun)
return friends
def get_cascader_elsewhere_count(cascaders: List[str], notRoom: str) -> int:
rooms = filter(lambda name: name != notRoom,
flask_redis.smembers("forresthill-rooms"))
rooms = map(lambda name: flask_redis.hgetall(name), rooms)
count: int = 0
for room in rooms:
room_machines = flask_redis.lrange(room['key'] + "-machines", 0, -1)
for machineName in room_machines:
machine = flask_redis.hgetall(machineName)
if machine['user']:
uun = find_cascader(cascaders, machine['user'])
if uun:
count += 1
return count
def friends():
if request.method == "POST":
formtype = request.form.get('type')
if formtype == "del":
remove_friends = request.form.getlist('delfriends')
flask_redis.srem(current_user.get_id() + "-friends", *remove_friends)
elif formtype == "add":
add_friend = request.form.get('newfriend')
if(re.match("^[A-Za-z]+\ [A-Za-z]+$", add_friend) == None):
raise APIError("Friend name expected in [A-z]+\ [A-z]+ form.", status_code=400)
flask_redis.sadd(current_user.get_id() + "-friends", add_friend)
friends = flask_redis.smembers(current_user.get_id() + "-friends")
friends = list(friends)
friends = sorted(friends, key=lambda s: s.lower())
return jsonify(friendList=friends) #Set up for ajax responses
def get_friend(self, friend_hash, ignore_dnd=False):
from map import flask_redis
if check_uun_hash(self.get_username(), friend_hash):
if self.get_dnd() and not ignore_dnd:
return ""
return self.get_username()
all_friends = flask_redis.smembers(self.get_username() + '-friends')
for friend in all_friends:
if check_uun_hash(friend, friend_hash):
from map import flask_redis
is_dnd = flask_redis.sismember("dnd-users", friend)
if is_dnd and not ignore_dnd:
return ""
else:
return friend
return ""
def route_get_cascaders():
if current_user.is_disabled:
return jsonify([])
cascaders = get_cascaders()
rooms = map(lambda name: flask_redis.hgetall(name),
flask_redis.smembers("forresthill-rooms"))
result = []
for room in rooms:
room_machines = flask_redis.lrange(room['key'] + "-machines", 0, -1)
for machineName in room_machines:
machine = flask_redis.hgetall(machineName)
if machine['user']:
uun = find_cascader(cascaders, machine['user'])
if uun:
result.append({
'uun': uun,
'room': room['name'],
})
uuns = [f['uun'] for f in result]
# uun -> name
names = ldap.get_names(uuns)
# uun -> tagline
taglines = flask_redis.hmget("cascaders.taglines", uuns)
for i in range(len(result)):
uun = result[i]['uun']
if uun in names:
result[i]['name'] = names[uun]
result[i]['tagline'] = taglines[i]
return jsonify(result)
def get_cascaders() -> List[str]:
return list(flask_redis.smembers("cascaders.users"))
