def get(self):
# pass map of quarter DB representations (ints) to string representation
quarter = self.request.get('quarter') # try grabbing quarter/year from URL
year = self.request.get('year')
if not quarter or not year: # if they don't exist, try grabbing from session
temp = get_sess_vals(self.session, 'quarter', 'year')
if not temp: # if they don't exist there, redirect with error
return self.redirect('/admin?message=Please set a current quarter and year')
quarter,year = temp
quarter,year = int(quarter), int(year)
view = self.request.get('view') # check URL for 'view by' options (lab vs class)
view = view if view else 'class'
if view == 'class':
students = StudentModel.get_students_by_active_status(quarter, year).fetch()
else:
students = StudentModel.get_students_by_lab(quarter, year, int(view)).fetch()
current_assign = AssignmentModel.get_active_assign_with_latest_fade_in_date(quarter, year)
current_num = 1 if not current_assign else current_assign.number
template = JINJA_ENV.get_template('/templates/admin_add_solo_partnership.html')
template_values = {
'students': sorted(students, key=lambda x: x.last_name),
'view': str(view),
'quarter': quarter,
'year': year,
'user': users.get_current_user(),
'sign_out': users.create_logout_url('/'),
'current_num': current_num,
'num_labs': SettingModel.num_labs() if SettingModel.num_labs() else 1,
}
return self.response.write(template.render(template_values))
def get(self):
# pass map of quarter DB representations (ints) to string representation
# TODO:
# quarters should not be hardcoded
quarter_map = {1: 'Fall', 2: 'Winter', 3: 'Spring', 4: 'Summer'}
quarter = self.request.get('quarter')
year = self.request.get('year')
if not quarter or not year: # if quarter/year aren't in URL, get from session
temp = get_sess_vals(self.session, 'quarter', 'year')
if not temp: # if they don't exist there, redirect with error
return self.redirect('/admin?message=Please set a current quarter and year')
quarter,year = temp
quarter,year = int(quarter), int(year)
studentid = int(self.request.get('studentid')) # grab studentid from URL (guaranteed to be there, unless URL was tinkered with)
student = StudentModel.get_student_by_student_id(quarter, year, studentid)
# if the student wasn't found, he/she might be inactive
student = student if student else StudentModel.get_student_by_student_id(quarter, year, studentid, active=False)
template_values = {
'user': users.get_current_user(),
'sign_out': users.create_logout_url('/'),
'student': student,
'quarter': quarter,
'year': year,
}
template = JINJA_ENV.get_template('/templates/admin_student_edit.html')
return self.response.write(template.render(template_values))
def get(self):
# pass map of quarter DB representations (ints) to string representation
# TODO:
# quarters should not be hardcoded
quarter_map = {1: 'Fall', 2: 'Winter', 3: 'Spring', 4: 'Summer'}
quarter = self.request.get('quarter')
year = self.request.get('year')
if not quarter or not year: # if quarter/year aren't in URL, get from session
temp = get_sess_vals(self.session, 'quarter', 'year')
if not temp: # if they don't exist there, redirect with error
return self.redirect(
'/admin?message=Please set a current quarter and year')
quarter, year = temp
quarter, year = int(quarter), int(year)
studentid = int(
self.request.get('studentid')
) # grab studentid from URL (guaranteed to be there, unless URL was tinkered with)
student = StudentModel.get_student_by_student_id(
quarter, year, studentid)
# if the student wasn't found, he/she might be inactive
student = student if student else StudentModel.get_student_by_student_id(
quarter, year, studentid, active=False)
template_values = {
'user': users.get_current_user(),
'sign_out': users.create_logout_url('/'),
'student': student,
'quarter': quarter,
'year': year,
}
template = JINJA_ENV.get_template('/templates/admin_student_edit.html')
return self.response.write(template.render(template_values))
def get(self):
# pass map of quarter DB representations (ints) to string representation
# TODO:
# quarters should not be hardcoded
quarter_map = {1: 'Fall', 2: 'Winter', 3: 'Spring', 4: 'Summer'}
quarter = self.request.get('quarter') # try grabbing quarter/year from URL
year = self.request.get('year')
if not quarter or not year: # if they don't exist, try grabbing from session
temp = get_sess_vals(self.session, 'quarter', 'year')
if not temp: # if they don't exist there, redirect with error
return self.redirect('/admin?message=Please set a current quarter and year')
quarter,year = temp
quarter,year = int(quarter), int(year)
active_students = StudentModel.get_students_by_active_status(quarter, year).fetch()
inactive_students = StudentModel.get_students_by_active_status(quarter, year, active=False).fetch()
active_num = len(active_students)
inactive_num = len(inactive_students)
template = JINJA_ENV.get_template('/templates/admin_view.html')
template_values = {
'students': sorted(active_students + inactive_students, key=lambda x: (x.lab, x.last_name)),
'quarter_name': quarter_map[int(quarter)],
'quarter': int(quarter),
'year': int(year),
'student_num': active_num + inactive_num,
'active_num': active_num,
'inactive_num': inactive_num,
'user': users.get_current_user(),
'sign_out': users.create_logout_url('/'),
'message': self.request.get('message'),
}
return self.response.write(template.render(template_values))
def get(self):
# pass map of quarter DB representations (ints) to string representation
# TODO:
# quarters should not be hardcoded
# rethink logic
quarter_map = {1: 'Fall', 2: 'Winter', 3: 'Spring', 4: 'Summer'}
quarter = self.request.get('quarter') # try grabbing quarter/year from URL
year = self.request.get('year')
if not quarter or not year: # if they don't exist, try grabbing from session
temp = get_sess_vals(self.session, 'quarter', 'year')
if not temp: # if they don't exist there, redirect with error
return self.redirect('/admin?message=Please set a current quarter and year')
quarter,year = temp
quarter,year = int(quarter), int(year)
view_by = self.request.get('view_by') # check URL for 'view by' options (lab vs class)
view_by = view_by if view_by else 1
if view_by == 'class': # if user wants to view by class, or the view by option wasn't specified...
students = StudentModel.get_students_by_active_status(quarter, year).fetch()
else:
students = StudentModel.get_students_by_lab(quarter, year, int(view_by)).fetch()
all_partners = PartnershipModel.get_all_partnerships(quarter, year).fetch()
last_assign = AssignmentModel.get_assign_n(quarter, year, -1)
last_num = 1 if not last_assign else last_assign.number
first_assign = AssignmentModel.get_assign_n(quarter, year, 0)
first_num = 0 if not first_assign else first_assign.number
keys_to_students = dict(map(lambda x: (x.key,x), students)) # map student objects to keys for easy, fast access from partnership objects
keys_to_partnerships = keys_to_partners(all_partners) # map student keys to partnerships for easy, fast access
# create mapping of student info to partnership info that the partnership template expects
partnership_dict = student_info_to_partner_list(last_num, first_num, keys_to_partnerships, keys_to_students, students)
partnership_dict = sorted(partnership_dict.items(), key=lambda x: (x[0][4], x[0][2]))
num_labs = SettingModel.num_labs()
template_values = {
'partnerships': partnership_dict,
'view_by': str(view_by),
'year': year,
'quarter': quarter,
'num_labs': num_labs if num_labs else 0,
'last_num': last_num,
'first_num': first_num,
'user': users.get_current_user(),
'sign_out': users.create_logout_url('/'),
}
template = JINJA_ENV.get_template('/templates/admin_partnerships.html')
return self.response.write(template.render(template_values))
def get(self):
# pass map of quarter DB representations (ints) to string representation
# TODO:
# quarters should not be hardcoded
# rethink logic
quarter_map = {1: 'Fall', 2: 'Winter', 3: 'Spring', 4: 'Summer'}
quarter = self.request.get('quarter') # try grabbing quarter/year from URL
year = self.request.get('year')
if not quarter or not year: # if they don't exist, try grabbing from session
temp = get_sess_vals(self.session, 'quarter', 'year')
if not temp: # if they don't exist there, redirect with error
return self.redirect('/admin?message=Please set a current quarter and year')
quarter,year = temp
quarter,year = int(quarter), int(year)
view_by = self.request.get('view_by') # check URL for 'view by' options (lab vs class)
view_by = view_by if view_by else 1
if view_by == 'class': # if user wants to view by class, or the view by option wasn't specified...
students = StudentModel.get_students_by_active_status(quarter, year).fetch()
else:
students = StudentModel.get_students_by_lab(quarter, year, int(view_by)).fetch()
all_partners = PartnershipModel.get_all_partnerships(quarter, year).fetch()
last_assign = AssignmentModel.get_assign_n(quarter, year, -1)
last_num = 1 if not last_assign else last_assign.number
first_assign = AssignmentModel.get_assign_n(quarter, year, 0)
first_num = 0 if not first_assign else first_assign.number
keys_to_students = dict(map(lambda x: (x.key,x), students)) # map student objects to keys for easy, fast access from partnership objects
keys_to_partnerships = keys_to_partners(all_partners) # map student keys to partnerships for easy, fast access
# create mapping of student info to partnership info that the partnership template expects
partnership_dict = student_info_to_partner_list(last_num, first_num, keys_to_partnerships, keys_to_students, students)
partnership_dict = sorted(partnership_dict.items(), key=lambda x: (x[0][4], x[0][2]))
num_labs = SettingModel.num_labs()
template_values = {
'partnerships': partnership_dict,
'view_by': str(view_by),
'year': year,
'quarter': quarter,
'num_labs': num_labs if num_labs else 0,
'last_num': last_num,
'first_num': first_num,
'user': users.get_current_user(),
'sign_out': users.create_logout_url('/'),
}
template = JINJA_ENV.get_template('/templates/admin_partnerships.html')
return self.response.write(template.render(template_values))
def get(self):
user = users.get_current_user()
quarter = SettingModel.quarter()
year = SettingModel.year()
# grab message from URL, if it exists
message = self.request.get('message')
if (not quarter or not year) and not message:
message = 'Please set a current year and quarter'
template_values = {
'message': message,
'user': user,
'sign_out': users.create_logout_url('/'),
'quarter': quarter,
'year': year,
}
self.session['quarter'] = quarter
self.session['year'] = year
if quarter and year:
template_values['active_students'] = len(
StudentModel.get_students_by_active_status(quarter,
year).fetch())
template_values['inactive_students'] = len(
StudentModel.get_students_by_active_status(
quarter, year, active=False).fetch())
cur_assign = AssignmentModel.get_active_assign_with_latest_fade_in_date(
quarter, year)
if cur_assign:
template_values['cur_assign'] = cur_assign
# grab number of active partnerships for the current assignment
template_values['assign_partners'] = len(
PartnershipModel.get_all_partnerships_for_assign(
quarter, year, cur_assign.number))
eval_assign = AssignmentModel.get_active_assign_with_earliest_eval_due_date(
quarter, year)
if eval_assign:
template_values['eval_assign'] = eval_assign
# grab number of evals for the current eval assignment
template_values['assign_eval'] = len(
EvalModel.get_all_evals_for_assign(
quarter, year, cur_assign.number).fetch())
template = JINJA_ENV.get_template('/templates/admin.html')
return self.response.write(template.render(template_values))
def get(self):
# pass map of quarter DB representations (ints) to string representation
# TODO:
# quarters should not be hardcoded
quarter_map = {1: 'Fall', 2: 'Winter', 3: 'Spring', 4: 'Summer'}
quarter = self.request.get(
'quarter') # try grabbing quarter/year from URL
year = self.request.get('year')
if not quarter or not year: # if they don't exist, try grabbing from session
temp = get_sess_vals(self.session, 'quarter', 'year')
if not temp: # if they don't exist there, redirect with error
return self.redirect(
'/admin?message=Please set a current quarter and year')
quarter, year = temp
quarter, year = int(quarter), int(year)
active_students = StudentModel.get_students_by_active_status(
quarter, year).fetch()
inactive_students = StudentModel.get_students_by_active_status(
quarter, year, active=False).fetch()
active_num = len(active_students)
inactive_num = len(inactive_students)
template = JINJA_ENV.get_template('/templates/admin_view.html')
template_values = {
'students':
sorted(active_students + inactive_students,
key=lambda x: (x.lab, x.last_name)),
'quarter_name':
quarter_map[int(quarter)],
'quarter':
int(quarter),
'year':
int(year),
'student_num':
active_num + inactive_num,
'active_num':
active_num,
'inactive_num':
inactive_num,
'user':
users.get_current_user(),
'sign_out':
users.create_logout_url('/'),
'message':
self.request.get('message'),
}
return self.response.write(template.render(template_values))
def post(self):
# pass map of quarter DB representations (ints) to string representation
# TODO:
# quarters should not be hardcoded
quarter_map = {1: 'Fall', 2: 'Winter', 3: 'Spring', 4: 'Summer'}
quarter = self.request.get('quarter')
year = self.request.get('year')
if not quarter or not year: # if quarter/year aren't in URL, check sessions
temp = get_sess_vals(self.session, 'quarter', 'year')
if not temp: # if they don't exist there, redirect with error
return self.redirect(
'/admin?message=Please set a current quarter and year')
quarter, year = temp
quarter, year = int(quarter), int(year)
studentid = int(
self.request.get('studentid')
) # grab studentid from URL (guaranteed to be there, unless URL was tinkered with)
student = StudentModel.get_student_by_student_id(
quarter, year, studentid)
# if the student wasn't found, he/she might be inactive
student = student if student else StudentModel.get_student_by_student_id(
quarter, year, studentid, active=False)
message = ''
if student:
if self.request.get('to_delete') == 'yes':
message += 'Student ' + student.first_name + ', ' + student.last_name
message += ' (' + str(
student.studentid) + ') successfully deleted'
student.key.delete()
else:
student.ucinetid = self.request.get('ucinetid').strip()
student.first_name = self.request.get('first_name').strip()
student.last_name = self.request.get('last_name').strip()
student.email = self.request.get('email').strip()
student.lab = int(self.request.get('lab').strip())
student.active = eval(self.request.get('active'))
student.put()
message += 'Student ' + student.first_name + ', ' + student.last_name
message += ' (' + str(
student.studentid) + ') successfully updated'
self.redirect('/admin/roster/view?message=' + message)
def post(self):
quarter = SettingModel.quarter()
year = SettingModel.year()
user = users.get_current_user()
evaluator = StudentModel.get_student_by_email(quarter, year, user.email())
partners = PartnershipModel.get_active_partner_history_for_student(evaluator, quarter, year)
eval_key,num = split_last(self.request.get('evaluatee'))
eval_assign = int(num)
current_partner = ndb.Key(urlsafe=eval_key).get()
evaluations = EvalModel.get_existing_eval_by_assign(evaluator, current_partner, eval_assign)
for eval in evaluations:
eval.active = False
eval.put()
evaluation = Evaluation(evaluator = evaluator.key, evaluatee = current_partner.key)
evaluation.assignment_number = eval_assign
evaluation.year = evaluator.year
evaluation.quarter = evaluator.quarter
evaluation.active = True
for i in range(1, 11):
evaluation.responses.append(self.request.get('q' + str(i)))
evaluation.put()
message = 'Evaluation for ' + str(current_partner.last_name) + ', '
message += str(current_partner.first_name) + ' successfully submitted'
self.redirect('/partner?message=' + message)
def get(self):
user = users.get_current_user()
try:
quarter = SettingModel.quarter()
year = SettingModel.year()
student = StudentModel.get_student_by_email(quarter, year, user.email())
active_assigns = map(lambda x: x.number, AssignmentModel.get_active_assigns(quarter, year))
assign_range = AssignmentModel.get_assign_range(quarter, year)
partner_history = PartnershipModel.get_active_partner_history_for_student(student, quarter, year, fill_gaps=assign_range)
all_partner_history = PartnershipModel.get_all_partner_history_for_student(student, quarter, year)
evals = EvalModel.get_eval_history_by_evaluator(student, True, quarter, year).fetch()
evals += EvalModel.get_eval_history_by_evaluator(student, False, quarter, year).fetch()
evals = sorted(evals, key=lambda x: x.assignment_number)
except AttributeError:
return self.redirect('/partner')
template = JINJA_ENV.get_template('/templates/partner_student_view.html')
template_values = {
'student': student,
'partners': partner_history,
'all_partners': all_partner_history,
'assign_range': assign_range,
'active': active_assigns,
'evals': evals,
'user': users.get_current_user(),
'sign_out': users.create_logout_url('/'),
}
return self.response.write(template.render(template_values))
def post(self):
quarter = self.request.get(
'quarter') # try grabbing quarter/year from URL
year = self.request.get('year')
if not quarter or not year: # if they don't exist, try grabbing from session
temp = get_sess_vals(
self.session, 'quarter',
'year') # try grabbing quarter/year from session
if not temp: # redirect with error if it doesn't exist
return self.redirect(
'/admin?message=Please set a current quarter and year')
quarter, year = temp
try:
students = []
files = [(f.filename, f.file.read())
for f in self.request.POST.getall('picture_files')]
for f in files:
student = StudentModel.get_student_by_student_id(
quarter, year, f[0][:f[0].find(".")])
if student != None:
student.avatar = images.resize(f[1], 320, 320)
students.append(student)
# save student objects...
ndb.put_multi(students)
# ...and render the response
return self.redirect('/admin/roster/view?message=' +
'Successfully uploaded new pictures for ' +
str(len(students)) + ' students')
except Exception, e:
return self.redirect(
'/admin?message=' +
'There was a problem uploading the pictures: ' + str(e))
def post(self):
quarter = SettingModel.quarter()
year = SettingModel.year()
user = users.get_current_user()
student = StudentModel.get_student_by_email(quarter, year, user.email())
student.preferred_name = self.request.get('preferred_name').strip()
bio = self.request.get('bio').strip()
student.bio = bio if bio != '' else student.bio
availability = self.request.get('availability').strip()
student.availability = availability if availability != '' else student.availability
programming_ability = self.request.get('programming_ability')
student.programming_ability = programming_ability
# grab image and resize if necessary
avatar = str(self.request.get('avatar'))
student.avatar = images.resize(avatar, 320, 320) if avatar != '' else student.avatar
phone_number = self.request.get('phone_number')
student.phone_number = phone_number if phone_number != '000-000-0000' else student.phone_number
student.put()
# redirect to main page
#Related to the above implementation of availablity: append the availability to the URL
return self.redirect('/partner/edit/profile?message=Profile Successfully Changed!')#?ava='+availability
def get(self):
quarter = SettingModel.quarter()
year = SettingModel.year()
user = users.get_current_user()
invitation = ndb.Key(urlsafe=self.request.get('confirmed')).get()
confirming = StudentModel.get_student_by_email(quarter, year,
user.email())
being_confirmed = invitation.invitor.get()
for_assign = invitation.assignment_number
partnership = None
if not confirming and PartnershipModel.student_has_partner_for_assign(
being_confirmed, for_assign):
message = MessageModel.already_has_partner(False)
elif PartnershipModel.student_has_partner_for_assign(
being_confirmed, for_assign):
message = MessageModel.already_has_partner(False)
elif PartnershipModel.student_has_partner_for_assign(
confirming, for_assign):
message = MessageModel.already_has_partner(False)
else:
message = MessageModel.confirm_partnership(
[being_confirmed, confirming], False, being_confirmed)
partnership = PartnershipModel.create_partnership(
[being_confirmed, confirming], for_assign)
# set invitations between invitor and invitee (for current assignment) to inactive
if partnership:
InvitationModel.deactivate_invitations_for_students_and_assign(
confirming, being_confirmed, for_assign)
# SendMail(partnership, 'partner_confirm')
time.sleep(0.1)
return self.redirect('/partner?message=' + message)
def get_result_priority(result):
"""This function returns a priority associated with matches in partner selection,
so that for example, people of the same programming are matched together
"""
return 0
student = result[1][1]
quarter = SettingModel.quarter()
year = SettingModel.year()
user = users.get_current_user()
selector = StudentModel.get_student_by_email(quarter, year, user.email())
#This used to take into account how many available hours in common the students
#had. There was a when-to-meet like availablity selector available on the student
#profiles that enabled this, but the system was unreliable and so we replaced it
#with simple open response string availablity until we could iron out the issues.
their_availability = student.availability
my_availability = selector.availability
shared_hours = get_shared_hours(my_availability, their_availability)
ability_dif = abs(
int(student.programming_ability[0]) -
int(selector.programming_ability[0]))
return (shared_hours < 4) * 10 + (ability_dif + 1 - float(shared_hours) /
(5 * 15))
def get(self):
quarter = SettingModel.quarter()
year = SettingModel.year()
user = users.get_current_user()
student = StudentModel.get_student_by_email(quarter, year,
user.email())
assgn_num = 0
cancel = int(self.request.get('cancel'))
partnership = ndb.Key(urlsafe=self.request.get('p')).get()
if cancel:
assgn_num = partnership.assignment_number
if cancel:
# refine implementation of cancellation eventually
for s in partnership.members:
partnership = PartnershipModel.cancel_partnership(
s, partnership)
if not partnership.active:
EvalModel.cancel_evals_for_partnership(partnership)
time.sleep(0.1)
return self.redirect('/partner?message=' +
MessageModel.partnership_cancelled(assgn_num))
else:
PartnershipModel.uncancel_partnership(student, partnership)
time.sleep(0.1)
return self.redirect('/partner?message=' +
MessageModel.partnership_uncancelled())
def get_result_priority(result):
"""This function returns a priority associated with matches in partner selection,
so that for example, people of the same programming are matched together
"""
return 0
student = result[1][1]
quarter = SettingModel.quarter()
year = SettingModel.year()
user = users.get_current_user()
selector = StudentModel.get_student_by_email(quarter, year, user.email())
#This used to take into account how many available hours in common the students
#had. There was a when-to-meet like availablity selector available on the student
#profiles that enabled this, but the system was unreliable and so we replaced it
#with simple open response string availablity until we could iron out the issues.
their_availability = student.availability
my_availabiliy = selector.availability
shared_hours = 0 #get_shared_hours(my_availability, their_availability)
ability_dif = abs(student.programming_ability -
selector.programming_ability)
#Prioritize having the same programming ability, if you have more than 4 hours a week in common
#Else weight the number of shared hours higher
if shared_hours >= 4:
return 10 - ability_dif
else:
return 10 - (ability_dif + (4 - shared_hours) / (5 * 15))
def get(self):
user = users.get_current_user()
quarter = SettingModel.quarter()
year = SettingModel.year()
# grab message from URL, if it exists
message = self.request.get("message")
if (not quarter or not year) and not message:
message = "Please set a current year and quarter"
template_values = {
"message": message,
"user": user,
"sign_out": users.create_logout_url("/"),
"quarter": quarter,
"year": year,
}
self.session["quarter"] = quarter
self.session["year"] = year
if quarter and year:
template_values["active_students"] = len(StudentModel.get_students_by_active_status(quarter, year).fetch())
template_values["inactive_students"] = len(
StudentModel.get_students_by_active_status(quarter, year, active=False).fetch()
)
cur_assign = AssignmentModel.get_active_assign_with_latest_fade_in_date(quarter, year)
if cur_assign:
template_values["cur_assign"] = cur_assign
# grab number of active partnerships for the current assignment
template_values["assign_partners"] = len(
PartnershipModel.get_all_partnerships_for_assign(quarter, year, cur_assign.number)
)
eval_assign = AssignmentModel.get_active_assign_with_earliest_eval_due_date(quarter, year)
if eval_assign:
template_values["eval_assign"] = eval_assign
# grab number of evals for the current eval assignment
template_values["assign_eval"] = len(
EvalModel.get_all_evals_for_assign(quarter, year, cur_assign.number).fetch()
)
template = JINJA_ENV.get_template("/templates/admin.html")
return self.response.write(template.render(template_values))
def get(self):
quarter = SettingModel.quarter()
year = SettingModel.year()
user = users.get_current_user()
selector = StudentModel.get_student_by_email(quarter, year, user.email())
if not selector:
return self.redirect('/partner')
# use selector info to find students in same lab section
selectees = StudentModel.get_students_by_lab(quarter, year, selector.lab)
current_assignment = AssignmentModel.get_active_assign_with_latest_fade_in_date(quarter, year)
# if there are no assignments for this quarter, redirect to avoid errors
if not current_assignment:
return self.redirect('/partner?message=There are no assignments open for partner selection.')
# get error message, if any
e = self.request.get('error')
# check to see if partner selection period has closed
selection_closed = (datetime.now() - timedelta(hours=7) > current_assignment.close_date)
# get all current_partnerships for partnership status
partnerships = PartnershipModel.get_all_partnerships_for_assign(quarter, year, current_assignment.number)
members = []
for p in partnerships:
members += p.members
partnership = members
# build dict to store information about partnership status
selectees = sorted({s.ucinetid: (s.key in partnerships,s) for s in selectees}.items(), key=lambda x: x[1][1].last_name)
# pass template values...
template_values = {
'error': e,
'selector': selector,
'selectees': selectees,
'selection_closed': selection_closed,
'current': current_assignment,
'user': user,
'sign_out': users.create_logout_url('/'),
}
template = JINJA_ENV.get_template('/templates/partner_browse.html')
self.response.write(template.render(template_values))
def get(self):
# delcare page template
template = JINJA_ENV.get_template('/templates/partners_main.html')
# get current user
user = users.get_current_user()
student = None
try:
quarter = SettingModel.quarter()
year = SettingModel.year()
user = users.get_current_user()
selector = StudentModel.get_student_by_email(quarter, year, user.email())
if not selector:
return self.redirect('/partner')
# get error message, if any
e = self.request.get('error')
# get own email to query partner information.
assgn_num = int(self.request.get('assgn'))
# get list of all partners for student (roundabout solution)
all_assigns = sorted(AssignmentModel.get_all_assign(quarter, year), key = lambda x: x.number)
partner_history = PartnershipModel.get_all_partner_history_for_student(selector, quarter, year)
all_partners = dict([(x.number,PartnershipModel.get_partner_from_partner_history_by_assign(selector, partner_history, x.number)) for x in all_assigns])
# get queried partnership
partnership = None
for p in partner_history:
if p.assignment_number == assgn_num:
partnership = p
# Redirect to landing if query for that assignment's partnership turns up empty
if not len(all_partners[assgn_num]):
message = MessageModel.page_not_found()
return self.redirect('/partner?message=' + message)
except (AttributeError, IndexError):
template_values = {
'user': user,
'student': student,
'sign_out': users.create_logout_url('/'),
'email': user.email()
}
return self.response.write(template.render(template_values))
# pass template values...
template_values = {
'error': e,
'selector': selector,
'partner': all_partners[assgn_num][0],
'assgn_num': assgn_num,
'partnership': partnership,
'user': user,
'sign_out': users.create_logout_url('/'),
}
template = JINJA_ENV.get_template('/templates/partner_more_info.html')
self.response.write(template.render(template_values))
def post(self):
# pass map of quarter DB representations (ints) to string representation
# TODO:
# quarters should not be hardcoded
quarter_map = {1: 'Fall', 2: 'Winter', 3: 'Spring', 4: 'Summer'}
quarter = self.request.get('quarter')
year = self.request.get('year')
if not quarter or not year: # if quarter/year aren't in URL, check sessions
temp = get_sess_vals(self.session, 'quarter', 'year')
if not temp: # if they don't exist there, redirect with error
return self.redirect('/admin?message=Please set a current quarter and year')
quarter,year = temp
quarter,year = int(quarter), int(year)
studentid = int(self.request.get('studentid')) # grab studentid from URL (guaranteed to be there, unless URL was tinkered with)
student = StudentModel.get_student_by_student_id(quarter, year, studentid)
# if the student wasn't found, he/she might be inactive
student = student if student else StudentModel.get_student_by_student_id(quarter, year, studentid, active=False)
message = ''
if student:
if self.request.get('to_delete') == 'yes':
message += 'Student ' + student.first_name + ', ' + student.last_name
message += ' (' + str(student.studentid) + ') successfully deleted'
student.key.delete()
else:
student.ucinetid = self.request.get('ucinetid').strip()
student.first_name = self.request.get('first_name').strip()
student.last_name = self.request.get('last_name').strip()
student.email = self.request.get('email').strip()
student.lab = int(self.request.get('lab').strip())
student.active = eval(self.request.get('active'))
student.put()
message += 'Student ' + student.first_name + ', ' + student.last_name
message += ' (' + str(student.studentid) + ') successfully updated'
self.redirect('/admin/roster/view?message=' + message)
def post(self):
quarter = SettingModel.quarter()
year = SettingModel.year()
user = users.get_current_user()
evaluator = StudentModel.get_student_by_email(quarter, year,
user.email())
partners = PartnershipModel.get_active_partner_history_for_student(
evaluator, quarter, year)
eval_key, num = split_last(self.request.get('evaluatee'))
eval_assign = int(num)
current_partner = ndb.Key(urlsafe=eval_key).get()
# Log when eval is submitted
#current date for timestamp
cur_date = datetime.datetime.now().strftime("%m/%d/%Y %H:%M:%S")
#get current log, creating one if it does not exist
current_log = LogModel.get_log_by_student(evaluator, quarter,
year).get()
if current_log == None:
current_log = Log()
current_log.owner = evaluator.key
current_log.quarter = quarter
current_log.year = year
#log the submission of the eval
current_log.log.append(cur_date + " Submitted eval for: " +
current_partner.ucinetid + " assgt. " +
str(eval_assign))
#save to log
current_log.put()
evaluations = EvalModel.get_existing_eval_by_assign(
evaluator, current_partner, eval_assign)
for eval in evaluations:
eval.active = False
eval.put()
evaluation = Evaluation(evaluator=evaluator.key,
evaluatee=current_partner.key)
evaluation.assignment_number = eval_assign
evaluation.year = evaluator.year
evaluation.quarter = evaluator.quarter
evaluation.active = True
for i in range(1, 11):
evaluation.responses.append(self.request.get('q' + str(i)))
evaluation.put()
message = 'Evaluation for ' + str(current_partner.last_name) + ', '
message += str(
current_partner.first_name
) + ' confirmed: Please refresh the page and confirm the evaluation was submitted.'
self.redirect('/partner?message=' + message)
def get(self):
template = JINJA_ENV.get_template('/templates/partner_invitation_history.html')
quarter = SettingModel.quarter()
year = SettingModel.year()
user = users.get_current_user()
student = StudentModel.get_student_by_email(quarter, year, user.email())
# redirect to main page if student doesn't exist
if not student:
return self.redirect('/partner')
invites = InvitationModel.get_all_invitations_involving_student(student).order(Invitation.assignment_number).fetch()
current_assignment = AssignmentModel.get_active_assign_with_latest_fade_in_date(quarter, year)
# if there are no assignments for this quarter, render early to avoid errors
if not current_assignment:
return self.response.write(template.render({'user': user, 'sign_out': users.create_logout_url('/')}))
partners = PartnershipModel.get_active_partner_history_for_student(student, quarter, year)
current_partner = PartnershipModel.get_partner_from_partner_history_by_assign(student, partners, current_assignment.number)
active_range = set([a.number for a in AssignmentModel.get_active_assigns(quarter, year)])
invite_info = {}
# dict for custom ordering of invite info fields
ordering = {'Assign Num': 0, 'Who': 1, 'To/From': 2, 'Accepted': 3, 'Active': 4}
for invite in invites:
# organize invite info by time
i = (invite.created - timedelta(hours=7)).strftime('%m-%d-%Y %H:%M:%S')
invite_info[i] = {}
invite_info[i]['Assign Num'] = invite.assignment_number
# determine wheather invite was sent or received in relation to the user
invite_info[i]['To/From'] = 'Sent' if invite.invitor == student.key else 'Received'
who_key = invite.invitee if invite_info[i]['To/From'] == 'Sent' else invite.invitor
who = who_key.get()
# add invitor/invitee (depending on 'Sent'/'Received') to invite info
invite_info[i]['Who'] = str(who.last_name) + ', ' + str(who.first_name) + ' - ' + str(who.ucinetid)
invite_info[i]['Accepted'] = str(invite.accepted)
invite_info[i]['Active'] = str(invite.active)
invite_info[i]['key'] = invite.key.urlsafe()
template_values = {
'invites': sorted(invite_info.items(), reverse=True),
'fields': sorted(ordering.items(), key=lambda x: x[1]),
'user': user,
'sign_out': users.create_logout_url('/'),
'active_range': active_range,
}
return self.response.write(template.render(template_values))
def get(self):
# pass map of quarter DB representations (ints) to string representation
# TODO:
# quarters should not be hardcoded
quarter_map = {1: 'Fall', 2: 'Winter', 3: 'Spring', 4: 'Summer'}
quarter = self.request.get('quarter') # try grabbing quarter/year from URL
year = self.request.get('year')
if not quarter or not year: # if they don't exist, try grabbing from session
temp = get_sess_vals(self.session, 'quarter', 'year')
if not temp: # if they don't exist there, redirect with error
return self.redirect('/admin?message=Please set a current quarter and year')
quarter,year = temp
quarter,year = int(quarter), int(year)
view = self.request.get('view') # check URL for 'view by' options (lab vs class)
view = view if view else 'class'
if view == 'class':
students = StudentModel.get_students_by_active_status(quarter, year).fetch()
else:
students = StudentModel.get_students_by_lab(quarter, year, int(view)).fetch()
current_assign = AssignmentModel.get_active_assign_with_latest_fade_in_date(quarter, year)
current_num = 1 if not current_assign else current_assign.number
template = JINJA_ENV.get_template('/templates/admin_add_partnership.html')
template_values = {
'students': sorted(students, key=lambda x: x.last_name),
'view': str(view),
'quarter': quarter,
'year': year,
'user': users.get_current_user(),
'sign_out': users.create_logout_url('/'),
'current_num': current_num,
'num_labs': SettingModel.num_labs() if SettingModel.num_labs() else 1,
}
return self.response.write(template.render(template_values))
def post(self):
quarter = SettingModel.quarter()
year = SettingModel.year()
user = users.get_current_user()
selector = StudentModel.get_student_by_email(quarter, year,
user.email())
selected = StudentModel.get_student_by_student_id(
quarter, year, self.request.get('selected_partner'))
try:
selected_assign = int(self.request.get('selected_assign'))
time.sleep(0.1)
except ValueError:
return self.redirect(
'/partner/selection?error=You must choose an assignment number'
)
# redirect with errors...
if PartnershipModel.were_partners_previously(
[selector, selected]) and not SettingModel.repeat_partners():
return self.redirect('/partner?message=' +
MessageModel.worked_previously(selected))
elif InvitationModel.have_open_invitations(selector, selected,
selected_assign):
return self.redirect('/partner?message=' +
MessageModel.have_open_invitations(selected))
elif PartnershipModel.student_has_partner_for_assign(
selector, selected_assign):
return self.redirect(
'/partner?message=' +
MessageModel.already_has_partner(False, False))
else:
InvitationModel.create_invitation(selector, selected,
selected_assign)
return self.redirect('/partner?message=' +
MessageModel.sent_invitation(selected))
def post(self):
quarter = int(self.request.get('quarter'))
year = int(self.request.get('year'))
student_ids = [int(sid) for sid in self.request.POST.getall('student')]
students = [] # init container for students to deactivate
to_deactivate = StudentModel.get_students_by_student_ids(quarter, year, student_ids) # query students to deactivate
for student in to_deactivate:
student.active = False
students.append(student)
ndb.put_multi(students) # save student objects to DB
message = 'Students successfully deactivated'
return self.redirect('/admin/roster/view?message=' + message)
def post(self):
quarter = int(self.request.get('quarter'))
year = int(self.request.get('year'))
student_ids = [int(sid) for sid in self.request.POST.getall('student')]
students = [] # init container for students to deactivate
to_deactivate = StudentModel.get_students_by_student_ids(
quarter, year, student_ids) # query students to deactivate
for student in to_deactivate:
student.active = False
students.append(student)
ndb.put_multi(students) # save student objects to DB
message = 'Students successfully deactivated'
return self.redirect('/admin/roster/view?message=' + message)
def get(self):
quarter = SettingModel.quarter()
year = SettingModel.year()
# get user
user = users.get_current_user()
# get student from user info
evaluator = StudentModel.get_student_by_email(quarter, year, user.email())
# get student's partner history
partners = PartnershipModel.get_active_partner_history_for_student(evaluator, quarter, year)
# grab the active eval assignments
eval_assigns = AssignmentModel.get_active_eval_assigns(quarter, year)
# grab partners for eval assignments
evaluatees = []
for eval_assign in eval_assigns:
for partner in PartnershipModel.get_partner_from_partner_history_by_assign(evaluator, partners, eval_assign.number):
evaluatees.append((eval_assign.number,partner))
# filter out No Partner partnerships
partners = list(filter(lambda x: x[1] != "No Partner" and x[1] != None, evaluatees))
eval_closed = len(eval_assigns) == 0
rate20scale = ["0 -- Never, completely inadequate", "1", "2", "3", "4"]
rate20scale += ["5 -- Seldom, poor quality", "6", "7", "8", "9"]
rate20scale += ["10 -- About half the time, average", "11", "12", "13", "14"]
rate20scale += ["15 -- Most of the time, good quality", "16", "17", "18", "19"]
rate20scale += ["20 -- Always, excellent"]
rate5scale = ['1 - My partner was much more capable than I was']
rate5scale += ['2 - My partner was a little more capable than I was']
rate5scale += ['3 - We were about evenly matched, on average']
rate5scale += ['4 - I was a little more capable than my partner']
rate5scale += ['5 - I was a lot more capable than my partner']
rate10scale = [str(x / 10.0) for x in range(0, 105, 5)]
template_values = {
'eval_closed': eval_closed,
'rate_scale': rate20scale,
'rate5scale': rate5scale,
'rate10scale': rate10scale,
'partners': partners,
}
template = JINJA_ENV.get_template('/templates/partner_eval.html')
self.response.write(template.render(template_values))
def get(self):
template = JINJA_ENV.get_template('/templates/partner_update_profile.html')
quarter = SettingModel.quarter()
year = SettingModel.year()
user = users.get_current_user()
student = StudentModel.get_student_by_email(quarter, year, user.email())
if not student:
# redirect to main page if the student doesn't exist in the DB
return self.redirect('/partner')
programming_ability = ['0: Never before this class, or just a few times', '1: I\'ve done some programming, but not as much as a whole class']
programming_ability += ['2: I\'ve done the equivalent of one programming course, but not a whole year\'s worth']
programming_ability += ['3: I have one to two years of programming experience', '4: I have been programming for more than two years']
#This is left over from implementing availability #as a when-to-meet style grid of available hours:
#Initally, when you pressed the confirm button to update your profile, the page would refresh and
#the availability chart would be rendered blank (because the write to the database wasn't quite
#complete by the end of the refresh.
#
#TO fix this, I kept the availablity as a string of 0 and 1 (for unavailable and available) in a URL
#param of the 'message' section of the url, as in 'message=Hello World?ava=0100110001000100100100110'
#Then here I would extract that information, separating the 'message' and 'ava' sections of the URL
#
#This was meant to be a temporary implementation until I got the rest of the availability system up
#and working, but it had to be put on hold due to instability before I could
o_message = self.request.get('message')
message = o_message#[:o_message.find("?ava")]
#ava = o_message[o_message.find("?ava")+5:]
template_values = {
'user': user,
'sign_out': users.create_logout_url('/'),
'student': student,
'programming_ability': programming_ability,
'key': student.key.urlsafe(),
#Related to the above implementation of availablity: grab from the URL if possible, else the database
'availability_string': student.availability,#if ava=='' else ava,
'message': message,
}
return self.response.write(template.render(template_values))
def get(self):
user = users.get_current_user()
try:
quarter = SettingModel.quarter()
year = SettingModel.year()
student = StudentModel.get_student_by_email(
quarter, year, user.email())
active_assigns = map(
lambda x: x.number,
AssignmentModel.get_active_assigns(quarter, year))
assign_range = AssignmentModel.get_assign_range(quarter, year)
partner_history = PartnershipModel.get_active_partner_history_for_student(
student, quarter, year, fill_gaps=assign_range)
all_partner_history = PartnershipModel.get_all_partner_history_for_student(
student, quarter, year)
evals = EvalModel.get_eval_history_by_evaluator(
student, True, quarter, year).fetch()
evals += EvalModel.get_eval_history_by_evaluator(
student, False, quarter, year).fetch()
evals = sorted(evals, key=lambda x: x.assignment_number)
except AttributeError:
return self.redirect('/partner')
template = JINJA_ENV.get_template(
'/templates/partner_student_view.html')
template_values = {
'student': student,
'partners': partner_history,
'all_partners': all_partner_history,
'assign_range': assign_range,
'active': active_assigns,
'evals': evals,
'user': users.get_current_user(),
'sign_out': users.create_logout_url('/'),
}
return self.response.write(template.render(template_values))
def get(self):
quarter = SettingModel.quarter()
year = SettingModel.year()
user = users.get_current_user()
student = StudentModel.get_student_by_email(quarter, year,
user.email())
active_assigns = AssignmentModel.get_active_assigns(quarter, year)
invitations = InvitationModel.get_recvd_invites_by_student_and_mult_assigns(
student, [x.number for x in active_assigns], as_dict=False)
# check to see if partner selection is still active
selection_closed = len(active_assigns) == 0
# pass template values...
template_values = {
'student': student,
'selection_closed': selection_closed,
'invitations': invitations,
}
template = JINJA_ENV.get_template('/templates/partner_confirm.html')
self.response.write(template.render(template_values))
def get(self):
quarter = SettingModel.quarter()
year = SettingModel.year()
user = users.get_current_user()
student = StudentModel.get_student_by_email(quarter, year,
user.email())
assgn_num = int(self.request.get('n'))
assignment = AssignmentModel.get_assign_by_number(
quarter, year, assgn_num)
partnership = PartnershipModel.get_active_partnerships_involving_students_by_assign(
[student], assgn_num).get()
# get list of all partners for student (roundabout solution)
all_assigns = sorted(AssignmentModel.get_all_assign(quarter, year),
key=lambda x: x.number)
partner_history = PartnershipModel.get_all_partner_history_for_student(
student, quarter, year)
all_partners = dict([
(x.number,
PartnershipModel.get_partner_from_partner_history_by_assign(
student, partner_history, x.number)) for x in all_assigns
])
current_time = datetime.datetime.fromtimestamp(time.time())
current_time = current_time - datetime.timedelta(hours=7)
# pass template values...
template_values = {
'student': student,
'partnership': partnership,
'partner': all_partners[assgn_num][0],
'assignment': assignment,
'current_time': current_time,
'assgn_num': assgn_num
}
template = JINJA_ENV.get_template(
'/templates/cancel_partner_modal.html')
self.response.write(template.render(template_values))
def get(self):
template = JINJA_ENV.get_template('/templates/partner_update_profile.html')
quarter = SettingModel.quarter()
year = SettingModel.year()
user = users.get_current_user()
student = StudentModel.get_student_by_email(quarter, year, user.email())
if not student:
# redirect to main page if the student doesn't exist in the DB
return self.redirect('/partner')
programming_ability = ['0: Never, or just a few times', '1: Occaisionally, but not regularly']
programming_ability += ['2: Regularly, but without much comfort or expertise']
programming_ability += ['3: Regularly, with comfortable proficiency', '4: Frequently and with some expertise']
template_values = {
'user': user,
'sign_out': users.create_logout_url('/'),
'student': student,
'programming_ability': programming_ability,
'key': student.key.urlsafe(),
}
return self.response.write(template.render(template_values))
def post(self):
quarter = SettingModel.quarter()
year = SettingModel.year()
user = users.get_current_user()
student = StudentModel.get_student_by_email(quarter, year, user.email())
student.preferred_name = self.request.get('preferred_name').strip()
bio = self.request.get('bio').strip()
student.bio = bio if bio != '' else student.bio
availability = self.request.get('availability').strip()
student.availability = availability if availability != '' else student.availability
programming_ability = self.request.get('programming_ability')
student.programming_ability = programming_ability
# grab image and resize if necessary
avatar = str(self.request.get('avatar'))
student.avatar = images.resize(avatar, 320, 320) if avatar != '' else student.avatar
phone_number = self.request.get('phone_number')
student.phone_number = phone_number if phone_number != '000-000-0000' else student.phone_number
student.put()
# redirect to main page
return self.redirect('/partner/edit/profile')
def get(self):
# delcare page template
template = JINJA_ENV.get_template('/templates/partners_main.html')
# get current user
user = users.get_current_user()
student = None
try:
quarter = SettingModel.quarter()
year = SettingModel.year()
# use user info to find student int DB
student = StudentModel.get_student_by_email(
quarter, year, user.email())
self.session['quarter'] = quarter
self.session['year'] = year
self.session['student'] = student.key.urlsafe()
# Get current time in UTC, then convert to PDT
current_time = datetime.datetime.fromtimestamp(time.time())
current_time = current_time - datetime.timedelta(hours=7)
#get all assignments
all_assigns = sorted(AssignmentModel.get_all_assign(quarter, year),
key=lambda x: x.number)
# get active assignments
active_assigns = sorted(AssignmentModel.get_active_assigns(
quarter, year),
key=lambda x: x.number)
# get inactive assignments
inactive_assigns = sorted(AssignmentModel.get_inactive_assigns(
quarter, year),
key=lambda x: x.number)
# get active eval assigns
eval_assigns = sorted(AssignmentModel.get_active_eval_assigns(
quarter, year),
key=lambda x: x.number)
# find any active invitations for the current assignment that student has sent
sent_invitations = InvitationModel.get_sent_invites_by_student_and_mult_assigns(
student, [x.number for x in active_assigns])
# find any active invitations for the current assignment that the student has received
received_invitations = InvitationModel.get_recvd_invites_by_student_and_mult_assigns(
student, [x.number for x in active_assigns])
# find any partnerships in which the student has been involved
partners = PartnershipModel.get_all_partner_history_for_student(
student, quarter, year)
partners = dict([
(x.number,
PartnershipModel.get_partner_from_partner_history_by_assign(
student, partners, x.number)) for x in all_assigns
])
# create list of assignment numbers which student has a partner for (IF PYTHON 3, use .items() instead of .iteritems())
assgn_nums_with_partner = []
for assgn_num, partner in partners.iteritems():
if len(partner):
assgn_nums_with_partner.append(assgn_num)
# find evals the student has submitted
evals = EvalModel.get_eval_history_by_evaluator(
student, True, quarter, year)
evals = dict([(x.assignment_number, x) for x in evals])
# get activity message, if any
message = self.request.get('message')
dropped = []
for x in active_assigns:
dropped += PartnershipModel.get_inactive_partnerships_by_student_and_assign(
student, x.number).fetch()
dropped = sorted(dropped, key=lambda x: x.assignment_number)
except (AttributeError, IndexError):
template_values = {
'user': user,
'student': student,
'sign_out': users.create_logout_url('/'),
'email': user.email()
}
return self.response.write(template.render(template_values))
template_values = {
'user':
user,
'student':
student,
'current_time':
current_time,
'all_assigns':
all_assigns,
'inactive_assigns':
inactive_assigns,
'assgn_nums_with_partner':
assgn_nums_with_partner,
'active':
active_assigns,
'evals':
eval_assigns,
'submitted_evals':
evals,
'sent_invitations':
sorted(sent_invitations, key=lambda x: x.assignment_number),
'received_invitations':
sorted(received_invitations.items(), key=lambda x: x[0]),
'partners':
partners,
'sign_out':
users.create_logout_url('/'),
'message':
message,
'profile':
student.bio is None or student.availability is None
or student.programming_ability is None,
'dropped':
dropped,
'show_dropped':
len(dropped) > 0
and len(filter(lambda x: x != None,
partners.values())) < len(active_assigns),
}
self.response.write(template.render(template_values))
def post(self):
try:
file = self.request.get('the_file')
file = file.strip().split('\n')
quarter = int(self.request.get('quarter'))
year = int(self.request.get('year'))
num_labs = 0
# students to be uploaded
students = []
# to check for duplicates in roster
student_cache = set()
# grab students in DB (active and not active)
existing_students = StudentModel.get_students_by_active_status(quarter, year).fetch()
existing_students += StudentModel.get_students_by_active_status(quarter, year, active=False).fetch()
existing_students = dict(map(lambda x: (int(x.studentid), x), existing_students))
for row in file:
row = row.split(',')
# save highest lab number found
if int(row[5]) > num_labs:
num_labs = int(row[5])
# grab student ID from current row of CSV roster
studentid = int(row[0].strip())
# if student w/ same studentid has already been found in roster, skip...
if studentid in student_cache:
continue
# ...else, add them to 'seen' cache
student_cache.add(studentid)
# if student in DB, skip to next student...
if studentid in existing_students:
existing_student = existing_students[studentid]
# ...unless they're inactive; if so, activate them...
if not existing_student.active:
existing_student.active = True
students.append(existing_student)
# ...or if they've switched labs; if so, update lab num...
if existing_student.lab != int(row[5]):
existing_student.lab = int(row[5])
students.append(existing_student)
# ...to see which students have dropped the class, remove active students from existing_students
del existing_students[studentid]
# ...and continue to next student
continue
# create student object
student = Student()
student.studentid = studentid
student.last_name = row[1].strip().title()
student.last_name = row[1].strip('"').title()
student.first_name = row[2].strip().title()
student.first_name = row[2].strip('"').title()
student.ucinetid = row[3].lower().strip()
student.email = row[4].lower().strip()
student.lab = int(row[5])
student.quarter = quarter
student.year = year
student.active = True
students.append(student)
# deactivate students who have dropped (students left in existing_students)
for dropped in existing_students.values():
dropped.active = False
students.append(dropped)
# save student objects...
ndb.put_multi(students)
# ...save num_labs...
setting = Setting.query().get()
setting = setting if setting else Setting()
setting.num_labs = num_labs
setting.put()
# ...and render the response
return self.redirect('/admin/roster/view?message=' + 'Successfully uploaded new roster')
except Exception, e:
return self.redirect('/admin?message=' + 'There was a problem uploading the roster: ' + str(e))
def get(self):
quarter = SettingModel.quarter()
year = SettingModel.year()
user = users.get_current_user()
selector = StudentModel.get_student_by_email(quarter, year,
user.email())
student = StudentModel.get_student_by_email(quarter, year,
user.email())
repeat = SettingModel.repeat_partners()
if not selector:
return self.redirect('/partner')
# use selector info to find students in same lab section
selectees = StudentModel.get_students_by_lab(quarter, year,
selector.lab)
current_assignment = AssignmentModel.get_active_assign_with_latest_fade_in_date(
quarter, year)
# if there are no assignments for this quarter, redirect to avoid errors
if not current_assignment:
return self.redirect(
'/partner?message=There are no assignments open for partner selection.'
)
# get error message, if any
e = self.request.get('error')
# check to see if partner selection period has closed
selection_closed = (datetime.now() - timedelta(hours=7) >
current_assignment.close_date)
# get all current_partnerships for partnership status
partnerships = PartnershipModel.get_all_partnerships_for_assign(
quarter, year, current_assignment.number)
partner_history = PartnershipModel.get_all_partner_history_for_student(
student, quarter, year)
members = []
for p in partner_history:
if p.active:
members += p.members
for p in partnerships:
if p.members not in members:
members += p.members
# build dict to store information about partnership status
available = []
for s in selectees:
if (s.key not in members) or repeat:
available.append((s.ucinetid, (s.key in partnerships, s)))
available = sorted(available, key=get_result_priority)
# pass template values...
template_values = {
'error': e,
'student': student,
'selector': selector,
'selectees': available,
'selection_closed': selection_closed,
'current': current_assignment,
'user': user,
'sign_out': users.create_logout_url('/'),
}
template = JINJA_ENV.get_template('/templates/partner_browse.html')
self.response.write(template.render(template_values))
def post(self):
try:
file = self.request.get('the_file')
file = file.strip().split('\n')
quarter = int(self.request.get('quarter'))
year = int(self.request.get('year'))
num_labs = 0
# students to be uploaded
students = []
# to check for duplicates in roster
student_cache = set()
# grab students in DB (active and not active)
existing_students = StudentModel.get_students_by_active_status(
quarter, year).fetch()
existing_students += StudentModel.get_students_by_active_status(
quarter, year, active=False).fetch()
existing_students = dict(
map(lambda x: (int(x.studentid), x), existing_students))
for row in file:
row = row.split(',')
# save highest lab number found
if int(row[5]) > num_labs:
num_labs = int(row[5])
# grab student ID from current row of CSV roster
studentid = int(row[0].strip())
# if student w/ same studentid has already been found in roster, skip...
if studentid in student_cache:
continue
# ...else, add them to 'seen' cache
student_cache.add(studentid)
# if student in DB, skip to next student...
if studentid in existing_students:
existing_student = existing_students[studentid]
# ...unless they're inactive; if so, activate them...
if not existing_student.active:
existing_student.active = True
students.append(existing_student)
# ...or if they've switched labs; if so, update lab num...
if existing_student.lab != int(row[5]):
existing_student.lab = int(row[5])
students.append(existing_student)
# ...to see which students have dropped the class, remove active students from existing_students
del existing_students[studentid]
# ...and continue to next student
continue
# create student object
student = Student()
student.studentid = studentid
student.last_name = row[1].strip().title()
student.last_name = row[1].strip('"').title()
student.first_name = row[2].strip().title()
student.first_name = row[2].strip('"').title()
student.ucinetid = row[3].lower().strip()
student.email = row[4].lower().strip()
if not student.email.endswith("@uci.edu"):
student.email = student.email + "@uci.edu"
student.lab = int(row[5])
student.quarter = quarter
student.year = year
student.active = True
students.append(student)
# deactivate students who have dropped (students left in existing_students)
for dropped in existing_students.values():
dropped.active = False
students.append(dropped)
# save student objects...
ndb.put_multi(students)
# ...save num_labs...
setting = Setting.query().get()
setting = setting if setting else Setting()
setting.num_labs = num_labs
setting.put()
# ...and render the response
return self.redirect('/admin/roster/view?message=' +
'Successfully uploaded new roster')
except Exception, e:
return self.redirect('/admin?message=' +
'There was a problem uploading the roster: ' +
str(e))
def get(self):
quarter = SettingModel.quarter()
year = SettingModel.year()
user = users.get_current_user()
student = StudentModel.get_student_by_email(quarter, year,
user.email())
selector = StudentModel.get_student_by_email(quarter, year,
user.email())
selectees = StudentModel.get_students_by_lab(quarter, year,
selector.lab)
active_assigns = AssignmentModel.get_active_assigns(quarter, year)
# get course config
repeat = SettingModel.repeat_partners()
cross_section = SettingModel.cross_section_partners()
# get default parameter
default_assgn = int(self.request.get("assgn")) if self.request.get(
"assgn") is not "" else -1
# get all current_partnerships for partnership status
partnerships = PartnershipModel.get_all_partnerships_for_assign(
quarter, year, default_assgn)
partner_history = PartnershipModel.get_all_partner_history_for_student(
student, quarter, year)
members = []
for p in partner_history:
if p.active:
members += p.members
for p in partnerships:
if p.members not in members:
members += p.members
# build dict to store information about partnership status
available = []
for s in selectees:
if (s.key not in members) or repeat:
available.append((s.ucinetid, (s.key in partnerships, s)))
available = sorted(available, key=get_result_priority)
av_list = []
for av in available:
av_list.append((av[0],
get_shared_hours(selector.availability,
av[1][1].availability)))
# get error message, if any
e = self.request.get('error')
# check to see if partner selection period has closed
selection_closed = len(active_assigns) == 0
template_values = {
'error': e,
'selector': selector,
'selectees': available,
'selection_closed': selection_closed,
'assgn': default_assgn,
'active': active_assigns,
'default_assgn': default_assgn,
'repeat': repeat,
'cross_section': cross_section,
'availability_list': av_list,
}
template = JINJA_ENV.get_template('/templates/partner_selection.html')
self.response.write(template.render(template_values))
def post(self):
quarter = SettingModel.quarter()
year = SettingModel.year()
user = users.get_current_user()
# these will only have values if this request is coming from an admin
confirming_key = self.request.get('admin_confirming')
being_confirmed_key = self.request.get('admin_being_confirmed')
if confirming_key == '':
confirming_key = 'None'
# if not admin...
if not confirming_key or not being_confirmed_key:
invitation = ndb.Key(urlsafe=self.request.get('confirmed')).get()
confirming = StudentModel.get_student_by_email(
quarter, year, user.email())
being_confirmed = invitation.invitor.get()
for_assign = invitation.assignment_number
admin = False
else:
for_assign = int(self.request.get('assign_num'))
being_confirmed = ndb.Key(urlsafe=being_confirmed_key).get()
confirming = ndb.Key(urlsafe=confirming_key).get(
) if confirming_key != 'None' else None
admin = True
partnership = None
if not confirming and PartnershipModel.student_has_partner_for_assign(
being_confirmed, for_assign):
message = MessageModel.already_has_partner(admin)
elif not confirming:
message = MessageModel.confirm_solo_partnership(being_confirmed)
partnership = PartnershipModel.create_partnership(
[being_confirmed], for_assign)
elif PartnershipModel.student_has_partner_for_assign(
being_confirmed, for_assign):
message = MessageModel.already_has_partner(admin)
# message = ''
# partnership = PartnershipModel.get_partnerships_for_students_by_assign([being_confirmed], for_assign)
# partnership = PartnershipModel.add_members_to_partnership([confirming], partnership[0])
elif PartnershipModel.student_has_partner_for_assign(
confirming, for_assign):
message = MessageModel.already_has_partner(admin)
else:
message = MessageModel.confirm_partnership(
[being_confirmed, confirming], admin, confirming)
partnership = PartnershipModel.create_partnership(
[being_confirmed, confirming], for_assign)
# set invitations between invitor and invitee (for current assignment) to inactive
if partnership:
InvitationModel.deactivate_invitations_for_students_and_assign(
confirming, being_confirmed, for_assign)
# SendMail(partnership, 'partner_confirm')
if not admin:
time.sleep(0.1)
return self.redirect('/partner?message=' + message)
else:
time.sleep(0.1)
return self.redirect('/admin/partners/add?message=' + message)
def get(self):
# delcare page template
template = JINJA_ENV.get_template('/templates/partners_main.html')
# get current user
user = users.get_current_user()
student = None
try:
quarter = SettingModel.quarter()
year = SettingModel.year()
# use user info to find student int DB
student = StudentModel.get_student_by_email(quarter, year, user.email())
self.session['quarter'] = quarter
self.session['year'] = year
self.session['student'] = student.key.urlsafe()
# Get current time in UTC, then convert to PDT
current_time = datetime.datetime.fromtimestamp(time.time())
current_time = current_time - datetime.timedelta(hours=7)
#get all assignments
all_assigns = sorted(AssignmentModel.get_all_assign(quarter, year), key = lambda x: x.number)
# get active assignments
active_assigns = sorted(AssignmentModel.get_active_assigns(quarter, year), key=lambda x: x.number)
# get active eval assigns
eval_assigns = sorted(AssignmentModel.get_active_eval_assigns(quarter, year), key=lambda x: x.number)
# find any active invitations for the current assignment that student has sent
sent_invitations = InvitationModel.get_sent_invites_by_student_and_mult_assigns(student, [x.number for x in active_assigns])
# find any active invitations for the current assignment that the student has received
received_invitations = InvitationModel.get_recvd_invites_by_student_and_mult_assigns(student, [x.number for x in active_assigns])
# find any partnerships in which the student has been involved
partners = PartnershipModel.get_all_partner_history_for_student(student, quarter, year)
partners = dict([(x.number,PartnershipModel.get_partner_from_partner_history_by_assign(student, partners, x.number)) for x in all_assigns])
# create list of assignment numbers which student has a partner for (IF PYTHON 3, use .items() instead of .iteritems())
assgn_nums_with_partner = []
for assgn_num, partner in partners.iteritems():
if len(partner):
assgn_nums_with_partner.append(assgn_num)
# find evals the student has submitted
evals = EvalModel.get_eval_history_by_evaluator(student, True, quarter, year)
evals = dict([(x.assignment_number,x) for x in evals])
# get activity message, if any
message = self.request.get('message')
dropped = []
for x in active_assigns:
dropped += PartnershipModel.get_inactive_partnerships_by_student_and_assign(student, x.number).fetch()
dropped = sorted(dropped, key=lambda x: x.assignment_number)
except (AttributeError, IndexError):
template_values = {
'user': user,
'student': student,
'sign_out': users.create_logout_url('/'),
'email': user.email()
}
return self.response.write(template.render(template_values))
template_values = {
'user': user,
'student': student,
'current_time': current_time,
'all_assigns': all_assigns,
'assgn_nums_with_partner': assgn_nums_with_partner,
'active': active_assigns,
'evals': eval_assigns,
'submitted_evals': evals,
'sent_invitations': sorted(sent_invitations, key=lambda x: x.assignment_number),
'received_invitations': sorted(received_invitations.items(), key=lambda x: x[0]),
'partners': partners,
'sign_out': users.create_logout_url('/'),
'message': message,
'profile': student.bio is None or student.availability is None or student.programming_ability is None,
'dropped': dropped,
'show_dropped': len(dropped) > 0 and len(filter(lambda x: x != None, partners.values())) < len(active_assigns),
}
self.response.write(template.render(template_values))
def get(self):
quarter = SettingModel.quarter()
year = SettingModel.year()
# get user
user = users.get_current_user()
# get student from user info
evaluator = StudentModel.get_student_by_email(quarter, year,
user.email())
# get student's partner history
partners = PartnershipModel.get_active_partner_history_for_student(
evaluator, quarter, year)
# grab the active eval assignments
eval_assigns = AssignmentModel.get_active_eval_assigns(quarter, year)
# grab partners for eval assignments
evaluatees = []
for eval_assign in eval_assigns:
for partner in PartnershipModel.get_partner_from_partner_history_by_assign(
evaluator, partners, eval_assign.number):
evaluatees.append((eval_assign.number, partner))
# filter out No Partner partnerships
partners = list(
filter(lambda x: x[1] != "No Partner" and x[1] != None,
evaluatees))
eval_closed = len(eval_assigns) == 0
# Log when eval page is visited
#get current date (for timestamp)
cur_date = datetime.datetime.now().strftime("%m/%d/%Y %H:%M:%S")
#get current log, creating one if it does not exist
current_log = LogModel.get_log_by_student(evaluator, quarter,
year).get()
if current_log == None:
current_log = Log()
current_log.owner = evaluator.key
current_log.quarter = quarter
current_log.year = year
#log if the student visited the page with all evals closed
if eval_closed:
current_log.log.append(cur_date +
" Viewed eval page: ALL EVALS CLOSED")
else:
#log all open evaluations when student visited the page
open_evals = ""
for ev in evaluatees:
open_evals += ev[1].ucinetid + " assgt. " + str(ev[0]) + " , "
current_log.log.append(cur_date + " Viewed eval page: " +
open_evals)
#save to log
current_log.put()
rate20scale = ["0 -- Never, completely inadequate", "1", "2", "3", "4"]
rate20scale += ["5 -- Seldom, poor quality", "6", "7", "8", "9"]
rate20scale += [
"10 -- About half the time, average", "11", "12", "13", "14"
]
rate20scale += [
"15 -- Most of the time, good quality", "16", "17", "18", "19"
]
rate20scale += ["20 -- Always, excellent"]
rate5scale = ['1 - My partner was much more capable than I was']
rate5scale += ['2 - My partner was a little more capable than I was']
rate5scale += ['3 - We were about evenly matched, on average']
rate5scale += ['4 - I was a little more capable than my partner']
rate5scale += ['5 - I was a lot more capable than my partner']
rate10scale = [str(x / 10.0) for x in range(0, 105, 5)]
template_values = {
'eval_closed': eval_closed,
'rate_scale': rate20scale,
'rate5scale': rate5scale,
'rate10scale': rate10scale,
'partners': partners,
}
template = JINJA_ENV.get_template('/templates/partner_eval.html')
self.response.write(template.render(template_values))
def get(self):
template = JINJA_ENV.get_template(
'/templates/partner_invitation_history.html')
quarter = SettingModel.quarter()
year = SettingModel.year()
user = users.get_current_user()
student = StudentModel.get_student_by_email(quarter, year,
user.email())
# redirect to main page if student doesn't exist
if not student:
return self.redirect('/partner')
invites = InvitationModel.get_all_invitations_involving_student(
student).order(Invitation.assignment_number).fetch()
current_assignment = AssignmentModel.get_active_assign_with_latest_fade_in_date(
quarter, year)
# if there are no assignments for this quarter, render early to avoid errors
if not current_assignment:
return self.response.write(
template.render({
'user': user,
'sign_out': users.create_logout_url('/')
}))
partners = PartnershipModel.get_active_partner_history_for_student(
student, quarter, year)
current_partner = PartnershipModel.get_partner_from_partner_history_by_assign(
student, partners, current_assignment.number)
active_range = set([
a.number
for a in AssignmentModel.get_active_assigns(quarter, year)
])
invite_info = {}
# dict for custom ordering of invite info fields
ordering = {
'Assign Num': 0,
'Who': 1,
'To/From': 2,
'Accepted': 3,
'Active': 4
}
for invite in invites:
# organize invite info by time
i = (invite.created -
timedelta(hours=7)).strftime('%m-%d-%Y %H:%M:%S')
invite_info[i] = {}
invite_info[i]['Assign Num'] = invite.assignment_number
# determine wheather invite was sent or received in relation to the user
invite_info[i][
'To/From'] = 'Sent' if invite.invitor == student.key else 'Received'
who_key = invite.invitee if invite_info[i][
'To/From'] == 'Sent' else invite.invitor
who = who_key.get()
# add invitor/invitee (depending on 'Sent'/'Received') to invite info
invite_info[i]['Who'] = str(who.last_name) + ', ' + str(
who.first_name) + ' - ' + str(who.ucinetid)
invite_info[i]['Accepted'] = str(invite.accepted)
invite_info[i]['Active'] = str(invite.active)
invite_info[i]['key'] = invite.key.urlsafe()
template_values = {
'invites': sorted(invite_info.items(), reverse=True),
'fields': sorted(ordering.items(), key=lambda x: x[1]),
'user': user,
'sign_out': users.create_logout_url('/'),
'active_range': active_range,
}
return self.response.write(template.render(template_values))
