def class_status(self, request, tl, one, two, module, extra, prog):
clsid = 0
if request.POST.has_key('clsid'):
clsid = request.POST['clsid']
else:
clsid = extra
classes = ClassSubject.objects.filter(id=clsid)
if len(classes) != 1 or not request.user.canEdit(classes[0]):
return render_to_response(self.baseDir() + 'cannoteditclass.html',
request, (prog, tl), {})
cls = classes[0]
context = {
'cls':
cls,
'module':
self,
'blogposts':
Entry.find_posts_by_perms(request.user, GetNode('V/Subscribe'),
cls.anchor)
}
return render_to_response(self.baseDir() + 'class_status.html',
request, (prog, tl), context)
def bulkapproval(self, request, tl, one, two, module, extra, prog):
"""
Allow admins to approve classes en masse by entering a list of
ClassSubject ids separated by newlines.
"""
if request.POST.has_key('clslist'):
clsids = request.POST['clslist'].split('\n')
clsids = [id.strip() for id in clsids if id.strip() != ""]
# Ignore the class category symbols. We don't need to read them,
# and half the time people are probably going to get them wrong.
clsids = [''.join(c for c in id if c in '0123456789') for id in clsids]
cls_subjects = ClassSubject.objects.filter(id__in=clsids, parent_program=prog)
cls_subjects.update(status=10)
cls_sections = ClassSection.objects.filter(parent_class__in=cls_subjects)
cls_sections.update(status=10)
context = {}
context['updated_classes'] = cls_subjects
cls_id_strings = set([str(cls.id) for cls in cls_subjects])
context['failed_ids'] = [id for id in clsids if not (id in cls_id_strings)]
context['num_failures'] = len(context['failed_ids'])
return render_to_response(self.baseDir()+"approval_success.html", request, (prog, tl), context)
return render_to_response(self.baseDir()+"mass_approve_form.html", request, (prog, tl), {})
def printschedules(self, request, tl, one, two, module, extra, prog):
" A link to print a schedule. "
if not request.GET.has_key('sure') and not request.GET.has_key('gen_img'):
printers = Printer.objects.all().values_list('name', flat=True)
return render_to_response(self.baseDir()+'instructions.html',
request, {'printers': printers})
if request.GET.has_key('sure'):
return render_to_response(self.baseDir()+'studentschedulesrenderer.html',
request, {})
requests = PrintRequest.objects.filter(time_executed__isnull=True)
if extra and Printer.objects.filter(name=extra).exists():
requests = requests.filter(printer__name=extra)
for req in requests:
req.time_executed = datetime.now()
req.save()
# get students
old_students = set([ ESPUser(req.user) for req in requests ])
if len(old_students) > 0:
response = ProgramPrintables.get_student_schedules(request, list(old_students), prog, onsite=True)
# set the refresh rate
#response['Refresh'] = '2'
return response
else:
# No response if no users
return HttpResponse('')
def commpanel(self, request, tl, one, two, module, extra, prog):
usc = UserSearchController()
context = {}
context['program'] = prog
# If list information was submitted, continue to prepare a message
if request.method == 'POST':
# Turn multi-valued QueryDict into standard dictionary
data = {}
for key in request.POST:
data[key] = request.POST[key]
## Handle normal list selecting submissions
if ('base_list' in data
and 'recipient_type' in data) or ('combo_base_list'
in data):
filterObj = usc.filter_from_postdata(prog, data)
if data['use_checklist'] == '1':
(response, unused) = get_user_checklist(
request,
ESPUser.objects.filter(filterObj.get_Q()).distinct(),
filterObj.id,
'/manage/%s/commpanel_old' % prog.getUrlBase())
return response
context['filterid'] = filterObj.id
context['listcount'] = ESPUser.objects.filter(
filterObj.get_Q()).distinct().count()
return render_to_response(self.baseDir() + 'step2.html',
request, (prog, tl), context)
## Prepare a message starting from an earlier request
elif 'msgreq_id' in data:
msgreq = MessageRequest.objects.get(id=data['msgreq_id'])
context['filterid'] = msgreq.recipients.id
context['listcount'] = msgreq.recipients.getList(
ESPUser).count()
context['from'] = msgreq.sender
context['subject'] = msgreq.subject
context['replyto'] = msgreq.special_headers_dict.get(
'Reply-To', '')
context['body'] = msgreq.msgtext
return render_to_response(self.baseDir() + 'step2.html',
request, (prog, tl), context)
else:
raise ESPError(
True
), 'What do I do without knowing what kind of users to look for?'
# Otherwise, render a page that shows the list selection options
context.update(usc.prepare_context(prog))
return render_to_response(self.baseDir() + 'commpanel_new.html',
request, (prog, tl), context)
def search_for_user(request, user_type='Any', extra='', returnList = False):
""" Interface to search for a user. If you need a user, just use this.
Returns (user or response, user returned?) """
users = None
error = False
usc = UserSearchController()
if isinstance(user_type, basestring):
user_query = usc.query_from_criteria(user_type, request.GET)
QSUsers = ESPUser.objects.filter(user_query).distinct()
elif isinstance(user_type, QuerySet):
QSUsers = usc.filter_from_criteria(user_type, request.GET)
else:
raise ESPError(True), 'Invalid user_type: %s' % type(user_type)
# We need to ask for more user input if no filtering options were selected
if not usc.updated:
users = None
else:
users = [ ESPUser(user) for user in QSUsers ]
if users is not None and len(users) == 0:
error = True
users = None
if users is None:
return (render_to_response('users/usersearch.html', request, None, {'error': error, 'extra':extra, 'list': returnList}), False)
if len(users) == 1:
return (users[0], True)
else:
users.sort()
if (request.GET.has_key('listokay') and request.GET['listokay'] == 'true') or \
(request.GET.has_key('submitform') and request.GET['submitform'] == 'Use Filtered List'):
Q_Filter = None
if not hasattr(Q_include, 'old'):
Q_Filter = Q_include
if not hasattr(Q_exclude, 'old'):
Q_Filter &= ~Q_exclude
else:
if not hasattr(Q_exclude, 'old'):
Q_Filter = ~Q_exclude
return (Q_Filter, True)
context = {'users': users, 'extra':str(extra), 'list': returnList}
return (render_to_response('users/userpick.html', request, None, context), False)
print 'Ran into some kind of problem. %d users' % len(users)
def deleteclass(self, request, tl, one, two, module, extra, prog):
classes = ClassSubject.objects.filter(id=extra)
if len(classes) != 1 or not request.user.canEdit(classes[0]):
return render_to_response(self.baseDir() + 'cannoteditclass.html',
request, {})
cls = classes[0]
if cls.num_students() > 0:
return render_to_response(self.baseDir() + 'toomanystudents.html',
request, {})
cls.delete()
return self.goToCore(tl)
def class_docs(self, request, tl, one, two, module, extra, prog):
from esp.web.forms.fileupload_form import FileUploadForm
from esp.qsdmedia.models import Media
clsid = 0
if request.POST.has_key('clsid'):
clsid = request.POST['clsid']
else:
clsid = extra
classes = ClassSubject.objects.filter(id=clsid)
if len(classes) != 1 or not request.user.canEdit(classes[0]):
return render_to_response(self.baseDir() + 'cannoteditclass.html',
request, (prog, tl), {})
target_class = classes[0]
context_form = FileUploadForm()
if request.method == 'POST':
if request.POST['command'] == 'delete':
docid = request.POST['docid']
media = Media.objects.get(id=docid)
media.delete()
elif request.POST['command'] == 'add':
form = FileUploadForm(request.POST, request.FILES)
if form.is_valid():
media = Media(friendly_name=form.cleaned_data['title'],
anchor=target_class.anchor)
ufile = form.cleaned_data['uploadedfile']
# Append the class code on the filename
desired_filename = '%s_%s' % (target_class.emailcode(),
ufile.name)
media.handle_file(ufile, desired_filename)
media.format = ''
media.save()
else:
context_form = form
context = {
'cls': target_class,
'uploadform': context_form,
'module': self
}
return render_to_response(self.baseDir() + 'class_docs.html', request,
(prog, tl), context)
def allClassList(self, request, tl, one, two, module, extra, prog):
""" Display a list of all classes that still have space in them """
# This view still uses classes, not sections. The templates show information
# for each section of each class.
classes = [(i.num_students() / (i.class_size_max + 1), i)
for i in self.program.classes()]
classes.sort()
classes = [i[1] for i in classes]
categories = {}
for cls in classes:
categories[cls.category_id] = {
'id': cls.category_id,
'category': cls.category.category
}
printers = [x.name for x in GetNode('V/Publish/Print').children()]
return render_to_response(
self.baseDir() + 'allclasslist.html', request, (prog, tl), {
'classes': classes,
'prog': self.program,
'one': one,
'two': two,
'categories': categories.values(),
'printers': printers
})
def edit_availability(self, request, tl, one, two, module, extra, prog):
"""
Admins edits availability of the specified user.
"""
target_id = None
if request.GET.has_key('user'):
target_id = request.GET['user']
elif request.POST.has_key('user'):
target_id = request.POST['user']
else:
context = {}
return render_to_response(
self.baseDir() + 'check_availability.html', request, context)
try:
teacher = ESPUser.objects.get(id=target_id)
except:
try:
teacher = ESPUser.objects.get(username=target_id)
except:
raise ESPError(False), "The user with id/username="******" does not appear to exist!"
return self.availabilityForm(request, tl, one, two, prog, teacher,
True)
def survey_create(self, request, tl, one, two, module, extra, prog):
context = {'program': prog}
return render_to_response(
'program/modules/surveymanagement/create.html', request,
prog.anchor, context)
def resources_timeslot(self, request, tl, one, two, module, extra, prog):
context = {}
response = None
controller = ResourceController(prog)
if request.GET.has_key('op') and request.GET['op'] == 'edit':
# pre-fill form
current_slot = Event.objects.get(id=request.GET['id'])
context['timeslot_form'] = TimeslotForm()
context['timeslot_form'].load_timeslot(current_slot)
if request.GET.has_key('op') and request.GET['op'] == 'delete':
# show delete confirmation page
context['prog'] = self.program
context['timeslot'] = Event.objects.get(id=request.GET['id'])
response = render_to_response(
self.baseDir() + 'timeslot_delete.html', request, context)
if request.method == 'POST':
data = request.POST
if data['command'] == 'reallyremove':
controller.delete_timeslot(data['id'])
elif data['command'] == 'addedit':
# add/edit timeslot
form = TimeslotForm(data)
if form.is_valid():
controller.add_or_edit_timeslot(form)
else:
context['timeslot_form'] = form
return (response, context)
def userview(request):
""" Render a template displaying all the information about the specified user """
try:
user = ESPUser.objects.get(username=request.GET['username'])
except:
raise ESPError(False), "Sorry, can't find anyone with that username."
teacherbio = TeacherBio.getLastBio(user)
if not teacherbio.picture:
teacherbio.picture = 'images/not-available.jpg'
from esp.users.forms.user_profile import StudentInfoForm
if 'graduation_year' in request.GET:
student_info = user.getLastProfile().student_info
student_info.graduation_year = int(request.GET['graduation_year'])
student_info.save()
change_grade_form = StudentInfoForm(user=user)
if 'disabled' in change_grade_form.fields['graduation_year'].widget.attrs:
del change_grade_form.fields['graduation_year'].widget.attrs['disabled']
change_grade_form.fields['graduation_year'].initial = ESPUser.YOGFromGrade(user.getGrade())
change_grade_form.fields['graduation_year'].choices = filter(lambda choice: bool(choice[0]), change_grade_form.fields['graduation_year'].choices)
context = {
'user': user,
'taught_classes' : user.getTaughtClasses().order_by('parent_program', 'id'),
'enrolled_classes' : user.getEnrolledSections().order_by('parent_class__parent_program', 'id'),
'taken_classes' : user.getSections().order_by('parent_class__parent_program', 'id'),
'teacherbio': teacherbio,
'domain': settings.SITE_INFO[1],
'change_grade_form': change_grade_form,
}
return render_to_response("users/userview.html", request, context )
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 satprepinfo(self, request, tl, one, two, module, extra, prog):
subject_list = module_ext.SATPrepTeacherModuleInfo.subjects()
moduleinfos = module_ext.SATPrepTeacherModuleInfo.objects.filter(
user=request.user, program=self.program)
if request.method == 'POST':
if len(moduleinfos) == 0:
form = SATPrepTeacherInfoForm(subject_list, request.POST)
if form.is_valid():
info = form.save(commit=False)
info.user = request.user
info.program = self.program
info.save()
return self.goToCore(tl)
else:
form = SATPrepTeacherInfoForm(subject_list,
request.POST,
instance=moduleinfos[0])
if form.is_valid():
form.save()
return self.goToCore(tl)
else:
if len(moduleinfos) == 0:
form = SATPrepTeacherInfoForm(subject_list)
else:
form = SATPrepTeacherInfoForm(subject_list,
instance=moduleinfos[0])
return render_to_response(self.baseDir() + 'satprep_info.html',
request, (prog, tl), {'form': form})
def medicalbypass(self, request, tl, one, two, module, extra, prog):
# yes it's hacky, but it's two days before Splash student reg
# still hacky, because it works and I'm too lazy to refactor ~shulinye
status = None
if request.method == 'POST':
username = request.POST['username']
if ESPUser.objects.filter(username=username).exists():
user = ESPUser.objects.get(username=username)
if Record.objects.filter(user=user,
program=self.program,
event="med_bypass").exists():
status = 'bypass exists'
elif Record.objects.filter(user=user,
program=self.program,
event="med").exists():
status = 'reg bit exists'
else:
Record.objects.create(user=user,
program=self.program,
event="med_bypass")
status = 'success'
else:
status = 'invalid user'
context = {'status': status}
return render_to_response(self.baseDir() + 'medicalbypass.html',
request, context)
def splashinfo(self, request, tl, one, two, module, extra, prog):
form = SplashInfoForm(program=prog)
missing_siblingname = False
if request.method == 'POST':
new_data = request.POST.copy()
form = SplashInfoForm(new_data, program=prog)
if form.is_valid():
if 'siblingdiscount' in form.cleaned_data and eval(
form.cleaned_data['siblingdiscount']) and len(
form.cleaned_data['siblingname']) == 0:
missing_siblingname = True
else:
spi = SplashInfo.getForUser(request.user, self.program)
form.save(spi)
return self.goToCore(tl)
else:
spi = SplashInfo.getForUser(request.user, self.program)
form.load(spi)
context = {}
context['form'] = form
context['missing_siblingname'] = missing_siblingname
return render_to_response(self.baseDir() + 'splashinfo.html', request,
(prog, tl), context)
def medicalbypass(self, request, tl, one, two, module, extra, prog):
status = None
if request.method == 'POST':
form = GenericSearchForm(request.POST)
if form.is_valid():
user = form.cleaned_data['target_user']
if Record.objects.filter(user=user,
program=self.program,
event="med_bypass").exists():
status = 'bypass exists'
elif Record.objects.filter(user=user,
program=self.program,
event="med").exists():
status = 'reg bit exists'
else:
Record.objects.create(user=user,
program=self.program,
event="med_bypass")
status = 'success'
else:
status = 'invalid user'
context = {'status': status, 'form': GenericSearchForm()}
return render_to_response(self.baseDir() + 'medicalbypass.html',
request, context)
def get_user_checklist(request, userList, extra='', nextpage=None):
""" Generate a checklist of users given an initial list of users to pick from.
Returns a tuple (userid_query or response, users found?)
The query that's returned contains the id's of just the users which are checked off. """
if request.POST.has_key('submit_checklist') and \
request.POST['submit_checklist'] == 'true':
UsersQ = Q(id=-1)
for key in request.POST.keys():
if 'userno' in key:
try:
val = int(request.POST[key])
UsersQ |= Q(id=val)
except:
pass
return (UsersQ, True)
context = {}
context['extra'] = extra
context['users'] = userList
if nextpage is None:
context['nextpage'] = request.path
else:
context['nextpage'] = nextpage
return (render_to_response('users/userchecklist.html', request, None, context), False) # make the checklist
def payonline(self, request, tl, one, two, module, extra, prog):
user = ESPUser(request.user)
iac = IndividualAccountingController(self.program, request.user)
context = {}
context['module'] = self
context['one'] = one
context['two'] = two
context['tl'] = tl
context['user'] = user
context['invoice_id'] = iac.get_id()
context['identifier'] = iac.get_identifier()
payment_type = iac.default_payments_lineitemtype()
sibling_type = iac.default_siblingdiscount_lineitemtype()
grant_type = iac.default_finaid_lineitemtype()
context['itemizedcosts'] = iac.get_transfers().exclude(
line_item__in=[payment_type, sibling_type, grant_type]).order_by(
'-line_item__required')
context['itemizedcosttotal'] = iac.amount_due()
context['subtotal'] = iac.amount_requested()
context['financial_aid'] = iac.amount_finaid()
context['sibling_discount'] = iac.amount_siblingdiscount()
context['amount_paid'] = iac.amount_paid()
if 'HTTP_HOST' in request.META:
context['hostname'] = request.META['HTTP_HOST']
else:
context['hostname'] = Site.objects.get_current().domain
context['institution'] = settings.INSTITUTION_NAME
context['storename'] = self.store_id
context['support_email'] = settings.DEFAULT_EMAIL_ADDRESSES['support']
return render_to_response(self.baseDir() + 'cardpay.html', request,
context)
def view_app(self, request, tl, one, two, module, extra, prog):
scrmi = prog.getModuleExtension('StudentClassRegModuleInfo')
reg_nodes = scrmi.reg_verbs()
try:
cls = ClassSubject.objects.get(id = extra)
section = cls.default_section()
except ClassSubject.DoesNotExist:
raise ESPError(False), 'Cannot find class.'
student = request.GET.get('student',None)
if not student:
student = request.POST.get('student','')
try:
student = ESPUser(User.objects.get(id = student))
except ESPUser.DoesNotExist:
raise ESPError(False), 'Cannot find student, %s' % student
if student.userbit_set.filter(qsc__parent=cls.anchor, verb__in=reg_nodes).count() == 0:
raise ESPError(False), 'Student not a student of this class.'
try:
student.app = student.studentapplication_set.get(program = self.program)
except:
student.app = None
assert False, student.studentapplication_set.all()[0].__dict__
raise ESPError(False), 'Error: Student did not apply. Student is automatically rejected.'
return render_to_response(self.baseDir()+'app_popup.html', request, (prog, tl), {'class': cls, 'student': student})
def teachercheckin(self, request, tl, one, two, module, extra, prog):
context = {}
if 'when' in request.GET:
form = TeacherCheckinForm(request.GET)
if form.is_valid():
when = form.cleaned_data['when']
if when is not None:
context['when'] = when
context['url_when'] = request.GET['when']
else:
form = TeacherCheckinForm()
context['module'] = self
context['form'] = form
context['time_slots'] = prog.getTimeSlots()
now = prog.getTimeSlots().filter(
start__gte=datetime.now()).order_by('start')
if now.exists():
context['now'] = now[0]
else:
context['now'] = None
return render_to_response(self.baseDir() + 'teachercheckin.html',
request, (prog, tl), context)
def editremoteprofile(self, request, tl, one, two, module, extra, prog):
context = {'module': self}
profile_qs = module_ext.RemoteProfile.objects.filter(
user=request.user, program=self.program)
if profile_qs.exists():
profile = profile_qs.order_by('-id')[0]
else:
profile, created = module_ext.RemoteProfile.objects.get_or_create(
user=request.user, program=self.program)
profile.save()
if request.method == 'POST':
form = RemoteTeacherProfileForm(self, request.POST)
if form.is_valid():
form.instance = profile
form.save()
return self.goToCore(tl)
else:
form = RemoteTeacherProfileForm(module=self, instance=profile)
context['form'] = form
return render_to_response(self.baseDir() + 'editprofile.html', request,
(prog, tl), context)
def bio_edit_user_program(request, founduser, foundprogram, external=False):
""" Edits a teacher bio, given user and program """
if founduser is None:
if external:
raise ESPError(), 'No user given.'
else:
raise Http404
if not founduser.isTeacher():
raise ESPError(False), '%s is not a teacher of ESP.' % \
(founduser.name())
if request.user.id != founduser.id and request.user.is_staff != True:
raise ESPError(False), 'You are not authorized to edit this biography.'
lastbio = TeacherBio.getLastBio(founduser)
# if we submitted a newly edited bio...
from esp.web.forms.bioedit_form import BioEditForm
if request.method == 'POST' and request.POST.has_key('bio_submitted'):
form = BioEditForm(request.POST, request.FILES)
if form.is_valid():
if foundprogram is not None:
# get the last bio for this program.
progbio = TeacherBio.getLastForProgram(founduser, foundprogram)
else:
progbio = lastbio
# the slug bio and bio
progbio.slugbio = form.cleaned_data['slugbio']
progbio.bio = form.cleaned_data['bio']
progbio.save()
# save the image
if form.cleaned_data['picture'] is not None:
progbio.picture = form.cleaned_data['picture']
else:
progbio.picture = lastbio.picture
progbio.save()
if external:
return True
return HttpResponseRedirect(progbio.url())
else:
formdata = {
'slugbio': lastbio.slugbio,
'bio': lastbio.bio,
'picture': lastbio.picture
}
form = BioEditForm(formdata)
return render_to_response(
'users/teacherbioedit.html', request, GetNode('Q/Web/myesp'), {
'form': form,
'institution': settings.INSTITUTION_NAME,
'user': founduser,
'picture_file': lastbio.picture
})
def create_filter(self, request, program, template=None, target_path=None):
""" Function to obtain a list of users, possibly requiring multiple requests.
Similar to the old get_user_list function.
"""
if template is None:
template = 'program/modules/commmodule/usersearch_default.html'
if request.method == 'POST':
# Turn multi-valued QueryDict into standard dictionary
data = {}
for key in request.POST:
data[key] = request.POST[key]
# Look for signs that this request contains user search options and act accordingly
if ('base_list' in data
and 'recipient_type' in data) or ('combo_base_list'
in data):
filterObj = self.filter_from_postdata(program, data)
return (filterObj, True)
if target_path is None:
target_path = request.path
return (render_to_response(template, request, (program, 'manage'),
self.prepare_context(program,
target_path)), False)
def teacherhandout(self,
request,
tl,
one,
two,
module,
extra,
prog,
template_file='teacherschedules.html'):
# Use the template defined in ProgramPrintables
from esp.program.modules.handlers import ProgramPrintables
context = {'module': self}
pmos = ProgramModuleObj.objects.filter(
program=prog, module__handler__icontains='printables')
if pmos.count() == 1:
pmo = ProgramPrintables(pmos[0])
teacher = ESPUser(request.user)
scheditems = []
for cls in teacher.getTaughtClasses().filter(
parent_program=self.program):
if cls.isAccepted():
for section in cls.sections.all():
scheditems.append({
'name': teacher.name(),
'teacher': teacher,
'cls': section
})
scheditems.sort()
context['scheditems'] = scheditems
return render_to_response(pmo.baseDir() + template_file, request,
context)
else:
raise ESPError(
False
), 'No printables module resolved, so this document cannot be generated. Consult the webmasters.'
def resources_equipment(self, request, tl, one, two, module, extra, prog):
context = {}
response = None
controller = ResourceController(prog)
if request.GET.has_key('op') and request.GET['op'] == 'edit':
# pre-fill form
equip = Resource.objects.get(id=request.GET['id'])
context['equipment_form'] = EquipmentForm(self.program)
context['equipment_form'].load_equipment(self.program, equip)
if request.GET.has_key('op') and request.GET['op'] == 'delete':
# show delete confirmation page
context['prog'] = self.program
context['equipment'] = Resource.objects.get(id=request.GET['id'])
response = render_to_response(
self.baseDir() + 'equipment_delete.html', request, context)
if request.method == 'POST':
data = request.POST
if data['command'] == 'reallyremove':
controller.delete_equipment(data['id'])
elif data['command'] == 'addedit':
# add/edit restype
form = EquipmentForm(self.program, data)
if form.is_valid():
form.save_equipment(self.program)
else:
context['equipment_form'] = form
return (response, context)
def signup(self, request, tl, one, two, module, extra, prog):
context = {}
if request.method == 'POST':
form = VolunteerOfferForm(request.POST, program=prog)
if form.is_valid():
offers = form.save()
context['complete'] = True
context['complete_name'] = offers[0].name
context['complete_email'] = offers[0].email
context['complete_phone'] = offers[0].phone
form = VolunteerOfferForm(program=prog)
else:
form = VolunteerOfferForm(program=prog)
# Pre-fill information if possible
if hasattr(request.user, 'email'):
form.load(request.user)
# Override default appearance; template doesn't mind taking a string instead
context['form'] = form._html_output(
normal_row=
u'<tr%(html_class_attr)s><th>%(label)s</th><td>%(errors)s%(field)s%(help_text)s</td></tr>',
error_row=u'<tr><td colspan="2">%s</td></tr>',
row_ender=u'</td></tr>',
help_text_html=u'%s',
errors_on_separate_row=False)
return render_to_response(
'program/modules/volunteersignup/signup.html', request, context)
def getClass(self, request, extra):
found = False
if not found and extra is not None and len(extra.strip()) > 0:
try:
clsid = int(extra)
finally:
cls, found = self.getClassFromId(clsid)
if found:
return (cls, True)
elif cls is not False:
return (cls, False)
if not found and request.POST.has_key('clsid'):
try:
clsid = int(request.POST['clsid'])
finally:
cls, found = self.getClassFromId(clsid)
if found:
return (cls, True)
elif cls is not False:
return (cls, False)
if not found and request.GET.has_key('clsid'):
try:
clsid = int(request.GET['clsid'])
finally:
cls, found = self.getClassFromId(clsid)
if found:
return (cls, True)
elif cls is not False:
return (cls, False)
return (render_to_response(self.baseDir()+'cannotfindclass.html', {}), False)
def quiz(self, request, tl, one, two, module, extra, prog):
custom_form_id = Tag.getProgramTag('quiz_form_id', prog, None)
if custom_form_id:
cf = Form.objects.get(id=int(custom_form_id))
else:
raise ESPError(
'Cannot find an appropriate form for the quiz. Please ask your administrator to create a form and set the quiz_form_id Tag.'
)
form_wizard = FormHandler(cf, request, request.user).get_wizard()
form_wizard.curr_request = request
if request.method == 'POST':
form = form_wizard.get_form(0, request.POST, request.FILES)
if form.is_valid():
form_wizard.done([form])
self.controller.markCompleted(request.user)
return self.goToCore(tl)
else:
form = form_wizard.get_form(0)
return render_to_response(self.baseDir() + 'quiz.html', request,
(prog, tl), {
'prog': prog,
'form': form
})
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('/')
