def Generator(request):
allofem = Assignment.objects.all()
for a in allofem:
a.delete()
pref = UserProfile.objects.all()
opt_dict = {}
for stu in pref:
opt_dict[stu]= [stu.option1, stu.option2, stu.option3, stu.option4, stu.option5]
courses = Course.objects.all()
results = {}
caps = {}
for i in courses:
caps[mkkey(i.name,i.available)]= i.max_cap
for i in courses:
results[mkkey(i.name, i.available)]= []
for stu in pref:
for i in range(5):
if canassign(opt_dict[stu][i], stu.user, str(stu.grade), caps, results):
results[mkkey(opt_dict[stu][i], str(stu.grade))].append(stu.user)
else:
continue
for i in results.keys():
for j in results[i]:
assignment = Assignment()
assignment.user = j
assignment.class_name = i
assignment.save()
return HttpResponseRedirect(reverse('showassignments'))
class TestModelAssignment(unittest.TestCase):
def setUp(self):
sys.path.insert(0, "../../src")
from models import Assignment
start_date = datetime.date(2000, 5, 5)
due_date = datetime.date(2020, 12, 12)
self.assignment1 = Assignment(1)
self.assignment2 = Assignment(2, start_date, due_date)
def test_assignment_start_date(self):
answer1 = datetime.date(2000, 1, 1)
answer2 = datetime.date(2000, 5, 5)
self.assertEqual(self.assignment1.start_date, answer1)
self.assertEqual(self.assignment2.start_date, answer2)
def test_assignment_due_date(self):
due_date1 = datetime.date(2000, 1, 1)
due_date2 = datetime.date(2020, 12, 12)
self.assertEqual(self.assignment1.end_date, due_date1)
self.assertEqual(self.assignment2.end_date, due_date2)
def test_assignment_id(self):
self.assertEqual(self.assignment1.assignment_id, 1)
self.assertEqual(self.assignment2.assignment_id, 2)
def test_assignment_repr(self):
self.assertEqual(self.assignment1.__repr__(), "Assignment 1")
self.assertEqual(self.assignment2.__repr__(), "Assignment 2")
def make_assignment_with_pk_vals(quarter, year, assign):
assignment = Assignment()
assignment.year = year
assignment.quarter = quarter
assignment.number = assign
return assignment
def setUp(self):
sys.path.insert(0, "../../src")
from models import Assignment
start_date = datetime.date(2000, 5, 5)
due_date = datetime.date(2020, 12, 12)
self.assignment1 = Assignment(1)
self.assignment2 = Assignment(2, start_date, due_date)
def make_assignment_with_pk_vals(quarter, year, assign):
assignment = Assignment()
assignment.year = year
assignment.quarter = quarter
assignment.number = assign
return assignment
def assignment_insert(self, assignment):
""" Add or update an assignment owned by the given user """
if assignment.from_datastore:
assignment_with_parent = assignment
else: assignment_with_parent = Assignment(parent = main.get_parent_key(endpoints.get_current_user()),
name = assignment.name)
assignment_with_parent.put()
return assignment_with_parent
def test_optional_field(self):
testsubject = Subject(name = "testname", description = "testdescription", link = "http://www.google.ro/")
testsubject.save()
now = datetime.datetime.utcnow().replace(tzinfo=utc)
testassignment = Assignment(subject_id = testsubject, name="test", text = "asda", deadline = now)
testassignment.save()
testsubject.delete()
testassignment.delete()
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 module003_assignment_course(course_id):
form = AssigmentForm()
course = Course.query.filter_by(id=course_id).first()
follow = Follow.query.filter(
and_(Follow.course_id == course_id,
Follow.user_id == current_user.id)).first()
assignments = Assignment.query.filter_by(course_id=course_id)
if follow:
if request.method == 'POST':
if form.validate_on_submit():
if form.never_expire.data:
assignment = Assignment(course_id=course_id,
author_id=current_user.id,
name=form.name.data,
descripcion=form.descripcion.data)
else:
assignment = Assignment(
course_id=course_id,
author_id=current_user.id,
name=form.name.data,
descripcion=form.descripcion.data,
date_expire=datetime.datetime.combine(
form.date_expire.data, form.time_expire.data))
try:
db.session.add(assignment)
db.session.commit()
flash("Assignment created")
except:
db.session.rollback()
flash("Error creating Assignment!")
return redirect(
url_for('module003.module003_assignment_course',
course_id=course.id))
else:
if current_user.profile in ('admin', 'staff', 'student'):
follows = Follow.query.filter_by(user_id=current_user.id)
return render_template("module003_assignment_especifico.html",
form=form,
module="module003",
rows=follows,
course=course,
assignments=assignments)
else:
flash("Access denied!")
return redirect(url_for('index'))
else:
flash("Access denied!")
# abort(404,description="Access denied!")
return redirect(url_for('index'))
def get_assignments(user):
""" Gets all of the assignments for this user and makes a key map for them. """
assignments = Assignment.query(ancestor=get_parent_key(user)).order(Assignment.name).fetch()
assignments_map = {}
for assignment in assignments:
assignments_map[assignment.key] = assignment
return assignments, assignments_map
def post(self):
if bool(self.request.get('choice')):
ndb.delete_multi(Student.query().fetch(keys_only=True))
ndb.delete_multi(Assignment.query().fetch(keys_only=True))
ndb.delete_multi(Setting.query().fetch(keys_only=True))
self.redirect('/admin')
def add_lesson_to_course(courseID):
"""Adds a lesson to a course"""
form = request.form
course = Course.query.get(courseID)
try:
lesson = Lesson(course_id=courseID,
title=form.get("title"),
num=form.get("num"),
date_due=form.get("date_due"))
db.session.add(lesson)
db.session.commit()
for student in course.students_enrolled:
assignment = Assignment(student_enrollment_id=student.id,
lesson_id=lesson.id,
complete=False,
turned_in=False)
db.session.add(assignment)
db.session.commit()
flash("Successfully added lesson")
except:
flash("Failed to add lesson")
return redirect("/")
def assginment_no_exists(form, field):
if Assignment.select().where(Assignment.name == field.data).exists():
print("x============x")
pass
else:
raise ValidationError('Assignment does not exist!')
def get(self,slug):
cookie = self.request.cookies.get('CookieProtocolServices')
if cookie:
session = ndb.Key(urlsafe=str(cookie)).get()
user = session.key.parent().get()
page = Page.query(Page.slug == slug).get()
assignments = Assignment.query(
Assignment.active == True,
Assignment.user == user.key,
Assignment.completed == False).order(
-Assignment.when).fetch(10)
if page:
#TODO: Manage subscriptions
template = JINJA_ENVIRONMENT.get_template('app.html')
self.response.write(template.render(
{'auth': True,
'page': page,
'user': user,
'homepage': user.subscription.get().startpage,
'assignments': assignments,
'text': process_text(page.text)}))
else:
template = JINJA_ENVIRONMENT.get_template('404.html')
self.response.write(template.render({}))
else:
self.redirect('/login')
def delete_assign_by_number(quarter,year,number):
assgn = Assignment.query(
Assignment.quarter == quarter,
Assignment.year == year,
Assignment.number == number,
).get()
assgn.key.delete()
def post(self):
if bool(self.request.get('choice')):
ndb.delete_multi(Student.query().fetch(keys_only=True))
ndb.delete_multi(Assignment.query().fetch(keys_only=True))
ndb.delete_multi(Setting.query().fetch(keys_only=True))
self.redirect('/admin')
def get(self):
user, logout = check_user(users.get_current_user())
if user:
if self.request.get('id'):
t = ndb.Key(urlsafe=self.request.get('id')).get()
u = t.to_dict()
t.revised = True
t.put()
else:
cursor = None
u = []
more = True
while more:
d, curs, more = Assignment.query(
Assignment.active == True).order(
-Assignment.when).fetch_page(
100, start_cursor=cursor)
for ditem in d:
u.append(ditem.to_dict())
self.response.out.headers['Content-Type'] = 'application/json'
self.response.out.write(json.dumps({'data':u}))
def get_assign_n(quarter, year, n):
assigns = Assignment.query(
Assignment.quarter == quarter,
Assignment.year == year,
).order(Assignment.number).fetch()
try:
return assigns[n]
except IndexError:
return None
def get_assign_n(quarter, year, n):
assigns = Assignment.query(
Assignment.quarter == quarter,
Assignment.year == year,
).order(Assignment.number).fetch()
try:
return assigns[n]
except IndexError:
return None
def get_active_assign_with_latest_fade_in_date(quarter, year):
assigns_after_now = Assignment.query(
Assignment.quarter == quarter,
Assignment.year == year,
Assignment.fade_in_date < dt.now() - td(hours=7)
).order(Assignment.fade_in_date).fetch()
try:
return assigns_after_now[-1]
except IndexError:
return None
def get_active_assign_with_earliest_eval_due_date(quarter, year):
evals_after_now = Assignment.query(
Assignment.quarter == quarter,
Assignment.year == year,
Assignment.eval_date > dt.now() - td(hours=7)
).order(Assignment.eval_date).fetch()
if len(evals_after_now) > 0:
return evals_after_now[0]
else:
return None
def get_active_assign_with_latest_fade_in_date(quarter, year):
assigns_after_now = Assignment.query(
Assignment.quarter == quarter,
Assignment.year == year,
Assignment.fade_in_date < dt.now() - td(hours=7)
).order(Assignment.fade_in_date).fetch()
try:
return assigns_after_now[-1]
except IndexError:
return None
def get_active_assign_with_earliest_eval_due_date(quarter, year):
evals_after_now = Assignment.query(
Assignment.quarter == quarter,
Assignment.year == year,
Assignment.eval_date > dt.now() - td(hours=7)
).order(Assignment.eval_date).fetch()
if len(evals_after_now) > 0:
return evals_after_now[0]
else:
return None
def post(self):
parser = reqparse.RequestParser()
parser.add_argument(
"sid",
type=str,
required=True,
)
parser.add_argument(
"ordinal",
type=str,
choices=assignment_function_mapping.keys(),
required=True,
)
parser.add_argument(
"answers",
required=True,
action="append",
)
try:
args = parser.parse_args()
except Exception:
raise ParameterMissing
correctnesses = assignment_function_mapping[args.ordinal](args.answers)
if args.sid:
past_assignment = Assignment.query.filter_by(
sid=args.sid,
ordinal=args.ordinal,
).first()
if past_assignment is not None:
updated_correctenesses = self._merge_correctnesses(
self._deserialize_correctnesses(
past_assignment.correctnesses, ),
correctnesses,
)
past_assignment.correctnesses = self._serialize_correctnesses(
updated_correctenesses, )
db.session.commit()
else:
assignment = Assignment(
sid=args.sid,
ordinal=args.ordinal,
correctnesses=self._serialize_correctnesses(correctnesses),
)
db.session.add(assignment)
db.session.commit()
return {
"correctnesses": correctnesses,
}
def get(self):
cookie = self.request.cookies.get('CookieProtocolServices')
admin, logout = check_user(users.get_current_user())
if cookie:
session = ndb.Key(urlsafe=str(cookie)).get()
user = session.key.parent().get()
assignments = Assignment.query(
Assignment.active == True,
Assignment.user == user.key,
Assignment.completed == False).order(
-Assignment.when).fetch(10)
template = JINJA_ENVIRONMENT.get_template('user.html')
self.response.write(template.render(
{'auth': False,
'user': user.to_dict(),
'assignments': assignments}))
elif admin:
user = ndb.Key(urlsafe=self.request.get('id')).get()
assignments = Assignment.query(
Assignment.user == user.key,
Assignment.completed == False).order(
-Assignment.when).fetch(10)
template = JINJA_ENVIRONMENT.get_template('user.html')
self.response.write(template.render(
{'auth': True,
'user': user.to_dict(),
'assignments': assignments}))
else:
self.redirect('/login?to={}'.format(slug))
def add():
if request.method == "GET":
course_num = request.args['courseNum']
return render_template("addAssignment.html", course_num=course_num)
name = request.form.get('assignment')
course_num = request.form.get('courseNum')
newAssignment = Assignment(name=name, class_id=course_num)
db_session.add(newAssignment)
db_session.commit()
db_session.add(Grade(grade=0, assignment_id=newAssignment.id))
db_session.commit()
return redirect(url_for('search', courseNum=course_num))
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 get_inactive_assigns(quarter, year):
all_assigns = Assignment.query(
Assignment.quarter == quarter,
Assignment.year == year
).order(Assignment.fade_in_date).fetch()
to_return = []
for i in range(len(all_assigns) - 1, -1, -1):
if all_assigns[i].fade_out_date < dt.now() - td(hours=7) or all_assigns[i].fade_in_date > dt.now() - td(hours=7):
to_return.append(all_assigns[i])
return to_return
def get_active_eval_assigns(quarter, year):
assigns_before_now = Assignment.query(
Assignment.quarter == quarter,
Assignment.year == year,
Assignment.eval_date > dt.now() - td(hours=7)
).order(Assignment.eval_date).fetch()
to_return = []
for i in range(len(assigns_before_now)):
if assigns_before_now[i].eval_open_date < dt.now() - td(hours=7):
to_return.append(assigns_before_now[i])
return to_return
def get_active_eval_assigns(quarter, year):
assigns_before_now = Assignment.query(
Assignment.quarter == quarter,
Assignment.year == year,
Assignment.eval_date > dt.now() - td(hours=7)
).order(Assignment.eval_date).fetch()
to_return = []
for i in range(len(assigns_before_now)):
if assigns_before_now[i].eval_open_date < dt.now() - td(hours=7):
to_return.append(assigns_before_now[i])
return to_return
def post(self):
"""
Creates an assignment
"""
data = request.json
title = data.get('title')
start_date = data.get('start_date')[:10] + " 00:00:00"
due_date = data.get('due_date')[:10] + " 23:59:59"
group_id = data.get('group_id')
problem_id = data.get('problem_id')
new_assignment = Assignment(title=title, start_date=start_date,
due_date=due_date, group_id=group_id,
problem_id=problem_id)
db.session.add(new_assignment)
db.session.commit()
return new_assignment, 201
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 add_staff():
if "staff_id" not in session:
abort(401)
if not request.form["request_id"]:
abort(404)
# Get all the data from the single select element value, we need event request id and staff id
staff = Staff.query.filter_by(staff_id=session["staff_id"]).first()
eventRequest = EventRequest.query.filter_by(request_id=request.form["request_id"]).first()
if staff == None or eventRequest == None: # Make sure both exist in the DB, for FK validation
abort(404)
assign = Assignment(eventRequest.request_id, staff.staff_id)
db.session.add(assign)
db.session.commit()
flash("Staff " + staff.username + " assigned to event " + str(eventRequest) + " successfully!")
return redirect(url_for('staff'))
def createNewRecord(eventID=None):
""" return a reference to a newly created record or elss None"""
eventID = cleanRecordID(eventID)
rec = None
if eventID > 0:
#test that countEvent record exits
cnt = CountEvent.query.filter(CountEvent.ID == eventID).count()
if cnt > 0:
rec = Assignment(eventID, getUID())
db.session.add(rec)
else:
flash(
printException(
"Invalid countEvent ID during Count Event creation.",
"error"))
return rec
def setUp(self):
db.drop_all()
db.create_all()
teacher = Teacher.seed_db(name="teacher_name", username="******", password="******")
db.session.add(teacher)
student = Student.seed_db(name="student_name", username="******", password="******", teacher_id=1)
db.session.add(student)
assignment = Assignment(title='title', body='body', teacher_id=1)
db.session.add(assignment)
one = StudentAssignment(assignment_id=assignment.id, student_id=student.id)
db.session.add(one)
db.session.commit()
def homework_upload():
# Save the file
file = request.files['homework']
file2 = request.files['homeworksrc']
filename = str(uuid.uuid4())
file.save(
os.path.join(app.config['UPLOAD_FOLDER'],
secure_filename(filename + '.jar')))
file2.save(
os.path.join(app.config['UPLOAD_FOLDER'],
secure_filename(filename + '.zip')))
# Add file to the database of assignments
assignment = Assignment(id=filename, name=file.filename)
models.db.session.add(assignment)
models.db.session.commit()
return redirect('/')
def new_assignment():
'''
Create new assignment
'''
form = AssignmentForm()
if form.validate_on_submit():
my_assignment = Assignment()
form.populate_obj(my_assignment)
db.session.add(my_assignment)
try:
db.session.commit()
# User info
flash('Assignment created correctly', 'success')
return redirect(url_for('assignments'))
except:
db.session.rollback()
flash('Error generating assignment.', 'danger')
return render_template('web/new_assignment.html', form=form)
def addassignment():
"""
Utility view for adding assignments.
"""
req_json = request.get_json(silent=True)
if not req_json:
return "Assignment addition failed."
if req_json['key'] != SECRET_KEY:
return "Assignment addition failed; key incorrect."
assignment = Assignment(title=req_json['title'],
desc=req_json['desc'],
visible=req_json['visible'],
date_due=datetime.date.fromordinal(
req_json['date_due']))
db.session.add(assignment)
db.session.commit()
if assignment.visible:
send_email_users_new_asgn(assignment)
return "Added assignment " + str(assignment) + " successfully."
def add_assignments(enrollmentID):
"""This is a helper function that adds all the assignments to an enrolled student"""
enroll = Enrollment.query.get(enrollmentID)
lessons = Lesson.query.filter(Lesson.course_id == enroll.course.id)
assigned_lessons = [assigned.lesson for assigned in enroll.assignemnts]
for lesson in lessons:
if not lesson in assigned_lessons:
assignment = Assignment(student_enrollment_id=enrollmentID,
lesson_id=lesson.id,
complete=False,
turned_in=False)
db.session.add(assignment)
db.session.commit()
def assign(a, b):
body = request.get_json()
reviewer_id = body.get('reviewer_id', None)
project_id = body.get('project_id', None)
try:
reviewer = Reviewer.query.filter_by(id=reviewer_id).one_or_none()
project = Project.query.filter_by(id=project_id).one_or_none()
previous_assignments = Assignment.query.filter(
Assignment.reviewer_id == reviewer_id,
Assignment.project_id == project_id).count()
if previous_assignments > 0:
raise AuthError({
'code': 'Bad request',
'description': "this assignment is already existent"
}, 400)
if reviewer is None:
raise AuthError({
'code': 'Bad request',
'description': "reviewer does not exist"
}, 400)
if project is None:
raise AuthError({
'code': 'Bad request',
'description': "project does not exist"
}, 400)
assignment = Assignment()
assignment.reviewer_id = reviewer_id
assignment.project_id = project_id
assignment.insert()
return jsonify({
'success': True,
'assignment': assignment.format()
})
except Exception as e:
print("exception error post reviewer", e)
print(e)
if isinstance(e, AuthError):
raise e
abort(422)
def new_assignment(course_id):
course = Course.query.get(course_id)
if request.method == "POST":
name = request.form.get('name', None)
description = request.form.get('description', None)
due_at = request.form.get('due-at', None)
display_at = request.form.get('display-at', None)
file_ = request.files.get('file', None)
if name and due_at and display_at:
assignment = Assignment(name=name, description=description)
assignment.due_at = parse(due_at)
assignment.display_at = parse(display_at)
if file_:
filename = assignment_descs.save(file_)
assignment.description_filename = filename
course.add_assignment(assignment)
assignment.save()
return redirect(url_for('list_assignments', course_id=course_id))
return render_template('assignment/new.html', course=course)
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 load_homework(file_name):
"""
load homework from a unique csv file in the data folder
file_name: the name of the csv file
"""
path = "../data/" + file_name
data = pd.read_csv(path)
tprint("Homeworks", data)
homework_list = []
for index, row in data.iterrows():
a_assignment = Assignment(
cname=row["class"],
desc=row["description"],
duration=row["duration"],
due=row["due"],
)
homework_list.append(a_assignment)
return homework_list, data
def module003_create():
form = AssignmentCreateForm()
if request.method == 'POST':
try:
course = Course.query.get(form.course_id.data)
assignment = Assignment(title=form.title.data,
body=form.description.data,
date_expire=datetime.datetime.combine(
form.date_expire.data,
form.time_expire.data),
course_id=course.id,
course_name=course.name,
institution_name=course.institution_name,
user_id=current_user.id)
db.session.add(assignment)
db.session.commit()
flash("Tarea creda con exito")
except:
flash("Error creando tarea")
for course in Course.query.filter_by(user_id=current_user.id):
form.course_id.choices += [
(course.id, str(course.id) + ' - ' + course.institution_name +
' - ' + course.name)
]
assignments = Assignment.query.filter(
Assignment.user_id == current_user.id)
return render_template("module003_create.html",
module='module003',
form=form,
rows=assignments)
def new_assignment(course_id):
course = Course.query.get(course_id)
if request.method == "POST":
name = request.form.get('name', None)
description = request.form.get('description', None)
due_at = request.form.get('due-at', None)
display_at = request.form.get('display-at', None)
file_ = request.files.get('file', None)
if name and due_at and display_at:
assignment = Assignment(name=name, description=description)
assignment.due_at = parse(due_at)
assignment.display_at = parse(display_at)
if file_:
filename = assignment_descs.save(file_)
assignment.description_filename = filename
course.add_assignment(assignment)
assignment.save()
return redirect(url_for('list_assignments', course_id=course_id))
return render_template('assignment/new.html', course=course)
def create_assignment_rpc(course, name, file, command, batch_size,
grading_base):
assignment: Assignment = Assignment.query.filter_by(
name=name, course=course,
endpoint=get_endpoint(course=course)).one_or_none()
if not assignment:
assignment = Assignment(
name=name,
assignment_secret=new_secret(),
course=course,
endpoint=get_endpoint(course=course),
)
db.session.add(assignment)
assignment.file = file
assignment.command = command
assignment.last_modified = int(time.time())
assignment.batch_size = batch_size
assignment.grading_base = grading_base
db.session.commit()
return assignment.assignment_secret
import re
from models import Assignment, Problem
file = open("management/commands/sample.tex", "r")
data = file.read()
m = re.search(r"assignment{(.*)}", data)
name = m.group(1)
m = re.search(r"duedate{(.*)}", data)
due_date = m.group(1)
asgt = Assignment(name=name, due_date=due_date)
asgt.save()
problems = []
problem_locs = [m.end() for m in re.finditer("begin{problem}", data)]
for loc in problem_locs:
p = Problem()
m = re.search(r"\[(.*)\]", data[loc:])
p.name = m.group(1)
n = re.search(r"\[(.*)\]", data[loc+m.end():])
p.points = n.group(1)
o = re.search(r"([^]]*)\\end{problem}", data[loc + m.end() + n.end():])
p.solution = o.group(1)
p.save()
asgt.problems.add(p)
def _create_or_add_assignment(self, assignment_name, parentnode, extras):
# NOTE: Set default publishing_time two seconds after start_time to
# make sure it evaluates as "within" the period.
publishing_time = parentnode.start_time + timedelta(seconds=2)
assignment = Assignment(parentnode=parentnode, short_name=assignment_name,
long_name=assignment_name.capitalize(), publishing_time=publishing_time)
try:
assignment.full_clean()
assignment.save()
except ValidationError:
assignment = Assignment.objects.get(parentnode=parentnode,
short_name=assignment_name)
# add the users (only admins allowed in subject)
for admin in extras['admin']:
assignment.admins.add(self._create_or_add_user(admin))
if extras['pub']:
assignment.publishing_time += timedelta(days=int(extras['pub'][0]))
if extras['anon']:
if extras['anon'][0] == 'true':
assignment.anonymous = True
elif extras['anon'][0] == 'false':
assignment.anonymous = False
else:
raise ValueError("anon must be 'true' or 'false'")
if extras['ln']:
assignment.long_name = extras['ln'][0]
assignment.full_clean()
assignment.save()
vars(self)[parentnode.parentnode.short_name + '_' + # subject
parentnode.short_name + '_' + # period
assignment.short_name] = assignment
return assignment
def _create_or_add_assignment(self, assignment_name, parentnode, extras):
# NOTE: Set default publishing_time two seconds after start_time to
# make sure it evaluates as "within" the period.
publishing_time = parentnode.start_time + timedelta(seconds=2)
if extras['delivery_types']:
deliverytype_alias = extras['delivery_types'][0]
typemap = {'electronic': deliverytypes.ELECTRONIC,
'nonelectronic': deliverytypes.NON_ELECTRONIC}
delivery_types = typemap[deliverytype_alias]
else:
delivery_types = deliverytypes.ELECTRONIC
assignment = Assignment(parentnode=parentnode, short_name=assignment_name,
long_name=assignment_name.capitalize(), publishing_time=publishing_time,
delivery_types=delivery_types,
max_points=200)
try:
assignment.full_clean()
assignment.save()
except ValidationError:
assignment = Assignment.objects.get(parentnode=parentnode,
short_name=assignment_name)
# add the users (only admins allowed in subject)
for admin in extras['admin']:
assignment.admins.add(self._create_or_add_user(admin))
if extras['pub']:
assignment.publishing_time += timedelta(days=int(extras['pub'][0]))
if extras['anon']:
if extras['anon'][0] == 'true':
assignment.anonymous = True
elif extras['anon'][0] == 'false':
assignment.anonymous = False
else:
raise ValueError("anon must be 'true' or 'false'")
if extras['ln']:
assignment.long_name = extras['ln'][0]
if extras['first_deadline']:
days = int(extras['first_deadline'][0])
assignment.first_deadline = assignment.publishing_time
if days == 0:
assignment.first_deadline += timedelta(seconds=1)
else:
assignment.first_deadline += timedelta(days=days)
assignment.full_clean()
assignment.save()
vars(self)[parentnode.parentnode.short_name + '_' + # subject
parentnode.short_name + '_' + # period
assignment.short_name] = assignment
return assignment
from datetime import datetime, timedelta
import logging
from models import Exam, Assignment
from FCM import sendNotification
from apiMethods import createNotification
logging.basicConfig(level=logging.DEBUG)
LOG = logging.getLogger(__name__)
date = (datetime.now() + timedelta(days=7))
date = date.strftime('%d-%m-%Y')
LOG.info(date)
examList = Exam.query(Exam.dueDate == date).fetch()
LOG.info(str(examList))
assignmentList = Assignment.query(Assignment.dueDate == date).fetch()
for exam in examList:
LOG.info(str(exam))
sendNotification(exam.courseId.urlsafe(),
exam.key.urlsafe(), 'exam',
'Warning!!! Exam ahead',
'There is a exam next week')
course = exam.courseId.get()
title = course.courseName
notificationText = 'There is a exam next week'
createNotification(course.studentIds, title,
notificationText, 'exam',
exam.key.urlsafe(), course.key.urlsafe())
for assignment in assignmentList:
LOG.info(str(assignment))
sendNotification(assignment.courseId.urlsafe(),
def create_from_path(path):
""" Create a Node, Subject, Period, Assignment or AssignmentGroup from
``path``.
Examples::
assignmentgroup = create_from_path(
'ifi:inf1100.spring05.oblig1.student1,student2')
oblig1 = create_from_path(
'ifi:inf1100.spring05.oblig1')
"""
split = path.split(':', 1)
nodes = split[0].split('.')
for nodename in nodes:
node = Node(short_name=nodename, long_name=nodename.capitalize())
try:
node.clean()
node.save()
except:
node = Node.objects.get(short_name=nodename)
last = node
if len(split) != 2:
return last
pathsplit = split[1].split('.')
# Subject
subjectname = pathsplit[0]
subject = Subject(parentnode=node, short_name=subjectname,
long_name=subjectname.capitalize())
try:
subject.clean()
subject.save()
except:
subject = Subject.objects.get(short_name=subjectname)
last = subject
# Period
if len(pathsplit) > 1:
periodname = pathsplit[1]
period = Period(parentnode=subject, short_name=periodname,
long_name=periodname.capitalize(), start_time=datetime.now(),
end_time=datetime.now() + timedelta(10))
try:
period.clean()
period.save()
except:
period = Period.objects.get(parentnode=subject,
short_name=periodname)
last = period
# Assignment
if len(pathsplit) > 2:
assignmentname = pathsplit[2]
assignment = Assignment(parentnode=period, short_name=assignmentname,
long_name=assignmentname.capitalize(), publishing_time=datetime.now())
assignment.clean()
try:
assignment.save()
except:
assignment = Assignment.objects.get(parentnode=period,
short_name=assignmentname)
last = assignment
# Candidates
if len(pathsplit) > 3:
usernames = pathsplit[3].split(',')
users = []
for u in usernames:
user = User(username=u)
try:
user.save()
except:
user = User.objects.get(username=u)
users.append(user)
assignment_group = AssignmentGroup(parentnode=assignment)
assignment_group.clean()
assignment_group.save()
for user in users:
assignment_group.candidates.add(Candidate(student=user))
last = assignment_group
return last
def testAssignment(self):
what = Assignment(123)
what.setDescription("aerobic in aer liber")
what.setDeadline("martiembrie 201B")
what.setGrade(5.1231231231231231231231231)
assert what.getStudentID() == 123
assert what.getDescription() == "aerobic in aer liber"
assert what.getDeadline() == "martiembrie 201B"
assert what.getGrade() == 5.1231231231231231231231231
def get_current_assignments(session):
return Assignment.get_current_assignments(session)
def _create_or_add_assignment(self, assignment_name, parentnode, extras):
assignment = Assignment(parentnode=parentnode, short_name=assignment_name,
long_name=assignment_name.capitalize(), publishing_time=parentnode.start_time)
try:
assignment.full_clean()
assignment.save()
except:
assignment = Assignment.objects.get(parentnode=parentnode,
short_name=assignment_name)
# add the users (only admins allowed in subject)
for admin in extras['admin']:
assignment.admins.add(self._create_or_add_user(admin))
if extras['pub']:
assignment.publishing_time += timedelta(days=int(extras['pub'][0]))
if extras['anon']:
if extras['anon'][0] == 'true':
assignment.anonymous = True
elif extras['anon'][0] == 'false':
assignment.anonymous = False
else:
raise ValueError("anon must be 'true' or 'false'")
assignment.full_clean()
assignment.save()
vars(self)[parentnode.parentnode.short_name + '_' + # subject
parentnode.short_name + '_' + # period
assignment.short_name] = assignment
return assignment
def get_assign_by_number(quarter, year, number):
return Assignment.query(
Assignment.quarter == quarter,
Assignment.year == year,
Assignment.number == number,
).get()
def get_assigns_for_quarter(quarter, year):
return Assignment.query(
Assignment.quarter == quarter,
Assignment.year == year,
)
def get_all_assign(quarter, year):
return Assignment.query(
Assignment.quarter == quarter,
Assignment.year == year
).order(Assignment.number).fetch()
def _create_or_add_assignment(self, assignment_name, parentnode, extras):
# NOTE: Set default publishing_time two seconds after start_time to
# make sure it evaluates as "within" the period.
publishing_time = parentnode.start_time + timedelta(seconds=2)
if extras['delivery_types']:
deliverytype_alias = extras['delivery_types'][0]
typemap = {'electronic': deliverytypes.ELECTRONIC,
'nonelectronic': deliverytypes.NON_ELECTRONIC}
delivery_types = typemap[deliverytype_alias]
else:
delivery_types = deliverytypes.ELECTRONIC
assignment = Assignment(parentnode=parentnode, short_name=assignment_name,
long_name=assignment_name.capitalize(), publishing_time=publishing_time,
delivery_types=delivery_types,
max_points=200)
try:
assignment.full_clean()
assignment.save()
except ValidationError:
assignment = Assignment.objects.get(parentnode=parentnode,
short_name=assignment_name)
# add the users (only admins allowed in subject)
for admin in extras['admin']:
assignment.admins.add(self._create_or_add_user(admin))
if extras['pub']:
assignment.publishing_time += timedelta(days=int(extras['pub'][0]))
if extras['anon']:
if extras['anon'][0] == 'true':
assignment.anonymous = True
elif extras['anon'][0] == 'false':
assignment.anonymous = False
else:
raise ValueError("anon must be 'true' or 'false'")
if extras['ln']:
assignment.long_name = extras['ln'][0]
if extras['first_deadline']:
days = int(extras['first_deadline'][0])
assignment.first_deadline = assignment.publishing_time
if days == 0:
assignment.first_deadline += timedelta(seconds=1)
else:
assignment.first_deadline += timedelta(days=days)
assignment.full_clean()
assignment.save()
vars(self)[parentnode.parentnode.short_name + '_' + # subject
parentnode.short_name + '_' + # period
assignment.short_name] = assignment
return assignment
def _create_or_add_assignment(self, assignment_name, parentnode, extras):
assignment = Assignment(parentnode=parentnode,
short_name=assignment_name,
long_name=assignment_name.capitalize(),
publishing_time=parentnode.start_time)
try:
assignment.full_clean()
assignment.save()
except ValidationError:
assignment = Assignment.objects.get(parentnode=parentnode,
short_name=assignment_name)
# add the users (only admins allowed in subject)
for admin in extras['admin']:
assignment.admins.add(self._create_or_add_user(admin))
if extras['pub']:
assignment.publishing_time += timedelta(days=int(extras['pub'][0]))
if extras['anon']:
if extras['anon'][0] == 'true':
assignment.anonymous = True
elif extras['anon'][0] == 'false':
assignment.anonymous = False
else:
raise ValueError("anon must be 'true' or 'false'")
assignment.full_clean()
assignment.save()
vars(self)[parentnode.parentnode.short_name + '_' + # subject
parentnode.short_name + '_' + # period
assignment.short_name] = assignment
return assignment
def assignment_list(self, query):
""" List all the assignments owned by the given user """
user = endpoints.get_current_user()
assignments = Assignment.query(ancestor=main.get_parent_key(user)).order(Assignment.name)
return assignments
