def run(self):
query = StudentAnswersEntity.all().run(limit=600)
for ans_ent in query:
ans_dict = transforms.loads(ans_ent.data)
for assessment, answers in ans_dict.iteritems():
student = Student.all().filter('user_id',
ans_ent.key().name()).get()
s_scores = transforms.loads(student.scores)
d = {
'email': student.key().name(),
'assessment': assessment,
'score': s_scores.get(assessment, '?????? wtf'),
}
for answer in answers:
k = 'q%d' % (answer['index'] + 1)
if answer['correct']:
d[k] = 'correct'
else:
if isinstance(answer['value'], int):
d[k] = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'[
answer['value']]
else:
d[k] = ''
yield d
def run(self):
"""Computes student statistics."""
enrollment = EnrollmentAggregator()
scores = ScoresAggregator()
names = NamesAggregator()
mapper = utils.QueryMapper(Student.all(),
batch_size=500,
report_every=1000)
def map_fn(student):
enrollment.visit(student)
scores.visit(student)
names.visit(student)
mapper.run(map_fn)
data = {
'enrollment': {
'enrolled': enrollment.enrolled,
'unenrolled': enrollment.unenrolled
},
'scores': scores.name_to_tuple,
'id': names.st_id
}
return data
def post(self):
user = self.personalizePageAndGetUser()
if not user:
self.redirect(users.create_login_url(self.request.uri))
return
if (MAX_CLASS_SIZE and Student.all(keys_only=True).count() >= MAX_CLASS_SIZE):
self.templateValue['course_status'] = 'full'
else:
# Create student record
name = self.request.get('form01')
# create new or re-enroll old student
student = Student.get_by_email(user.email())
if student:
if not student.is_enrolled:
student.is_enrolled = True
student.name = name
else:
student = Student(key_name=user.email(), name=name, is_enrolled=True)
student.put()
# Render registration confirmation page
self.templateValue['navbar'] = {'registration': True}
self.render('confirmation.html')
def run(self):
query = Student.all().filter('is_participant', True).run(limit=600)
for student in query:
yield {
'email': student.key().name(),
'group_id': student.group_id,
}
def run(self):
"""Computes student statistics."""
enrollment = EnrollmentAggregator()
scores = ScoresAggregator()
student_scores = StudentAggregator()
feedback = PostcourseAggregator()
mapper = utils.QueryMapper(
Student.all(), batch_size=500, report_every=1000)
def map_fn(student):
enrollment.visit(student)
scores.visit(student)
student_scores.visit(student)
mapper.run(map_fn)
mapper = utils.QueryMapper(
StudentAnswersEntity.all(), batch_size=500, report_every=1000)
def map_fn1(student):
feedback.visit(student)
mapper.run(map_fn1)
data = {
'enrollment': {
'enrolled': enrollment.enrolled,
'unenrolled': enrollment.unenrolled},
'scores': scores.name_to_tuple,
'students' : student_scores.name_to_tuple,
'feedback' : feedback.name_to_tuple}
return data
def run(self):
query = Student.all().filter('is_participant', True).run(limit=600)
for student in query:
yield {
'email': student.key().name(),
'group_id': student.group_id,
}
def get_student_count():
count = generalcounter.get_count(PARTICIPANT_COUNT)
if not count:
count = Student.all(keys_only=True).filter("is_participant",
True).count(limit=10000)
generalcounter.increment(PARTICIPANT_COUNT, by=count)
return count
def run(self):
"""Computes student statistics."""
enrollment = EnrollmentAggregator()
scores = ScoresAggregator()
names = NamesAggregator()
mapper = utils.QueryMapper(
Student.all(), batch_size=500, report_every=1000)
def map_fn(student):
enrollment.visit(student)
scores.visit(student)
names.visit(student)
mapper.run(map_fn)
data = {
'enrollment': {
'enrolled': enrollment.enrolled,
'unenrolled': enrollment.unenrolled},
'scores': scores.name_to_tuple,
'id': names.st_id
}
return data
def run(self):
query = Student.all().filter('is_participant =', True).run(limit=600)
unit = self.unit
for student in query:
# TODO use defaultdict('') instead of local vars?
unit_page = WikiPage.get_page(student, unit=unit)
posted_unit = bool(unit_page)
num_endorsements = num_exemplaries = num_comments = ''
if unit_page:
num_endorsements = Annotation.endorsements(
what=unit_page).count()
num_exemplaries = Annotation.exemplaries(
what=unit_page).count()
num_comments = WikiComment.all().filter('topic',
unit_page).count()
fields = viewable_model(unit_page)
else:
fields = {}
num_given = Annotation.endorsements(who=student, unit=unit).count()
exemps_given = Annotation.exemplaries(who=student,
unit=unit).count()
info = {
'email':
student.key().name(),
'name':
student.name,
'unit':
unit,
'group_id':
student.group_id,
'posted_unit':
posted_unit,
'endorsements_received':
num_endorsements,
'endorsements_given':
num_given,
'exemplaries_received':
num_exemplaries,
'exemplaries_given':
exemps_given,
'num_comments':
num_comments,
'link':
Markup('<a href="%s%s?%s">link</a>') %
(self.request.host_url, '/wiki',
urllib.urlencode({
'unit': unit,
'student': student.wiki_id,
'action': 'view'
})),
}
info.update(
{k: re.sub(r'<[^>]*?>', '', v)
for k, v in fields.items()})
#info.update(fields)
yield info
def get(self):
if not(Roles.is_course_admin(self.app_context)):
self.redirect("preview")
self.response.headers['Content-type'] = 'text/csv'
self.response.headers['Content-disposition'] = 'attachment; filename=students.csv'
course = self.get_course()
assessments=[]
for unit in course.get_units():
if (unit.type=="A"):
assessments.append(str(unit.unit_id))
writer = UnicodeWriter(self.response.out)
keys = Student.all(keys_only=True).run()
rows=[]
for key in keys:
student=Student.get_by_key_name(key.name())
rec={"email": key.name(), "name": student.name, "enrolled": unicode(student.is_enrolled), "dateEnrolled": unicode(student.enrolled_on) }
if (student.scores):
scores=json.loads(student.scores)
for assessmentName, score in scores.iteritems():
rec[assessmentName]=str(score)
rows.append(rec)
headerRow = ["Email", "Name", "Is Enrolled", "Enrolled On"]
for assessmentName in assessments:
headerRow.append(course.find_unit_by_id(assessmentName).title)
writer.writerow(headerRow)
for row in rows:
renderedRow=[row["email"],row["name"],row["enrolled"],row["dateEnrolled"]]
for assessmentName in assessments:
if (assessmentName in row):
renderedRow.append(row[assessmentName])
else:
renderedRow.append("")
writer.writerow(renderedRow)
def run(self):
for s in Student.all().run(limit=9999):
d = db.to_dict(s)
d['email'] = s.key().name()
if d.get('is_participant', False):
d['can_use_location'] = find_can_use_location(s)
for p in d.keys():
if type(d[p]) is list:
d[p] = u", ".join(d[p])
yield d
def run(self):
for s in Student.all().run(limit=9999):
d = db.to_dict(s)
d['email'] = s.key().name()
if d.get('is_participant', False):
d['can_use_location'] = find_can_use_location(s)
for p in d.keys():
if type(d[p]) is list:
d[p] = u", ".join(d[p])
yield d
def run(self):
"""Computes student statistics."""
enrollment = self.EnrollmentAggregator()
scores = self.ScoresAggregator()
mapper = models_utils.QueryMapper(Student.all(), batch_size=500, report_every=1000)
def map_fn(student):
enrollment.visit(student)
scores.visit(student)
mapper.run(map_fn)
data = {
"enrollment": {"enrolled": enrollment.enrolled, "unenrolled": enrollment.unenrolled},
"scores": scores.name_to_tuple,
}
return data
def run(self):
query = Student.all().filter('is_participant =', True).run(limit=600)
unit = self.unit
for student in query:
# TODO use defaultdict('') instead of local vars?
unit_page = WikiPage.get_page(student, unit=unit)
posted_unit = bool(unit_page)
num_endorsements = num_exemplaries = num_comments = ''
if unit_page:
num_endorsements = Annotation.endorsements(what=unit_page).count()
num_exemplaries = Annotation.exemplaries(what=unit_page).count()
num_comments = WikiComment.all().filter('topic', unit_page).count()
fields = viewable_model(unit_page)
else:
fields = {}
num_given = Annotation.endorsements(who=student, unit=unit).count()
exemps_given = Annotation.exemplaries(who=student, unit=unit).count()
info = {
'email': student.key().name(),
'name': student.name,
'unit': unit,
'group_id': student.group_id,
'posted_unit': posted_unit,
'endorsements_received': num_endorsements,
'endorsements_given': num_given,
'exemplaries_received': num_exemplaries,
'exemplaries_given': exemps_given,
'num_comments': num_comments,
'link': Markup('<a href="%s%s?%s">link</a>') % (
self.request.host_url,
'/wiki',
urllib.urlencode({
'unit': unit,
'student': student.wiki_id,
'action': 'view'
})),
}
info.update({k: re.sub(r'<[^>]*?>', '', v) for k, v in fields.items()})
#info.update(fields)
yield info
def post(self):
user = users.get_current_user()
if user:
email = user.email()
self.templateValue["email"] = email
self.templateValue["logoutUrl"] = users.create_logout_url("/")
# Restrict the maximum course size to 250000 people
# FIXME: you can change this number if you wish.
students = Student.all(keys_only=True)
if students.count() > 249999:
self.templateValue["course_status"] = "full"
# Create student record
name = self.request.get("form01")
student = Student(key_name=user.email(), name=name)
student.put()
# Render registration confirmation page
navbar = {"registration": True}
self.templateValue["navbar"] = navbar
self.render("confirmation.html")
def post(self):
user = users.get_current_user()
if user:
email = user.email()
self.templateValue['email'] = email
self.templateValue['logoutUrl'] = users.create_logout_url('/')
# Restrict the maximum course size to 250000 people
# FIXME: you can change this number if you wish.
students = Student.all(keys_only=True)
if (students.count() > 249999):
self.templateValue['course_status'] = 'full'
# Create student record
name = self.request.get('form01')
student = Student(key_name=user.email(), name=name)
student.put()
# Render registration confirmation page
navbar = {'registration': True}
self.templateValue['navbar'] = navbar
self.render('confirmation.html')
def post(self):
user = users.get_current_user()
if user:
email = user.email()
self.templateValue['email'] = email
self.templateValue['logoutUrl'] = users.create_logout_url('/')
# Restrict the maximum course size to 250000 people
# FIXME: you can change this number if you wish.
students = Student.all(keys_only=True)
if (students.count() > 249999):
self.templateValue['course_status'] = 'full'
# Create student record
name = self.request.get('form01')
student = Student(key_name=user.email(), name=name)
student.put()
# Render registration confirmation page
navbar = {'registration': True}
self.templateValue['navbar'] = navbar
self.render('confirmation.html')
def run(self):
query = StudentAnswersEntity.all().run(limit=600)
for ans_ent in query:
ans_dict = transforms.loads(ans_ent.data)
for assessment, answers in ans_dict.iteritems():
student = Student.all().filter('user_id', ans_ent.key().name()).get()
s_scores = transforms.loads(student.scores)
d = {
'email': student.key().name(),
'assessment': assessment,
'score': s_scores.get(assessment, '?????? wtf'),
}
for answer in answers:
k = 'q%d' % (answer['index'] + 1)
if answer['correct']:
d[k] = 'correct'
else:
if isinstance(answer['value'], int):
d[k] = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'[answer['value']]
else:
d[k] = ''
yield d
def get_students(self):
"""CGL-MOOC-Builder: return all students"""
everyone = Student.all()
return everyone
def get_students(self):
everyone = Student.all()
return everyone
def get_students(self):
everyone = Student.all()
return everyone
def get(self):
"""Handles GET requests."""
if not self.personalize_page_and_get_enrolled():
return
self.template_value['navbar'] = {'statistics': True}
#cogemos unidades, lecciones y alumnos
unidades = self.get_units()
alumnos = [s for s in Student.all()]
curso = self.get_course()
# dicceionarios auxliares para calculos intermedios
media_examen = {}
count_examen = {}
examen_completado = {}
#**** VARIABLES FINALES
units = []
assessments = []
students = { 'total': 0, 'last_week': 0, 'last_month': 0 }
#**** UNIDADES Y LECCIONES
# Creamos estructura de unidades > lecciones para posteriormente realizar tracking de alumnos
for unit in unidades:
if unit.type == 'U': # si es unidad, cogemos actividades y creamos objeto
lecciones = curso.get_lessons(unit.unit_id)
my_lessons = []
for lesson in lecciones:
my_lessons.append({'id': lesson.lesson_id, 'title': lesson.title, 'students': 0})
units.append({ 'id': int(unit.unit_id), 'title': unit.title, 'students': 0, 'lessons': my_lessons })
if unit.type == 'A':
assessments.append({ 'id': unit.unit_id, 'title': unit.title, 'studentsCompleted': 0, 'studentsDone': 0, 'average': 0})
#**** ALUMNOS
count_alumnos = len(alumnos)
alumnos_week = 0
alumnos_month = 0
last_week = datetime.datetime.now() - datetime.timedelta(days=7)
last_month = datetime.datetime.now() - datetime.timedelta(days=30)
for alumno in alumnos:
students['total'] += 1
if alumno.enrolled_on >= last_week:
students['last_week'] += 1
if alumno.enrolled_on >= last_month:
students['last_month'] += 1
# Scores del alumno
scores = curso.get_all_scores(alumno)
for score in scores: # hacemos conteos y acumulaciones para las notas medias
if score['completed'] == True:
examen_completado[score['id']] = examen_completado.get(score['id'], 0) + 1
media_examen[score['id']] = media_examen.get(score['id'], 0) + score['score']
count_examen[score['id']] = count_examen.get(score['id'], 0) + 1
# Tracking del alumno
for unit in units:
tracker = curso.get_progress_tracker()
progress = tracker.get_or_create_progress(alumno)
lecciones_hechas = 0
lecciones_total = 0
for lesson in unit['lessons']:
lecciones_total += 1
if(tracker.get_html_status(progress, unit['id'], lesson['id'])): #lección hecha
lecciones_hechas += 1
lesson['students'] += 1
if(lecciones_hechas == lecciones_total):
unit['students'] += 1
# Calculamos las notas medias
for asm in assessments:
if(media_examen[asm['id']] > 0):
asm['average'] = media_examen[asm['id']] / count_examen[asm['id']]
asm['studentsCompleted'] = examen_completado.get(asm['id'], 0)
"""Insertamos las variables de estadisticas"""
self.template_value['units'] = units
self.template_value['assessments'] = assessments
self.template_value['students'] = students
self.render('statistics.html')
