def paiditems(self, request, tl, one, two, module, extra, prog):
user, found = search_for_user(request, self.program.students_union())
if not found:
return user
context = {}
context['student'] = user
context['program'] = prog
li_types = prog.getLineItemTypes(user)
try:
invoice = Document.get_invoice(user,
prog.anchor,
li_types,
dont_duplicate=True,
get_complete=True)
except:
invoice = Document.get_invoice(user,
prog.anchor,
li_types,
dont_duplicate=True)
context['reserveditems'] = invoice.get_items()
context['cost'] = invoice.cost()
return render_to_response(self.baseDir() + 'paiditems.html', request,
(prog, tl), context)
def admin_morph(self, request, tl, one, two, module, extra, prog):
""" This function will allow someone to morph into a user for testing purposes. """
# If there's no 'extra' component to the URL, return the options page.
if extra is None or extra == '':
context = {'module': self}
return render_to_response(self.baseDir()+'options.html', request, (prog, tl), context)
# Default query is to get program participants
query = self.program.students_union(True) | self.program.teachers_union(True) | self.program.volunteers_union(True)
# List all of the useful queries we can think of. If we had some autosave (pickle type)
# feature, that could be really cool.
saved_queries = { 'student': self.program.students_union(True),
'teacher': self.program.teachers_union(True),
'volunteer': self.program.volunteers_union(True),
'program': self.program.students_union(True) | self.program.teachers_union(True) | self.program.volunteers_union(True),
'all': Q()
}
if extra in saved_queries:
query = saved_queries[extra]
user, found = search_for_user(request, ESPUser.objects.filter(query))
if not found:
return user
request.user.switch_to_user(request,
user,
'/manage/%s/admin_morph/' % prog.getUrlBase(),
'Managing %s' % self.program.niceName(),
False)
return HttpResponseRedirect('/')
def satprepuserdiagnostic(self, request, tl, one, two, module, extra,
prog):
context = {}
response, userfound = search_for_user(request,
self.program.students_union())
if not userfound:
return response
user = response
if request.method == 'POST':
form = SATPrepDiagForm(request.POST)
if form.is_valid():
reginfo = SATPrepRegInfo.getLastForProgram(user, prog)
form.instance = reginfo
form.save()
return self.goToCore(tl)
else:
reginfo = SATPrepRegInfo.getLastForProgram(user, prog)
form = SATPrepDiagForm(instance=reginfo)
return render_to_response(self.baseDir() + 'satprep_diag.html',
request, (prog, tl), {
'form': form,
'user': user
})
def schedule_students(self, request, tl, one, two, module, extra, prog):
""" Redirect to student registration, having morphed into the desired
student. """
user, found = search_for_user(request,
ESPUser.getAllOfType('Student', False))
if not found:
return user
request.user.switch_to_user(request, user, self.getCoreURL(tl),
'OnSite Registration!', True)
return HttpResponseRedirect('/learn/%s/studentreg' %
self.program.getUrlBase())
def schedule_students(self, request, tl, one, two, module, extra, prog):
""" Redirect to student registration, having morphed into the desired
student. """
user, found = search_for_user(request, ESPUser.getAllOfType('Student', False))
if not found:
return user
request.user.switch_to_user(request,
user,
self.getCoreURL(tl),
'OnSite Registration!',
True)
return HttpResponseRedirect('/learn/%s/studentreg' % self.program.getUrlBase())
def paiditems(self, request, tl, one, two, module, extra, prog):
# Get a user
user, found = search_for_user(request)
if not found:
return user
# Get the optional purchases for that user
iac = IndividualAccountingController(prog, user)
context = {}
context['student'] = user
context['requireditems'] = iac.get_transfers(required_only=True)
context['reserveditems'] = iac.get_transfers(optional_only=True)
context['amount_requested'] = iac.amount_requested()
context['amount_finaid'] = iac.amount_finaid()
context['amount_due'] = iac.amount_due()
return render_to_response(self.baseDir()+'paiditems.html', request, context)
def checkin(self, request, tl, one, two, module, extra, prog):
user, found = search_for_user(request, self.program.students_union())
if not found:
return user
self.student = user
if request.method == 'POST':
for key in ['attended','paid','liab','med']:
if request.POST.has_key(key):
self.create_record(key)
else:
self.delete_record(key)
return self.goToCore(tl)
return render_to_response(self.baseDir()+'checkin.html', request, {'module': self, 'program': prog})
def checkin(self, request, tl, one, two, module, extra, prog):
user, found = search_for_user(request, self.program.students_union())
if not found:
return user
self.student = user
if request.method == 'POST':
for key in ['Attended', 'Paid', 'LiabilityFiled', 'MedicalFiled']:
if request.POST.has_key(key):
self.createBit(key)
else:
self.deleteBit(key)
return self.goToCore(tl)
return render_to_response(self.baseDir() + 'checkin.html', request,
(prog, tl), {'module': self})
def admin_morph(self, request, tl, one, two, module, extra, prog):
""" This function will allow someone to morph into a user for testing purposes. """
# If there's no 'extra' component to the URL, return the options page.
if extra is None or extra == '':
context = {'module': self}
return render_to_response(self.baseDir()+'options.html', request, context)
# Prepare Q objects for common student, teacher, and volunteer searches.
# This used to use Program.students_union() et al, but those are way too complicated queries.
search_keys = {
'student': ['profile', 'enrolled', 'lotteried_students', 'confirmed'],
'teacher': ['profile', 'class_submitted'],
'volunteer': ['volunteer_all'],
}
saved_queries = {}
self.program.setup_user_filters()
for key in search_keys:
user_list = getattr(self.program, key + 's')(QObjects=True)
saved_queries[key] = reduce(operator.or_, [user_list[user_type] for user_type in search_keys[key] if user_type in user_list])
saved_queries['program'] = reduce(operator.or_, saved_queries.values())
saved_queries['all'] = Q()
# Default to using all program participants, if no query type is specified
if extra in saved_queries:
query = saved_queries[extra]
else:
query = saved_queries['program']
user, found = search_for_user(request, ESPUser.objects.filter(query))
if not found:
return user
request.user.switch_to_user(request,
user,
'/manage/%s/admin_morph/' % prog.getUrlBase(),
'Managing %s' % self.program.niceName(),
False)
return HttpResponseRedirect('/')
def admin_morph(self, request, tl, one, two, module, extra, prog):
""" This function will allow someone to morph into a user for testing purposes. """
# If there's no 'extra' component to the URL, return the options page.
if extra is None or extra == '':
context = {'module': self}
return render_to_response(self.baseDir()+'options.html', request, context)
# Prepare Q objects for common student, teacher, and volunteer searches.
# This used to use Program.students_union() et al, but those are way too complicated queries.
search_keys = {
'student': ['profile', 'enrolled', 'lotteried_students', 'confirmed'],
'teacher': ['profile', 'class_submitted'],
'volunteer': ['volunteer_all'],
}
saved_queries = {}
self.program.setup_user_filters()
for key in search_keys:
user_list = getattr(self.program, key + 's')(QObjects=True)
saved_queries[key] = reduce(operator.or_, [user_list[user_type] for user_type in search_keys[key] if user_type in user_list], Q())
saved_queries['program'] = reduce(operator.or_, saved_queries.values())
saved_queries['all'] = Q()
# Default to using all program participants, if no query type is specified
if extra in saved_queries:
query = saved_queries[extra]
else:
query = saved_queries['program']
user, found = search_for_user(request, ESPUser.objects.filter(query))
if not found:
return user
request.user.switch_to_user(request,
user,
'/manage/%s/admin_morph/' % prog.getUrlBase(),
'Managing %s' % self.program.niceName(),
False)
return HttpResponseRedirect('/')
