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)