def display_member_management():
log = logger.new(request=request)
log.info('Display Member Management')
username = request.headers.get('x-webauth-user')
account = ldap_get_member(username)
if not ldap_is_eval_director(account) and not ldap_is_financial_director(
account):
return "must be eval director", 403
member_list = get_members_info()
onfloor_list = get_onfloor_members()
co_op_list = [(ldap_get_member(member.uid).displayName, member.semester, member.uid) \
for member in CurrentCoops.query.filter(
CurrentCoops.date_created > start_of_year(),
CurrentCoops.semester != "Neither")]
freshmen = FreshmanAccount.query
freshmen_list = []
for freshman_user in freshmen: # pylint: disable=not-an-iterable
freshmen_list.append({
"id":
freshman_user.id,
"name":
freshman_user.name,
"onfloor":
freshman_user.onfloor_status,
"room":
"" if freshman_user.room_number is None else
freshman_user.room_number,
"eval_date":
freshman_user.eval_date
})
settings = EvalSettings.query.first()
if settings:
lockdown = settings.site_lockdown
intro_form = settings.intro_form_active
accept_dues_until = settings.accept_dues_until
else:
lockdown = False
intro_form = False
accept_dues_until = datetime.now()
return render_template(request,
"member_management.html",
username=username,
active=member_list,
num_current=len(member_list),
num_active=len(ldap_get_active_members()),
num_fresh=len(freshmen_list),
num_onfloor=len(onfloor_list),
freshmen=freshmen_list,
co_op=co_op_list,
site_lockdown=lockdown,
accept_dues_until=accept_dues_until,
intro_form=intro_form)
def get_non_alumni_non_coop(internal=False):
log = logger.new(user_name=request.headers.get("x-webauth-user"),
request_id=str(uuid.uuid4()))
log.info('api', action='retrieve house meeting attendance list')
# Only Members Who Have Paid Dues Are Required to
# go to house meetings
non_alumni_members = ldap_get_active_members()
coop_members = [u.username for u in CurrentCoops.query.all()]
named_members = [{
'display': f.name,
'value': f.id,
'freshman': True
} for f in FreshmanAccount.query.filter(
FreshmanAccount.eval_date > datetime.now())]
for m in non_alumni_members:
uid = m['uid'][0].decode('utf-8')
if uid in coop_members:
continue
name = "{name} ({uid})".format(name=get_name(m), uid=uid)
named_members.append({
'display': name,
'value': uid,
'freshman': False
})
if internal:
return named_members
else:
return jsonify({'members': named_members}), 200
def export_active_list():
sio = io.StringIO()
csvw = csv.writer(sio)
active_list = [["Full Name", "RIT Username", "Amount to Charge"]]
for member in ldap_get_active_members():
full_name = member.cn
# XXX[ljm] this should be renamed in LDAP/IPA schema to be ritUid
rit_username = member.ritDn
will_coop = CurrentCoops.query.filter(
CurrentCoops.date_created > start_of_year(),
CurrentCoops.uid == member.uid).first()
dues_per_semester = app.config['DUES_PER_SEMESTER']
if will_coop:
dues = dues_per_semester
else:
dues = 2 * dues_per_semester
active_list.append([full_name, rit_username, dues])
csvw.writerows(active_list)
output = make_response(sio.getvalue())
output.headers[
"Content-Disposition"] = "attachment; filename=csh_active_list.csv"
output.headers["Content-type"] = "text/csv"
return output
def get_voting_members():
if datetime.today() < datetime(start_of_year().year, 12, 31):
semester = 'Fall'
else:
semester = 'Spring'
active_members = set(member.uid for member in ldap_get_active_members())
intro_members = set(member.uid for member in ldap_get_intro_members())
on_coop = set(member.uid for member in CurrentCoops.query.filter(
CurrentCoops.date_created > start_of_year(),
CurrentCoops.semester == semester).all())
voting_list = list(active_members - intro_members - on_coop)
passed_fall = FreshmanEvalData.query.filter(
FreshmanEvalData.freshman_eval_result == "Passed",
FreshmanEvalData.eval_date > start_of_year()
).distinct()
for intro_member in passed_fall:
if intro_member.uid not in voting_list:
voting_list.append(intro_member.uid)
return voting_list
def display_member_management():
log = logger.new(user_name=request.headers.get("x-webauth-user"),
request_id=str(uuid.uuid4()))
log.info('frontend', action='display member management')
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 director", 403
members = [m['uid'] for m in ldap_get_current_students()]
member_list, onfloor_number = get_members_info(members)
freshmen = FreshmanAccount.query
freshmen_list = []
for freshman_user in freshmen:
freshmen_list.append({
"id":
freshman_user.id,
"name":
freshman_user.name,
"onfloor":
freshman_user.onfloor_status,
"room":
"" if freshman_user.room_number is None else
freshman_user.room_number,
"eval_date":
freshman_user.eval_date
})
settings = EvalSettings.query.first()
if settings:
lockdown = settings.site_lockdown
intro_form = settings.intro_form_active
else:
lockdown = False
intro_form = False
return render_template(request,
"member_management.html",
username=user_name,
active=member_list,
num_current=len(member_list),
num_active=len(ldap_get_active_members()),
num_fresh=len(freshmen_list),
num_onfloor=onfloor_number,
freshmen=freshmen_list,
site_lockdown=lockdown,
intro_form=intro_form)
def display_member_management(user_dict=None):
log = logger.new(request=request, auth_dict=user_dict)
log.info('Display Member Management')
if not ldap_is_eval_director(
user_dict['account']) and not ldap_is_financial_director(
user_dict['account']):
return "must be eval director", 403
member_list = get_members_info()
onfloor_list = get_onfloor_members()
freshmen = FreshmanAccount.query
freshmen_list = []
for freshman_user in freshmen: # pylint: disable=not-an-iterable
freshmen_list.append({
"id":
freshman_user.id,
"name":
freshman_user.name,
"onfloor":
freshman_user.onfloor_status,
"room":
"" if freshman_user.room_number is None else
freshman_user.room_number,
"eval_date":
freshman_user.eval_date
})
settings = EvalSettings.query.first()
if settings:
lockdown = settings.site_lockdown
intro_form = settings.intro_form_active
accept_dues_until = settings.accept_dues_until
else:
lockdown = False
intro_form = False
accept_dues_until = datetime.now()
return render_template("member_management.html",
username=user_dict['username'],
active=member_list,
num_current=len(member_list),
num_active=len(ldap_get_active_members()),
num_fresh=len(freshmen_list),
num_onfloor=len(onfloor_list),
freshmen=freshmen_list,
site_lockdown=lockdown,
accept_dues_until=accept_dues_until,
intro_form=intro_form)
def clear_active_members(user_dict=None):
log = logger.new(request=request, auth_dict=user_dict)
if not ldap_is_eval_director(user_dict['account']):
return "must be eval director", 403
# Get the active group.
members = ldap_get_active_members()
# Clear the active group.
for account in members:
if account.uid != user_dict['username']:
log.info('Remove {} from Active Status'.format(account.uid))
ldap_set_inactive(account)
return jsonify({"success": True}), 200
def clear_active_members():
log = logger.new(request=request)
username = request.headers.get('x-webauth-user')
account = ldap_get_member(username)
if not ldap_is_eval_director(account):
return "must be eval director", 403
# Get the active group.
members = ldap_get_active_members()
# Clear the active group.
for account in members:
if account.uid != username:
log.info('Remove {} from Active Status'.format(account.uid))
ldap_set_inactive(account)
return jsonify({"success": True}), 200
def get_voting_members():
voting_list = []
active_members = [x['uid'][0].decode('utf-8') for x
in ldap_get_active_members()]
intro_members = [x['uid'][0].decode('utf-8') for x
in ldap_get_intro_members()]
passed_fall = FreshmanEvalData.query.filter(
FreshmanEvalData.freshman_eval_result == "Passed"
).distinct()
for intro_member in passed_fall:
voting_list.append(intro_member.uid)
for active_member in active_members:
if active_member not in intro_members:
voting_list.append(active_member)
return voting_list
def get_non_alumni_non_coop(internal=False, user_dict=None):
log = logger.new(request=request, auth_dict=user_dict)
log.info('Retrieve House Meeting Attendance List')
# Get all active members as a base house meeting attendance.
active_members = ldap_get_active_members()
if datetime.today() < datetime(start_of_year().year, 12, 31):
semester = 'Fall'
else:
semester = 'Spring'
coop_members = [
u.uid for u in CurrentCoops.query.filter(
CurrentCoops.date_created > start_of_year(), CurrentCoops.semester
== semester).all()
]
eligible_members = [{
'display': f.name,
'value': f.id,
'freshman': True
} for f in FreshmanAccount.query.filter(
FreshmanAccount.eval_date > datetime.now())]
for account in active_members:
if account.uid in coop_members:
# Members who are on co-op don't need to go to house meeting.
continue
eligible_members.append({
'display': account.displayName,
'value': account.uid,
'freshman': False
})
if internal:
return eligible_members
return jsonify({'members': eligible_members}), 200
def display_spring_evals(internal=False):
log = logger.new(user_name=request.headers.get("x-webauth-user"),
request_id=str(uuid.uuid4()))
log.info('frontend', action='display membership evaluations listing')
def get_cm_count(member_id):
return len([a for a in MemberCommitteeAttendance.query.filter(
MemberCommitteeAttendance.uid == member_id)])
user_name = None
if not internal:
user_name = request.headers.get('x-webauth-user')
members = [m['uid'] for m in ldap_get_active_members()]
sp_members = []
for member_uid in members:
uid = member_uid[0].decode('utf-8')
print(uid)
spring_entry = SpringEval.query.filter(
SpringEval.uid == uid and
SpringEval.active).first()
if spring_entry is None:
spring_entry = SpringEval(uid)
db.session.add(spring_entry)
db.session.flush()
db.session.commit()
# something bad happened to get here
print("User did not have existing spring eval data")
elif spring_entry.status != "Pending":
continue
eval_data = None
h_meetings = [m.meeting_id for m in
MemberHouseMeetingAttendance.query.filter(
MemberHouseMeetingAttendance.uid == uid
).filter(
MemberHouseMeetingAttendance.attendance_status == "Absent"
)]
member = {
'name': ldap_get_name(uid),
'uid': uid,
'status': spring_entry.status,
'committee_meetings': get_cm_count(uid),
'house_meetings_missed':
[
{
"date": m.date.strftime("%Y-%m-%d"),
"reason":
MemberHouseMeetingAttendance.query.filter(
MemberHouseMeetingAttendance.uid == uid).filter(
MemberHouseMeetingAttendance.meeting_id == m.id).first().excuse
}
for m in HouseMeeting.query.filter(
HouseMeeting.id.in_(h_meetings)
)
],
'major_projects': [
{
'name': p.name,
'status': p.status,
'description': p.description
} for p in MajorProject.query.filter(
MajorProject.uid == uid)]
}
member['major_projects_len'] = len(member['major_projects'])
member['major_project_passed'] = False
for mp in member['major_projects']:
if mp['status'] == "Passed":
member['major_project_passed'] = True
break
if internal:
member['housing_evals'] = eval_data
sp_members.append(member)
sp_members.sort(key=lambda x: x['committee_meetings'], reverse=True)
sp_members.sort(key=lambda x: len(x['house_meetings_missed']))
sp_members.sort(key=lambda x: len([p for p in x['major_projects'] if p['status'] == "Passed"]), reverse=True)
# return names in 'first last (username)' format
if internal:
return sp_members
else:
return render_template(request,
'spring_evals.html',
username=user_name,
members=sp_members)
def migrate_models():
print("BEGIN: freshman evals")
# ==========
tech_sems = {}
freshman_evals = [{
'username': f.username,
'evalDate': f.voteDate,
'projectStatus': f.freshProjPass,
'signaturesMissed': f.numMissedSigs,
'socialEvents': f.socEvents,
'techSems': f.techSems,
'comments': f.comments,
'result': f.result
} for f in zoo_session.query(zoo.FreshmanEval).all()]
for f in freshman_evals:
if not f['username'].startswith('f_'):
# freshman who have completed packet and have a CSH account
eval_data = models.FreshmanEvalData(f['username'],
f['signaturesMissed'])
# FIXME: Zookeeper was only pass/fail for freshman project not pending
if f['projectStatus'] == 1:
eval_data.freshman_project = 'Passed'
eval_data.social_events = f['socialEvents']
eval_data.other_notes = f['comments']
eval_data.eval_date = f['evalDate']
# TODO: conditional
if f['result'] == "pass":
eval_data.freshman_eval_result = "Passed"
elif f['result'] == "fail":
eval_data.freshman_eval_result = "Failed"
else:
eval_data.freshman_eval_result = "Pending"
if f['techSems'] is not None:
t_sems = f['techSems'].split(',')
for sem in t_sems:
if sem not in tech_sems:
tech_sems[sem] = [f['username']]
else:
tech_sems[sem].append(f['username'])
db.session.add(eval_data)
else:
# freshman not yet done with packet
# TODO FIXME The FALSE dictates that they are not given onfloor
# status
account = models.FreshmanAccount(f['username'], False)
account.eval_date = f['evalDate']
if f['techSems'] is not None:
t_sems = f['techSems'].split(',')
for sem in t_sems:
if sem not in tech_sems:
tech_sems[sem] = [f['username']]
else:
tech_sems[sem].append(f['username'])
db.session.add(account)
print("tech sems")
tech_sems.pop('', None)
print(tech_sems)
for t_sem in tech_sems:
# TODO FIXME: Is there a timestamp we can migrate for seminars?
from datetime import datetime
sem = models.TechnicalSeminar(t_sem, datetime.now())
db.session.add(sem)
db.session.flush()
db.session.refresh(sem)
print(sem.__dict__)
for m in tech_sems[t_sem]:
if m.startswith("f_"):
print(sem.id)
a = models.FreshmanSeminarAttendance(get_fid(m), sem.id)
db.session.add(a)
else:
a = models.MemberSeminarAttendance(m, sem.id)
db.session.add(a)
db.session.flush()
print("END: freshman evals")
# ==========
print("BEGIN: migrate committee meeting attendance")
# ==========
c_meetings = [(m.meeting_date, m.committee_id)
for m in zoo_session.query(zoo.Attendance).all()]
c_meetings = list(set(c_meetings))
c_meetings = list(filter(lambda x: x[0] is not None, c_meetings))
c_meetings.sort(key=lambda col: col[0])
com_meetings = []
for cm in c_meetings:
m = models.CommitteeMeeting(id_to_committee(cm[1]), cm[0])
if cm[0] is None:
# f**k man
continue
db.session.add(m)
db.session.flush()
db.session.refresh(m)
com_meetings.append(cm)
c_meetings = [(m.username, (m.meeting_date, m.committee_id))
for m in zoo_session.query(zoo.Attendance).all()]
for cm in c_meetings:
if cm[1][0] is None:
# f**k man
continue
if cm[1][1] == 8:
continue
if cm[0].startswith('f_'):
f = models.FreshmanCommitteeAttendance(get_fid(cm[0]),
com_meetings.index(cm[1]))
db.session.add(f)
else:
m = models.MemberCommitteeAttendance(cm[0],
com_meetings.index(cm[1]) + 1)
db.session.add(m)
db.session.flush()
print("END: migrate committee meeting attendance")
# ==========
print("BEGIN: migrate conditionals")
# ==========
condits = [{
"uid": c.username,
"desc": c.description,
"deadline": c.deadline,
"status": c.status
} for c in zoo_session.query(zoo.Conditional).all()]
for c in condits:
condit = models.Conditional(c['uid'], c['desc'], c['deadline'])
db.session.add(condit)
print("END: migrate conditionals")
# ==========
print("BEGIN: house meetings")
h_meetings = [hm.date for hm in zoo_session.query(zoo.HouseMeeting).all()]
h_meetings = list(set(h_meetings))
h_meetings.sort()
print(h_meetings)
house_meetings = {}
for hm in h_meetings:
m = models.HouseMeeting(hm)
db.session.add(m)
db.session.flush()
db.session.refresh(m)
house_meetings[hm.strftime("%Y-%m-%d")] = m.id
print(house_meetings)
hma = [{
'uid': hm.username,
'date': hm.date,
'present': hm.present,
'excused': hm.excused,
'comments': hm.comments
} for hm in zoo_session.query(zoo.HouseMeeting).all()]
for a in hma:
meeting_id = house_meetings[a['date'].strftime("%Y-%m-%d")]
if a['present'] == 1:
status = "Attended"
elif a['excused'] == 1:
status = "Excused"
else:
status = "Absent"
excuse = a['comments']
if a['uid'].startswith("f_"):
# freshman
fhma = models.FreshmanHouseMeetingAttendance(
get_fid(a['uid']), meeting_id, excuse, status)
db.session.add(fhma)
else:
# member
mhma = models.MemberHouseMeetingAttendance(a['uid'], meeting_id,
excuse, status)
db.session.add(mhma)
print("END: house meetings")
# ==========
print("BEGIN: Major Projects")
projects = [{
'username': mp.username,
'name': mp.project_name,
'description': mp.project_description,
'status': mp.status
} for mp in zoo_session.query(zoo.MajorProject).all()]
for p in projects:
mp = models.MajorProject(p['username'], p['name'], p['description'])
if p['status'] == 'pass':
mp.status = 'Passed'
if p['status'] == 'fail':
mp.status = 'Failed'
db.session.add(mp)
print("END: Major Projects")
# ==========
print("BEGIN: ON FLOOR")
import conditional.util.ldap as ldap
from datetime import datetime
members = [
m['uid'][0].decode('utf-8') for m in ldap.ldap_get_onfloor_members()
]
for m in members:
db.session.add(models.OnFloorStatusAssigned(m, datetime.utcnow()))
print("END: ON FLOOR")
print("BEGIN: SPRING EVALS")
members = [
m['uid'][0].decode('utf-8') for m in ldap.ldap_get_active_members()
]
for m in members:
db.session.add(models.SpringEval(m))
print("END: SPRING EVALS")
print("BEGIN: Housing Evals")
hevals = [{
'username': he.username,
'social_attended': he.social_attended,
'social_hosted': he.social_hosted,
'seminars_attended': he.seminars_attended,
'seminars_hosted': he.seminars_hosted,
'projects': he.projects,
'comments': he.comments
} for he in zoo_session.query(zoo.WinterEval).all()]
for he in hevals:
db.session.add(
models.HousingEvalsSubmission(he['username'],
he['social_attended'],
he['social_hosted'],
he['seminars_attended'],
he['seminars_hosted'],
he['projects'], he['comments']))
print("END: Housing Evals")
# Default EvalDB Settings
db.session.add(models.EvalSettings())
db.session.flush()
db.session.commit()
def display_spring_evals(internal=False):
log = logger.new(request=request)
log.info('Display Membership Evaluations Listing')
user_name = None
if not internal:
user_name = request.headers.get('x-webauth-user')
active_members = [account for account in ldap_get_active_members()]
sp_members = []
for account in active_members:
uid = account.uid
spring_entry = SpringEval.query.filter(
SpringEval.date_created > start_of_year(), SpringEval.uid == uid,
SpringEval.active == True).first() # pylint: disable=singleton-comparison
if spring_entry is None:
spring_entry = SpringEval(uid)
db.session.add(spring_entry)
db.session.flush()
db.session.commit()
elif spring_entry.status != "Pending" and internal:
continue
eval_data = None
h_meetings = [m.meeting_id for m in get_hm(account, only_absent=True)]
member = {
'name':
account.cn,
'uid':
uid,
'status':
spring_entry.status,
'committee_meetings':
len(get_cm(account)),
'req_meetings':
req_cm(account),
'house_meetings_missed': [{
"date":
m.date.strftime("%Y-%m-%d"),
"reason":
MemberHouseMeetingAttendance.query.filter(
MemberHouseMeetingAttendance.uid == uid).filter(
MemberHouseMeetingAttendance.meeting_id ==
m.id).first().excuse
} for m in HouseMeeting.query.filter(
HouseMeeting.id.in_(h_meetings))],
'major_projects': [{
'name': p.name,
'status': p.status,
'description': p.description
} for p in MajorProject.query.filter(
MajorProject.date > start_of_year(), MajorProject.uid == uid)]
}
member['major_projects_len'] = len(member['major_projects'])
member['major_projects_passed'] = [{
'name': p.name,
'status': p.status,
'description': p.description
} for p in MajorProject.query.filter(
MajorProject.date > start_of_year(), MajorProject.status ==
"Passed", MajorProject.uid == uid)]
member['major_projects_passed_len'] = len(
member['major_projects_passed'])
member['major_project_passed'] = False
for mp in member['major_projects']:
if mp['status'] == "Passed":
member['major_project_passed'] = True
break
if internal:
member['housing_evals'] = eval_data
sp_members.append(member)
sp_members.sort(key=lambda x: x['committee_meetings'], reverse=True)
sp_members.sort(key=lambda x: len(x['house_meetings_missed']))
sp_members.sort(key=lambda x: len(
[p for p in x['major_projects'] if p['status'] == "Passed"]),
reverse=True)
# return names in 'first last (username)' format
if internal:
return sp_members
return render_template(request,
'spring_evals.html',
username=user_name,
members=sp_members)
def get_onfloor_members():
return [uid for uid in [members.uid for members in ldap_get_active_members()]
if uid in [members.uid for members in ldap_get_onfloor_members()]]
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)
