def export_submissions():
assignment_id = int(request.values.get('assignment_id'))
assignment = Assignment.by_id(assignment_id)
course_id = get_course_id(True)
user, user_id = get_user()
# Verify exists
check_resource_exists(assignment, "Assignment", assignment_id)
# Verify permissions
assignment = Assignment.by_id(int(assignment_id))
if course_id is None or not user.is_instructor(int(course_id)):
return "You are not an instructor or the owner of the assignment!"
# Get data
suas = Submission.by_assignment(assignment_id, course_id)
submissions = [sua[0] for sua in suas]
users = [sua[1] for sua in suas]
bundle = export_zip(assignments=[assignment],
submissions=submissions,
users=users)
filename = assignment.get_filename(extension='.zip')
return Response(bundle,
mimetype='application/zip',
headers={
'Content-Disposition':
'attachment;filename={}'.format(filename)
})
def edit_assignment():
'''
Lets user choose Assignemnt obj. and change it's attribiutes values
Paramaters:
None
Returns:
None
Updates:
Assignemnt obj.
'''
print_assignments()
assignment = get_assignment_form_user_input()
if assignment:
name, deadline, max_grade = get_valid_inputs()
deadline = format_date(deadline)
assignment.name = name
assignment.deadline = deadline
assignment.max_grade = max_grade
Assignment.save_assignments_to_file('assignments.csv')
else:
no_assignment_message = assignment_view.get_no_assignment_message()
view.print_message(no_assignment_message)
def prj_drop_assignment():
asn = json.loads(request.form['params'])
numrows = Assignment.delete(asn['id'])
assignments = Assignment.get_for_project(asn['project_id'])
return jsonify(
assignments=assignments
)
def emp_drop_assignment():
asn = json.loads(request.form['params'])
numrows = Assignment.delete(asn['id'])
assignments = Assignment.get_for_employee(asn['employee_id'])
return jsonify(
assignments=assignments
)
def load_database():
'''
Initialize all objects stored in data/..
Close program if there is not enough database to function properly.
Parameters, Returns: None
Initialize:
Student objs.
Mentor objs.
Employee objs.
Manager objs.
Assigments objs.
Logins.list_of_logins
'''
Assignment.get_assignments_from_file('assignments.csv')
Attendance.get_attendance_from_file('attendance.csv')
Student.get_codecoolers_from_file('students.csv')
Employee.get_codecoolers_from_file('employees.csv')
Mentor.get_codecoolers_from_file('mentors.csv')
Manager.get_codecoolers_from_file('managers.csv')
if len(Manager.list_of_managers) < 1 or len(
Employee.list_of_employees) < 1:
err_msg = 'There is no database stored. Contact our support at [email protected]'
view.print_message(err_msg)
sys.exit()
Logins.from_codecoolers(Student.list_of_students,
Employee.list_of_employees,
Manager.list_of_managers, Mentor.list_of_mentors)
def grade_assignment():
'''
Prints the list of students to choose a student.
Then prints assignments of the student.
Then asks the user for the choice and changing the grade.
'''
if Student.list_of_students == []:
return mentor_view.print_empty_database_msg()
view_students()
student_index = get_student_index()
if student_index is not None:
assignment_controller.print_student_assignments(student_index)
assignment = assignment_controller.get_assignment_form_user_input()
if assignment:
solution = assignment.solutions[student_index]
if solution.can_be_graded:
view.print_message(solution.get_content())
solution.grade = get_new_grade(assignment.max_grade)
Assignment.save_assignments_to_file('assignments.csv')
else:
mentor_view.assignment_already_graded()
else:
mentor_view.no_such_assignment()
else:
mentor_view.index_doesnt_exist()
def emp_add_assignment():
values = json.loads(request.form['params'])
try:
asnid = Assignment.add(values)
except Exception as ex:
return jsonify(error=str(ex))
assignments = Assignment.get_for_employee(values['employee_id'])
return jsonify(asnid=asnid, assignments=assignments)
def create_assignment():
'''
Creates new Assignemnt obj. and updated Solutions of all Students objs. in data
'''
name, add_date, deadline, max_grade, solutions = get_assignment_data()
Assignment(name, add_date, deadline, max_grade, solutions)
Assignment.save_assignments_to_file('assignments.csv')
def remove_assignment(lti=None):
assignment_id = int(request.values.get('assignment_id'))
assignment = Assignment.by_id(assignment_id)
# Verify exists
check_resource_exists(assignment, "Assignment", assignment_id)
# Verify permissions
require_course_instructor(g.user, assignment.course_id)
Assignment.remove(assignment.id)
return jsonify(success=True)
def new_assignment():
data = request.get_json()
assignment = Assignment()
for key, val in data:
if hasattr(assignment, key):
setattr(assignment, key, val)
assignment.save()
return jsonify({"assignment": assignment.json()})
def prj_update_assignment():
values = json.loads(request.form['params'])
asnid = values['id']
try:
asnid = Assignment.update(values)
except Exception as ex:
return jsonify(error=str(ex))
assignments = Assignment.get_for_project(values['project_id'])
return jsonify(asnid=asnid, assignments=assignments)
def drop_asn(self):
selections = self.view.get_selected_asns()
ids = [x.id for x in selections]
if not ids:
uil.show_error('No assignments selected!')
return
if uil.confirm(self.view, 'Drop selected assignments?'):
try:
Assignment.drop_many(Dao(), ids)
except Exception as ex:
uil.show_error(str(ex))
return
def load_assignment(lti=lti):
# Get arguments
assignment_id = int(request.values.get('assignment_id'))
assignment = Assignment.by_id(assignment_id)
course_id = get_course_id(True)
user, user_id = get_user()
# Verify exists
check_resource_exists(assignment, "Assignment", assignment_id)
# Verify permissions
if course_id is None:
editor_information = assignment.for_read_only_editor(user_id)
else:
editor_information = assignment.for_editor(user_id, course_id)
browser_info = repr({
'platform': request.user_agent.platform,
'browser': request.user_agent.browser,
'version': request.user_agent.version,
'language': request.user_agent.language,
'user_agent': request.user_agent.string
})
# Log the event
if user is not None:
make_log_entry(assignment_id,
assignment.version,
course_id,
user_id,
'Session.Start',
message=browser_info)
# Verify passcode, if necessary
if assignment.passcode_fails(request.values.get('passcode')):
return ajax_failure("Passcode {!r} rejected".format(
request.values.get("passcode")))
return ajax_success(editor_information)
def setUp(self):
student = Student('test', 1)
course = Course(1, 'test_course')
datetime_format = '%Y-%m-%dT%H:%M:%SZ'
assignment = Assignment(1, 'hw1', '2018-01-02T23:59:00Z', course,
datetime_format)
self.grade = Grade(student, course, assignment, 0.85)
def test_add_assignments(self):
# Add a single assignment
datetime_format = '%Y-%m-%dT%H:%M:%SZ'
self.course1.add_assignments(
Assignment(1, 'hw1', '2018-01-02T23:59:00Z', None,
datetime_format))
self.assertEqual(len(self.course1.assignments), 1)
# Add multiple assignments (note that assignment added in previous test already exists, so three total)
datetime_format = '%Y-%m-%dT%H:%M:%SZ'
self.course1.add_assignments([
Assignment(2, 'hw2', '2018-01-02T23:59:00Z', None,
datetime_format),
Assignment(3, 'hw3', '2018-02-03T23:59:00Z', None, datetime_format)
])
self.assertEqual(len(self.course1.assignments), 3)
def watch():
assignment_list = request.values.get('assignments', '')
assignments = [int(aid) for aid in assignment_list.split(',') if len(aid) > 0]
course_id = request.values.get('course_id', g.course.id if 'course' in g else None)
if course_id == None or course_id == "":
return ajax_failure("No Course ID given!")
if g.user is None or not g.user.is_instructor(int(course_id)):
return ajax_failure("You are not an instructor in this assignments' course.")
update = request.values.get('update', 'false') == "true"
if update:
data = []
for aid in assignments:
submissions = Submission.by_assignment(aid, int(course_id))
completions = sum([int(sua[0].correct) for sua in submissions])
workings = Submission.get_latest(aid, int(course_id))
histories = [process_history([h['time'] for h in sua[0].get_history()])
for sua in submissions]
touches = [int(sua[0].version) for sua in submissions]
feedbacks = [l[0] for l in Log.calculate_feedbacks(aid, course_id)]
data.append({'id': aid,
'Completions': completions,
'Workings': workings,
'Time': histories,
'Touches': touches,
'Feedbacks': feedbacks})
return jsonify(success=True, data=data)
else:
assignments = [Assignment.by_id(aid) for aid in assignments]
return render_template('blockpy/watch.html', course_id=course_id, assignments=assignments,
assignment_list=assignment_list)
def import_bundle(bundle, owner_id, course_id=None, update=True):
if 'course' in bundle:
course = Course.decode_json(bundle['course'], owner_id=owner_id)
db.session.add(course)
db.session.commit()
else:
course = Course.by_id(course_id)
assignment_remap = {}
assignments = bundle.get('assignments', [])
for assignment_data in natsorted(assignments, key=lambda a: a['name']):
assignment = Assignment.decode_json(assignment_data,
course_id=course.id,
owner_id=owner_id)
assignment_remap[assignment_data['url']] = assignment.id
group_remap = {}
groups = bundle.get('groups', [])
for group_data in natsorted(groups, key=lambda g: g['name']):
group = AssignmentGroup.decode_json(group_data,
course_id=course.id,
owner_id=owner_id)
group_remap[group_data['url']] = group.id
memberships = bundle.get('memberships', [])
for member_data in sorted(memberships, key=sorter):
assignment_id = assignment_remap[member_data['assignment_url']]
group_id = group_remap[member_data['assignment_group_url']]
member = AssignmentGroupMembership.decode_json(
member_data,
assignment_id=assignment_id,
assignment_group_id=group_id)
return True
def get_assignment(lti=lti):
assignment_id = int(request.values.get('assignment_id'))
assignment = Assignment.by_id(assignment_id)
is_embedded = ('embed' == request.values.get('menu', "select"))
# Verify exists
check_resource_exists(assignment, "Assignment", assignment_id)
# Perform action
select_url = get_select_menu_link(assignment.id, assignment.title(),
is_embedded, False)
return jsonify(success=True,
redirect=url_for('assignments.load',
assignment_id=assignment.id),
id=assignment.id,
name=assignment.name,
type=assignment.type,
instructions=strip_tags(assignment.instructions)[:255],
title=assignment.title(),
view=url_for('assignments.load',
assignment_id=assignment.id,
embed=is_embedded),
select=select_url,
edit=url_for('assignments.load',
assignment_id=assignment.id,
course_id=assignment.course_id),
date_modified=assignment.pretty_date_modified())
def get_assignments():
assignment_ids = request.values.get('assignment_ids', "")
course_id = get_course_id()
user, user_id = get_user()
# TODO: verify that they have the permissions to see these assignments
assignments, groups = [], []
errors = []
if not assignment_ids:
course: Course = Course.by_id(course_id)
check_resource_exists(course, "Course", course_id)
grouped_assignments = natsorted(
course.get_submitted_assignments_grouped(),
key=lambda r:
(r.AssignmentGroup.name
if r.AssignmentGroup is not None else None, r.Assignment.name))
assignments = [a.Assignment.encode_json() for a in grouped_assignments]
groups = [
a.AssignmentGroup.encode_json()
if a.AssignmentGroup is not None else None
for a in grouped_assignments
]
else:
for assignment_id in assignment_ids.split(","):
if not assignment_id.isdigit():
errors.append(f"Unknown Assignment ID: {assignment_id!r}")
assignment_id = int(assignment_id)
# With Course Role Information
assignment = Assignment.by_id(assignment_id)
check_resource_exists(assignment, "Assignment", assignment_id)
assignments.append(assignment.encode_json())
return ajax_success(
dict(assignments=assignments, errors=errors, groups=groups))
def dump_logs():
assignment_id = int(request.values.get('assignment_id'))
course_id = int(request.values.get('course_id'))
assignment = Assignment.by_id(assignment_id)
user, user_id = get_user()
# Verify exists
check_resource_exists(assignment, "Assignment", assignment_id)
# Verify permissions
if not user.is_grader(course_id):
return "You are not a grader in this course."
# Get data
suas = Submission.by_assignment(assignment_id, course_id)
data = {
'assignment':
assignment.encode_json(),
'submissions': [{
'user':
u.encode_json(),
'submission':
sub.encode_json(),
'history':
Log.get_history(course_id, assignment_id, u.id),
'reviews':
sub.get_reviews()
} for (sub, u, assign) in suas]
}
filename = assignment.get_filename() + '_submissions.json'
return Response(json.dumps(data),
mimetype='application/json',
headers={
'Content-Disposition':
'attachment;filename={}'.format(filename)
})
def seedAssignments():
assignments = []
for i in range(0,10):
name = 'Assignment_%s' % i
weight = i * 1.2
assign_date = i * 2
due_date = i * 4
a = Assignment(
name = name,
weight = weight,
assign_date = assign_date,
due_date = due_date
)
a.put()
assignments.append(a)
return assignments
def emp_assignments():
from models.assignment import Assignment
from models.month import Month
empid = int(request.args['empid'])
month = Month.today()
data = Assignment.get_for_employee(empid, month)
return jsonify(assignments=data)
def remove_student_solutions(student_index):
'''
Fallows remowing student. Removes all his solutions stored in database.
Parameters:
student_index : int
Returns:
None
Updated:
Assignemnt, Solution classes data
'''
for assignment in Assignment.list_of_assignments:
del assignment.solutions[student_index]
Assignment.save_assignments_to_file('assignments.csv')
def add_student_assignment(self, deadline, title, description):
"""Add new assignment to student"""
if self.assignments:
for existing_assignment in self.assignments:
if existing_assignment.title.lower() == title.lower():
return
assignment = Assignment(deadline, title, description)
self.assignments.append(assignment)
def assign_assignments_to_new_student():
'''
Fallows adding student. Creates Solution objs. for all assignemts stored in system
Paramaters:
None
Returns:
None
Updates:
Solution, Assignment class data
'''
for assignment in Assignment.list_of_assignments:
assignment.solutions.append(Solution(0, '0', '0'))
Assignment.save_assignments_to_file('assignments.csv')
def prj_assignments():
from models.assignment import Assignment
# from models.month import Month
prjid = int(request.args['prjid'])
# month = Month.today() # This gets current assignments
data = Assignment.get_for_project(prjid)
return jsonify(assignments=data)
def load_assignment(lti=lti):
# Get arguments
assignment_id = int(request.values.get('assignment_id'))
assignment = Assignment.by_id(assignment_id)
student_id = maybe_int(request.values.get('user_id'))
course_id = get_course_id(True)
user, user_id = get_user()
force_download = maybe_bool(request.values.get('force_download', "false"))
# Verify exists
check_resource_exists(assignment, "Assignment", assignment_id)
# Verify permissions
if user_id != student_id and not user.is_grader(course_id):
return ajax_failure(
"Only graders can see submissions for other people.")
if course_id is None:
editor_information = assignment.for_read_only_editor(student_id)
else:
editor_information = assignment.for_editor(student_id, course_id)
browser_info = json.dumps({
'platform': request.user_agent.platform,
'browser': request.user_agent.browser,
'version': request.user_agent.version,
'language': request.user_agent.language,
'user_agent': request.user_agent.string
})
# Log the event
if user is not None:
if user_id != student_id:
make_log_entry(assignment_id,
assignment.version,
course_id,
user_id,
'X-Submission.Get',
message=str(student_id))
else:
make_log_entry(assignment_id,
assignment.version,
course_id,
user_id,
'Session.Start',
message=browser_info)
# Verify passcode, if necessary
if assignment.passcode_fails(request.values.get('passcode')):
return ajax_failure("Passcode {!r} rejected".format(
request.values.get("passcode")))
if force_download:
student_filename = User.by_id(student_id).get_filename("")
filename = assignment.get_filename(
"") + "_" + student_filename + '_submission.json'
return Response(json.dumps(editor_information),
mimetype='application/json',
headers={
'Content-Disposition':
'attachment;filename={}'.format(filename)
})
else:
return ajax_success(editor_information)
def run(self, **kwargs):
from models.user import User
from models.course import Course
from models.role import Role
from models.assignment_group import AssignmentGroup
from models.assignment_group_membership import AssignmentGroupMembership
from models.assignment import Assignment
default_course = Course.query.first()
print("Adding Teacher")
teacher = User(first_name="Klaus",
last_name="Bart",
password=hash_password("password"),
confirmed_at=datetime.datetime.now(),
active=True,
email="*****@*****.**")
db.session.add(teacher)
db.session.flush()
db.session.add(
Role(name='instructor',
course_id=default_course.id,
user_id=teacher.id))
print("Adding Student")
student = User(first_name="Ada",
last_name="Bart",
password=hash_password("password"),
confirmed_at=datetime.datetime.now(),
active=True,
email="*****@*****.**")
db.session.add(student)
db.session.flush()
db.session.add(
Role(name='student',
course_id=default_course.id,
user_id=student.id))
print("Adding basic assignments")
basic_group = AssignmentGroup(name="First Group",
course_id=default_course.id,
owner_id=teacher.id)
db.session.add(basic_group)
db.session.flush()
for i in range(5):
assignment = Assignment(name="Problem {}".format(i),
instructions="Complete this problem",
owner_id=teacher.id,
course_id=default_course.id)
db.session.add(assignment)
db.session.flush()
db.session.add(
AssignmentGroupMembership(assignment_group_id=basic_group.id,
assignment_id=assignment.id))
db.session.commit()
print("Complete")
def setUp(self):
student = Student('test', 1)
course = Course(1, 'test_course')
datetime_format = '%Y-%m-%dT%H:%M:%SZ'
assignment1 = Assignment(1, 'hw1', '2018-01-02T23:59:00Z', course,
datetime_format)
assignment2 = Assignment(2, 'hw2', '2018-01-02T23:59:00Z', course,
datetime_format)
assignment3 = Assignment(3, 'hw3', '2018-01-02T23:59:00Z', course,
datetime_format)
assignment4 = Assignment(4, 'hw4', '2018-01-02T23:59:00Z', course,
datetime_format)
self.grade1 = Grade(student, course, assignment1, 0.85)
self.grade2 = Grade(student, course, assignment2, 0.75)
self.grade3 = Grade(student, course, assignment3, 0.65)
self.grade4 = Grade(student, course, assignment4, 0.55)
self.enrollment = Enrollment(student, course, [self.grade1], 0.75)
def import_endpoint():
user = load_api_user()
course_id = request.json.get('course_id')
if course_id is None:
abort(400, "You need to specify the course_id")
assignments = request.json.get('assignments', [])
for assignment in assignments:
assignment = Assignment.by_url(assignment['url'])
if not user.is_instructor(assignment.course_id):
return abort(400, "Not an instructor in this assignments' course.")
groups = request.json.get('groups', [])
for group in groups:
group = Assignment.by_url(group['url'])
if not user.is_instructor(group.course_id):
return abort(400, "Not an instructor in this assignments' course.")
# TODO: Verify that memberships are all attached to a group owned by this user
import_bundle(request.json, owner_id=user.id, course_id=course_id)
return jsonify(success=True)
def get_existing(cls, data):
group_url = data['assignment_group_url']
assignment_url = data['assignment_url']
assignment = Assignment.by_url(assignment_url)
group = AssignmentGroup.by_url(group_url)
if not assignment or not group:
return None
return (AssignmentGroupMembership.query.filter_by(
assignment_group_id=group.id, assignment_id=assignment.id).first())
def __load(self, months):
employees = Employee.get_all()
assignments = Assignment.get_for_timeframe(months[0], months[-1])
employee_assignments = {}
for assignment in assignments:
if assignment['employee_id'] not in employee_assignments:
employee_assignments[assignment['employee_id']] = []
employee_assignments[assignment['employee_id']].append(assignment)
for employee in employees:
row = EffortRow(employee)
for month in months:
cell = EffortCell(month)
if employee['id'] not in employee_assignments:
continue
for emp_asn in employee_assignments[employee['id']]:
if int(month) < emp_asn['first_month'] or int(month) > emp_asn['last_month']:
continue
cell.total += emp_asn['effort']
cell.percent_efforts.append(
PercentEffort(emp_asn['project'], emp_asn['effort'])
)
row.effort_cells.append(cell)
if row.effort_cells:
self.effort_rows.append(row)
def deleteAll():
ndb.delete_multi(Assignment.query().fetch(keys_only=True))
ndb.delete_multi(Course.query().fetch(keys_only=True))
ndb.delete_multi(Grade.query().fetch(keys_only=True))
ndb.delete_multi(Student.query().fetch(keys_only=True))
