def add_subject(self, request, teacher): try: subject_id = request.GET['subject_id'] subject = Subject.objects.get(pk=subject_id) TeacherResponsibility.objects.get_or_create(teacher=teacher, subject=subject) level_classroom_list = [] school_year = get_school_year() for level in Level.objects.filter( school_year=school_year).order_by('order_of_appearance', 'name'): classroom_list = [] for classroom in Classroom.objects.filter(level=level): if subject.get_teacher(classroom): classroom.is_assigned = True classroom_list.append(classroom) obj = {"name": level.name, "classroom_list": classroom_list} level_classroom_list.append(obj) context = { 'subject': subject, 'level_classroom_list': level_classroom_list } return render(request, 'school/snippets/teacher_responsibility_list.html', context) except: response = {'error': "Server error occurred."} return HttpResponse(json.dumps(response))
def get_context_data(self, **kwargs): context = super(KidDetail, self).get_context_data(**kwargs) user = self.request.user parent_profile = get_object_or_404(ParentProfile, member=user) student = context['student'] db = student.school.database add_database(db) subject_list = get_subject_list(student.classroom, using=db) for subject in subject_list: subject.score_list = student.get_score_list(subject, using=db) context['subject_list'] = subject_list kid_list = parent_profile.student_list now = datetime.now() end_year_date = datetime(day=31, month=8, year=get_school_year() + 1) month_expiry = now + timedelta(days=30) term_expiry = now + timedelta(days=90) # kid_list.remove(student) context['kid_list'] = kid_list context['using'] = db parent1 = Parent.objects.filter(student=student)[0] context['is_first_parent'] = parent1.email == user.email or parent1.phone == user.phone context['has_pending_assignment'] = Assignment.objects.using(db).filter(classroom=student.classroom, deadline__lt=now) context['has_pending_invoice'] = Invoice.objects.using(db).filter(student=student, status=Invoice.PENDING).count() > 0 context['has_pending_disc'] = DisciplineLogEntry.objects.using(db).filter(student=student, was_viewed=False).count() > 0 context['has_new_score'] = Score.objects.using(db).filter(student=student, was_viewed=False).count() > 0 context['month_expiry'] = min(month_expiry, end_year_date) context['term_expiry'] = min(term_expiry, end_year_date) context['year_expiry'] = end_year_date context['school_config'] = SchoolConfig.objects.using(db).get(service=student.school) return context
def set_student_counts(): """ Sets student_count for each Classroom, Level and School """ total_boys, total_girls = 0, 0 school_year = get_school_year() for level in Level.objects.filter(school_year=school_year): level_boys, level_girls = 0, 0 for classroom in level.classroom_set.all(): classroom.girls_count = classroom.student_set.filter( gender=FEMALE, is_excluded=False).count() classroom.boys_count = classroom.student_set.filter( gender=MALE, is_excluded=False).count() classroom.save() level_girls += classroom.girls_count level_boys += classroom.boys_count level.girls_count = level_girls level.boys_count = level_boys level.save() total_girls += level_girls total_boys += level_boys school = get_service_instance().config school.girls_count = total_girls school.boys_count = total_boys school.save()
def get_current(): try: session = Session.objects.get(is_current=True, school_year=get_school_year()) except Session.DoesNotExist: try: session = Session.objects.filter( school_year=get_school_year())[0] session.is_current = True session.save() except IndexError: return None except MultipleObjectsReturned: session = Session.objects.filter( is_current=True, school_year=get_school_year()).order_by('-id')[0] Session.objects.exclude(pk=session.id).update(is_current=False) return session
def get_context_data(self, **kwargs): context = super(TeacherDetail, self).get_context_data(**kwargs) object_id = kwargs['object_id'] member = get_object_or_404(Member, pk=object_id) school_year = get_school_year(self.request) teacher = Teacher.objects.get(member=member, school_year=school_year) teacher_subject_list = [ obj.subject for obj in teacher.teacherresponsibility_set.all() ] teacher_subject_list_copy = list(teacher_subject_list) subject_level_classroom_list = [] for subject in teacher_subject_list_copy: level_classroom_list = [] classroom_fk_list = TeacherResponsibility.objects.get( teacher=teacher, subject=subject).classroom_fk_list if len(classroom_fk_list) == 0: teacher_subject_list.remove(subject) continue for level in Level.objects.filter( school_year=school_year).order_by('order_of_appearance', 'name'): classroom_list = [] for classroom in Classroom.objects.filter(level=level): if classroom.id in classroom_fk_list: classroom.is_active = True current_teacher = subject.get_teacher(classroom) if current_teacher and current_teacher != teacher: classroom.is_assigned = True classroom_list.append(classroom) obj = {"name": level.name, "classroom_list": classroom_list} level_classroom_list.append(obj) sub = { "id": subject.id, "name": subject.name, "level_classroom_list": level_classroom_list } subject_level_classroom_list.append(sub) level_classroom_list = [] for level in Level.objects.filter(school_year=school_year).order_by( 'order_of_appearance', 'name'): obj = { "name": level.name, "classroom_list": Classroom.objects.filter(level=level) } level_classroom_list.append(obj) context['teacher'] = teacher context['subject_level_classroom_list'] = subject_level_classroom_list context['level_classroom_list'] = level_classroom_list context['teacher_subject_list'] = teacher_subject_list context['subject_list'] = Subject.objects.exclude( pk__in=[obj.id for obj in teacher_subject_list], is_visible=False) context['verbose_name'] = _('Teacher') context['verbose_name_plural'] = _('Teachers') return context
def get(self, request, *args, **kwargs): action = self.request.GET.get('action') object_id = kwargs['object_id'] member = get_object_or_404(Member, pk=object_id) teacher, update = Teacher.objects.get_or_create( member=member, school_year=get_school_year()) if action == 'add_subject': return self.add_subject(self.request, teacher) elif action == 'save_responsibilities': return self.save_responsibilities(self.request, teacher) elif action == 'remove_subject': return self.remove_subject(self.request, teacher) return super(TeacherDetail, self).get(request, *args, **kwargs)
def get_context_data(self, **kwargs): context = super(ReportCardDownloadList, self).get_context_data(**kwargs) session_id = kwargs['session_id'] classroom_id = kwargs.get('classroom_id') session = get_object_or_404(Session, pk=session_id) school_year = get_school_year(self.request) report_cards_root = getattr(settings, 'REPORT_CARDS_ROOT') report_cards_url = getattr(settings, 'REPORT_CARDS_URL') session_group_folder = report_cards_root + '%s_%d-%d/%s/' % (REPORT_CARDS_FOLDER, school_year, school_year + 1, slugify(session.session_group.name).capitalize()) session_folder = session_group_folder + slugify(session.name).capitalize() summary_folder = session_group_folder + SUMMARY_FOLDER classroom_list = [] if classroom_id: queryset = Classroom.objects.filter(pk=classroom_id) else: queryset = Classroom.objects.filter(school_year=school_year, mark_students=True) for classroom in queryset: try: if session.order_number % 2 == 0: filename = session_folder + '/' + slugify(str(classroom).decode('utf8')) + '.7z' classroom.archive = { 'url': filename.replace(report_cards_root, report_cards_url), 'size': os.path.getsize(filename) / 1048576.0 } else: # Term end summary_filename = summary_folder + '/' + slugify(str(classroom).decode('utf8')) + '.7z' classroom.archive = { 'url': summary_filename.replace(report_cards_root, report_cards_url), 'size': os.path.getsize(summary_filename) / 1048576.0 } except OSError: continue classroom_list.append(classroom) if session.order_number % 2 == 0: bundle_filename = session_folder + '.7z' bundle_archive = { 'url': bundle_filename.replace(report_cards_root, report_cards_url), 'size': os.path.getsize(bundle_filename) / 1073741824.0 # Calculate size rather in GB } context['bundle_archive'] = bundle_archive else: summary_bundle_filename = summary_folder + '.7z' summary_bundle_archive = { 'url': summary_bundle_filename.replace(report_cards_root, report_cards_url), 'size': os.path.getsize(summary_bundle_filename) / 1073741824.0 } context['bundle_archive'] = summary_bundle_archive context['classroom_list'] = classroom_list context['session'] = session return context
def get_context_data(self, **kwargs): context = super(KidList, self).get_context_data(**kwargs) user = self.request.user try: parent_profile = ParentProfile.objects.get(member=user) except: parent_profile = ParentProfile.objects.create(member=user) kid_list = parent_profile.student_list suggestion_key = 'kid_list:suggestion_list:' + user.username suggestion_list = cache.get(suggestion_key) if suggestion_list is None: suggestion_list = [] for obj in Parent.objects.select_related('student').filter(Q(email=user.email) | Q(phone=user.phone)): student = obj.student if student.school_year < get_school_year(): obj.delete() continue if student.my_kids_expiry: diff = student.my_kids_expiry - datetime.now() if diff.total_seconds() <= 0: student.my_kids_expired = True student.save() else: student.my_kids_expired = True student.save() if student.id in parent_profile.student_fk_list or student in suggestion_list: continue try: suggestion_list.append(student) except: pass cache.set(suggestion_key, suggestion_list, 5 * 60) min_search_chars = 0 try: app = Application.objects.get(slug='foulassi') school_count = Service.objects.filter(app=app).count() min_search_chars = len(str(school_count)) - 2 except: pass context['suggestion_list'] = suggestion_list context['kid_list'] = kid_list context['min_search_chars'] = min_search_chars return context
def close_session(request, *args, **kwargs): session = Session.get_current() if Score.objects.filter(session=session).count() == 0: # Cannot close a session without any score being set return HttpResponse( json.dumps({'success': True}, 'content-type: text/json')) session.is_active = False session.is_current = False session.save() event_id = request.GET['event_id'] Event.objects.filter(pk=event_id).update(is_processed=True) try: i = session.order_number next_session = Session.objects.filter( school_year=get_school_year())[i + 1] next_session.is_active = True next_session.is_current = True next_session.save() except IndexError: pass return HttpResponse( json.dumps({'success': True}, 'content-type: text/json'))
def check_all_scores_set(session): """ Checks whether all scores have been set for all students in all classrooms for the current session. When it returns True, it means that we can generate report cards. """ all_scores_set = True school_year = get_school_year() for classroom in Classroom.objects.filter(school_year=school_year, mark_students=True): try: student = classroom.student_set.filter(is_excluded=False)[0] except: continue subject_list = get_subject_list(classroom) for subject in subject_list: try: Score.objects.get(session=session, subject=subject, student=student) except: all_scores_set = False break if all_scores_set: session.all_scores_set_on = datetime.now() event_type, change = EventType.objects\ .get_or_create(codename=ALL_SCORES_SET, renderer='ikwen_foulassi.foulassi.events.render_all_scores_set') try: Event.objects.raw_query({ 'object_id_list': { '$elemMatch': { '$eq': session.id } } }).filter(type=event_type)[0] except IndexError: Event.objects.create(type=event_type, object_id_list=[session.id]) return all_scores_set
def get_queryset(self): return Level.objects.filter(school_year=get_school_year(self.request))
def confirm_my_kids_payment(request, *args, **kwargs): tx = kwargs['tx'] invoice = Invoice.objects.get(pk=tx.object_id) school = invoice.school school_config = SchoolConfig.objects.get(service=school) ikwen_charges = tx.amount * school_config.my_kids_share_rate / 100 tx.fees = ikwen_charges tx.save(using='wallets') mean = tx.wallet amount = tx.amount - ikwen_charges school.raise_balance(amount, provider=mean) share_payment_and_set_stats(invoice, mean, tx) invoice.paid = invoice.amount invoice.status = Invoice.PAID invoice.save() member = invoice.member student = invoice.student max_expiry = datetime(day=31, month=8, year=get_school_year() + 1) days = get_billing_cycle_days_count(invoice.my_kids_cycle) expiry = datetime.now() + timedelta(days=days) expiry = min(expiry, max_expiry) student.my_kids_expiry = expiry student.my_kids_expired = False student.save() db = school.database add_database(db) invoice.save(using=db) payment = Payment(invoice=invoice, method=Payment.MOBILE_MONEY, amount=tx.amount, processor_tx_id=tx.processor_tx_id) if school_config.my_kids_share_rate < 100: # Payment appears in school log panel only if the have something to collect out of that payment.save(using=db) if member.email: try: currency = Currency.active.default().symbol except: currency = school_config.currency_code invoice_url = school.url + reverse('billing:invoice_detail', args=(invoice.id, )) subject, message, sms_text = get_payment_confirmation_message( payment, member) html_content = get_mail_content( subject, message, template_name='billing/mails/notice.html', extra_context={ 'member_name': member.first_name, 'invoice': invoice, 'cta': _("View invoice"), 'invoice_url': invoice_url, 'currency': currency }) sender = '%s <no-reply@%s>' % (school_config.company_name, school.domain) msg = XEmailMessage(subject, html_content, sender, [member.email]) msg.content_subtype = "html" try: invoicing_config = get_invoicing_config_instance() invoice_pdf_file = generate_pdf_invoice(invoicing_config, invoice) msg.attach_file(invoice_pdf_file) except: pass return HttpResponse( "Notification for transaction %s received with status %s" % (tx.id, tx.status))
def set_my_kids_payment(request, *args, **kwargs): school_id = request.POST['school_id'] student_id = request.POST['student_id'] cycle = request.POST['my_kids_cycle'] school = Service.objects.get(pk=school_id) student = Student.objects.get(pk=student_id) school_config = SchoolConfig.objects.get(service=school) Invoice.objects.filter(student=student, is_my_kids=True, status=Invoice.PENDING).delete() max_expiry = datetime(day=31, month=8, year=get_school_year() + 1) if cycle == Service.YEARLY: amount = school_config.my_kids_fees elif cycle == Service.QUARTERLY: amount = school_config.my_kids_fees_term else: amount = school_config.my_kids_fees_month cycle = Service.MONTHLY item = InvoiceItem(label=_("MyKids fees"), amount=amount) days = get_billing_cycle_days_count(cycle) now = datetime.now() expiry = now + timedelta(days=days) expiry = min(expiry, max_expiry) short_description = now.strftime("%Y/%m/%d") + ' - ' + expiry.strftime( "%Y/%m/%d") entry = InvoiceEntry(item=item, short_description=short_description, total=amount, quantity_unit='') number = get_next_invoice_number() member = request.user invoice = Invoice.objects.create(number=number, member=member, student=student, school=school, is_one_off=True, amount=amount, my_kids_cycle=cycle, due_date=now, entries=[entry], is_my_kids=True) foulassi_weblet = get_service_instance() # This is Foulassi service itself # Transaction is hidden from school if ikwen collects 100%. # This is achieved by changing the service_id of transaction tx_service_id = school.id if school_config.my_kids_share_rate < 100 else foulassi_weblet.id model_name = 'billing.Invoice' mean = request.GET.get('mean', MTN_MOMO) signature = ''.join([ random.SystemRandom().choice(string.ascii_letters + string.digits) for i in range(16) ]) MoMoTransaction.objects.using(WALLETS_DB_ALIAS).filter( object_id=invoice.id).delete() tx = MoMoTransaction.objects.using(WALLETS_DB_ALIAS)\ .create(service_id=tx_service_id, type=MoMoTransaction.CASH_OUT, amount=amount, phone='N/A', model=model_name, object_id=invoice.id, task_id=signature, wallet=mean, username=request.user.username, is_running=True) notification_url = foulassi_weblet.url + reverse( 'foulassi:confirm_my_kids_payment', args=(tx.id, signature)) cancel_url = request.META['HTTP_REFERER'] return_url = request.META['HTTP_REFERER'] return invoice, amount, notification_url, return_url, cancel_url
def get_context_data(self, **kwargs): context = super(Dashboard, self).get_context_data(**kwargs) discipline_report = [] school_year = get_school_year(self.request) for item in DisciplineItem.objects.filter(is_active=True): discipline_report_obj, update = DisciplineReport.objects\ .get_or_create(discipline_item=item, level=None, classroom=None, school_year=school_year) set_counters(discipline_report_obj) students_yesterday = slice_watch_objects(StudentDisciplineReport, 1, 'last_add_on') students_last_week = slice_watch_objects(StudentDisciplineReport, 7, 'last_add_on') students_last_28_days = slice_watch_objects(StudentDisciplineReport, 28, 'last_add_on') item_report_obj = { 'item': _(item.name), 'report': { 'yesterday': { 'summary': calculate_watch_info(discipline_report_obj.total_history, 1), 'student_list': rank_watch_objects(students_yesterday, 'count_history') }, 'last_week': { 'summary': calculate_watch_info(discipline_report_obj.total_history, 7), 'student_list': rank_watch_objects(students_last_week, 'count_history') }, 'last_28_days': { 'summary': calculate_watch_info(discipline_report_obj.total_history, 28), 'student_list': rank_watch_objects(students_last_28_days, 'count_history') } } } discipline_report.append(item_report_obj) # Classes report classes_report = { 'today': {'count': 0, 'hours': 0}, 'yesterday': {'count': 0, 'hours': 0}, 'last_week': {'count': 0, 'hours': 0}, 'last_28_days': {'count': 0, 'hours': 0} } for report in LessonReport.objects.filter(school_year=school_year): set_counters(report) classes_report['today']['count'] += calculate_watch_info(report.count_history)['total'] classes_report['today']['hours'] += calculate_watch_info(report.hours_count_history)['total'] for report in LessonReport.objects.filter(school_year=school_year): set_counters(report) classes_report['yesterday']['count'] += calculate_watch_info(report.count_history, 1)['total'] classes_report['yesterday']['hours'] += calculate_watch_info(report.hours_count_history, 1)['total'] for report in LessonReport.objects.filter(school_year=school_year): set_counters(report) classes_report['last_week']['count'] += calculate_watch_info(report.count_history, 7)['total'] classes_report['last_week']['hours'] += calculate_watch_info(report.hours_count_history, 7)['total'] for report in LessonReport.objects.filter(school_year=school_year): set_counters(report) classes_report['last_28_days']['count'] += calculate_watch_info(report.count_history, 28)['total'] classes_report['last_28_days']['hours'] += calculate_watch_info(report.hours_count_history, 28)['total'] classroom_count = Classroom.objects.filter(school_year=school_year).count() for val in classes_report.values(): val['count'] = round(float(val['count'])/classroom_count, 2) if classroom_count else 0 val['hours'] = round(float(val['hours'])/classroom_count, 2) if classroom_count else 0 # Session scores report session_queryset = Session.objects.filter(Q(is_active=False) | Q(is_current=True), school_year=school_year) all_session_list = [] for session in session_queryset: if Score.objects.filter(session=session).count() > 0: all_session_list.append(session) session_group_list = list(SessionGroup.objects.filter(school_year=school_year)) session_group_count = 0 if len(all_session_list) >= 2: if len(session_group_list) >= 1: all_session_list.insert(2, session_group_list[0]) session_group_count += 1 if len(all_session_list) >= 5: if len(session_group_list) >= 2: all_session_list.insert(5, session_group_list[1]) session_group_count += 1 if len(all_session_list) >= 8: if len(session_group_list) >= 3: all_session_list.append(session_group_list[2]) session_group_count += 1 session_report, update = SessionReport.objects\ .get_or_create(level=None, classroom=None, subject=None, school_year=school_year) session_group_report, update = SessionGroupReport.objects\ .get_or_create(level=None, classroom=None, subject=None, school_year=school_year) # Billing report pending_invoice_count = Invoice.objects.filter(status=Invoice.PENDING, school_year=school_year).count() try: aggr = Invoice.objects.filter(status=Invoice.PENDING, school_year=school_year).aggregate(Sum('amount')) pending_invoice_amount = aggr['amount__sum'] except IndexError: pending_invoice_amount = 0 pending_invoice_data_list = [] for classroom in Classroom.objects.filter(school_year=school_year): student_list = list(classroom.student_set.filter(is_excluded=False)) count = Invoice.objects.filter(student__in=student_list, status=Invoice.PENDING).count() if count > 0: obj = { 'classroom': classroom, 'count': Invoice.objects.filter(student__in=student_list, status=Invoice.PENDING).count() } pending_invoice_data_list.append(obj) pending_invoice_data_list.sort(cmp=lambda x, y: 1 if x['count'] < y['count'] else -1) pending_invoice_data = { 'count': pending_invoice_count, 'amount': pending_invoice_amount, 'list': pending_invoice_data_list } context['discipline_report'] = discipline_report context['all_session_list'] = all_session_list try: context['selected_session'] = all_session_list[-1] context['selected_session_order_number'] = all_session_list[-1].order_number except: pass context['session_report'] = session_report context['session_group_report'] = session_group_report context['classes_report'] = classes_report context['range_session_group'] = range(session_group_count) context['range_session'] = range(session_queryset.count()) context['pending_invoice_data'] = pending_invoice_data return context
def get_queryset(self): return SessionGroup.objects.filter( school_year=get_school_year(self.request))
def _get_order_number(self): all_sessions = list( Session.objects.filter(school_year=get_school_year())) return all_sessions.index(self)
def generate_report_card_files(request, classroom=None): member = request.user school_year = get_school_year(request) session = Session.get_current() is_term_end = session.order_number % 2 != 0 is_end_year = session.order_number == 5 if classroom: classroom_list = [classroom] total = classroom.student_set.filter(is_excluded=False).count() event_object_id_list = [session.id, classroom.id] else: classroom_list = Classroom.objects.filter(school_year=school_year, mark_students=True) total = Student.objects.filter(school_year=school_year, is_excluded=False).count() event_object_id_list = [session.id] if is_term_end: session_group_batch = ReportCardBatch.objects.create(member=member, session_group=session.session_group, total=total) else: batch = ReportCardBatch.objects.create(member=member, session=session, total=total) t0 = datetime.now() try: EventType.objects.get(codename=REPORT_CARDS_GENERATED) except EventType.DoesNotExist: EventType.objects.create(codename=REPORT_CARDS_GENERATED, renderer='ikwen_foulassi.foulassi.events.render_report_cards_generated') try: EventType.objects.get(codename=REPORT_CARDS_FAILED_TO_GENERATE) except EventType.DoesNotExist: EventType.objects.create(codename=REPORT_CARDS_FAILED_TO_GENERATE, renderer='ikwen_foulassi.foulassi.events.render_report_cards_failed_to_generate') lang = request.GET['lang'] activate(lang) report_card_header = ReportCardHeader.objects.get(lang=lang) report_cards_root = getattr(settings, 'REPORT_CARDS_ROOT') session_group_folder = report_cards_root + '%s_%d-%d/%s' % (REPORT_CARDS_FOLDER, school_year, school_year + 1, slugify(session.session_group.name).capitalize()) session_folder = session_group_folder + '/' + slugify(session.name).capitalize() summary_folder = session_group_folder + '/' + SUMMARY_FOLDER session_archive = session_folder + '.7z' if is_term_end: summary_archive = summary_folder + '.7z' if os.path.exists(summary_archive): os.unlink(summary_archive) else: if os.path.exists(session_archive): os.unlink(session_archive) try: for classroom in classroom_list: if classroom.student_set.filter(is_excluded=False).count == 0: continue if is_term_end: generate_session_group_report_card(classroom, session.session_group, report_card_header, session_group_batch) classroom_folder = summary_folder + '/' + slugify(str(classroom).decode('utf8')) classroom_archive = classroom_folder + '.7z' if os.path.exists(classroom_archive): os.unlink(classroom_archive) subprocess.call(["7z", "a", classroom_archive, classroom_folder + '/*']) subprocess.call(["7z", "a", "-x!*.7z", summary_archive, summary_folder + '/*']) subprocess.call(["rm", "-fr", classroom_folder]) else: generate_session_report_card(classroom, session, report_card_header, batch) classroom_folder = session_folder + '/' + slugify(str(classroom).decode('utf8')) classroom_archive = classroom_folder + '.7z' if os.path.exists(classroom_archive): os.unlink(classroom_archive) subprocess.call(["7z", "a", classroom_archive, classroom_folder + '/*']) subprocess.call(["7z", "a", "-x!*.7z", session_archive, session_folder + '/*']) subprocess.call(["rm", "-fr", classroom_folder]) diff = datetime.now() - t0 if is_term_end: session_group_batch.duration = diff.total_seconds() session_group_batch.message = "OK" else: batch.duration = diff.total_seconds() batch.message = "OK" event_type = EventType.objects.get(codename=REPORT_CARDS_GENERATED) session.report_cards_generated_on = datetime.now() session.save() except: service = get_service_instance() logger.error("%s: Report cards failed to generate." % service.ikwen_name, exc_info=True) if is_term_end: session_group_batch.message = traceback.format_exc() else: batch.message = traceback.format_exc() event_type = EventType.objects.get(codename=REPORT_CARDS_FAILED_TO_GENERATE) finally: if is_term_end: session_group_batch.save() else: batch.save() Event.objects.create(type=event_type, object_id_list=event_object_id_list)
def get_model_form(self, obj): form = super(ChangeSession, self).get_model_form(obj) school_year = get_school_year(self.request) form.fields['session_group'].queryset = SessionGroup.objects.filter( school_year=school_year) return form
def get_queryset(self): school_year = get_school_year(self.request) return Teacher.objects.filter(school_year=school_year)