def main_student():
sm = students_model.Students(flask.session['id'])
courses = sm.get_courses()
context = dict(data=courses)
signed_in = True if sm.has_signed_in() else False
if request.method == 'GET':
return render_template(
'main_student.html',
signed_in=signed_in,
**context)
elif request.method == 'POST':
if 'secret_code' in request.form.keys():
provided_secret = request.form['secret_code']
cid = int(request.form['cid'])
actual_secret, seid = sm.get_secret_and_seid(cid)
if courses:
for course in courses:
if course['cid'] == cid:
if int(provided_secret) == int(actual_secret):
sm.sign_in(seid=seid)
course['secret_valid'] = True
course['signed_in'] = True
else:
course['secret_valid'] = False
context = dict(data=courses)
return render_template(
'main_student.html',
submitted=True,
**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 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 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 main_student():
sm = students_model.Students(g.conn, flask.session['id'])
courses = sm.get_courses()
context = dict(data=courses)
signed_in = True if sm.has_signed_in() else False
if request.method == 'GET':
return render_template('main_student.html',
signed_in=signed_in,
**context)
elif request.method == 'POST':
if 'secret_code' in request.form.keys():
provided_secret = request.form['secret_code']
actual_secret, seid = sm.get_secret_and_seid()
if provided_secret == actual_secret:
sm.insert_attendance_record(seid)
valid = True
else:
valid = False
return render_template('main_student.html',
submitted=True,
valid=valid,
**context)
else:
return render_template('main_student.html',
signed_in=signed_in,
**context)
def test_insert_attendance_record(db):
grommash = students_model.Students(db, 5)
assert not grommash.has_signed_in()
# insert grommash into session (seid=2)
grommash.insert_attendance_record(2)
assert grommash.has_signed_in()
def test_get_courses(self):
student = sm.Students(sid=STUDENT['sid'])
for enrolled in ENROLLMENT:
self.store_model('enrolled_in', **enrolled)
student_courses = sorted(student.get_courses(), key=lambda c: c['cid'])
correct_courses = sorted(COURSES, key=lambda x: x['cid'])
self.assertEquals(len(student_courses), len(correct_courses))
'''
def student_change_request(seid):
sm = students_model.Students(g.conn, flask.session['id'])
message = request.form['message'] or ''
sm.create_change_request(seid, message)
redirect = flask.session.pop('redirect', None)
return flask.redirect(redirect or '/student/')
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_num_attendance_records(db):
jaina = students_model.Students(db, 6)
cid_of_ah = 4
assert jaina.get_num_attendance_records(cid_of_ah) == 0
# insert into 1st session
jaina.insert_attendance_record(1)
assert jaina.get_num_attendance_records(cid_of_ah) == 1
# insert into 2nd session
jaina.insert_attendance_record(2)
assert jaina.get_num_attendance_records(cid_of_ah) == 2
def test_get_course_attendance(self):
for session in SESSIONS:
self.store_model('sessions', **session)
for record in RECORDS:
self.store_model('attendance_records', **record)
student = sm.Students(sid=STUDENT['sid'])
attendance = sorted(student.get_course_attendance(COURSES[0]['cid']),
key=lambda x: x['seid'])
correct_att = sorted(SESSIONS, key=lambda x: x['seid'])
self.assertEquals(len(attendance), len(correct_att))
for s1, s2 in zip(attendance, correct_att):
for attr in s1:
self.assertEquals(s1[attr], s2[attr])
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 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 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 test_get_uni_existing_student(self):
student = sm.Students(sid=STUDENT['sid'])
uni = student.get_uni()
self.assertEquals(uni, STUDENT['uni'])
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 test_get_courses_no_courses(self):
student = sm.Students(sid=STUDENT['sid'])
courses = student.get_courses()
self.assertEquals(len(courses), 0)
def main_student():
sm = students_model.Students(flask.session['id'])
courses = sm.get_courses()
context = dict(data=courses)
signed_in, ontime_or_not = sm.has_signed_in()
# signed_in = True if sm.has_signed_in() else False
record_timestamp, record_coordinate = sm.get_attendance_record()
valid = 0
new_record_timestamp = record_timestamp+timedelta(hours=-4)
if request.method == 'GET':
return render_template(
'main_student.html',
valid=valid,
signed_in=signed_in,
ontime_or_not=ontime_or_not,
uni=sm.get_uni(),
record_timestamp=new_record_timestamp,
record_coordinate=record_coordinate,
**context)
elif request.method == 'POST':
if 'secret_code' in request.form.keys():
# Provided_secret is student's secret code input
provided_secret = request.form['secret_code']
# provided_timestamp = datetime.datetime.now(tz=EST5EDT())
provided_timestamp = datetime.now()
provided_coordinate_data = json.load(urlopen(_URL + "/" + str(request.remote_addr)))
if 'lat' not in provided_coordinate_data:
provided_coordinate = [0, 0]
else:
provided_coordinate = [provided_coordinate_data['lat'], provided_coordinate_data['lon']]
# actual_secret, and seid is the real secret code and real session id related to the course above.
actual_secret, seid, course_timestamp, course_coordinate = sm.get_secret_and_seid()
# valid = 1 true valid
# valid = 2 out of distance range
# valid = 3 out of timestamp range
# valid = 4 invalid secret code
if provided_secret == '':
provided_secret = 999
if int(provided_secret) == int(actual_secret):
if (course_timestamp + timedelta(minutes=15)).replace(tzinfo=None) >= provided_timestamp:
distance = great_circle(tuple(provided_coordinate), tuple(course_coordinate)).meters
if distance <= 25:
sm.insert_attendance_record(seid, provided_timestamp, provided_coordinate, True)
valid = 1
else:
valid = 2
else:
sm.insert_attendance_record(seid, provided_timestamp, provided_coordinate, False)
valid = 3
else:
valid = 4
new_signin_timestamp = provided_timestamp+timedelta(hours=-4)
return render_template(
'main_student.html',
submitted=True,
valid=valid,
uni=sm.get_uni(),
actual_secret=actual_secret,
signin_timestamp=new_signin_timestamp,
signin_coordinate=provided_coordinate,
**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)
def test_get_uni(db):
sm = students_model.Students(db, 3)
assert sm.get_uni() == 'ds9876'
def test_has_signed_in(db):
dave = students_model.Students(db, 3)
assert dave.has_signed_in()
grommash = students_model.Students(db, 5)
assert not grommash.has_signed_in()
def test_get_uni_nonexistant_student(self):
invalid_id = 9999
student = sm.Students(sid=invalid_id)
uni = student.get_uni()
self.assertFalse(uni)
