def index(request, **kwargs):
bad = restricted(request, 5)
if bad:
return bad
context = {
'courses': Courses.filter(year=getyear()).order_by('tradition__order'),
'year': getyear(),
}
return render(request, 'reports/index.html', context)
def courses(request, **kwargs):
me = getme(request)
if not me or not me.owner or not me.owner.children_eligible_in(getyear()):
return redirect('/register')
if request.GET.get('action') == u'add':
return add(request, **kwargs)
elif request.GET.get('action') == u'defer':
return defer(request, **kwargs)
current_id = kwargs.setdefault('id',0)
if 'id' in kwargs:
current_id = kwargs['id']
current_student = me.owner.children.fetch(id=current_id)
if not current_student:
return redirect('/')
else:
current_student = me.owner.children_eligible_in(getyear())[0]
reg_year = getyear()
cart = me.owner.enrollments_in(reg_year).filter(course__tradition__e=True)
cart = cart.filter(status__in=['aud_pass','aud_pend','invoiced','deferred','maydefer','enrolled','need_pay','pend_pub','aud_lock'])
cart_pend = cart.filter(status__in=['aud_pend','invoiced','deferred'])
cart_paid = cart.filter(status='enrolled')
# cart_unpaid = cart.difference(cart_pend,cart_paid) # Use this line instead of next in Django 1.11+
cart_unpaid = cart.exclude(status__in=['aud_pend','invoiced','deferred','enrolled'])
volunteer_total = me.owner.volunteer_total_in(reg_year)
context = {
'ref':kwargs.get('ref'),
'invoiceable' : bool(cart_unpaid), # TODO: This is simple enough now to be calculated in the HTML page
'reg_year': reg_year,
'family' : me.owner,
'students': equip(me.owner.children_eligible_in(getyear()), lambda student: student.hst_age_in(reg_year), attr='age'),
'current_student' : current_student,
'menu' : current_student.course_menu(year=reg_year),
'cart' : cart,
'nCourses': {
'total' : len(cart),
'pend' : len(cart_pend),
'paid' : len(cart_paid),
'unpaid': len(cart_unpaid),
},
'tuition' : {
'total' : sum(collect(cart, lambda enr: enr.course.tuition())),
'pend' : sum(collect(cart_pend, lambda enr: enr.course.tuition())),
'paid' : sum(collect(cart_paid, lambda enr: enr.course.tuition())),
'unpaid': sum(collect(cart_unpaid, lambda enr: enr.course.tuition())),
},
'hours' : {
'total' : me.owner.volunteer_total_in(reg_year),
'pend' : me.owner.hours_signed_in(reg_year),
'paid' : me.owner.hours_worked_in(reg_year),
'unpaid': me.owner.volunteer_total_in(reg_year)
- me.owner.hours_signed_in(reg_year)
- me.owner.hours_worked_in(reg_year),
},
}
return render(request, 'courses.html', context)
def get_stat(show_id, status):
if type(status) is not list:
status = [status]
x = len(Enrollments.filter(course__year=getyear(),course__tradition=K[show_id]['10'],status__in=status))
xv = len(Enrollments.filter(course__year=getyear(),course__tradition=K[show_id]['15'],status__in=status))
xx = len(Enrollments.filter(course__year=getyear(),course__tradition=K[show_id]['20'],status__in=status))
return {
'10':x,
'15':xv,
'20':xx,
'total': (x * 10) + (xv * 15) + (xx * 20)
}
def students_edit(request, ref, id):
me = getme(request)
if not me or not me.owner or not (me.owner.mother or me.owner.father):
return redirect('/register/redirect/')
student = Students.fetch(id=id)
if not student:
return redirect('/{}/students/new/'.format(ref))
forminit(request, 'student', student_fields, obj=student)
context = {
'new':
False,
'reg_year':
getyear(),
'family':
me.owner,
't_shirt_sizes':
collect(
Students.model.t_shirt_sizes, lambda obj: dict(
collect(obj, lambda val, index: ['no' + str(index), val]))),
'students':
me.owner.children.all(),
'ref':
ref,
'current_student':
student,
'e':
request.session['e'],
'p':
request.session['p'],
}
return render(request, 'students2.html', context)
def deferred(request, **kwargs):
families = Families.filter(
children__enrollment__course__year=getyear(),
children__enrollment__course__tradition__id__startswith='K',
children__enrollment__status='deferred'
).distinct().order_by('last','name_num').prefetch_related('children__enrollment')
agg = []
for family in families:
row = {}
for show in K:
tix = 0
for qty in K[show]:
tix += sum(Each(family.children).enrollment.filter(status='deferred',course__tradition__id=K[show][qty]).count()) * int(qty)
row[show] = tix
row['amount'] = sum(row.values()) * 10.00
row['o'] = family
agg.append(row)
context = {
'families':agg
}
for show_id in K:
total = 0
context[show_id] = {}
for status in ['enrolled','invoiced','deferred']:
new = get_stat(show_id, status)
total += new['total']
context[show_id][status] = new
new = get_stat(show_id,['need_pay','maydefer'])
context[show_id]['in_cart'] = get_stat(show_id,['need_pay','maydefer'])
context[show_id]['total'] = total + new['total']
return render(request, 'radmin/deferred.html', context)
def students_new(request, ref):
me = getme(request)
if not me or not me.owner or not (me.owner.mother or me.owner.father):
return redirect('/register/redirect/')
students = list(me.owner.children.all())
students.append(new_student)
print students
context = {
'new':
True,
'reg_year':
getyear(),
'family':
me.owner,
't_shirt_sizes':
collect(
Students.model.t_shirt_sizes, lambda obj: dict(
collect(obj, lambda val, index: ['no' + str(index), val]))),
'students':
students,
'ref':
ref,
'current_student':
new_student,
'e':
request.session['e'],
'p':
request.session['p'],
}
return render(request, 'students2.html', context)
def signin(request):
day = request.GET.get('day')
if not day:
context = {
'today': datetime.datetime.today(),
}
return render(request, 'reports/signin_home.html', context)
else:
start = cleandate(request.GET.get('start'))
qset = Enrollments.filter(
course__tradition__m=True,
course__tradition__day=day,
course__year=getyear(start),
).order_by(
'student__family__last',
'student__family__name_num',
'student__birthday',
'course__tradition__start',
).distinct()
weeks = request.GET.get('weeks')
starts = list(set(Each(qset).course.tradition.start))
starts.sort()
context = {
'qset': starts,
}
return render(request, 'reports/signin.html', context)
def refresh_summary(request, **kwargs):
bad = restricted(request, 5)
if bad:
return bad
kwargs.setdefault('year', getyear())
for course in Courses.filter(year__in=[kwargs['year'], kwargs['year'] - 1],
tradition__action='trig'):
for student in Students.filter(enrollment__course=course):
course.trig(student)
return redirect('/reports/summary/')
def course_menu(self, year=getyear()):
courses = Courses.filter(year=year,
tradition__e=True,
tradition__m=True)
courses = courses.order_by('tradition__order')
for course in courses:
enrollment = Enrollments.fetch(student=self, course=course)
if not enrollment or enrollment.status == 'nonexist':
enrollment = Enrollments.model(student=self, course=course)
enrollment.status = calc_status(enrollment)
yield enrollment
def summary(request, **kwargs):
bad = restricted(request, 5)
if bad:
return bad
kwargs.setdefault('year', getyear())
context = {
'year': Year(int(kwargs['year'])),
'prev': Year(int(kwargs['year']) - 1),
'date': datetime.datetime.now(),
}
return render(request, 'reports/summary.html', context)
def title_kwargs(self):
return {
'student' : self.student.family if self.course.tradition.byFamily() else self.student,
'family' : self.student.family,
'course' : self.course.title,
'year' : self.course.year,
'invoice' : self.invoice.id if self.invoice else 0,
'pronoun' : 'he' if self.student.sex == 'M' else 'she',
'proverb' : 'was' if self.course.year < getyear() else 'is',
'audskil' : 'audition' if self.course.id[2] in 'SC' else 'skill assessment',
'article' : 'an' if self.course.id[2] in 'SC' else 'a',
}
def account(request):
me = getme(request)
if not me:
return redirect('/')
password = unicode(me.password.html)
context = {
'me': me,
'password': password,
'year': getyear(),
'policy': Policies.current,
}
return render(request, 'main/account.html', context)
def registration(request, **kwargs):
bad = restricted(request, 1)
if bad:
return bad
year = int(request.GET.copy().setdefault('year', getyear()))
context = {
'year': year,
'now': datetime.datetime.now(),
'sc': Courses.fetch(year=year, tradition=CourseTrads.fetch(id='SC')),
}
context.update(layered_students_and_families(year, enrollments=True))
return render(request, 'reports/registration.html', context)
def directory(request, **kwargs):
bad = restricted(request, 1)
if bad:
return bad
year = getyear()
# families = Families.filter(children__enrollment__course__year=year).order_by('last').distinct()
families = layered_students_and_families(year)['families']
context = {
'families': families,
'year': year,
}
return render(request, 'reports/directory.html', context)
def address(request, **kwargs):
bad = restricted(request, 1)
if bad:
return bad
year = getyear()
context = {
'families':
Families.filter(children__enrollment__course__year=year).order_by(
'last').distinct(),
'year':
year,
}
return render(request, 'reports/addresses.html', context)
def edit(request, **kwargs):
bad = restricted(request, 5)
if bad:
return bad
year = int(kwargs.get('year') or getyear())
policy = Policies.fetch(year=year)
if not policy:
policy = Policies.fetch(year=year - 1)
context = {
'current': policy.markdown,
'year': year,
}
return render(request, 'radmin/policy/edit.html', context)
def index(request):
if 'course' in request.GET:
course = request.GET['course']
if course:
return redirect('/reports/roster/{}'.format(course))
else:
return redirect('/')
me = getme(request)
context = {
'year':
getyear(),
'me':
me,
'name':
me.owner if me else None,
'incomplete_registration':
me and me.owner and not me.owner.children,
'sudo':
Users.fetch(id=request.session.get('sudo')),
'courses':
Courses.filter(year=getyear(),
tradition__m=True).order_by('tradition__order')
}
return render(request, 'main/index.html', context)
def fate(self, year=None):
if not year:
year = getyear()
for enrollment in self.enrollments_in(year):
if not eligible(enrollment.course, self):
enrollment.delete()
while True:
drops = self.enrollments_in(year)
for drop in drops:
if eligible(drop.course, self):
drops = drops.exclude(id=drop.id)
else:
drop.delete()
if not drops:
break
def mass_enroll(request, **kwargs):
bad = restricted(request, 5)
if bad:
return bad
year = kwargs.setdefault('year', getyear())
courses = Courses.filter(year=kwargs['year'])
students = []
for x in request.POST:
if x.isdigit():
students.append(Students.fetch(id=int(x)))
students.sort(key=lambda student: student.last)
context = {
'students': students,
'courses': courses,
'status_choices': dict(status_choices).keys(),
}
return render(request, 'reports/mass_enroll.html', context)
def enrollment_matrix(request, **kwargs):
bad = restricted(request, 5)
if bad:
return bad
year = int(kwargs['year']) if 'year' in kwargs else getyear()
kwargs.update(request.GET)
everyone = kwargs.setdefault('everyone', False) == [u'True']
siblings = kwargs.setdefault('siblings', False) == [u'True']
siblings |= everyone
families = Families.all()
if not everyone:
families = families.filter(
children__enrollment__course__year=year).distinct()
families = families.order_by('last', 'name_num')
table = []
blank = {'content': '', 'rowspan': 1, 'class': 'enr'}
ctids = {'SB': 'TT', 'SG': 'GB', 'SJ': 'JR'}
for family in families:
oldest = True
children = family.children.all(
) if siblings else family.children_enrolled_in(year)
for student in children:
row = {
'family': family,
'last': family.unique_last_in(year),
'student': student,
'age': student.hst_age_in(year),
'nchild': len(children),
'oldest': oldest,
'XW': [],
}
oldest = False
for enrollment in student.enrollments_in(year):
ctid = enrollment.course.tradition.id
row[enrollment.course.genre] = {
'enr': enrollment,
'ctid': sub(ctid, ctids)
}
if ctid[0] in 'XW':
row['XW'].append(enrollment)
table.append(row)
context = {
'year': year,
'table': table,
}
return render(request, 'reports/enrollment_matrix_edit.html', context)
def create(self, **kwargs):
kwargs.setdefault('year', getyear())
year0000 = (int(kwargs['year']) % 100) * 10000
qset = self.filter(id__gte=year0000,id__lte=year0000+9999)
kwargs.setdefault('id',max([year0000]+list(Each(qset).id)) + 1)
# kwargs.setdefault('amount', kwargs['family'].total_tuition_in(kwargs['year']))
this = super(InvoiceManager, self).create(**kwargs)
qset = Enrollments.filter(
student__family=kwargs['family'],
course__year=kwargs['year'],
status__in=['aud_pass','aud_lock','need_pay','maydefer'])
for q in qset:
q.invoice = this
q.status = 'invoiced'
q.save()
amount = this.update_amount()
this.update_amount()
return this
def new(request, method=None):
bad = restricted(request,5)
if bad:
return bad
context = {
'year': getyear(),
}
if 'year' in request.GET:
year = request.GET['year']
context.update({
'year' : year,
'year2' : year[-2:],
'courses': equip(CourseTrads.filter(alias=None).order_by('order'), lambda trad: bool(Courses.filter(year=year,tradition=trad)), attr='already'),
})
elif request.GET:
for key in request.GET:
if request.GET[key] == 'on':
Courses.create_by_id(key)
return redirect('/admin/year/')
return render(request, 'radmin/newyear/year.html', context)
def grade(self):
return self.grade_in(getyear())
def hst_age(self):
return self.hst_age_in(getyear())
def infolock(self):
return getyear() != 2019 and self.family.policyDate > self.created_at
def fate(self, year=None):
if not year:
year = getyear()
Each(self.children.all()).fate(year)
def live_enrollments(self):
return self.live_enrollments_in(getyear())
def enrollments(self):
return self.enrollments_in(getyear())
def all_enrollments(self):
return self.all_enrollments_in(getyear())
def has_accepted_policy(self, year=getyear()):
policy = Policies.fetch(year=year)
return not policy or self.policyYear == year and self.policyPage == policy.nPages
