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_co_op_form(user_dict=None):
log = logger.new(request=request, auth_dict=user_dict)
log.info('Display Co-Op Submission Page')
co_op = CurrentCoops.query.filter(
CurrentCoops.uid == user_dict['username'],
CurrentCoops.date_created > start_of_year()).first()
return render_template('co_op.html',
username=user_dict['username'],
year=start_of_year().year,
on_coop=co_op)
def display_co_op_form():
log = logger.new(request=request)
log.info('Display Co-Op Submission Page')
# get user data
user_name = request.headers.get('x-webauth-user')
co_op = CurrentCoops.query.filter(
CurrentCoops.uid == user_name,
CurrentCoops.date_created > start_of_year()).first()
return render_template(request,
'co_op.html',
username=user_name,
year=start_of_year().year,
on_coop=co_op)
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 display_major_project():
log = logger.new(request=request)
log.info('Display Major Project Page')
# get user data
user_name = request.headers.get('x-webauth-user')
major_projects = [{
'username': p.uid,
'name': ldap_get_member(p.uid).cn,
'proj_name': p.name,
'status': p.status,
'description': p.description,
'id': p.id,
'is_owner': bool(user_name == p.uid)
} for p in MajorProject.query.filter(
MajorProject.date > start_of_year()).order_by(desc(MajorProject.id))]
major_projects_len = len(major_projects)
# return names in 'first last (username)' format
return render_template(request,
'major_project_submission.html',
major_projects=major_projects,
major_projects_len=major_projects_len,
username=user_name)
def submit_co_op_form(user_dict=None):
log = logger.new(request=request, auth_dict=user_dict)
valid_semesters = ['Fall', 'Spring']
post_data = request.get_json()
semester = post_data['semester']
if post_data['semester'] not in valid_semesters:
return "Invalid semester submitted", 400
if not ldap_is_current_student(user_dict['account']):
return "Must be current student", 403
log.info('Submit {} Co-Op'.format(semester))
if CurrentCoops.query.filter(
CurrentCoops.uid == user_dict['username'],
CurrentCoops.date_created > start_of_year()).first():
return "User has already submitted this form!", 403
# Add to corresponding co-op ldap group
ldap_add_member_to_group(user_dict['account'], semester.lower() + '_coop')
co_op = CurrentCoops(uid=user_dict['username'], semester=semester)
db.session.add(co_op)
db.session.flush()
db.session.commit()
req_cm.cache_clear()
return jsonify({"success": True}), 200
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 req_cm(member):
# Get the number of required committee meetings based on if the member
# is going on co-op in the current operating session.
co_op = CurrentCoops.query.filter(
CurrentCoops.uid == member.uid,
CurrentCoops.date_created > start_of_year()).first()
if co_op:
return 15
return 30
def get_hm(member, only_absent=False):
h_meetings = MemberHouseMeetingAttendance.query.outerjoin(
HouseMeeting,
MemberHouseMeetingAttendance.meeting_id == HouseMeeting.id).with_entities(
MemberHouseMeetingAttendance.meeting_id,
MemberHouseMeetingAttendance.attendance_status,
HouseMeeting.date).filter(
HouseMeeting.date > start_of_year(),
MemberHouseMeetingAttendance.uid == member.uid)
if only_absent:
h_meetings = h_meetings.filter(MemberHouseMeetingAttendance.attendance_status == "Absent")
return h_meetings
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_co_op_management(user_dict=None):
log = logger.new(request=request, auth_dict=user_dict)
log.info('Display Co-Op Management')
if not ldap_is_eval_director(user_dict['account']):
return "must be eval director", 403
co_op_list = [(member.semester, member.uid)
for member in CurrentCoops.query.filter(
CurrentCoops.date_created > start_of_year(),
CurrentCoops.semester != "Neither")]
return render_template(
"co_op_management.html",
username=user_dict['username'],
co_op=co_op_list,
)
def get_cm(member):
c_meetings = [
{
"uid": cm.uid,
"timestamp": cm.timestamp,
"committee": cm.committee
} for cm in CommitteeMeeting.query.join(
MemberCommitteeAttendance, MemberCommitteeAttendance.meeting_id
== CommitteeMeeting.id).with_entities(
MemberCommitteeAttendance.uid, CommitteeMeeting.timestamp,
CommitteeMeeting.committee).filter(
CommitteeMeeting.timestamp > start_of_year(),
MemberCommitteeAttendance.uid == member.uid,
CommitteeMeeting.approved == True # pylint: disable=singleton-comparison
).all()
]
return c_meetings
def delete_co_op(uid):
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
log.info('Delete {}\'s Co-Op'.format(uid))
CurrentCoops.query.filter(
CurrentCoops.uid == uid,
CurrentCoops.date_created > start_of_year()).delete()
db.session.flush()
db.session.commit()
return jsonify({"success": True}), 200
def submit_co_op_form():
log = logger.new(request=request)
user_name = request.headers.get('x-webauth-user')
post_data = request.get_json()
semester = post_data['semester']
log.info('Submit {} Co-Op'.format(semester))
if CurrentCoops.query.filter(
CurrentCoops.uid == user_name,
CurrentCoops.date_created > start_of_year()).first():
return "User has already submitted this form!", 403
co_op = CurrentCoops(uid=user_name, semester=semester)
db.session.add(co_op)
db.session.flush()
db.session.commit()
return jsonify({"success": True}), 200
def delete_co_op(uid, 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
log.info('Delete {}\'s Co-Op'.format(uid))
# Remove from corresponding co-op ldap group
if ldap_is_member_of_group(user_dict['account'], 'fall_coop'):
ldap_remove_member_from_group(user_dict['account'], 'fall_coop')
if ldap_is_member_of_group(user_dict['account'], 'spring_coop'):
ldap_remove_member_from_group(user_dict['account'], 'spring_coop')
CurrentCoops.query.filter(
CurrentCoops.uid == uid,
CurrentCoops.date_created > start_of_year()).delete()
db.session.flush()
db.session.commit()
return jsonify({"success": True}), 200
def display_intro_evals(internal=False, user_dict=None):
log = logger.new(request=request, auth_dict=user_dict)
log.info('Display Intro Evals Listing')
# get user data
def get_fid_cm_count(member_id):
return len([
a for a in FreshmanCommitteeAttendance.query.filter(
FreshmanCommitteeAttendance.fid == member_id)
if CommitteeMeeting.query.filter(
CommitteeMeeting.id == a.meeting_id).first().approved
])
members = [account for account in ldap_get_intro_members()]
ie_members = []
# freshmen who don't have accounts
fids = [
f for f in FreshmanAccount.query.filter(
FreshmanAccount.eval_date > start_of_year(),
FreshmanAccount.eval_date > datetime.now())
]
for fid in fids:
h_meetings = [
m.meeting_id for m in FreshmanHouseMeetingAttendance.query.
filter(FreshmanHouseMeetingAttendance.fid == fid.id).filter(
FreshmanHouseMeetingAttendance.attendance_status == "Absent")
]
if fid.signatures_missed is None:
signatures_missed = -1
else:
signatures_missed = fid.signatures_missed
freshman = {
'name':
fid.name,
'uid':
fid.id,
'eval_date':
fid.eval_date.strftime("%Y-%m-%d"),
'signatures_missed':
signatures_missed,
'committee_meetings':
get_fid_cm_count(fid.id),
'committee_meetings_passed':
get_fid_cm_count(fid.id) >= 10,
'house_meetings_missed': [{
"date":
m.date.strftime("%Y-%m-%d"),
"reason":
FreshmanHouseMeetingAttendance.query.filter(
FreshmanHouseMeetingAttendance.fid == fid.id).filter(
FreshmanHouseMeetingAttendance.meeting_id ==
m.id).first().excuse
} for m in HouseMeeting.query.filter(
HouseMeeting.id.in_(h_meetings))],
'technical_seminars': [
s.name for s in TechnicalSeminar.query.filter(
TechnicalSeminar.id.in_([
a.seminar_id
for a in FreshmanSeminarAttendance.query.filter(
FreshmanSeminarAttendance.fid == fid.id)
if TechnicalSeminar.query.filter(
TechnicalSeminar.id ==
a.seminar_id).first().approved
]))
],
'social_events':
'',
'comments':
"",
'ldap_account':
False,
'status':
"Pending"
}
ie_members.append(freshman)
# freshmen who have accounts
for member in members:
uid = member.uid
name = member.cn
freshman_data = FreshmanEvalData.query.filter(
FreshmanEvalData.eval_date > start_of_year(),
FreshmanEvalData.uid == uid).first()
if freshman_data is None:
continue
elif freshman_data.freshman_eval_result != "Pending" and internal:
continue
h_meetings = [m.meeting_id for m in get_hm(member, only_absent=True)]
member_info = {
'name':
name,
'uid':
uid,
'eval_date':
freshman_data.eval_date.strftime("%Y-%m-%d"),
'signatures_missed':
freshman_data.signatures_missed,
'committee_meetings':
len(get_cm(member)),
'committee_meetings_passed':
len(get_cm(member)) >= 10,
'house_meetings_missed': [{
"date":
m.date.strftime("%Y-%m-%d"),
"reason":
MemberHouseMeetingAttendance.query.filter(
MemberHouseMeetingAttendance.uid == uid,
MemberHouseMeetingAttendance.meeting_id ==
m.id).first().excuse
} for m in HouseMeeting.query.filter(
HouseMeeting.id.in_(h_meetings))],
'technical_seminars': [
seminar.name for seminar in TechnicalSeminar.query.join(
MemberSeminarAttendance, MemberSeminarAttendance.seminar_id
== TechnicalSeminar.id).with_entities(
TechnicalSeminar.name).filter(
TechnicalSeminar.timestamp > start_of_year(),
MemberSeminarAttendance.uid == member.uid,
TechnicalSeminar.approved == True # pylint: disable=singleton-comparison
).all()
],
'social_events':
freshman_data.social_events,
'comments':
freshman_data.other_notes,
'ldap_account':
True,
'status':
freshman_data.freshman_eval_result
}
ie_members.append(member_info)
ie_members.sort(key=lambda x: len(x['house_meetings_missed']))
ie_members.sort(key=lambda x: x['committee_meetings'], reverse=True)
ie_members.sort(key=lambda x: x['signatures_missed'])
ie_members.sort(key=lambda x: x['status'] == "Passed")
if internal:
return ie_members
# return names in 'first last (username)' format
return render_template('intro_evals.html',
username=user_dict['username'],
members=ie_members)
def attendance_history(user_dict=None):
def get_meeting_attendees(meeting_id):
attendees = [
ldap_get_member(a.uid).displayName
for a in MemberCommitteeAttendance.query.filter(
MemberCommitteeAttendance.meeting_id == meeting_id).all()
]
for freshman in [
a.fid for a in FreshmanCommitteeAttendance.query.filter(
FreshmanCommitteeAttendance.meeting_id ==
meeting_id).all()
]:
attendees.append(
FreshmanAccount.query.filter(
FreshmanAccount.id == freshman).first().name)
return attendees
def get_seminar_attendees(meeting_id):
attendees = [
ldap_get_member(a.uid).displayName
for a in MemberSeminarAttendance.query.filter(
MemberSeminarAttendance.seminar_id == meeting_id).all()
]
for freshman in [
a.fid for a in FreshmanSeminarAttendance.query.filter(
FreshmanSeminarAttendance.seminar_id == meeting_id).all()
]:
attendees.append(
FreshmanAccount.query.filter(
FreshmanAccount.id == freshman).first().name)
return attendees
log = logger.new(request=request, auth_dict=user_dict)
if not ldap_is_eboard(user_dict['account']):
return jsonify({"success": False, "error": "Not EBoard"}), 403
page = request.args.get('page', 1)
log.info('View Past Attendance Submitions')
offset = 0 if int(page) == 1 else ((int(page) - 1) * 10)
limit = int(page) * 10
all_cm = [{
"id": m.id,
"name": m.committee,
"dt_obj": m.timestamp,
"date": m.timestamp.strftime("%a %m/%d/%Y"),
"attendees": get_meeting_attendees(m.id),
"type": "cm"
} for m in CommitteeMeeting.query.filter(
CommitteeMeeting.timestamp > start_of_year(),
CommitteeMeeting.approved).all()]
all_ts = [{
"id": m.id,
"name": m.name,
"dt_obj": m.timestamp,
"date": m.timestamp.strftime("%a %m/%d/%Y"),
"attendees": get_seminar_attendees(m.id),
"type": "ts"
} for m in TechnicalSeminar.query.filter(
TechnicalSeminar.timestamp > start_of_year(),
TechnicalSeminar.approved).all()]
pend_cm = [{
"id": m.id,
"name": m.committee,
"dt_obj": m.timestamp,
"date": m.timestamp.strftime("%a %m/%d/%Y"),
"attendees": get_meeting_attendees(m.id)
} for m in CommitteeMeeting.query.filter(
CommitteeMeeting.timestamp > start_of_year(), CommitteeMeeting.approved
== False).all()] # pylint: disable=singleton-comparison
pend_ts = [{
"id": m.id,
"name": m.name,
"dt_obj": m.timestamp,
"date": m.timestamp.strftime("%a %m/%d/%Y"),
"attendees": get_seminar_attendees(m.id)
} for m in TechnicalSeminar.query.filter(
TechnicalSeminar.timestamp > start_of_year(), TechnicalSeminar.approved
== False).all()] # pylint: disable=singleton-comparison
all_meetings = sorted((all_cm + all_ts),
key=lambda k: k['dt_obj'],
reverse=True)[offset:limit]
if len(all_cm) % 10 != 0:
total_pages = (int(len(all_cm) / 10) + 1)
else:
total_pages = (int(len(all_cm) / 10))
return render_template('attendance_history.html',
username=user_dict['username'],
history=all_meetings,
pending_cm=pend_cm,
pending_ts=pend_ts,
num_pages=total_pages,
current_page=int(page))
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 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)
