def get_members_info():
members = [m['uid'] for m in ldap_get_current_students()]
member_list = []
number_onfloor = 0
for member_uid in members:
uid = member_uid[0].decode('utf-8')
name = ldap_get_name(uid)
active = ldap_is_active(uid)
onfloor = ldap_is_onfloor(uid)
room_number = ldap_get_room_number(uid)
room = room_number if room_number != "N/A" else ""
hp = ldap_get_housing_points(uid)
member_list.append({
"uid": uid,
"name": name,
"active": active,
"onfloor": onfloor,
"room": room,
"hp": hp
})
if onfloor:
number_onfloor += 1
return member_list, number_onfloor
def edit_uid(uid, flask_request, username):
log = logger.new(request=flask_request, auth_dict={'username': username})
post_data = flask_request.get_json()
account = ldap_get_member(uid)
active_member = post_data['activeMember']
current_account = ldap_get_member(username)
if ldap_is_eval_director(current_account):
room_number = post_data['roomNumber']
onfloor_status = post_data['onfloorStatus']
housing_points = post_data['housingPoints']
log.info('Edit {} - Room: {} On-Floor: {} Points: {}'.format(
uid, post_data['roomNumber'], post_data['onfloorStatus'],
post_data['housingPoints']))
ldap_set_roomnumber(account, room_number)
if onfloor_status:
# If a OnFloorStatusAssigned object exists, don't make another
if not ldap_is_onfloor(account):
db.session.add(OnFloorStatusAssigned(uid, datetime.now()))
ldap_add_member_to_group(account, "onfloor")
else:
for ofs in OnFloorStatusAssigned.query.filter(
OnFloorStatusAssigned.uid == uid):
db.session.delete(ofs)
db.session.flush()
db.session.commit()
if ldap_is_onfloor(account):
ldap_remove_member_from_group(account, "onfloor")
ldap_set_housingpoints(account, housing_points)
# Only update if there's a diff
log.info('Set {} Active: {}'.format(uid, active_member))
if ldap_is_active(account) != active_member:
if active_member:
ldap_set_active(account)
else:
ldap_set_inactive(account)
if active_member:
db.session.add(SpringEval(uid))
else:
SpringEval.query.filter(SpringEval.uid == uid
and SpringEval.active).update(
{'active': False})
clear_members_cache()
def get_members_info():
members = [account for account in ldap_get_current_students()]
member_list = []
for account in members:
uid = account.uid
name = account.cn
active = ldap_is_active(account)
onfloor = ldap_is_onfloor(account)
room = ldap_get_roomnumber(account)
hp = account.housingPoints
member_list.append({
"uid": uid,
"name": name,
"active": active,
"onfloor": onfloor,
"room": room,
"hp": hp
})
return member_list
def get_housing_queue(is_eval_director=False):
# Generate a dictionary of dictionaries where the UID is the key
# and {'time': <datetime obj>} is the value. We are doing a left
# outer join on the two tables to get a single result that has
# both the member's UID and their on-floor datetime.
in_queue = {entry.uid: {'time': entry.onfloor_granted} for entry
in InHousingQueue.query.outerjoin(OnFloorStatusAssigned,
OnFloorStatusAssigned.uid == InHousingQueue.uid)\
.with_entities(InHousingQueue.uid, OnFloorStatusAssigned.onfloor_granted)\
.all()}
# Populate a list of dictionaries containing the name, username,
# and on-floor datetime for each member who has on-floor status,
# is not already assigned to a room and is in the above query.
queue = [{
"uid":
account.uid,
"name":
account.cn,
"points":
account.housingPoints,
"time":
in_queue.get(account.uid, {}).get('time', datetime.now())
or datetime.now(),
"in_queue":
account.uid in in_queue
} for account in ldap_get_current_students()
if ldap_is_onfloor(account) and (
is_eval_director or account.uid in in_queue)
and account.roomNumber is None]
# Sort based on time (ascending) and then points (decending).
queue.sort(key=lambda m: m['time'])
queue.sort(key=lambda m: m['points'], reverse=True)
return queue
def member_management_getuserinfo(uid):
log = logger.new(user_name=request.headers.get("x-webauth-user"),
request_id=str(uuid.uuid4()))
log.info('api', action='retrieve user info')
user_name = request.headers.get('x-webauth-user')
if not ldap_is_eval_director(user_name) and not ldap_is_financial_director(
user_name):
return "must be eval or financial director", 403
acct = None
if uid.isnumeric():
acct = FreshmanAccount.query.filter(FreshmanAccount.id == uid).first()
# missed hm
def get_hm_date(hm_id):
return HouseMeeting.query.filter(
HouseMeeting.id == hm_id). \
first().date.strftime("%Y-%m-%d")
# if fid
if acct:
missed_hm = [{
'date': get_hm_date(hma.meeting_id),
'id': hma.meeting_id,
'excuse': hma.excuse,
'status': hma.attendance_status
} for hma in FreshmanHouseMeetingAttendance.query.filter(
FreshmanHouseMeetingAttendance.fid == acct.id and (
FreshmanHouseMeetingAttendance.attendance_status !=
attendance_enum.Attended))]
hms_missed = []
for hm in missed_hm:
if hm['status'] != "Attended":
hms_missed.append(hm)
return jsonify({
'id': acct.id,
'name': acct.name,
'eval_date': acct.eval_date.strftime("%Y-%m-%d"),
'missed_hm': hms_missed,
'onfloor_status': acct.onfloor_status,
'room_number': acct.room_number,
'sig_missed': acct.signatures_missed
}), 200
if ldap_is_eval_director(user_name):
missed_hm = [{
'date': get_hm_date(hma.meeting_id),
'id': hma.meeting_id,
'excuse': hma.excuse,
'status': hma.attendance_status
} for hma in MemberHouseMeetingAttendance.query.filter(
MemberHouseMeetingAttendance.uid == uid and (
MemberHouseMeetingAttendance.attendance_status !=
attendance_enum.Attended))]
hms_missed = []
for hm in missed_hm:
if hm['status'] != "Attended":
hms_missed.append(hm)
return jsonify({
'name': ldap_get_name(uid),
'room_number': ldap_get_room_number(uid),
'onfloor_status': ldap_is_onfloor(uid),
'housing_points': ldap_get_housing_points(uid),
'active_member': ldap_is_active(uid),
'missed_hm': hms_missed,
'user': '******'
}), 200
else:
return jsonify({
'name': ldap_get_name(uid),
'active_member': ldap_is_active(uid),
'user': '******'
}), 200
def display_dashboard():
log = logger.new(user_name=request.headers.get("x-webauth-user"),
request_id=str(uuid.uuid4()))
log.info('frontend', action='display dashboard')
# get user data
user_name = request.headers.get('x-webauth-user')
can_vote = get_voting_members()
data = dict()
data['username'] = user_name
data['name'] = ldap_get_name(user_name)
# Member Status
data['active'] = ldap_is_active(user_name)
# On-Floor Status
data['onfloor'] = ldap_is_onfloor(user_name)
# Voting Status
data['voting'] = bool(user_name in can_vote)
# freshman shit
if ldap_is_intromember(user_name):
data['freshman'] = get_freshman_data(user_name)
else:
data['freshman'] = False
spring = {}
c_meetings = [
m.meeting_id for m in MemberCommitteeAttendance.query.filter(
MemberCommitteeAttendance.uid == user_name)
]
spring['committee_meetings'] = len(c_meetings)
h_meetings = [(m.meeting_id, m.attendance_status)
for m in MemberHouseMeetingAttendance.query.filter(
MemberHouseMeetingAttendance.uid == user_name)]
spring['hm_missed'] = len([h for h in h_meetings if h[1] == "Absent"])
data['spring'] = spring
# only show housing if member has onfloor status
if ldap_is_onfloor(user_name):
housing = dict()
housing['points'] = ldap_get_housing_points(user_name)
housing['room'] = ldap_get_room_number(user_name)
if housing['room'] == "N/A":
housing['queue_pos'] = "%s / %s" % (get_queue_position(user_name),
get_queue_length())
else:
housing['queue_pos'] = "N/A"
else:
housing = None
data['housing'] = housing
data['major_projects'] = [{
'id': p.id,
'name': p.name,
'status': p.status,
'description': p.description
} for p in MajorProject.query.filter(MajorProject.uid == user_name)]
data['major_projects_count'] = len(data['major_projects'])
spring['mp_status'] = "Failed"
for mp in data['major_projects']:
if mp['status'] == "Pending":
spring['mp_status'] = 'Pending'
continue
if mp['status'] == "Passed":
spring['mp_status'] = 'Passed'
break
conditionals = [{
'date_created': c.date_created,
'date_due': c.date_due,
'description': c.description,
'status': c.status
} for c in Conditional.query.filter(Conditional.uid == user_name)]
data['conditionals'] = conditionals
data['conditionals_len'] = len(conditionals)
cm_attendance = [{
'type': m.committee,
'datetime': m.timestamp.date()
} for m in CommitteeMeeting.query.filter(
CommitteeMeeting.id.in_(c_meetings))]
hm_attendance = [{
'reason':
m.excuse,
'datetime':
HouseMeeting.query.filter(HouseMeeting.id == m.meeting_id).first().date
} for m in MemberHouseMeetingAttendance.query.filter(
MemberHouseMeetingAttendance.uid == user_name).filter(
MemberHouseMeetingAttendance.attendance_status == "Absent")]
data['cm_attendance'] = cm_attendance
data['cm_attendance_len'] = len(cm_attendance)
data['hm_attendance'] = hm_attendance
data['hm_attendance_len'] = len(hm_attendance)
return render_template(request, 'dashboard.html', **data)
def member_management_getuserinfo(uid, user_dict=None):
log = logger.new(request=request, auth_dict=user_dict)
log.info('Get {}\'s Information'.format(uid))
if not ldap_is_eval_director(
user_dict['account']) and not ldap_is_financial_director(
user_dict['account']):
return "must be eval or financial director", 403
acct = None
if uid.isnumeric():
acct = FreshmanAccount.query.filter(FreshmanAccount.id == uid).first()
# missed hm
def get_hm_date(hm_id):
return HouseMeeting.query.filter(
HouseMeeting.id == hm_id). \
first().date.strftime("%Y-%m-%d")
# if fid
if acct:
missed_hm = [{
'date': get_hm_date(hma.meeting_id),
'id': hma.meeting_id,
'excuse': hma.excuse,
'status': hma.attendance_status
} for hma in FreshmanHouseMeetingAttendance.query.filter(
FreshmanHouseMeetingAttendance.fid == acct.id and (
FreshmanHouseMeetingAttendance.attendance_status !=
attendance_enum.Attended))]
hms_missed = []
for hm in missed_hm:
if hm['status'] != "Attended":
hms_missed.append(hm)
return jsonify({
'id': acct.id,
'name': acct.name,
'eval_date': acct.eval_date.strftime("%Y-%m-%d"),
'missed_hm': hms_missed,
'onfloor_status': acct.onfloor_status,
'room_number': acct.room_number,
'sig_missed': acct.signatures_missed
}), 200
account = ldap_get_member(uid)
if ldap_is_eval_director(ldap_get_member(user_dict['username'])):
missed_hm = [{
'date': get_hm_date(hma.meeting_id),
'id': hma.meeting_id,
'excuse': hma.excuse,
'status': hma.attendance_status
} for hma in MemberHouseMeetingAttendance.query.filter(
MemberHouseMeetingAttendance.uid == uid and (
MemberHouseMeetingAttendance.attendance_status !=
attendance_enum.Attended))]
hms_missed = []
for hm in missed_hm:
if hm['status'] != "Attended":
hms_missed.append(hm)
return jsonify({
'name': account.cn,
'room_number': account.roomNumber,
'onfloor_status': ldap_is_onfloor(account),
'housing_points': account.housingPoints,
'active_member': ldap_is_active(account),
'missed_hm': hms_missed,
'user': '******'
}), 200
return jsonify({
'name': account.cn,
'active_member': ldap_is_active(account),
'user': '******'
}), 200
def display_dashboard(user_dict=None):
log = logger.new(request=request, auth_dict=user_dict)
log.info('display dashboard')
# Get the list of voting members.
can_vote = get_voting_members()
data = dict()
data['username'] = user_dict['account'].uid
data['active'] = ldap_is_active(user_dict['account'])
data['bad_standing'] = ldap_is_bad_standing(user_dict['account'])
data['onfloor'] = ldap_is_onfloor(user_dict['account'])
data['voting'] = bool(user_dict['account'].uid in can_vote)
data['voting_count'] = {
"Voting Members": len(can_vote),
"Active Members": len(ldap_get_active_members())
}
# freshman shit
if ldap_is_intromember(user_dict['account']):
data['freshman'] = get_freshman_data(user_dict['account'].uid)
else:
data['freshman'] = False
spring = {}
c_meetings = get_cm(user_dict['account'])
spring['committee_meetings'] = len(c_meetings)
spring['req_meetings'] = req_cm(user_dict['account'])
h_meetings = [(m.meeting_id, m.attendance_status)
for m in get_hm(user_dict['account'])]
spring['hm_missed'] = len([h for h in h_meetings if h[1] == "Absent"])
eval_entry = SpringEval.query.filter(
SpringEval.uid == user_dict['account'].uid,
SpringEval.date_created > start_of_year(),
SpringEval.active == True).first() # pylint: disable=singleton-comparison
if eval_entry is not None:
spring['status'] = eval_entry.status
else:
spring['status'] = None
data['spring'] = spring
# only show housing if member has onfloor status
if ldap_is_onfloor(user_dict['account']):
housing = dict()
housing['points'] = user_dict['account'].housingPoints
housing['room'] = user_dict['account'].roomNumber
housing['queue_pos'] = get_queue_position(user_dict['account'].uid)
else:
housing = None
data['housing'] = housing
data['major_projects'] = [{
'id': p.id,
'name': p.name,
'status': p.status,
'description': p.description
} for p in MajorProject.query.filter(
MajorProject.uid == user_dict['account'].uid,
MajorProject.date > start_of_year())]
data['major_projects_count'] = len(data['major_projects'])
spring['mp_status'] = "Failed"
for mp in data['major_projects']:
if mp['status'] == "Pending":
spring['mp_status'] = 'Pending'
continue
if mp['status'] == "Passed":
spring['mp_status'] = 'Passed'
break
conditionals = [{
'date_created': c.date_created,
'date_due': c.date_due,
'description': c.description,
'status': c.status
} for c in Conditional.query.filter(
Conditional.uid == user_dict['account'].uid,
Conditional.date_due > start_of_year())]
data['conditionals'] = conditionals
data['conditionals_len'] = len(conditionals)
hm_attendance = [{
'reason': m.excuse,
'datetime': m.date
} for m in MemberHouseMeetingAttendance.query.outerjoin(
HouseMeeting, MemberHouseMeetingAttendance.meeting_id ==
HouseMeeting.id).with_entities(
MemberHouseMeetingAttendance.excuse, HouseMeeting.date).filter(
MemberHouseMeetingAttendance.uid == user_dict['account'].uid,
MemberHouseMeetingAttendance.attendance_status == "Absent",
HouseMeeting.date > start_of_year())]
data['cm_attendance'] = c_meetings
data['cm_attendance_len'] = len(c_meetings)
data['hm_attendance'] = hm_attendance
data['hm_attendance_len'] = len(hm_attendance)
return render_template('dashboard.html', **data)