def add_class():
tid = flask.session['id']
tm = teachers_model.Teachers(tid)
if request.method == 'GET':
return render_template('add_class.html', error=None)
elif request.method == 'POST':
# first check that all unis are valid
um = users_model.Users()
for uni in request.form['unis'].split('\n'):
uni = uni.strip('\r')
# always reads at least one empty line from form
if not uni:
continue
if not um.is_valid_uni(uni):
invalid_uni = "Invalid UNI's entered, please recreate the class"
return render_template('add_class.html', error=invalid_uni)
course_name = request.form['classname']
cid = tm.add_course(course_name)
if cid == -1:
coursename_exists = "There is already a course by this name that you teach"
return render_template('add_class.html', error=coursename_exists)
cm = courses_model.Courses(cid)
for uni in request.form['unis'].split('\n'):
uni = uni.strip('\r')
cm.add_student(uni)
return flask.redirect(flask.url_for('main_teacher'))
def test_a_teacher(self):
imhere.app.testing = True
imhere.app.secret_key = str(uuid.uuid4())
self.app = imhere.app.test_client()
teacher_instance = teachers_model.Teachers(TEACHER_ACCOUNT_ID)
classname_1 = "COMS 4111"
self.__class__.cid_1 = teacher_instance.add_course(classname_1)
# course_instance_1 = courses_model.Courses(self.__class__.cid_1)
#course_instance_1.add_student('xz2222')
classname_2 = "COMS 4112"
self.__class__.cid_2 = teacher_instance.add_course(classname_2)
course_instance_2 = courses_model.Courses(self.__class__.cid_2)
self.__class__.sid_2 = course_instance_2.add_student('xz2222')
with imhere.app.test_client() as t_t:
# log in with teacher account
with t_t.session_transaction() as session_teacher:
self.login(session_teacher, TEACHER_ACCOUNT,
TEACHER_ACCOUNT_ID)
session_teacher['is_teacher'] = True
rv = t_t.get('/teacher/')
self.assertEqual(200, rv.status_code)
def main_teacher():
tid = flask.session['id']
if request.method == 'GET':
index = index_model.Index(tid)
if (not index.is_teacher()):
return render_template('error.html')
tm = teachers_model.Teachers(tid)
ssm = sessions_model.Sessions()
if request.method == 'POST':
if "close" in request.form.keys():
cid = request.form["close"]
ssm.open_session(cid)
ssm.close_window()
elif "open" in request.form.keys():
cid = int(request.form["open"])
new_seid = ssm.open_session(cid)
ssm.open_window(new_seid)
course = courses_model.Courses()
students = course.get_students_sids(cid)
for student in students:
sm = students_model.Students(student['sid'])
sm.insert_attendance_record(new_seid)
courses = tm.get_courses_with_session()
empty = True if len(courses) == 0 else False
context = dict(data=courses)
return render_template('main_teacher.html', empty=empty, **context)
def main_teacher():
tm = teachers_model.Teachers(flask.session['id'])
if request.method == 'POST':
cm = courses_model.Courses()
if "close" in request.form.keys():
cid = request.form["close"]
cm.cid = cid
cm.close_session(cm.get_active_session())
elif "open" in request.form.keys():
cid = request.form["open"]
cm.cid = cid
cm.open_session()
courses = tm.get_courses_with_session()
empty = True if len(courses) == 0 else False
context = dict(data=courses)
disable_rest_open_windows = False
for item in context['data']:
if item['active'] == 1:
disable_rest_open_windows = True
return render_template('main_teacher.html',
empty=empty,
disable_rest_open_windows=disable_rest_open_windows,
**context)
def update_session(seid):
sm = sessions_model.Sessions(g.conn, seid)
tm = teachers_model.Teachers(g.conn, flask.session['id'])
action = request.form['action']
sid = request.form['sid'] if 'sid' in request.form.keys() else None
stm = students_model.Students(g.conn, sid)
if action == 'mark_present':
stm.insert_attendance_record(seid)
elif action == 'mark_absent':
sm.remove_attendance_record(sid)
elif action == 'approve':
status = 1
tm.update_change_request(int(status), int(seid), int(sid))
stm.insert_attendance_record(seid)
elif action == 'deny':
status = 0
tm.update_change_request(int(status), int(seid), int(sid))
elif action == 'delete_session':
sm.delete_session()
return flask.redirect('/teacher/')
session = sm.get_session()[0]
attendance = sm.get_attendance_record()
return render_template('session.html',
session=session,
attendance=attendance)
def add_class():
tm = teachers_model.Teachers(g.conn, flask.session['id'])
if request.method == 'GET':
return render_template('add_class.html')
elif request.method == 'POST':
# first check that all unis are valid
um = users_model.Users(g.conn)
for uni in request.form['unis'].split('\n'):
uni = uni.strip('\r')
# always reads at least one empty line from form
if not uni:
continue
if not um.is_valid_uni(uni):
return render_template('add_class.html', invalid_uni=True)
# then create course and add students to course
course_name = request.form['classname']
cid = tm.add_course(course_name)
cm = courses_model.Courses(g.conn, cid)
for uni in request.form['unis'].split('\n'):
uni = uni.strip('\r')
cm.add_student(uni)
return flask.redirect(flask.url_for('main_teacher'))
def filled_db():
imhere.app.secret_key = str(uuid.uuid4())
um = users_model.Users()
um.get_or_create_user(stu)
um.get_or_create_user(newt)
m = model.Model()
ds = m.get_client()
key = ds.key('student')
entity = datastore.Entity(
key=key)
entity.update({
'sid': stu['id'],
'uni': 'cs4156'
})
ds.put(entity)
key = ds.key('teacher')
entity = datastore.Entity(
key=key)
entity.update({
'tid': newt['id']
})
ds.put(entity)
tm = teachers_model.Teachers(newt['id'])
course_name = 'Writing'
cid = tm.add_course(course_name)
cm = courses_model.Courses(cid)
cm.add_student('cs4156')
yield cid
def remove_class():
tm = teachers_model.Teachers(flask.session['id'])
# show potential courses to remove on get request
if request.method == 'GET':
courses = tm.get_courses()
context = dict(data=courses)
return render_template('remove_class.html', **context)
# remove course by cid
elif request.method == 'POST':
cid = request.form['cid']
tm.remove_course(cid)
return flask.redirect(flask.url_for('main_teacher'))
def test_add_course(db):
douglas = teachers_model.Teachers(db, 4)
assert len(douglas.get_courses()) == 1
cid = douglas.add_course('Mining')
query = 'SELECT MAX(cid) from courses'
res = db.execute(query)
blah = []
for b in res:
blah.append(b)
assert cid == blah[0]['max']
# assert cid == 5 # next available cid
assert len(douglas.get_courses()) == 2
def test_get_courses(db):
douglas = teachers_model.Teachers(db, 4)
courses_list = douglas.get_courses()
assert len(courses_list) == 1
assert type(courses_list) is list
# len of 2 because we're selecting courses.cid and courses.name
assert len(courses_list[0]) == 2
assert type(courses_list[0]) is sqlalchemy.engine.RowProxy
# check for each key that we selected
rowproxy = courses_list[0]
assert 'cid' in rowproxy
assert 'name' in rowproxy
assert 'notselected' not in rowproxy
def main_teacher():
tm = teachers_model.Teachers(g.conn, flask.session['id'])
if request.method == 'POST':
cm = courses_model.Courses(g.conn)
if "close" in request.form.keys():
cid = request.form["close"]
cm.cid = cid
cm.close_session(cm.get_active_session())
elif "open" in request.form.keys():
cid = request.form["open"]
cm.cid = cid
cm.open_session()
courses = tm.get_courses_with_session()
empty = True if len(courses) == 0 else False
context = dict(data=courses)
return render_template('main_teacher.html', empty=empty, **context)
def test_remove_course(db):
douglas = teachers_model.Teachers(db, 4)
assert len(douglas.get_courses()) == 2
# remove mining class
query = 'SELECT MAX(cid) from courses'
res = db.execute(query)
blah = []
for b in res:
blah.append(b)
mining_cid = blah[0]['max']
douglas.remove_course(mining_cid)
assert len(douglas.get_courses()) == 1
# remove imaginary class
douglas.remove_course(-1)
assert len(douglas.get_courses()) == 1
def test_get_courses_with_session(db):
douglas = teachers_model.Teachers(db, 4)
courses_list_with_session = douglas.get_courses_with_session()
assert len(courses_list_with_session) == 1
assert type(courses_list_with_session) is list
# len of 4 because we're selecting courses.cid, name, active, secret
assert len(courses_list_with_session[0]) == 4
assert type(courses_list_with_session[0]) is sqlalchemy.engine.RowProxy
# check for each key that we selected
rowproxy = courses_list_with_session[0]
assert 'cid' in rowproxy
assert 'name' in rowproxy
assert 'active' in rowproxy
assert 'secret' in rowproxy
assert ('active', 1) in rowproxy.items()
assert ('secret', '0000') in rowproxy.items()
def view_requests():
tm = teachers_model.Teachers(g.conn, flask.session['id'])
if request.method == 'GET':
results = tm.get_change_requests()
context = dict(data=results)
return render_template('view_requests.html', **context)
elif request.method == 'POST':
if 'approve' in request.form.keys():
iden = request.form['approve'].split()
seid = int(iden[0])
sid = int(iden[1])
sm = students_model.Students(g.conn, sid)
sm.insert_attendance_record(seid)
tm.update_change_request(1, seid, sid)
elif 'deny' in request.form.keys():
iden = request.form['deny'].split()
seid = int(iden[0])
sid = int(iden[1])
tm.update_change_request(-1, seid, sid)
results = tm.get_change_requests()
context = dict(data=results)
return render_template('view_requests.html', **context)
def teacher_view_excuses():
#get courses
tid = flask.session['id']
teacher = teachers_model.Teachers(tid)
courses_taught = teacher.get_courses()
#get sessions for selected course id and submitted excuses
context = dict(data=[])
if not courses_taught:
return render_template("teacher_view_excuses.html",
courses_taught=courses_taught,
**context)
if request.method == 'POST':
cid = request.form['cid']
else:
cid = courses_taught[0]['cid']
course = courses_model.Courses(cid)
sessions = course.get_sessions()
#get unis and excuse messages for all sessions
sm = students_model.Students(1)
results = []
for s in sessions:
excuses = arm.Attendance_Records().get_excuses_multi(seid=s['seid'])
if excuses:
for e in excuses:
sm.sid = e['sid']
e['uni'] = sm.get_uni()
s['excuses'] = excuses
results.append(s)
context['data'] = results
context['course_name'] = course.get_course_name()
return render_template("teacher_view_excuses.html",
courses_taught=courses_taught,
**context)
def view_class():
tm = teachers_model.Teachers(flask.session['id'])
if request.method == 'GET':
flask.redirect(flask.url_for('main_teacher'))
elif request.method == 'POST':
cm = courses_model.Courses()
if 'close' in request.form.keys():
cid = request.form['close']
cm.cid = cid
cm.close_session(cm.get_active_session())
elif 'open' in request.form.keys():
cid = request.form['open']
cm.cid = cid
cm.open_session()
else:
cid = request.form['cid']
cm.cid = cid
res = 0
uni = None
if 'add_student' in request.form.keys():
uni = request.form['add_student']
res = cm.add_student(uni)
elif 'remove_student' in request.form.keys():
uni = request.form['remove_student']
res = cm.remove_student(uni)
course_name = cm.get_course_name()
secret = cm.get_secret_code()
# Get class timestamp
timestamp = cm.get_timestamp()
# Get class coordinate
coordinate = cm.get_coordinate()
num_sessions = cm.get_num_sessions()
students = cm.get_students()
students_with_ar = []
for student in students:
sm = students_model.Students(student['id'])
student_uni = sm.get_uni()
num_ar = sm.get_num_attendance_records(cid)
num_late = sm.get_num_late_attendance_records(cid)
students_with_ar.append([student, student_uni, num_ar, num_late])
context = dict(students=students_with_ar)
if timestamp:
new_timestamp = timestamp+timedelta(hours=-4)
else:
new_timestamp = "NO TIME."
courses = tm.get_courses_with_session()
context_course = dict(data=courses)
disable_rest_open_windows = False
for item in context_course['data']:
if item['active'] == 1:
disable_rest_open_windows = True
return render_template(
'view_class.html',
cid=cid,
secret=secret,
timestamp=new_timestamp,
coordinate=coordinate,
course_name=course_name,
num_sessions=num_sessions,
uni=uni,
disable_rest_open_windows=disable_rest_open_windows,
res=res,
**context)
