def get(self, sessionId):
user = users.get_current_user()
if user:
session = models.Session.get_by_id(int(sessionId))
if session and session.observer == user.email():
session_records = models.SessionRecord.all().ancestor(session).fetch(1000)
session_records.sort(key=lambda x: x.startTime)
# Check to see if a note was placed, if not, insert a default placeholder value
if isinstance(session.notes, NoneType) == True:
session.notes = ''
session_notes = ["No Comments$$N/A"]
else:
# Split session.notes string into separate entries (all notes are stored in ONE string)
session_notes = session.notes.split("##")
for i in range(0, len(session_notes)):
session_notes[i] = session_notes[i].split("$$")
for sr in session_records:
sr.totalSeconds = sr.endTime - sr.startTime
self.response.write(riot_utils.render_template('templates/session_records.html', {
'session': session,
'session_records': session_records,
'session_notes': session_notes
}))
else:
self.response.write({'error': 'invalid session id'})
else:
self.redirect(users.create_login_url(self.request.uri))
def get(self):
user = users.get_current_user()
if user:
sessions = models.get_sessions_for_user(user)
self.response.write(riot_utils.render_template('templates/sessions.html', {
'sessions': sessions
}))
else:
self.redirect(users.create_login_url(self.request.uri))
def get(self):
user = users.get_current_user()
if user:
self.response.write(riot_utils.render_template('templates/home.html', {
'user': user,
'test': 'loof'
}))
else:
self.redirect(users.create_login_url(self.request.uri))
def get(self, sessionId):
user = users.get_current_user()
#Code to package a grid to send to session template
grid_dimension = 10
Num_students = grid_dimension**2
student_list = []
student_grid = []
for i in range(0,Num_students):
student_list.append('Student '+str(i+1))
grid_counter = 0
for i in range(0,grid_dimension):
grid_entry = []
for j in range(0,grid_dimension):
grid_entry.append(student_list[grid_counter])
grid_counter += 1
student_grid.append(grid_entry)
# End code to package a grid to send to session template
if user:
session = models.Session.get_by_id(int(sessionId))
if session and user.email() == session.observer:
query = models.InteractionGroup.all()
interactionGroups = query.run()
interactions = []
choral_response = []
for interaction in interactionGroups:
interactionItems = models.InteractionItem.all().order("order").ancestor(interaction).fetch(1000)
interactions.append(InteractionGroupItems(interaction, interactionItems))
for item in interactionItems:
if item.name == "Small group time":
groupId = item.parent().key().id()
itemId = item.key().id()
color = item.color
sg_time = [groupId,itemId,color]
self.response.write(riot_utils.render_template('templates/session.html', {
'session': session,
'interactions': interactions,
'students': student_grid,
'sg_time': sg_time
}))
else:
self.response.write({'error': 'invalid session id'})
else:
self.redirect(users.create_login_url(self.request.uri))
def get(self):
user = users.get_current_user()
if user:
query = models.InteractionGroup.all()
interactionGroups = query.run()
interactions = []
for interaction in interactionGroups:
interactionItems = models.InteractionItem.all().ancestor(interaction).fetch(1000)
interactions.append(InteractionGroupItems(interaction, interactionItems))
self.response.write(riot_utils.render_template('templates/interactions.html', {
'user': user,
'interactions': interactions
}))
else:
self.redirect(users.create_login_url(self.request.uri))
def get(self, sessionId):
user = users.get_current_user()
if user:
session = models.Session.get_by_id(int(sessionId))
if session and session.observer == user.email():
session_records = models.SessionRecord.all().ancestor(session).fetch(1000)
for sr in session_records:
sr.totalSeconds = sr.endTime - sr.startTime
self.response.write(riot_utils.render_template('templates/session_records.html', {
'session': session,
'session_records': session_records
}))
else:
self.response.write({'error': 'invalid session id'})
else:
self.redirect(users.create_login_url(self.request.uri))
def get(self):
user = users.get_current_user()
if user:
sessions = models.get_sessions_for_user(user)
sessions.sort(key=lambda x: x.date)
# Convert from UTC to PST
for session in sessions:
date_utc = session.date
date_pst = datetime.datetime.fromtimestamp(time.mktime(date_utc.timetuple()), Pacific_tzinfo())
session.date = date_pst
session.put()
self.response.write(riot_utils.render_template('templates/sessions.html', {
'sessions': sessions
}))
else:
self.redirect(users.create_login_url(self.request.uri))
def get(self, sessionId):
user = users.get_current_user()
if user:
session = models.Session.get_by_id(int(sessionId))
if session and user.email() == session.observer:
query = models.InteractionGroup.all()
interactionGroups = query.run()
interactions = []
for interaction in interactionGroups:
interactionItems = models.InteractionItem.all().ancestor(interaction).fetch(1000)
interactions.append(InteractionGroupItems(interaction, interactionItems))
self.response.write(riot_utils.render_template('templates/session.html', {
'session': session,
'interactions': interactions
}))
else:
self.response.write({'error': 'invalid session id'})
else:
self.redirect(users.create_login_url(self.request.uri))
def get(self):
user = users.get_current_user()
if user:
self.response.write(riot_utils.render_template('templates/new_session.html', {}))
else:
self.redirect(users.create_login_url(self.request.uri))
def get(self, sessionId):
user = users.get_current_user()
if user:
session = models.Session.get_by_id(int(sessionId))
session_count_array = []
for i in range(1,101):
if ('Student' + ' '+ str(i) ) in session.studentcounts:
session_count_array.append( ( ( session.studentcounts[ ('Student' + ' '+ str(i) ) ] ), 'btn-black' ) )
else:
session_count_array.append((0,'btn-grey'))
session_count_map = []
for i in range(0,100,10):
session_count_map.append( (session_count_array[i:i+10] ) )
if session and session.observer == user.email():
session_records = models.SessionRecord.all().ancestor(session).fetch(1000)
session_records.sort(key = lambda x:x.startTime)
session_start = session_records[0].startTime
session_end = session_records[-1].endTime
session_dur = session_end - session_start
student_counts = session.studentcounts
color_map = {} #Create the color mappings, for converting names like btn-red to hex codes for plotting
color_map["btn-grey"] = "#a5a5a5"
color_map["btn-blue"] = "#0084cc"
color_map["btn-lightblue"] = "#bbd5dc"
color_map["btn-green"] = "#5e933d"
color_map["btn-darkgreen"] = "#435a3e"
color_map["btn-lightgreen"] = "#92bc89"
color_map["btn-red"] = "#f40000"
color_map["btn-orange"] = "#e58900"
color_map["btn-yellow"] = "#e4e11f"
color_map["btn-black"] = "#000000"
color_map["btn-purple"] = "#dc18b5"
color_map["btn-lightpurple"] = "#d7a8ff"
color_map["btn-success"] = "#62c462"
# These lists below are for timelines
student_actions = []
student_colors = []
teacher_actions = []
teacher_colors = []
ind_student_actions = []
# These are for pie charts (dictionaries/arrays)
mode_dict = {}
mode_plot = []
student_activity = {}
student_activity_plot = []
teacher_activity = {}
teacher_activity_plot = []
# Create dict for time spent between student/teacher
student_teacher = {}
student_teacher["Teacher"] = 0
student_teacher["Students"] = 0
student_teacher_plot = []
# Create student participation array for pie chart
student_plot = []
for item in student_counts:
student_plot.append([item,student_counts[item]])
session_start = session_records[0].startTime
counter = 0
for sr in session_records:
# Get relevant information from each session record
int_start = sr.startTime - session_start
int_end = sr.endTime - session_start
int_dur = str(int_start)+'-'+str(int_end)+' s'
total_seconds = sr.endTime - sr.startTime
int_item = sr.interactionItem.name
actor = sr.actor
mode = sr.mode
color = color_map[sr.color]
#print int_item, sr.color, color
# Sum up all the times spent in each mode
if mode in mode_dict:
mode_dict[mode] += total_seconds
else:
mode_dict[mode] = total_seconds
if actor == "Students" or actor.split()[0] == "Student":
# Add time into student teacher times
student_teacher["Students"] += total_seconds
# add up student interaction times
if (int_item,color) in student_activity:
student_activity[(int_item,color)] += total_seconds
else:
student_activity[(int_item,color)] = total_seconds
# Fill arrays for TOTAL student timeline
if int_start != 0 and len(student_actions) == 0:
student_actions.append(("Students", counter, 0, int_start, "transparent"))
counter -= 1
student_actions.append(("Students",int_item+' ('+int_dur+ ')',int_start, int_end, color))
#Fill in dictionary for INDIVIDUAL student timeline
if actor.split()[0] == "Student":
ind_student_actions.append((actor, int_item+' ('+int_dur+ ')', int_start, int_end, color))
elif actor == "Teacher":
student_teacher["Teacher"] += total_seconds # Add time into student teacher times
if (int_item,color) in teacher_activity:
teacher_activity[(int_item,color)] += total_seconds
else:
teacher_activity[(int_item,color)] = total_seconds
if int_start != 0 and len(teacher_actions) == 0:
teacher_actions.append(("Teacher", counter, 0, int_start,"transparent"))
counter -= 1
teacher_actions.append(("Teacher",int_item+' ('+int_dur+ ')',int_start,int_end,color))
counter += 1
# Add in the last whitespace between end of last session entry and absolute end of session
if len(student_actions) != 0:
if student_actions[-1][3] != session_dur:
last_end_time = student_actions[-1][3]
student_actions.append(("Students", counter,last_end_time, session_dur,"transparent"))
else:
student_actions = [("Students","None",0,0,"transparent")]
if len(teacher_actions) != 0:
if teacher_actions[-1][3] != session_dur:
last_end_time = teacher_actions[-1][3]
teacher_actions.append(("Teacher", counter, last_end_time, session_dur,"transparent"))
else:
teacher_actions = [("Teacher","None",0,0,"transparent")]
# Place dictionary items in a list for easier plotting via javascript
for key in mode_dict:
mode_plot.append([key,mode_dict[key]])
for key in student_teacher:
student_teacher_plot.append([key,student_teacher[key]])
for key in student_activity:
student_activity_plot.append([key,student_activity[key]])
for key in teacher_activity:
teacher_activity_plot.append([key,teacher_activity[key]])
# Sort the arrays in which color IS important, this helps keep the plot colors in order
ind_student_actions = sorted(ind_student_actions, key=lambda x: x[0])
student_activity_plot = sorted(student_activity_plot, key=lambda x: x[0][1])
teacher_activity_plot = sorted(teacher_activity_plot, key=lambda x: x[0][1])
self.response.write(riot_utils.render_template('templates/session_charts.html', {
'student_actions': student_actions,
'teacher_actions': teacher_actions,
'ind_student_actions': ind_student_actions,
'mode_plot': mode_plot,
'student_plot': student_plot,
'student_teacher_plot': student_teacher_plot,
'student_activity_plot': student_activity_plot,
'teacher_activity_plot': teacher_activity_plot,
'session_count_map': session_count_map
}))
if not session:
self.response.write({'error': 'no session with id: ' + sessionId})
return
if not session.observer == user.email():
self.response.write({'error': 'not authorized'})
return
# checks pass
else:
self.response.write({'error': 'must be logged in'})
