def test_get_active_session(db):
cm = courses_model.Courses(db, 4) # art history
seid = cm.get_active_session()
assert seid == 2
cm = courses_model.Courses(db, 1) # running, no active session
seid = cm.get_active_session()
assert seid == -1
def test_get_num_sessions(db):
cm = courses_model.Courses(db, 3) # german 3, has no sessions
num_sessions = cm.get_num_sessions()
assert num_sessions == 0
cm = courses_model.Courses(db, 4) # art history, has 2 sessions
num_sessions = cm.get_num_sessions()
assert num_sessions == 2
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 test_add_student(db):
cm = courses_model.Courses(db, 4) # art history
# check length before
student_list = cm.get_students()
assert len(student_list) == 2
# check for a valid add_student call
add_student_result = cm.add_student('jp9122') # adding Jaina Proudmoore
assert add_student_result == 0
# check length after
student_list = cm.get_students()
assert len(student_list) == 3
# check for adding a student already in the class
add_student_result = cm.add_student('jp9122')
assert add_student_result == -2
# check length to make sure it remains
student_list = cm.get_students()
assert len(student_list) == 3
# check for adding a non-existent student
add_student_result = cm.add_student('nonexistent')
assert add_student_result == -1
# check length to make sure it remains
student_list = cm.get_students()
assert len(student_list) == 3
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 test_add_teacher(db):
cm = courses_model.Courses(db, 6) # test_add_teacher course
teachers = cm.get_teachers()
assert len(teachers) == 1
assert teachers[0]['email'] == '*****@*****.**'
# insert a fake user
result = cm.add_teacher('*****@*****.**')
assert result[0] == False
assert 'User [email protected] not found' in result[1]
# insert a user that isn't a teacher
result = cm.add_teacher('*****@*****.**')
assert result[0] == True
#insert a user that is a teacher
result = cm.add_teacher('*****@*****.**')
assert result[0] == True
teachers = cm.get_teachers()
assert len(teachers) == 3
cm.remove_teacher(11)
teachers = cm.get_teachers()
assert len(teachers) == 2
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 test_main_student(db):
with imhere.app.test_client() as c:
res = c.get('/student/')
assert 302 == res.status_code
with c.session_transaction() as sess:
login(sess, unreg, unreg_id)
sess['is_teacher'] = False
sess['is_student'] = True
cid = db.execute(
"select cid from courses where name = 'newts big class'").fetchone(
)['cid']
res = c.get('/student/')
assert 'Student View' in res.data
cm_big = courses_model.Courses(db, cid)
cm_big.add_student('uu0000')
res = c.get('/student/')
assert "newts big class" in res.data
assert "No sign-in window" in res.data
serket = cm_big.open_session()
res = c.get('/student/')
assert "Sign in now!" in res.data
res = c.post('/student/')
assert "Student View" in res.data
payload = {'secret_code': 0000}
res = c.post('/student/', data=payload)
assert "Invalid Secret Code" in res.data
payload = {'secret_code': serket}
res = c.post('/student/', data=payload)
assert "Successful sign-in!" in res.data
payload = {'secret_code': serket}
res = c.post('/student/', data=payload)
assert "Successful sign-in!" not in res.data
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 test_get_courses(db):
dave = students_model.Students(db, 3)
dave_courses = dave.get_courses()
assert len(dave_courses) == 1
art = dave_courses[0]
assert art['cid'] == 4
assert art['name'] == 'Art History'
cm_running = courses_model.Courses(db, 1)
cm_running.add_student('ds9876')
dave_courses = dave.get_courses()
assert len(dave_courses) == 2
running = dave_courses[0]
assert running['cid'] == 1
assert running['name'] == 'Running'
art = dave_courses[1]
assert art['cid'] == 4
assert art['name'] == 'Art History'
jaina = students_model.Students(db, 6)
jaina_courses = jaina.get_courses()
assert len(jaina_courses) == 0
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 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 student_view_attendance():
sm = students_model.Students(flask.session['id'])
courses = sm.get_courses()
records = list()
course_name=""
#need to error check for when student is not enrolled in any courses
if request.method == 'POST':
cid = request.form['cid']
course_name = courses_model.Courses(cid).get_course_name()
elif courses:
cid = courses[0]['cid']
course_name = courses[0]['name']
records = sm.get_course_attendance(cid)
attendance_model = arm.Attendance_Records()
excuses = attendance_model.get_excuses_multi(sid=flask.session['id'])
excuse_session_ids = [int(e['seid']) for e in excuses]
for r in records:
r['excuse_submitted'] = False
if r['seid'] in excuse_session_ids:
r['excuse_submitted'] = True
return render_template(
'view_student_record.html',
courses=courses,
records=records,
course_name=course_name
)
def test_sql_injection(db):
cm = courses_model.Courses(db, 1)
assert cm.add_student("' or 1=1;") == -1
assert cm.add_student("'little bobby tables'") == -1
assert cm.remove_student("' or 1=1;") == -1
assert cm.remove_student("'little bobby tables'") == -1
def test_open_session(db):
cm = courses_model.Courses(db, 1) # running, no active session
seid = cm.get_active_session()
assert seid == -1 # no active session
cm.open_session()
seid = cm.get_active_session()
assert seid != -1
def test_close_session(db):
cm = courses_model.Courses(db, 4) # art history, has open session
seid = cm.get_active_session()
assert seid == 2
cm.close_session(seid)
# checking if seid is -1 for same class that was just open
seid = cm.get_active_session()
assert seid == -1
def view_class():
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()
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)
students_with_ar.append([student, student_uni, num_ar])
context = dict(students=students_with_ar)
return render_template(
'view_class.html',
cid=cid,
secret=secret,
course_name=course_name,
num_sessions=num_sessions,
uni=uni,
res=res,
**context)
def test_get_students(db):
cm = courses_model.Courses(db, 4) # art history
student_list = cm.get_students()
assert type(student_list) is list
assert len(student_list) == 2
assert 3 in student_list[0].items()[0]
assert 'Dave' in student_list[0].items()[1]
assert 'Student' in student_list[0].items()[2]
assert '*****@*****.**' in student_list[0].items()[3]
assert 5 in student_list[1].items()[0]
assert 'Grommash' in student_list[1].items()[1]
assert 'Hellscream' in student_list[1].items()[2]
assert '*****@*****.**' in student_list[1].items()[3]
def test_e_students_signin(self):
with imhere.app.test_client() as t_s:
rv = t_s.get("/student/")
self.assertEqual(302, rv.status_code)
with t_s.session_transaction() as session_student:
self.login(session_student, STUDENT_ACCOUNT_2,
self.sid_2) # STUDENT_ACCOUNT_2_ID
session_student['is_teacher'] = False
session_student['is_student'] = True
# add student, nto yet open window
rv = t_s.get('/student/')
#pdb.set_trace()
self.assertIn("Switch To Teacher View", rv.data)
course_1 = courses_model.Courses(self.cid_1)
course_1.add_student("xz2222")
rv = t_s.get("/student/")
self.assertIn("COMS 4111", rv.data)
self.assertIn("No Sign-in Window Available!", rv.data)
# Open Sign-in & get secret code
real_secret_code = course_1.open_session()
rv = t_s.get('/student/')
self.assertIn("Sign in now!", rv.data)
self.assertIn("Student View", rv.data)
data = {'secret_code': 0000}
rv = t_s.post("/student/", data=data, follow_redirects=True)
self.assertIn("Invalid Secret Code", rv.data)
data = {'secret_code': real_secret_code}
rv = t_s.post("/student/", data=data, follow_redirects=True)
self.assertEqual(200, rv.status_code)
self.assertIn("Successful sign-in!", rv.data)
# Check timstamp & coordiantes
self.assertIn("Time", rv.data)
self.assertIn("Coordinate", rv.data)
t_s.get('/oauth/logout')
rv = t_s.get('/student/')
self.assertEqual(302, rv.status_code)
def test_get_secret_code(db):
cm = courses_model.Courses(db, 2) # writing, has no active session
seid = cm.get_active_session()
assert seid == -1 # make sure no active session exists
randsecret = cm.open_session()
seid = cm.get_active_session()
assert seid != -1 # make sure an active session exists now
secret = cm.get_secret_code()
assert randsecret == secret
assert secret is not None
cm.close_session(seid)
secret = cm.get_secret_code()
assert secret is None
def test_remove_student(db):
cm = courses_model.Courses(db, 4) # art history
# check length before (Jaina now in class)
student_list = cm.get_students()
assert len(student_list) == 3
# check for a valid remove_student call
remove_student_result = cm.remove_student('jp9122') # removing Jaina
assert remove_student_result == 0
# check length after valid remove
student_list = cm.get_students()
assert len(student_list) == 2
# check for removing a student not in the class
remove_student_result = cm.remove_student('jp9122')
assert remove_student_result == -3
# check length to make sure it remains the same
student_list = cm.get_students()
assert len(student_list) == 2
# check for removing a nonexistent student
remove_student_result = cm.remove_student('nonexistent')
assert remove_student_result == -1
# check length to make sure it remains the same
student_list = cm.get_students()
assert len(student_list) == 2
###########################################################################
# now test that remove_student takes away attendance records
# testing with Dave, who has an AR in an old session of art history
query = ('select * from attendance_records '
'where sid = %s'
% 3)
result = db.execute(query)
assert result.rowcount == 2 # Dave is in two sessions of this course
# now remove Dave
cm.remove_student('ds9876')
result = db.execute(query)
assert result.rowcount == 0
def setUp(self):
super(AttendanceTestCase, self).setUp()
self.context = {}
self.context['student'] = [self.store_model('student', **STUDENT)]
self.context['courses'] = [
self.store_model('courses', **course) for course in COURSES
]
self.context['enrolled_in'] = [
self.store_model('enrolled_in', **e) for e in ENROLLS
]
self.context['sessions'] = [
self.store_model('sessions', **s) for s in SESSIONS
]
self.student = sm.Students(STUDENT['sid']),
self.courses = [cm.Courses(c['cid']) for c in COURSES],
self.record = arm.Attendance_Records(sid=RECORD['sid'],
seid=RECORD['seid'])
def student_view_class(cid):
cm = courses_model.Courses(g.conn, cid)
sm = students_model.Students(g.conn, flask.session['id'])
course_name = cm.get_course_name()
attendance_record = sm.get_attendance_record(cid)
present = 0
total = len(attendance_record)
for rec in attendance_record:
if rec['sid'] is not None:
present += 1
flask.session['redirect'] = '/student/view_class/%s' % cid
return render_template('student_view_class.html',
course_name=course_name,
attendance_record=attendance_record,
present=present,
total=total)
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_sessions(db):
cid = 7
student = 15
cm = courses_model.Courses(db, cid)
sm = students_model.Students(db, student)
sessions = cm.get_sessions()
assert len(sessions) == 0
secret = cm.open_session()
seid = cm.get_active_session()
sessions = cm.get_sessions()
assert len(sessions) == 1
assert sessions[0]['enrollment'] == 1
assert sessions[0]['attendance'] == 0
sm.insert_attendance_record(seid)
sessions = cm.get_sessions()
assert sessions[0]['attendance'] == 1
def student_view_excuses():
sid = flask.session['id']
excuses = arm.Attendance_Records().get_excuses_multi(sid=sid)
data = {}
for e in excuses:
session = arm.Attendance_Records().get_session(e['seid'])
if session:
cid = session['cid']
course_name = courses_model.Courses(cid).get_course_name()
if not course_name:
continue
if not data.get(course_name):
data[course_name] = []
#add the excuse message to the session information
session['excuse'] = e['excuse']
data[course_name].append(session)
return render_template("student_excuses.html",
data=data)
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 test_get_course_name(db):
cm = courses_model.Courses(db, 4) # art history
name = cm.get_course_name()
assert name == 'Art History'
def view_class():
if request.method == 'GET':
flask.redirect(flask.url_for('main_teacher'))
elif request.method == 'POST':
cm = courses_model.Courses()
ssm = sessions_model.Sessions()
if 'close' in request.form.keys():
cid = request.form['close']
cm.cid = cid
ssm.open_session(cid)
ssm.close_window()
elif 'open' in request.form.keys():
cid = request.form['open']
cm.cid = cid
new_seid = ssm.open_session(cid)
ssm.open_window(new_seid)
else:
cid = request.form['cid']
cm.cid = cid
res = 0
uni = None
if 'add_student' in request.form.keys():
for uni in request.form['add_student'].split('\n'):
uni = uni.strip('\r')
res = cm.add_student(uni)
elif 'remove_student' in request.form.keys():
for uni in request.form['remove_student'].split('\n'):
uni = uni.strip('\r')
res = cm.remove_student(uni)
course_name = cm.get_course_name()
secret = ssm.get_secret_code()
num_sessions = cm.get_num_sessions()
sess = cm.get_sessions()
ssm2 = sessions_model.Sessions()
labels = []
values = []
for ses in sess:
denom = float(ssm2.get_current_roster_size(ses['seid']))
numerator = float(ssm2.get_attendance_count(ses['seid']))
if(denom == 0):
values.append(0)
else:
values.append((float(numerator/denom))*100)
labels.append(str(ses['date']))
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)
students_with_ar.append([student, student_uni, num_ar])
context = dict(students=students_with_ar)
return render_template(
'view_class.html',
cid=cid,
secret=secret,
course_name=course_name,
num_sessions=num_sessions,
uni=uni,
res=res,
labels=labels,
values=values,
**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)
