def generate_contract_file(self): report = TemplateReport() report.data['contract'] = self report.filename = unicode(self.company) + "_contract" if settings.PREFERED_FORMAT == "m": report.file_format = "doc" else: report.file_format = "odt" if self.company and self.company.alternative_contract_template: template = self.company.alternative_contract_template.file else: template = Template.get_or_make_blank(name="Work Study Contract").file.path if template : report_file = report.pod_save(template, get_tmp_file=True) self.contract_file.save(unicode(self.company) + "." + unicode(report.file_format), File(open(report_file)))
def generate_contract_file(self): report = TemplateReport() report.data['contract'] = self report.filename = unicode(self.company) + "_contract" if settings.PREFERED_FORMAT == "m": report.file_format = "doc" else: report.file_format = "odt" if self.company and self.company.alternative_contract_template: template = self.company.alternative_contract_template.file else: template = Template.get_or_make_blank(name="Work Study Contract").file.path if template : report_file = report.pod_save(template, get_tmp_file=True) self.contract_file.save(unicode(self.company) + "." + unicode(report.file_format), File(open(report_file)))
def download_student_results(self, test, format, template, cohorts=None): """ Make appy based report showing results for each student """ report = TemplateReport() report.file_format = format if cohorts: test_instances = test.active_testinstance_set.filter( student__cohort__in=cohorts).distinct() else: test_instances = test.active_testinstance_set.all() benchmarks = Benchmark.objects.filter(question__test=test).distinct() for benchmark in benchmarks: benchmark.points_possible = test.question_set.filter( benchmarks=benchmark).aggregate( Sum('point_value'))['point_value__sum'] # aggregate() may return None, which will raise a TypeError upon attempting arithmetic if benchmark.points_possible is None: benchmark.points_possible = 0 for test_instance in test_instances: benchmark_instances = [] for benchmark in benchmarks: benchmark_instance = Struct() benchmark_instance.benchmark = benchmark benchmark_instance.points_possible = benchmark.points_possible benchmark_instance.answers = test_instance.answerinstance_set.filter( question__benchmarks=benchmark) benchmark_instance.points_earned = benchmark_instance.answers.aggregate( Sum('points_earned'))['points_earned__sum'] # aggregate() may return None, which will raise a TypeError upon attempting arithmetic if benchmark_instance.points_earned is None: benchmark_instance.points_earned = 0 benchmark_instance.questions = '' for answer in benchmark_instance.answers.all(): benchmark_instance.questions += '{}, '.format( answer.question.get_order_start_one) benchmark_instance.questions = benchmark_instance.questions[: -2] benchmark_instances.append(benchmark_instance) test_instance.benchmarks = benchmark_instances test_instance.incorrects = test_instance.answerinstance_set.filter( points_earned__lt=F('points_possible')) for incorrect in test_instance.incorrects: incorrect.benchmarks = '' for benchmark in incorrect.question.benchmarks.all(): incorrect.benchmarks += '{}, '.format(benchmark.number) incorrect.benchmarks = incorrect.benchmarks[:-2] try: incorrect.right_answer = incorrect.question.answer_set.order_by( 'point_value').reverse()[0] except: incorrect.right_answer = "No correct answer" report.data['test'] = test report.data['tests'] = test_instances report.filename = 'Student Results for ' + unicode(test) return report.pod_save(template)
def download_student_results(self, test, format, template): """ Make appy based report showing results for each student """ report = TemplateReport() report.file_format = format test_instances = test.testinstance_set.all() benchmarks = Benchmark.objects.filter(question__test=test) for benchmark in benchmarks: benchmark.points_possible = test.question_set.filter(benchmarks=benchmark).aggregate(Sum('point_value'))['point_value__sum'] for test_instance in test_instances: benchmark_instances = [] for benchmark in benchmarks: benchmark_instance = Struct() benchmark_instance.benchmark = benchmark benchmark_instance.points_possible = benchmark.points_possible benchmark_instance.points_earned = test_instance.answerinstance_set.filter(question__benchmarks=benchmark).aggregate(Sum('points_earned'))['points_earned__sum'] benchmark_instances.append(benchmark_instance) test_instance.benchmarks = benchmark_instances test_instance.incorrects = test_instance.answerinstance_set.filter(points_earned__lt=F('points_possible')) for incorrect in test_instance.incorrects: try: incorrect.right_answer = incorrect.question.answer_set.order_by('point_value').reverse()[0] except: incorrect.right_answer = "No correct answer" report.data['test'] = test report.data['tests'] = test_instances report.filename = 'Student Results for ' + unicode(test) return report.pod_save(template)
def download_teacher_results(self, test, format, template): """ Make appy based report showing results for a whole class """ report = TemplateReport() report.file_format = format test_instances = test.testinstance_set.annotate(Sum('answerinstance__points_earned')) test.benchmarks = Benchmark.objects.filter(question__test=test).distinct() points_possible = test.points_possible points_to_earn = 0.70 * test.points_possible number_above_70 = test_instances.filter(answerinstance__points_earned__sum__gte=points_to_earn).count() total_test_takers = test.testinstance_set.filter(answerinstance__points_earned__gt=0).distinct().count() test.percent_over_70 = float(number_above_70) / total_test_takers for benchmark in test.benchmarks: question_benchmarks = test.question_set.filter(benchmarks=benchmark) benchmark.points_possible = question_benchmarks.aggregate(Sum('point_value'))['point_value__sum'] benchmark.total_points_possible = benchmark.points_possible * test_instances.count() benchmark.total_points_earned = question_benchmarks.aggregate(Sum('answerinstance__points_earned'))['answerinstance__points_earned__sum'] benchmark.average = float(benchmark.total_points_earned) / benchmark.total_points_possible # Percent students over 70% test_instances_over_70 = 0 for test_instance in test_instances: answers = test_instance.answerinstance_set.filter(question__benchmarks=benchmark) answers_points = answers.aggregate(Sum('points_earned'), Sum('points_possible')) instance_points_earned = answers_points['points_earned__sum'] instance_points_possible = answers_points['points_possible__sum'] instance_average = float(instance_points_earned) / instance_points_possible if instance_average >= 0.70: test_instances_over_70 += 1 benchmark.over_70 = float(test_instances_over_70) / test_instances.count() benchmark.assessed_on = "" for question_benchmark in question_benchmarks: benchmark.assessed_on += "{}, ".format(question_benchmark.get_order_start_one) benchmark.assessed_on = benchmark.assessed_on[:-2] test.questions = test.question_set.all() for question in test.questions: question.benchmark_text = '' for benchmark in question.benchmarks.all(): question.benchmark_text += '{}, '.format(benchmark.number) question.benchmark_text = question.benchmark_text[:-2] question.num_correct = question.answerinstance_set.filter(points_earned__gte=F('points_possible')).count() question.num_total = question.answerinstance_set.count() question.percent_correct = float(question.num_correct) / question.num_total report.data['test'] = test report.data['tests'] = test_instances report.filename = 'Teacher Results for ' + unicode(test) return report.pod_save(template)
def download_student_results(self, test, format, template, cohorts=None): """ Make appy based report showing results for each student """ report = TemplateReport() report.file_format = format if cohorts: test_instances = test.active_testinstance_set.filter(student__cohort__in=cohorts).distinct() else: test_instances = test.active_testinstance_set.all() benchmarks = Benchmark.objects.filter(question__test=test).distinct() for benchmark in benchmarks: benchmark.points_possible = test.question_set.filter(benchmarks=benchmark).aggregate(Sum('point_value'))['point_value__sum'] # aggregate() may return None, which will raise a TypeError upon attempting arithmetic if benchmark.points_possible is None: benchmark.points_possible = 0 for test_instance in test_instances: benchmark_instances = [] for benchmark in benchmarks: benchmark_instance = Struct() benchmark_instance.benchmark = benchmark benchmark_instance.points_possible = benchmark.points_possible benchmark_instance.answers = test_instance.answerinstance_set.filter(question__benchmarks=benchmark) benchmark_instance.points_earned = benchmark_instance.answers.aggregate(Sum('points_earned'))['points_earned__sum'] # aggregate() may return None, which will raise a TypeError upon attempting arithmetic if benchmark_instance.points_earned is None: benchmark_instance.points_earned = 0 benchmark_instance.questions = '' for answer in benchmark_instance.answers.all(): benchmark_instance.questions += '{}, '.format(answer.question.get_order_start_one) benchmark_instance.questions = benchmark_instance.questions[:-2] benchmark_instances.append(benchmark_instance) test_instance.benchmarks = benchmark_instances test_instance.incorrects = test_instance.answerinstance_set.filter(points_earned__lt=F('points_possible')) for incorrect in test_instance.incorrects: incorrect.benchmarks = '' for benchmark in incorrect.question.benchmarks.all(): incorrect.benchmarks += '{}, '.format(benchmark.number) incorrect.benchmarks = incorrect.benchmarks[:-2] try: incorrect.right_answer = incorrect.question.answer_set.order_by('point_value').reverse()[0] except: incorrect.right_answer = "No correct answer" report.data['test'] = test report.data['tests'] = test_instances report.filename = 'Student Results for ' + unicode(test) return report.pod_save(template)
def download_student_results(self, test, format, template): """ Make appy based report showing results for each student """ report = TemplateReport() report.file_format = format test_instances = test.active_testinstance_set.all() benchmarks = Benchmark.objects.filter(question__test=test).distinct() for benchmark in benchmarks: benchmark.points_possible = test.question_set.filter(benchmarks=benchmark).aggregate(Sum("point_value"))[ "point_value__sum" ] for test_instance in test_instances: benchmark_instances = [] for benchmark in benchmarks: benchmark_instance = Struct() benchmark_instance.benchmark = benchmark benchmark_instance.points_possible = benchmark.points_possible benchmark_instance.answers = test_instance.answerinstance_set.filter(question__benchmarks=benchmark) benchmark_instance.points_earned = benchmark_instance.answers.aggregate(Sum("points_earned"))[ "points_earned__sum" ] benchmark_instance.questions = "" for answer in benchmark_instance.answers.all(): benchmark_instance.questions += "{}, ".format(answer.question.get_order_start_one) benchmark_instance.questions = benchmark_instance.questions[:-2] benchmark_instances.append(benchmark_instance) test_instance.benchmarks = benchmark_instances test_instance.incorrects = test_instance.answerinstance_set.filter(points_earned__lt=F("points_possible")) for incorrect in test_instance.incorrects: incorrect.benchmarks = "" for benchmark in incorrect.question.benchmarks.all(): incorrect.benchmarks += "{}, ".format(benchmark.number) incorrect.benchmarks = incorrect.benchmarks[:-2] try: incorrect.right_answer = incorrect.question.answer_set.order_by("point_value").reverse()[0] except: incorrect.right_answer = "No correct answer" report.data["test"] = test report.data["tests"] = test_instances report.filename = "Student Results for " + unicode(test) return report.pod_save(template)
def download_student_results(self, test, format, template): """ Make appy based report showing results for each student """ report = TemplateReport() report.file_format = format test_instances = test.testinstance_set.all() benchmarks = Benchmark.objects.filter(question__test=test) for benchmark in benchmarks: benchmark.points_possible = test.question_set.filter( benchmarks=benchmark).aggregate( Sum('point_value'))['point_value__sum'] for test_instance in test_instances: benchmark_instances = [] for benchmark in benchmarks: benchmark_instance = Struct() benchmark_instance.benchmark = benchmark benchmark_instance.points_possible = benchmark.points_possible benchmark_instance.points_earned = test_instance.answerinstance_set.filter( question__benchmarks=benchmark).aggregate( Sum('points_earned'))['points_earned__sum'] benchmark_instances.append(benchmark_instance) test_instance.benchmarks = benchmark_instances test_instance.incorrects = test_instance.answerinstance_set.filter( points_earned__lt=F('points_possible')) for incorrect in test_instance.incorrects: try: incorrect.right_answer = incorrect.question.answer_set.order_by( 'point_value').reverse()[0] except: incorrect.right_answer = "No correct answer" report.data['test'] = test report.data['tests'] = test_instances report.filename = 'Student Results for ' + unicode(test) return report.pod_save(template)
def download_teacher_results(self, test, format, template, cohorts=None): """ Make appy based report showing results for a whole class """ if not cohorts: cohorts = Cohort.objects.all() # Stupid f*****g hack subquery = test.testinstance_set.filter(student__cohort__in=cohorts).distinct() report = TemplateReport() report.file_format = format test_instances = test.active_testinstance_set.filter(answerinstance__points_earned__gt=0).filter(pk__in=subquery).annotate(Sum('answerinstance__points_earned')) test.benchmarks = Benchmark.objects.filter(question__test=test).distinct() points_possible = test.points_possible points_to_earn = 0.70 * test.points_possible number_gte_70 = test_instances.filter(pk__in=subquery).filter(answerinstance__points_earned__sum__gte=points_to_earn).count() total_test_takers = test_instances.filter(pk__in=subquery).filter(answerinstance__points_earned__gt=0).distinct().count() if total_test_takers: test.percent_gte_70 = float(number_gte_70) / total_test_takers else: test.percent_gte_70 = 0 test.report_average = test.get_average(cohorts=cohorts) for benchmark in test.benchmarks: # TODO: eliminate this subquery? is the idea to eliminate any questions that all students left unanswered? qb_subquery = test.question_set.filter(answerinstance__test_instance__student__cohort__in=cohorts).distinct() question_benchmarks = test.question_set.filter(pk__in=qb_subquery).filter(benchmarks=benchmark).distinct() benchmark.points_possible = question_benchmarks.aggregate(Sum('point_value'))['point_value__sum'] # aggregate() may return None, which will raise a TypeError upon attempting arithmetic if benchmark.points_possible is None: benchmark.points_possible = 0 benchmark.total_points_possible = benchmark.points_possible * test_instances.count() # Really think this should work...but nope. #benchmark.total_points_earned = question_benchmarks.aggregate(Sum('answerinstance__points_earned'))['answerinstance__points_earned__sum'] earned_sum = 0 for question_benchmark in question_benchmarks: for answer in question_benchmark.active_answerinstance_set.filter(test_instance__student__cohort__in=cohorts).distinct(): earned_sum += answer.points_earned benchmark.total_points_earned = earned_sum if benchmark.total_points_possible: benchmark.average = float(benchmark.total_points_earned) / benchmark.total_points_possible else: benchmark.average = 0 # Percent of students scoring at or above 70% test_instances_gte_70 = 0 for test_instance in test_instances: answers = test_instance.answerinstance_set.filter(question__benchmarks=benchmark) answers_points = answers.aggregate(Sum('points_earned'), Sum('points_possible')) instance_points_earned = answers_points['points_earned__sum'] instance_points_possible = answers_points['points_possible__sum'] # aggregate() may return None, which will raise a TypeError upon attempting arithmetic if instance_points_earned is None: instance_points_earned = 0 if instance_points_possible is None: instance_points_possible = 0 if instance_points_earned and instance_points_possible: instance_average = float(instance_points_earned) / instance_points_possible if instance_average >= 0.70: test_instances_gte_70 += 1 if test_instances.count(): benchmark.gte_70 = float(test_instances_gte_70) / test_instances.count() else: benchmark.gte_70 = 0 benchmark.assessed_on = "" for question_benchmark in question_benchmarks: benchmark.assessed_on += "{}, ".format(question_benchmark.get_order_start_one) benchmark.assessed_on = benchmark.assessed_on[:-2] test.questions = test.question_set.all() for question in test.questions: question.benchmark_text = '' for benchmark in question.benchmarks.all(): question.benchmark_text += '{}, '.format(benchmark.number) question.benchmark_text = question.benchmark_text[:-2] # grab all the AnswerInstances that we care about for this question answerinstances = question.answerinstance_set.filter(test_instance__student__cohort__in=cohorts).distinct() # nasty! http://stackoverflow.com/questions/4093910/django-aggregates-sums-in-postgresql-dont-use-distinct-is-this-a-bug/4917507#4917507 answerinstances = question.active_answerinstance_set.filter(pk__in=answerinstances) # calculate the COUNT of correct student responses for this question question.num_correct = answerinstances.filter(points_earned__gte=F('points_possible')).count() # calculate the COUNT of all student responses for this question question.num_total = answerinstances.count() # http://www.merriam-webster.com/dictionary/percent: "cent" means 100, but I'll stick with the existing convention if question.num_total: question.percent_correct = float(question.num_correct) / question.num_total else: question.percent_correct = 0 # calculate the sum of all points earned and the sum of all points possible for this question earned_possible = answerinstances.aggregate(Sum('points_earned'), Sum('points_possible')) question.points_earned = earned_possible['points_earned__sum'] question.points_possible = earned_possible['points_possible__sum'] # aggregate() may return None, which will raise a TypeError upon attempting arithmetic if question.points_earned is None: question.points_earned = 0 if question.points_possible is None: question.points_possible = 0 if question.points_possible: question.percent_points_earned = float(question.points_earned) / question.points_possible else: question.percent_points_earned = 0 # Most common wrong answer most_wrong = question.answerinstance_set.filter( points_earned=0).values( 'answer' ).annotate( count=Count( 'id' ) ).order_by('-count').first() if most_wrong and most_wrong['count'] > 1: question.most_wrong = Answer.objects.get( id=most_wrong['answer'] ).letter question.most_wrong_times = most_wrong['count'] question.most_wrong_verbose = '{} ({})'.format( question.most_wrong, question.most_wrong_times,) else: question.most_wrong = '' question.most_wrong_times = '' question.most_wrong_verbose = '' report.data['test'] = test report.data['tests'] = test_instances report.filename = 'Teacher Results for ' + unicode(test) return report.pod_save(template)
def download_teacher_results(self, test, format, template, cohorts=None): """ Make appy based report showing results for a whole class """ if not cohorts: cohorts = Cohort.objects.all() # Stupid f*****g hack subquery = test.testinstance_set.filter( student__cohort__in=cohorts).distinct() report = TemplateReport() report.file_format = format test_instances = test.active_testinstance_set.filter( answerinstance__points_earned__gt=0).filter( pk__in=subquery).annotate(Sum('answerinstance__points_earned')) test.benchmarks = Benchmark.objects.filter( question__test=test).distinct() points_possible = test.points_possible points_to_earn = 0.70 * test.points_possible number_gte_70 = test_instances.filter(pk__in=subquery).filter( answerinstance__points_earned__sum__gte=points_to_earn).count() total_test_takers = test_instances.filter(pk__in=subquery).filter( answerinstance__points_earned__gt=0).distinct().count() if total_test_takers: test.percent_gte_70 = float(number_gte_70) / total_test_takers else: test.percent_gte_70 = 0 test.report_average = test.get_average(cohorts=cohorts) for benchmark in test.benchmarks: # TODO: eliminate this subquery? is the idea to eliminate any questions that all students left unanswered? qb_subquery = test.question_set.filter( answerinstance__test_instance__student__cohort__in=cohorts ).distinct() question_benchmarks = test.question_set.filter( pk__in=qb_subquery).filter(benchmarks=benchmark).distinct() benchmark.points_possible = question_benchmarks.aggregate( Sum('point_value'))['point_value__sum'] # aggregate() may return None, which will raise a TypeError upon attempting arithmetic if benchmark.points_possible is None: benchmark.points_possible = 0 benchmark.total_points_possible = benchmark.points_possible * test_instances.count( ) # Really think this should work...but nope. #benchmark.total_points_earned = question_benchmarks.aggregate(Sum('answerinstance__points_earned'))['answerinstance__points_earned__sum'] earned_sum = 0 for question_benchmark in question_benchmarks: for answer in question_benchmark.active_answerinstance_set.filter( test_instance__student__cohort__in=cohorts).distinct(): earned_sum += answer.points_earned benchmark.total_points_earned = earned_sum if benchmark.total_points_possible: benchmark.average = float(benchmark.total_points_earned ) / benchmark.total_points_possible else: benchmark.average = 0 # Percent of students scoring at or above 70% test_instances_gte_70 = 0 for test_instance in test_instances: answers = test_instance.answerinstance_set.filter( question__benchmarks=benchmark) answers_points = answers.aggregate(Sum('points_earned'), Sum('points_possible')) instance_points_earned = answers_points['points_earned__sum'] instance_points_possible = answers_points[ 'points_possible__sum'] # aggregate() may return None, which will raise a TypeError upon attempting arithmetic if instance_points_earned is None: instance_points_earned = 0 if instance_points_possible is None: instance_points_possible = 0 if instance_points_earned and instance_points_possible: instance_average = float( instance_points_earned) / instance_points_possible if instance_average >= 0.70: test_instances_gte_70 += 1 if test_instances.count(): benchmark.gte_70 = float( test_instances_gte_70) / test_instances.count() else: benchmark.gte_70 = 0 benchmark.assessed_on = "" for question_benchmark in question_benchmarks: benchmark.assessed_on += "{}, ".format( question_benchmark.get_order_start_one) benchmark.assessed_on = benchmark.assessed_on[:-2] test.questions = test.question_set.all() for question in test.questions: question.benchmark_text = '' for benchmark in question.benchmarks.all(): question.benchmark_text += '{}, '.format(benchmark.number) question.benchmark_text = question.benchmark_text[:-2] # grab all the AnswerInstances that we care about for this question answerinstances = question.answerinstance_set.filter( test_instance__student__cohort__in=cohorts).distinct() # nasty! http://stackoverflow.com/questions/4093910/django-aggregates-sums-in-postgresql-dont-use-distinct-is-this-a-bug/4917507#4917507 answerinstances = question.active_answerinstance_set.filter( pk__in=answerinstances) # calculate the COUNT of correct student responses for this question question.num_correct = answerinstances.filter( points_earned__gte=F('points_possible')).count() # calculate the COUNT of all student responses for this question question.num_total = answerinstances.count() # http://www.merriam-webster.com/dictionary/percent: "cent" means 100, but I'll stick with the existing convention if question.num_total: question.percent_correct = float( question.num_correct) / question.num_total else: question.percent_correct = 0 # calculate the sum of all points earned and the sum of all points possible for this question earned_possible = answerinstances.aggregate( Sum('points_earned'), Sum('points_possible')) question.points_earned = earned_possible['points_earned__sum'] question.points_possible = earned_possible['points_possible__sum'] # aggregate() may return None, which will raise a TypeError upon attempting arithmetic if question.points_earned is None: question.points_earned = 0 if question.points_possible is None: question.points_possible = 0 if question.points_possible: question.percent_points_earned = float( question.points_earned) / question.points_possible else: question.percent_points_earned = 0 report.data['test'] = test report.data['tests'] = test_instances report.filename = 'Teacher Results for ' + unicode(test) return report.pod_save(template)
def download_teacher_results(self, test, format, template, cohorts=None): """ Make appy based report showing results for a whole class """ if not cohorts: cohorts = Cohort.objects.all() # Stupid f*****g hack subquery = test.testinstance_set.filter(student__cohort__in=cohorts).distinct() report = TemplateReport() report.file_format = format test_instances = ( test.active_testinstance_set.filter(answerinstance__points_earned__gt=0) .filter(pk__in=subquery) .annotate(Sum("answerinstance__points_earned")) ) test.benchmarks = Benchmark.objects.filter(question__test=test).distinct() points_possible = test.points_possible points_to_earn = 0.70 * test.points_possible number_gte_70 = ( test_instances.filter(pk__in=subquery) .filter(answerinstance__points_earned__sum__gte=points_to_earn) .count() ) total_test_takers = ( test_instances.filter(pk__in=subquery).filter(answerinstance__points_earned__gt=0).distinct().count() ) test.percent_gte_70 = float(number_gte_70) / total_test_takers test.report_average = test.get_average(cohorts=cohorts) for benchmark in test.benchmarks: # TODO: eliminate this subquery? is the idea to eliminate any questions that all students left unanswered? qb_subquery = test.question_set.filter( answerinstance__test_instance__student__cohort__in=cohorts ).distinct() question_benchmarks = test.question_set.filter(pk__in=qb_subquery).filter(benchmarks=benchmark).distinct() benchmark.points_possible = question_benchmarks.aggregate(Sum("point_value"))["point_value__sum"] benchmark.total_points_possible = benchmark.points_possible * test_instances.count() # Really think this should work...but nope. # benchmark.total_points_earned = question_benchmarks.aggregate(Sum('answerinstance__points_earned'))['answerinstance__points_earned__sum'] earned_sum = 0 for question_benchmark in question_benchmarks: for answer in question_benchmark.active_answerinstance_set.filter( test_instance__student__cohort__in=cohorts ).distinct(): earned_sum += answer.points_earned benchmark.total_points_earned = earned_sum benchmark.average = float(benchmark.total_points_earned) / benchmark.total_points_possible # Percent of students scoring at or above 70% test_instances_gte_70 = 0 for test_instance in test_instances: answers = test_instance.answerinstance_set.filter(question__benchmarks=benchmark) answers_points = answers.aggregate(Sum("points_earned"), Sum("points_possible")) instance_points_earned = answers_points["points_earned__sum"] instance_points_possible = answers_points["points_possible__sum"] if instance_points_earned and instance_points_possible: instance_average = float(instance_points_earned) / instance_points_possible if instance_average >= 0.70: test_instances_gte_70 += 1 benchmark.gte_70 = float(test_instances_gte_70) / test_instances.count() benchmark.assessed_on = "" for question_benchmark in question_benchmarks: benchmark.assessed_on += "{}, ".format(question_benchmark.get_order_start_one) benchmark.assessed_on = benchmark.assessed_on[:-2] test.questions = test.question_set.all() for question in test.questions: question.benchmark_text = "" for benchmark in question.benchmarks.all(): question.benchmark_text += "{}, ".format(benchmark.number) question.benchmark_text = question.benchmark_text[:-2] # grab all the AnswerInstances that we care about for this question answerinstances = question.answerinstance_set.filter(test_instance__student__cohort__in=cohorts).distinct() # nasty! http://stackoverflow.com/questions/4093910/django-aggregates-sums-in-postgresql-dont-use-distinct-is-this-a-bug/4917507#4917507 answerinstances = question.active_answerinstance_set.filter(pk__in=answerinstances) # calculate the COUNT of correct student responses for this question question.num_correct = answerinstances.filter(points_earned__gte=F("points_possible")).count() # calculate the COUNT of all student responses for this question question.num_total = answerinstances.count() # http://www.merriam-webster.com/dictionary/percent: "cent" means 100, but I'll stick with the existing convention question.percent_correct = float(question.num_correct) / question.num_total # calculate the sum of all points earned and the sum of all points possible for this question earned_possible = answerinstances.aggregate(Sum("points_earned"), Sum("points_possible")) question.points_earned = earned_possible["points_earned__sum"] question.points_possible = earned_possible["points_possible__sum"] question.percent_points_earned = float(question.points_earned) / question.points_possible report.data["test"] = test report.data["tests"] = test_instances report.filename = "Teacher Results for " + unicode(test) return report.pod_save(template)