def gradeentry_insert(self, grade_entry):
""" Add or update a grade entry for an assignment """
if grade_entry.from_datastore:
grade_entry_with_parent = grade_entry
else:
student = grade_entry.student_key.get()
grade_entry_with_parent = GradeEntry(parent = grade_entry.assignment_key, id = student.rose_username,
score = grade_entry.score, student_key = grade_entry.student_key,
assignment_key = grade_entry.assignment_key)
grade_entry_with_parent.put()
return grade_entry_with_parent
def get_grade_entries(user, assignments_map, students_map):
""" Gets all of the grade entries for this user.
Replaces the assignment_key and student_key with an assignment and student. """
grade_entries = GradeEntry.query(ancestor=get_parent_key(user)).fetch()
for grade_entry in grade_entries:
grade_entry.assignment = assignments_map[grade_entry.assignment_key]
grade_entry.student = students_map[grade_entry.student_key]
return grade_entries
def remove_all_students(user):
""" Removes all grades and all students for a user. (use with caution) """
all_grades = GradeEntry.query(ancestor=get_parent_key(user))
for grade in all_grades:
grade.key.delete()
all_students = Student.query(ancestor=get_parent_key(user))
for student in all_students:
student.key.delete()
def assignment_delete(self, assignment):
""" Delete the assignment with the given key, plus all its associated grade entries"""
if not assignment.from_datastore:
raise endpoints.NotFoundException("No assignment with this key exists")
children = GradeEntry.query(ancestor=assignment.key)
for grade_entry in children:
grade_entry.key.delete()
assignment.key.delete()
return Assignment(name="deleted")
def assignment_delete(self, an_assignment):
""" Deletes an Assignment and all of its Grade Entries. """
if not an_assignment.from_datastore:
raise endpoints.NotFoundException("No Assignment found for that id.")
if endpoints.get_current_user().email().lower() != an_assignment.owner_email:
raise endpoints.ForbiddenException("You can only delete your own assignments.")
# Remove all of the entries for this assignment.
queryForGradeEntries = GradeEntry.query().filter(GradeEntry.assignment_id == an_assignment.key.id())
for a_grade_entry in queryForGradeEntries:
a_grade_entry.key.delete()
# Remove the assignment
an_assignment.key.delete()
return Assignment(assignment_name="deleted")
def post(self):
user = users.get_current_user()
if not user:
self.redirect(users.create_login_url(self.request.uri))
if (self.request.get('type') == 'Assignment'):
new_assignment = Assignment(assignment_name = self.request.get('assignment_name'), owner=user)
new_assignment.put()
else:
an_assignment_key = ndb.Key(Assignment, int(self.request.get('assignment_id')))
assignment_for_entry = an_assignment_key.get()
if assignment_for_entry is None:
raise endpoints.NotFoundException('Assignment id not found')
if user != assignment_for_entry.owner:
raise endpoints.ForbiddenException("You can only edit/create grade entries in your own Assignments.")
new_grade_entry = GradeEntry(student_name = self.request.get('student_name'),
score = self.request.get('score'),
assignment_id = int(self.request.get('assignment_id')),
parent = assignment_for_entry.key,
owner=user)
new_grade_entry.put()
time.sleep(0.5)
self.redirect('/')
def post(self):
user = users.get_current_user()
if not user:
self.redirect(users.create_login_url(self.request.uri))
return
next_active_assignemnt = None
if (self.request.get('type') == 'Student'):
rose_username = self.request.get('rose_username')
new_student = Student(parent=get_parent_key(user),
id=rose_username,
first_name=self.request.get('first_name'),
last_name=self.request.get('last_name'),
rose_username=rose_username,
team=self.request.get('team'))
new_student.put()
elif (self.request.get('type') == 'Assignment'):
active_assignment = Assignment(parent=get_parent_key(user),
name=self.request.get('assignment_name'))
if len(self.request.get('assignment_entity_key')) > 0:
assignment_key = ndb.Key(urlsafe=self.request.get('assignment_entity_key'))
if assignment_key:
assignment = assignment_key.get()
if assignment:
active_assignment = assignment
active_assignment.name = self.request.get('assignment_name')
active_assignment.put()
next_active_assignemnt = active_assignment.key.urlsafe()
elif (self.request.get('type') == 'SingleGradeEntry'):
assignment_key = ndb.Key(urlsafe=self.request.get('assignment_key'))
student_key = ndb.Key(urlsafe=self.request.get('student_key'))
student = student_key.get()
score = int(self.request.get('score'))
new_grade_entry = GradeEntry(parent=assignment_key,
id=student.rose_username,
assignment_key=assignment_key,
student_key=student_key,
score=score)
new_grade_entry.put()
next_active_assignemnt = assignment_key.urlsafe()
elif (self.request.get('type') == 'TeamGradeEntry'):
assignment_key = ndb.Key(urlsafe=self.request.get('assignment_key'))
score = int(self.request.get('score'))
team = self.request.get('team')
student_query = Student.query(Student.team==team, ancestor=get_parent_key(user))
for student in student_query:
new_grade_entry = GradeEntry(parent=assignment_key,
id=student.rose_username,
assignment_key=assignment_key,
student_key=student.key,
score=score)
new_grade_entry.put()
next_active_assignemnt = assignment_key.urlsafe()
if next_active_assignemnt:
self.redirect("/?active_assignemnt=" + next_active_assignemnt)
else:
self.redirect("/")
def get(self):
user = users.get_current_user()
if not user:
self.redirect(users.create_login_url(self.request.uri))
else:
assignments_with_grades = [];
assignment_query = Assignment.query().order(Assignment.assignment_name).filter(Assignment.owner_email == user.email().lower())
for an_assignment in assignment_query:
grade_entry_query = GradeEntry.query().order(GradeEntry.student_name).filter(GradeEntry.owner_email == user.email().lower()).filter(GradeEntry.assignment_id == an_assignment.id)
assignments_with_grades.append({'assignment_name': an_assignment.assignment_name, 'grade_entries': grade_entry_query})
self.response.out.write(template.render('templates/graderecorder.html',
{'assignments_with_grades': assignments_with_grades,
'assignments': assignment_query,
'use_hardcoded_roster': True,
'user_email': user.email(),
'logout_link': users.create_logout_url("/")}))
def get(self):
user = users.get_current_user()
if not user:
self.redirect(users.create_login_url(self.request.uri))
else:
grades = [];
assignment_query = Assignment.query().order(Assignment.assignment_name).filter(Assignment.owner == user)
for an_assignment in assignment_query:
assignment_dict = {'assignment_name': an_assignment.assignment_name}
grade_entries = []
grade_entry_query = GradeEntry.query().order(GradeEntry.student_name).filter(GradeEntry.owner == user).filter(GradeEntry.assignment_id == an_assignment.id)
for a_grade_entry in grade_entry_query:
self.add_team_individuals(a_grade_entry, grade_entries)
# grade_entries.append(a_grade_entry)
assignment_dict['grade_entries'] = sorted(grade_entries, key=operator.attrgetter('student_name'))
grades.append(assignment_dict)
self.response.out.write(template.render('templates/graderecorder.html',
{'grades': grades,
'assignments': assignment_query,
'use_hardcoded_roster': True,
'user_email': user.email(),
'logout_link': users.create_logout_url("/")}))
def get_csv_export_lists(user, export_student_name, export_rose_username,
export_team, urlsafe_assignment_keys):
table_data = []
student_row_index_map = {} # Map of student_key to row in the table_data
assignment_col_index_map = {} # Map of assignment_key to column in the table_data
header_row = []
table_data.append(header_row)
num_columns = 0
# Student Header
if export_student_name:
header_row.append("First")
header_row.append("Last")
num_columns += 2
if export_rose_username:
header_row.append("Username")
num_columns += 1
if export_team:
header_row.append("Team")
num_columns += 1
# Assignment Prep
assignment_keys = []
for urlsafe_assignment_key in urlsafe_assignment_keys:
assignment_keys.append(ndb.Key(urlsafe=urlsafe_assignment_key))
assignments = ndb.get_multi(assignment_keys)
assignments.sort(key=lambda assignment: assignment.name)
num_assignments_found = 0
for assignment in assignments:
if assignment:
header_row.append(assignment.name)
assignment_col_index_map[assignment.key] = num_columns
num_columns += 1
num_assignments_found += 1
# Student Data + assignment placeholders
num_rows = 1
students = Student.query(ancestor=get_parent_key(user)).order(Student.rose_username)
for student in students:
current_row = []
if export_student_name:
current_row.append(student.first_name)
current_row.append(student.last_name)
if export_rose_username:
current_row.append(student.rose_username)
if export_team:
current_row.append(student.team)
for i in range(num_assignments_found):
current_row.append("-")
table_data.append(current_row)
student_row_index_map[student.key] = num_rows
num_rows += 1
# Add the grades
grade_query = GradeEntry.query(ancestor=get_parent_key(user))
for grade in grade_query:
if grade.student_key in student_row_index_map and grade.assignment_key in assignment_col_index_map:
row = student_row_index_map[grade.student_key]
col = assignment_col_index_map[grade.assignment_key]
table_data[row][col] = grade.score
# Removing rows with no grades (allows for data merging)
for row_index in reversed(range(1, num_rows)):
row = table_data[row_index]
blank_grades = row.count("-")
if blank_grades == num_assignments_found:
table_data.remove(row)
return table_data
def remove_all_grades_for_assignment(user, assignment_key):
""" Removes all grades for the given student. """
grades_for_assignment = GradeEntry.query(ancestor=assignment_key)
for grade in grades_for_assignment:
grade.key.delete()
def remove_all_grades_for_student(user, student_key):
""" Removes all grades for the given student. """
grades_for_student = GradeEntry.query(GradeEntry.student_key==student_key, ancestor=get_parent_key(user))
for grade in grades_for_student:
grade.key.delete()
