def user_registration_validate(request):
"""Handle the account creation logic when the form is submitted
This function is overloaded to handle either one or two phase reg"""
if not Tag.getBooleanTag("ask_about_duplicate_accounts", default=False):
form = SinglePhaseUserRegForm(request.POST)
else:
form = UserRegForm(request.POST)
if form.is_valid():
try:
#there is an email-only account with that email address to upgrade
user = ESPUser.objects.get(email=form.cleaned_data['email'],
password='******')
except ESPUser.DoesNotExist:
try:
#there is an inactive account with that username
user = ESPUser.objects.filter(
username=form.cleaned_data['username'],
is_active=False).latest('date_joined')
except ESPUser.DoesNotExist:
user = ESPUser.objects.create_user(
username=form.cleaned_data['username'],
email=form.cleaned_data['email'])
user.username = form.cleaned_data['username']
user.last_name = form.cleaned_data['last_name']
user.first_name = form.cleaned_data['first_name']
user.set_password(form.cleaned_data['password'])
# Append key to password and disable until activation if desired
if Tag.getBooleanTag('require_email_validation', default=False):
userkey = random.randint(0, 2**31 - 1)
user.password += "_%d" % userkey
user.is_active = False
user.save()
user.groups.add(
Group.objects.get(name=form.cleaned_data['initial_role']))
if not Tag.getBooleanTag('require_email_validation', default=False):
user = authenticate(username=form.cleaned_data['username'],
password=form.cleaned_data['password'])
login(request, user)
return HttpResponseRedirect('/myesp/profile/')
else:
send_activation_email(user, userkey)
return render_to_response(
'registration/account_created_activation_required.html',
request, {
'user': user,
'site': Site.objects.get_current()
})
else:
return render_to_response('registration/newuser.html', request,
{'form': form})
def lotterystudentreg(self, request, tl, one, two, module, extra, prog):
"""
Serve the student reg page.
This is just a static page;
it gets all of its content from AJAX callbacks.
"""
from django.conf import settings
import json
from django.utils.safestring import mark_safe
crmi = prog.classregmoduleinfo
open_class_category = prog.open_class_category
# Convert the open_class_category ClassCategory object into a dictionary, only including the attributes the lottery needs or might need
open_class_category = dict( [ (k, getattr( open_class_category, k )) for k in ['id','symbol','category'] ] )
# Convert this into a JSON string, and mark it safe so that the Django template system doesn't try escaping it
open_class_category = mark_safe(json.dumps(open_class_category))
context = {'prog': prog, 'support': settings.DEFAULT_EMAIL_ADDRESSES['support'], 'open_class_registration': {False: 0, True: 1}[crmi.open_class_registration], 'open_class_category': open_class_category}
ProgInfo = prog.studentclassregmoduleinfo
#HSSP-style lottery
if ProgInfo.use_priority == True and ProgInfo.priority_limit > 1:
return render_to_response('program/modules/lotterystudentregmodule/student_reg_hssp.html', request, context)
#Splark/Spash style lottery
return render_to_response('program/modules/lotterystudentregmodule/student_reg_splash.html', request, context)
def grouptextpanel(self, request, tl, one, two, module, extra, prog):
if not self.is_configured():
return render_to_response(self.baseDir() + 'not_configured.html',
request, {})
usc = UserSearchController()
context = {}
context['program'] = prog
if request.method == "POST":
data = {}
for key in request.POST:
data[key] = request.POST[key]
filterObj = UserSearchController().filter_from_postdata(prog, data)
context['filterid'] = filterObj.id
context['num_users'] = ESPUser.objects.filter(
filterObj.get_Q()).distinct().count()
context['est_time'] = float(context['num_users']) * 1.0 / len(
settings.TWILIO_ACCOUNT_NUMBERS)
return render_to_response(self.baseDir() + 'options.html', request,
context)
context.update(
usc.prepare_context(prog,
target_path='/manage/%s/grouptextpanel' %
prog.url))
return render_to_response(self.baseDir() + 'search.html', request,
context)
def user_registration_phase1(request):
"""Displays phase 1, and receives and passes off phase 1 submissions."""
if request.user.is_authenticated():
return render_to_response('registration/already_logged_in.html',
request, {})
#depending on a tag, we'll either have registration all in one page,
#or in two separate ones
if not Tag.getBooleanTag("ask_about_duplicate_accounts", default=False):
if request.method == 'POST':
return user_registration_validate(request)
form = SinglePhaseUserRegForm()
return render_to_response('registration/newuser.html', request, {
'form': form,
'site': Site.objects.get_current()
})
#we do want to ask about duplicate accounts
if request.method == 'POST':
return user_registration_checkemail(request)
form = EmailUserRegForm()
return render_to_response('registration/newuser_phase1.html', request, {
'form': form,
'site': Site.objects.get_current()
})
def selectList(self, request, tl, one, two, module, extra, prog):
""" Select a group of users and generate a list of information
about them using the generateList view above. """
usc = UserSearchController()
context = {}
context['program'] = prog
# If list information was submitted, generate a query filter and
# show options for generating a user list
if request.method == 'POST':
# Turn multi-valued QueryDict into standard dictionary
data = {}
for key in request.POST:
data[key] = request.POST[key]
filterObj = usc.filter_from_postdata(prog, data)
# Display list generation options
form = ListGenForm()
context.update({
'form': form,
'filterid': filterObj.id,
'num_users': ESPUser.objects.filter(filterObj.get_Q()).distinct().count()
})
return render_to_response(self.baseDir()+'options.html', request, context)
# Otherwise, render a page that shows the list selection options
context.update(usc.prepare_context(prog, target_path='/manage/%s/selectList' % prog.url))
return render_to_response(self.baseDir()+'search.html', request, context)
def myesp_passwd(request):
""" Change password """
if request.user.username == 'onsite':
raise ESPError(
"Sorry, you're not allowed to change the password of this user. It's special.",
log=False)
if request.method == "POST":
form = UserPasswdForm(user=request.user, data=request.POST)
if form.is_valid():
new_data = form.cleaned_data
user = authenticate(username=request.user.username,
password=new_data['password'])
user.set_password(new_data['newpasswd'])
user.save()
login(request, user)
return render_to_response('users/passwd.html', request,
{'Success': True})
else:
form = UserPasswdForm(user=request.user)
return render_to_response('users/passwd.html', request, {
'Problem': False,
'form': form,
'Success': False
})
def resend_activation_view(request):
if request.user.is_authenticated():
return render_to_response('registration/already_logged_in.html',
request, {})
if request.method == 'POST':
form = AwaitingActivationEmailForm(request.POST)
if not form.is_valid():
return render_to_response('registration/resend.html', request, {
'form': form,
'site': Site.objects.get_current()
})
user = ESPUser.objects.get(username=form.cleaned_data['username'])
userkey = user.password[user.password.rfind("_") + 1:]
send_activation_email(user, userkey)
return render_to_response('registration/resend_done.html', request, {
'form': form,
'site': Site.objects.get_current()
})
else:
form = AwaitingActivationEmailForm()
return render_to_response('registration/resend.html', request, {
'form': form,
'site': Site.objects.get_current()
})
def confirmreg_forreal(self, request, tl, one, two, module, extra, prog, new_reg):
""" The page that is shown once the user saves their student reg,
giving them the option of printing a confirmation """
self.request = request
from esp.program.modules.module_ext import DBReceipt
iac = IndividualAccountingController(prog, request.user)
context = {}
context['one'] = one
context['two'] = two
context['itemizedcosts'] = iac.get_transfers()
user = request.user
context['finaid'] = user.hasFinancialAid(prog)
if user.appliedFinancialAid(prog):
context['finaid_app'] = user.financialaidrequest_set.filter(program=prog).order_by('-id')[0]
else:
context['finaid_app'] = None
context['balance'] = iac.amount_due()
context['owe_money'] = ( context['balance'] != Decimal("0.0") )
if not prog.user_can_join(user):
raise ESPError("This program has filled! It can't accept any more students. Please try again next session.", log=False)
modules = prog.getModules(request.user, tl)
completedAll = True
for module in modules:
if hasattr(module, 'onConfirm'):
module.onConfirm(request)
if not module.isCompleted() and module.required:
completedAll = False
context = module.prepare(context)
if completedAll:
if new_reg:
rec = Record.objects.create(user=user, event="reg_confirmed",
program=prog)
else:
raise ESPError("You must finish all the necessary steps first, then click on the Save button to finish registration.", log=False)
cfe = ConfirmationEmailController()
cfe.send_confirmation_email(request.user, self.program)
try:
receipt_text = DBReceipt.objects.get(program=self.program, action='confirm').receipt
context["request"] = request
context["program"] = prog
return HttpResponse( Template(receipt_text).render( Context(context, autoescape=False) ) )
except DBReceipt.DoesNotExist:
try:
receipt = 'program/receipts/'+str(prog.id)+'_custom_receipt.html'
return render_to_response(receipt, request, context)
except:
receipt = 'program/receipts/default.html'
return render_to_response(receipt, request, context)
def merge_accounts(request):
if request.method == 'POST':
form = UserMergeForm(request.POST)
if form.is_valid():
new_user, old_user = form.cleaned_data['absorber'], form.cleaned_data['absorbee']
merge_users(new_user, old_user)
return render_to_response('users/merge_success.html', request, {'new_user': new_user, 'old_user': old_user})
else:
form = UserMergeForm()
return render_to_response('users/merge_accounts.html', request, {'form': form})
def lottery(self, request, tl, one, two, module, extra, prog):
# Check that the lottery module is included
students = self.program.students()
if 'lotteried_students' not in students and 'twophase_star_students' not in students:
return render_to_response(self.baseDir() + 'not_configured.html', request, {'program': prog})
# Render control page with lottery options
context = {
'options': {k: v for k, v in LotteryAssignmentController.default_options.items() if v[1] is not False},
'has_old_schedules': StudentRegistration.objects.filter(section__parent_class__parent_program=self.program, relationship__name='Enrolled').count() > 0,
}
return render_to_response(self.baseDir()+'lottery.html', request, context)
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 make_admin(request):
if request.method == 'POST':
form = MakeAdminForm(request.POST)
if form.is_valid():
target_user = form.cleaned_data['target_user']
target_user.makeAdmin()
return render_to_response('users/make_admin_success.html', request,
{'target_user': target_user})
else:
form = MakeAdminForm()
return render_to_response('users/make_admin.html', request, {'form': form})
def grouptextfinal(self, request, tl, one, two, module, extra, prog):
if request.method != 'POST' or 'filterid' not in request.GET or 'message' not in request.POST:
raise ESPError(), 'Filter or message have not been properly set'
if not self.is_configured():
return render_to_response(self.baseDir() + 'not_configured.html', request, {})
# get the filter to use and text message to send from the request; this is set in grouptextpanel form
filterObj = PersistentQueryFilter.objects.get(id=request.GET['filterid'])
message = request.POST['message']
log = self.sendMessages(filterObj, message)
return render_to_response(self.baseDir()+'finished.html', request, {'log': log})
def commpanel(self, request, tl, one, two, module, extra, prog):
usc = UserSearchController()
context = {}
# 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)
sendto_fn_name = usc.sendto_fn_from_postdata(data)
sendto_fn = MessageRequest.assert_is_valid_sendto_fn_or_ESPError(sendto_fn_name)
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['sendto_fn_name'] = sendto_fn_name
context['listcount'] = self.approx_num_of_recipients(filterObj, sendto_fn)
return render_to_response(self.baseDir()+'step2.html', request, 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['sendto_fn_name'] = msgreq.sendto_fn_name
sendto_fn = MessageRequest.assert_is_valid_sendto_fn_or_ESPError(msgreq.sendto_fn_name)
context['listcount'] = self.approx_num_of_recipients(msgreq.recipients, sendto_fn)
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, context)
else:
raise ESPError('What do I do without knowing what kind of users to look for?', log=True)
# 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, 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('Invalid user_type: %s' % type(user_type), log=True)
# We need to ask for more user input if no filtering options were selected
if not usc.updated:
users = None
else:
users = [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, {
'error': error,
'extra': extra,
'list': returnList
}), False)
if len(users) == 1:
return (users[0], True)
else:
users.sort()
if request.GET.get('listokay') == 'true' or \
request.GET.get('submitform') == 'Use Filtered List':
Q_Filter = Q(id__in=QSUsers.values_list('id', flat=True))
return (Q_Filter, True)
context = {'users': users, 'extra': str(extra), 'list': returnList}
return (render_to_response('users/userpick.html', request,
context), False)
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 'clsid' in request.POST:
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, {})
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'],
owner=target_class)
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,
context)
def registrationtype_management(self, request, tl, one, two, module, extra,
prog):
from esp.program.modules.forms.admincore import VisibleRegistrationTypeForm as VRTF
from django.conf import settings
from esp.program.controllers.studentclassregmodule import RegistrationTypeController as RTC
context = {}
context['one'] = one
context['two'] = two
context['prog'] = prog
context['POST'] = False
context['saved'] = False
context['support'] = settings.DEFAULT_EMAIL_ADDRESSES['support']
if request.method == 'POST':
context['POST'] = True
form = VRTF(request.POST)
if form.is_valid():
context['saved'] = RTC.setVisibleRegistrationTypeNames(
form.cleaned_data['display_names'], prog)
display_names = list(
RTC.getVisibleRegistrationTypeNames(prog, for_VRT_form=True))
context['form'] = VRTF(data={'display_names': display_names})
return render_to_response(
self.baseDir() + 'registrationtype_management.html', request,
context)
def view_app(self, request, tl, one, two, module, extra, prog):
scrmi = prog.studentclassregmoduleinfo
reg_nodes = scrmi.reg_verbs()
try:
cls = ClassSubject.objects.get(id = extra)
section = cls.default_section()
except ClassSubject.DoesNotExist:
raise ESPError('Cannot find class.', log=False)
student = request.GET.get('student',None)
if not student:
student = request.POST.get('student','')
try:
student = ESPUser.objects.get(id = student)
except ESPUser.DoesNotExist:
raise ESPError('Cannot find student, %s' % student, log=False)
if student.studentregistration_set.filter(section__parent_class=cls).count() == 0:
raise ESPError('Student not a student of this class.', log=False)
try:
student.app = student.studentapplication_set.get(program = self.program)
except:
student.app = None
assert False, student.studentapplication_set.all()[0].__dict__
raise ESPError('Error: Student did not apply. Student is automatically rejected.', log=False)
return render_to_response(self.baseDir()+'app_popup.html', request, {'class': cls, 'student': student})
def _checkTeacher(moduleObj, request, *args, **kwargs):
if not_logged_in(request):
return HttpResponseRedirect('%s?%s=%s' % (LOGIN_URL, REDIRECT_FIELD_NAME, quote(request.get_full_path())))
if not request.user.isTeacher() and not request.user.isAdmin(moduleObj.program):
return render_to_response('errors/program/notateacher.html', request, {})
return method(moduleObj, request, *args, **kwargs)
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("Sorry, can't find anyone with that username.", log=False)
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:
user.set_student_grad_year(request.GET['graduation_year'])
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 = user.getYOG()
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,
'printers': StudentRegCore.printer_names(),
}
return render_to_response("users/userview.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 'submit_checklist' in request.POST 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,
context), False) # make the checklist
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()
if len(offers) > 0:
context['complete'] = True
context['complete_name'] = offers[0].name
context['complete_email'] = offers[0].email
context['complete_phone'] = offers[0].phone
else:
context['cancelled'] = True
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 volunteering(self, request, tl, one, two, module, extra, prog):
context = {}
if extra == 'csv':
response = HttpResponse(content_type="text/csv")
requests = self.program.getVolunteerRequests()
write_csv = csv.writer(response)
write_csv.writerow(("Activity","Time","Name","Phone Number","E-mail Address"))
for request in requests:
for offer in request.get_offers():
write_csv.writerow((request.timeslot.description, request.timeslot.pretty_time(), offer.name, offer.phone, offer.email))
response['Content-Disposition'] = 'attachment; filename=volunteers.csv'
return response
if 'op' in request.GET:
if request.GET['op'] == 'edit':
form = VolunteerRequestForm(program=prog)
form.load(VolunteerRequest.objects.get(id=request.GET['id']))
elif request.GET['op'] == 'delete':
form = VolunteerRequestForm(program=prog)
VolunteerRequest.objects.get(id=request.GET['id']).delete()
elif request.method == 'POST':
form = VolunteerRequestForm(request.POST, program=prog)
if form.is_valid():
if form.cleaned_data['vr_id']:
form.save(VolunteerRequest.objects.get(id=form.cleaned_data['vr_id']))
else:
form.save()
form = VolunteerRequestForm(program=prog)
else:
form = VolunteerRequestForm(program=prog)
context['form'] = form
context['requests'] = self.program.getVolunteerRequests()
return render_to_response('program/modules/volunteermanage/main.html', request, context)
def viewlotteryprefs(self, request, tl, one, two, module, extra, prog):
context = {}
context['student'] = request.user
priority_classids = set()
uniquified_flags = []
priority_flags = StudentRegistration.valid_objects().filter(user=request.user, section__parent_class__parent_program=prog, relationship__name='Priority/1')
for flag in priority_flags:
if flag.section.id not in priority_classids:
priority_classids.add(flag.section.id)
uniquified_flags.append(flag)
context['priority'] = uniquified_flags
if priority_flags.count() == 0:
context['pempty'] = True
else: context['pempty'] = False
interested_classids = set()
uniquified_interested = []
interested = StudentRegistration.valid_objects().filter(user=request.user, section__parent_class__parent_program=prog, relationship__name='Interested')
for flag in interested:
if flag.section.id not in interested_classids:
interested_classids.add(flag.section.id)
uniquified_interested.append(flag)
context['interested' ] = uniquified_interested
if interested.count() == 0:
context['iempty'] = True
else: context['iempty'] = False
return render_to_response(self.baseDir()+'view_lottery_prefs.html', request, context)
def rapidcheckin(self, request, tl, one, two, module, extra, prog):
context = {}
if request.method == 'POST':
# Handle submission of student
form = OnSiteRapidCheckinForm(request.POST)
if form.is_valid():
student = form.cleaned_data['user']
# Check that this is a student user who is not also teaching (e.g. an admin)
if student.isStudent(
) and student not in self.program.teachers()['class_approved']:
recs = Record.objects.filter(user=student,
event="attended",
program=prog)
if not recs.exists():
rec, created = Record.objects.get_or_create(
user=student, event="attended", program=prog)
context['message'] = '%s %s marked as attended.' % (
student.first_name, student.last_name)
if request.is_ajax():
return self.ajax_status(request, tl, one, two, module,
extra, prog, context)
else:
context[
'message'] = '%s %s is not a student and has not been checked in' % (
student.first_name, student.last_name)
if request.is_ajax():
return self.ajax_status(request, tl, one, two, module,
extra, prog, context)
else:
form = OnSiteRapidCheckinForm()
context['module'] = self
context['form'] = form
return render_to_response(self.baseDir() + 'ajaxcheckin.html', request,
context)
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': prog,
'form': form
})
def event_signup(self, request, tl, one, two, module, extra, prog):
if request.method == 'POST':
form = TeacherEventSignupForm(self, request.POST)
if form.is_valid():
data = form.cleaned_data
# Remove old bits
UserAvailability.objects.filter(user=request.user, event__event_type__in=self.event_types().values()).delete()
# Register for interview
if data['interview']:
ua, created = UserAvailability.objects.get_or_create( user=request.user, event=data['interview'], role=self.availability_role())
# Send the directors an e-mail
if self.program.director_email and created:
event_name = data['interview'].description
send_mail('['+self.program.niceName()+'] Teacher Interview for ' + request.user.first_name + ' ' + request.user.last_name + ': ' + event_name, \
"""Teacher Interview Registration Notification\n--------------------------------- \n\nTeacher: %s %s\n\nTime: %s\n\n""" % \
(request.user.first_name, request.user.last_name, event_name) , \
('%s <%s>' % (request.user.first_name + ' ' + request.user.last_name, request.user.email,)), \
[self.program.getDirectorCCEmail()], True)
# Register for training
if data['training']:
ua, created = UserAvailability.objects.get_or_create( user=request.user, event=data['training'], role=self.availability_role())
return self.goToCore(tl)
else:
data = {}
entries = self.entriesByTeacher(request.user)
if entries['interview'].count() > 0:
data['interview'] = entries['interview'][0].event.id
if entries['training'].count() > 0:
data['training'] = entries['training'][0].event.id
form = TeacherEventSignupForm(self, initial=data)
return render_to_response( self.baseDir()+'event_signup.html', request, {'prog':prog, 'form': form} )
def rank_classes(self, request, tl, one, two, module, extra, prog):
"""
Displays a filterable catalog including only class subjects for which
the student has a StudentSubjectInterest. The sticky on top
of the catalog lets the student order the top N priorities of classes
for this particular timeslot. The timeslot is specified through extra.
"""
try:
timeslot = Event.objects.get(pk=int(extra), program=prog)
except (TypeError, ValueError, Event.DoesNotExist) as e:
raise Http404
context = dict()
context['timeslot'] = timeslot
context['num_priorities'] = prog.priorityLimit()
context['priorities'] = []
for rel_index in range(1, prog.priorityLimit()+1):
rel_name = 'Priority/%s' % rel_index
rel, created = RegistrationType.objects.get_or_create(
name=rel_name, category='student')
context['priorities'].append((rel_index, rel))
catalog_context = self.catalog_context(
request, tl, one, two,module, extra, prog)
context.update(catalog_context)
return render_to_response(
self.baseDir() + 'rank_classes.html', request, context)
def mark_classes(self, request, tl, one, two, module, extra, prog):
"""
Displays a filterable catalog which allows starring classes that the
user is interested in.
"""
# get choices for filtering options
context = {}
def group_columns(items):
# collect into groups of 5
cols = []
for i, item in enumerate(items):
if i % 5 == 0:
col = []
cols.append(col)
col.append(item)
return cols
category_choices = []
for category in prog.class_categories.all():
# FIXME(gkanwar): Make this less hacky, once #770 is resolved
if category.category == 'Lunch':
continue
category_choices.append((category.id, category.category))
context['category_choices'] = group_columns(category_choices)
catalog_context = self.catalog_context(
request, tl, one, two,module, extra, prog)
context.update(catalog_context)
return render_to_response(self.baseDir() + 'mark_classes.html', request, context)
def mark_classes(self, request, tl, one, two, module, extra, prog):
"""
Displays a filterable catalog which allows starring classes that the
user is interested in.
"""
# get choices for filtering options
context = {}
def group_columns(items):
# collect into groups of 5
cols = []
for i, item in enumerate(items):
if i % 5 == 0:
col = []
cols.append(col)
col.append(item)
return cols
category_choices = []
for category in prog.class_categories.all():
# FIXME(gkanwar): Make this less hacky, once #770 is resolved
if category.category == 'Lunch':
continue
category_choices.append((category.id, category.category))
context['category_choices'] = group_columns(category_choices)
catalog_context = self.catalog_context(request, tl, one, two, module,
extra, prog)
context.update(catalog_context)
return render_to_response(self.baseDir() + 'mark_classes.html',
request, context)
def rank_classes(self, request, tl, one, two, module, extra, prog):
"""
Displays a filterable catalog including only class subjects for which
the student has a StudentSubjectInterest. The sticky on top
of the catalog lets the student order the top N priorities of classes
for this particular timeslot. The timeslot is specified through extra.
"""
try:
timeslot = Event.objects.get(pk=int(extra), program=prog)
except (TypeError, ValueError, Event.DoesNotExist) as e:
raise Http404
context = dict()
context['timeslot'] = timeslot
context['num_priorities'] = prog.priorityLimit()
context['priorities'] = []
for rel_index in range(1, prog.priorityLimit() + 1):
rel_name = 'Priority/%s' % rel_index
rel, created = RegistrationType.objects.get_or_create(
name=rel_name, category='student')
context['priorities'].append((rel_index, rel))
catalog_context = self.catalog_context(request, tl, one, two, module,
extra, prog)
context.update(catalog_context)
return render_to_response(self.baseDir() + 'rank_classes.html',
request, context)
def cybersource(self, request, tl, one, two, module, extra, prog):
# Force users to pay for non-optional stuffs
user = 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['contact_email'] = self.program.director_email
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()
context['result'] = request.GET.get("result")
context['post_url'] = settings.CYBERSOURCE_CONFIG['post_url']
context['merchant_id'] = settings.CYBERSOURCE_CONFIG['merchant_id']
if (not context['post_url']) or (not context['merchant_id']):
raise ESPError("The Cybersource module is not configured")
return render_to_response(self.baseDir() + 'cardpay.html', request, context)
def edit_availability(self, request, tl, one, two, module, extra, prog):
"""
Admins edits availability of the specified user.
"""
target_id = None
if 'user' in request.GET:
target_id = request.GET['user']
elif 'user' in request.POST:
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("The user with id/username="******" does not appear to exist!",
log=False)
return self.availabilityForm(request, tl, one, two, prog, teacher,
True)
def selector(request, keep_files=None):
if settings.LOCAL_THEME:
raise ESPError(THEME_ERROR_STRING, log=False)
context = {}
tc = ThemeController()
if request.method == 'POST' and 'action' in request.POST:
if request.POST['action'] == 'select':
theme_name = request.POST['theme'].replace(' (current)', '')
# Check for differences between the theme's files and those in the working copy.
# If there are differences, require a confirmation from the user for each file.
differences = tc.check_local_modifications(theme_name)
if len(differences) > 0 and keep_files is None:
return confirm_overwrite(request, current_theme=theme_name, differences=differences, orig_view='selector')
# Display configuration form if one is provided for the selected theme
if tc.get_config_form_class(theme_name) is not None:
return configure(request, current_theme=theme_name, force_display=True, keep_files=keep_files)
tc.save_customizations('%s-last' % tc.get_current_theme())
backup_info = tc.clear_theme(keep_files=keep_files)
tc.load_theme(theme_name, backup_info=backup_info)
elif request.POST['action'] == 'clear':
tc.save_customizations('%s-last' % tc.get_current_theme())
tc.clear_theme()
context['theme_name'] = tc.get_current_theme()
context['themes'] = tc.get_theme_names()
return render_to_response('themes/selector.html', request, context)
def _inner_function(request, *args, **kwargs):
if request.user.is_authenticated():
return render_to_response('errors/anonymous_only.html',
request,
{})
return method(request, *args, **kwargs)
def _checkTeacher(moduleObj, request, *args, **kwargs):
if not_logged_in(request):
return HttpResponseRedirect('%s?%s=%s' % (LOGIN_URL, REDIRECT_FIELD_NAME, quote(request.get_full_path())))
if not request.user.isTeacher() and not request.user.isAdmin(moduleObj.program):
return render_to_response('errors/program/notateacher.html', request, {})
return method(moduleObj, request, *args, **kwargs)
def resources_equipment(self, request, tl, one, two, module, extra, prog):
context = {}
response = None
controller = ResourceController(prog)
if request.GET.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.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 resources_timeslot(self, request, tl, one, two, module, extra, prog):
context = {}
response = None
controller = ResourceController(prog)
if request.GET.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.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 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()
if len(offers) > 0:
context['complete'] = True
context['complete_name'] = offers[0].name
context['complete_email'] = offers[0].email
context['complete_phone'] = offers[0].phone
else:
context['cancelled'] = True
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 volunteerschedule(self, request, tl, one, two, module, extra, prog):
# 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])
if request.user.isAdmin() and 'user' in request.GET:
volunteer = ESPUser.objects.get(id=request.GET['user'])
else:
volunteer = request.user
scheditems = []
offers = VolunteerOffer.objects.filter(
user=volunteer, request__program=self.program)
for offer in offers:
scheditems.append({
'name': volunteer.name(),
'volunteer': volunteer,
'offer': offer
})
#sort the offers by timeslot
scheditems.sort(
key=lambda item: item['offer'].request.timeslot.start)
context['scheditems'] = scheditems
return render_to_response(pmo.baseDir() + 'volunteerschedule.html',
request, context)
else:
raise ESPError(
'No printables module resolved, so this document cannot be generated. Consult the webmasters.',
log=False)
def cybersource(self, request, tl, one, two, module, extra, prog):
# Force users to pay for non-optional stuffs
user = 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['contact_email'] = self.program.director_email
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()
context['result'] = request.GET.get("result")
context['post_url'] = settings.CYBERSOURCE_CONFIG['post_url']
context['merchant_id'] = settings.CYBERSOURCE_CONFIG['merchant_id']
if (not context['post_url']) or (not context['merchant_id']):
raise ESPError("The Cybersource module is not configured")
return render_to_response(self.baseDir() + 'cardpay.html', request,
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 resources_equipment(self, request, tl, one, two, module, extra, prog):
context = {}
response = None
controller = ResourceController(prog)
if request.GET.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.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 disable_account(request):
curUser = request.user
if 'enable' in request.GET:
curUser.is_active = True
curUser.save()
elif 'disable' in request.GET:
curUser.is_active = False
curUser.save()
other_users = ESPUser.objects.filter(email=curUser.email).exclude(
id=curUser.id)
context = {
'user':
curUser,
'other_users':
other_users,
# Right now, we only deactivate the other users with the same email
# address if we are using mailman.
'will_deactivate_others':
curUser.is_active and other_users and settings.USE_MAILMAN,
}
return render_to_response('users/disable_account.html', request, 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 classsearch(self, request, tl, one, two, module, extra, prog):
data = request.GET.get('query')
query_builder = self.query_builder()
context = {
'query_builder': query_builder,
'program': self.program,
'query': None,
}
namequery = request.GET.get('namequery')
decoded = None
if data is not None:
decoded = json.loads(data)
elif namequery: # only search if not None and not ""
decoded = {
'filter': 'title',
'negated': False,
'values': [namequery]
}
if decoded is not None:
queryset = query_builder.as_queryset(decoded)
queryset = queryset.distinct().order_by('id').prefetch_related(
'flags', 'flags__flag_type', 'teachers', 'category',
'sections', 'sections__resourcerequest_set')
if request.GET.get('randomize'):
queryset = list(queryset)
random.shuffle(queryset)
if request.GET.get('lucky'):
return HttpResponseRedirect(queryset[0].get_absolute_url())
context['query'] = decoded
context['queryset'] = queryset
context['flag_types'] = self.program.flag_types.all()
return render_to_response(self.baseDir() + 'class_search.html',
request, context)
def ajax_clear_schedule(self, request, tl, one, two, module, extra, prog):
""" A view that you can use to remove schedule assignments for all class
sections below a certain lock level.
Be very careful using this view since it can sometimes work quite well,
and there is currently no backup.
"""
try:
lock_level = int(request.POST.get('lock_level', '0'))
except:
lock_level = 0
if request.method == 'POST':
num_affected_sections = self.clear_schedule_logic(prog, lock_level)
data = {
'message':
'Cleared schedule assignments for %d sections.' %
(num_affected_sections)
}
response = HttpResponse(content_type="application/json")
json.dump(data, response)
else:
context = {}
context['num_affected_sections'] = self._get_affected_sections(
prog, lock_level).count()
response = render_to_response(
self.baseDir() + 'clear_schedule_confirmation.html', request,
context)
return response
def resources_timeslot(self, request, tl, one, two, module, extra, prog):
context = {}
response = None
controller = ResourceController(prog)
if request.GET.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.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 payonline(self, request, tl, one, two, module, extra, prog):
# Check that the user has completed all required modules so that they
# are "finished" registering for the program. (In other words, they
# should be registered for at least one class, and filled out other
# required forms, before paying by credit card.)
modules = prog.getModules(request.user, tl)
completedAll = True
for module in modules:
if not module.isCompleted() and module.required:
completedAll = False
if not completedAll and not request.user.isAdmin(prog):
raise ESPError("Please go back and ensure that you have completed all required steps of registration before paying by credit card.", log=False)
# Check for setup of module. This is also required to initialize settings.
self.check_setup()
user = request.user
iac = IndividualAccountingController(self.program, request.user)
context = {}
context['module'] = self
context['program'] = prog
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()
offer_donation = self.settings['offer_donation']
donate_type = iac.get_lineitemtypes().get(text=self.settings['donation_text']) if offer_donation else None
context['itemizedcosts'] = iac.get_transfers().exclude(line_item__in=filter(None, [payment_type, sibling_type, grant_type, donate_type])).order_by('-line_item__required')
context['itemizedcosttotal'] = iac.amount_due()
# This amount should be formatted as an integer in order to be
# accepted by Stripe.
context['totalcost_cents'] = int(context['itemizedcosttotal'] * 100)
context['subtotal'] = iac.amount_requested()
context['financial_aid'] = iac.amount_finaid()
context['sibling_discount'] = iac.amount_siblingdiscount()
context['amount_paid'] = iac.amount_paid()
# Load donation amount separately, since the client-side code needs to know about it separately.
donation_prefs = iac.get_preferences([donate_type,]) if offer_donation else None
if donation_prefs:
context['amount_donation'] = Decimal(donation_prefs[0][2])
context['has_donation'] = True
else:
context['amount_donation'] = Decimal('0.00')
context['has_donation'] = False
context['amount_without_donation'] = context['itemizedcosttotal'] - context['amount_donation']
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['support_email'] = settings.DEFAULT_EMAIL_ADDRESSES['support']
return render_to_response(self.baseDir() + 'cardpay.html', request, context)
def landing(request):
if settings.LOCAL_THEME:
raise ESPError(THEME_ERROR_STRING, log=False)
context = {}
tc = ThemeController()
context['theme_name'] = tc.get_current_theme()
context['last_customization_name'] = tc.get_current_customization()
return render_to_response('themes/landing.html', request, context)
def catalogpreview(self, request, tl, one, two, module, extra, prog):
try:
qs = ClassSubject.objects.filter(id=int(extra))
cls = qs[0]
except (ValueError, IndexError):
raise Http404('The requested class could not be found.')
cls = ClassSubject.objects.catalog(cls.parent_program, force_all=True, initial_queryset=qs)[0]
return render_to_response(self.baseDir()+'catalogpreview.html', request, {'class': cls})
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]
cls.delete(True)
return self.goToCore(tl)
def _meets_cap(moduleObj, request, tl, one, two, module, extra, prog,
*args, **kwargs):
if prog.user_can_join(request.user):
return view_method(moduleObj, request, tl, one, two, module, extra,
prog, *args, **kwargs)
else:
return render_to_response('errors/program/program_full.html',
request, {'moduleObj': moduleObj})
def scheduling_checks(self, request, tl, one, two, module, extra, prog):
s = SchedulingCheckRunner(prog)
if extra:
results = s.run_diagnostics([extra])
return HttpResponse(results)
else:
context = {'check_list': s.all_diagnostics}
return render_to_response(self.baseDir()+'output.html', request, context)
def commprev(self, request, tl, one, two, module, extra, prog):
from esp.users.models import PersistentQueryFilter
from django.conf import settings
filterid, listcount, subject, body = [request.POST['filterid'],
request.POST['listcount'],
request.POST['subject'],
request.POST['body'] ]
sendto_fn_name = request.POST.get('sendto_fn_name', MessageRequest.SEND_TO_SELF_REAL)
# Set From address
if request.POST.get('from', '').strip():
fromemail = request.POST['from']
else:
# String together an address like [email protected]
fromemail = '%s@%s' % (request.user.username, settings.SITE_INFO[1])
# Set Reply-To address
if request.POST.get('replyto', '').strip():
replytoemail = request.POST['replyto']
else:
replytoemail = fromemail
try:
filterid = int(filterid)
except:
raise ESPError("Corrupted POST data! Please contact us at [email protected] and tell us how you got this error, and we'll look into it.")
userlist = PersistentQueryFilter.getFilterFromID(filterid, ESPUser).getList(ESPUser)
try:
firstuser = userlist[0]
except:
raise ESPError("You seem to be trying to email 0 people! Please go back, edit your search, and try again.")
MessageRequest.assert_is_valid_sendto_fn_or_ESPError(sendto_fn_name)
# If they were trying to use HTML, don't sanitize the content.
if '<html>' not in body:
htmlbody = body.replace('<', '<').replace('>', '>').replace('\n', '<br />')
else:
htmlbody = body
contextdict = {'user' : ActionHandler(firstuser, firstuser),
'program': ActionHandler(self.program, firstuser) }
renderedtext = Template(htmlbody).render(DjangoContext(contextdict))
return render_to_response(self.baseDir()+'preview.html', request,
{'filterid': filterid,
'sendto_fn_name': sendto_fn_name,
'listcount': listcount,
'subject': subject,
'from': fromemail,
'replyto': replytoemail,
'body': body,
'renderedtext': renderedtext})
def classchangerequest(self, request, tl, one, two, module, extra, prog):
timeslots = prog.getTimeSlots()
sections = prog.sections().filter(status=10, meeting_times__isnull=False).distinct()
enrollments = {}
for timeslot in timeslots:
try:
enrollments[timeslot] = ClassSubject.objects.get(nest_Q(StudentRegistration.is_valid_qobject(), 'sections__studentregistration'), sections__studentregistration__relationship__name="Enrolled", sections__studentregistration__user=request.user, sections__meeting_times=timeslot, parent_program=prog)
except ClassSubject.DoesNotExist:
enrollments[timeslot] = None
context = {}
context['timeslots'] = timeslots
context['enrollments'] = enrollments
context['user'] = request.user
if 'success' in request.GET:
context['success'] = True
else:
context['success'] = False
if request.user.isStudent():
sections_by_slot = dict([(timeslot,[(section, 1 == StudentRegistration.valid_objects().filter(user=context['user'], section=section, relationship__name="Request").count()) for section in sections if section.get_meeting_times()[0] == timeslot and section.parent_class.grade_min <= request.user.getGrade(prog) <= section.parent_class.grade_max and section.parent_class not in enrollments.values() and ESPUser.getRankInClass(request.user, section.parent_class) in (5,10)]) for timeslot in timeslots])
else:
sections_by_slot = dict([(timeslot,[(section, False) for section in sections if section.get_meeting_times()[0] == timeslot]) for timeslot in timeslots])
fields = {}
for i, timeslot in enumerate(sections_by_slot.keys()):
choices = [('0', "I'm happy with my current enrollment.")]
initial = '0'
for section in sections_by_slot[timeslot]:
choices.append((section[0].emailcode(), section[0].emailcode()+": "+section[0].title()))
if section[1]:
initial = section[0].emailcode()
fields['timeslot_'+str(i+1)] = forms.ChoiceField(label="Timeslot "+str(i+1)+" ("+timeslot.pretty_time()+")", choices=choices, initial=initial)
form = type('ClassChangeRequestForm', (forms.Form,), fields)
context['form'] = form()
if request.method == "POST":
old_requests = StudentRegistration.valid_objects().filter(user=context['user'], section__parent_class__parent_program=prog, relationship__name="Request")
for r in old_requests:
r.expire()
form = form(request.POST)
if form.is_valid():
for value in form.cleaned_data.values():
section = None
for s in sections:
if s.emailcode() == value:
section = s
break
if not section:
continue
r = StudentRegistration.valid_objects().get_or_create(user=context['user'], section=section, relationship=RegistrationType.objects.get_or_create(name="Request", category="student")[0])[0]
r.save()
return HttpResponseRedirect(request.path.rstrip('/')+'/?success')
else:
return render_to_response(self.baseDir() + 'classchangerequest.html', request, context)
def medliab(self, request, tl, one, two, module, extra, prog):
"""
Landing page redirecting to med-liab form on Formstack.
"""
t = Tag.getProgramTag("formstack_id", self.program)
v = Tag.getProgramTag("formstack_viewkey", self.program)
context = {"formstack_id": t, "formstack_viewkey": v}
return render_to_response(self.baseDir()+'medliab.html',
request, context)
def _check(moduleObj, request, tl, *args, **kwargs):
if test_func(moduleObj):
return view_method(moduleObj, request, tl, *args, **kwargs)
errorpage = 'errors/program/deadline-%s.html' % tl
return render_to_response(
errorpage,
request,
{'extension': error_message, 'moduleObj': moduleObj},
)
