def edit_registration(request, registration_id, event_slug=None):
registration = get_object_or_404(OutreachEventRegistration, pk=registration_id, event__unit__in=request.units)
if request.method == 'POST':
form = OutreachEventRegistrationForm(request.POST, instance=registration)
form.add_extra_questions(registration.event)
form.check_dietary_field(registration.event)
if form.is_valid():
registration = form.save(commit=False)
if 'extra_questions' in registration.event.config and len(registration.event.config['extra_questions']) > 0:
temp = {}
for question in registration.event.config['extra_questions']:
temp[question] = form.cleaned_data[question]
registration.config['extra_questions'] = temp
registration.save()
messages.add_message(request,
messages.SUCCESS,
'Registration was edited')
l = LogEntry(userid=request.user.username,
description="Edited registration for %s" % registration,
related_object=registration)
l.save()
if event_slug:
return HttpResponseRedirect(reverse('outreach:view_event_registrations', kwargs={'event_slug': event_slug}))
return HttpResponseRedirect(reverse('outreach:view_all_registrations'))
else:
form = OutreachEventRegistrationForm(instance=registration, initial={'confirm_email': registration.email})
form.add_extra_questions(registration.event)
form.check_dietary_field(registration.event)
return render(request, 'outreach/edit_registration.html', {'form': form, 'registration': registration,
'event_slug': event_slug})
def resolve_alert( request, alert_type, alert_id ):
"""
Resolve an alert
"""
alert = get_object_or_404(Alert, id=alert_id, alerttype__unit__in=request.units)
if request.method == 'POST':
form = ResolutionForm(request.POST)
if form.is_valid():
f = form.save(commit=False)
f.alert = alert
f.update_type = "RESO"
f.save()
messages.success(request, "Resolved alert %s." % str(alert) )
l = LogEntry(userid=request.user.username,
description="Resolved alert %s." % str(alert),
related_object=form.instance)
l.save()
return HttpResponseRedirect(reverse('alerts.views.view_alert', kwargs={'alert_type':alert_type, 'alert_id':alert_id}))
else:
form = ResolutionForm(initial={'resolved_until': datetime.date.today()})
return render(request, 'alerts/resolve_alert.html', { 'alert_type':alert.alerttype,
'alert':alert,
'form': form,
'resolve_reopen_or_comment_on': 'Resolve'})
def manage_program(request, grad_slug):
grad = get_object_or_404(GradStudent, slug=grad_slug, program__unit__in=request.units)
programs = GradProgram.objects.filter(unit__in=request.units)
# If you have access to programs from different units, display them.
if len(request.units) > 1:
program_choices = [(p.id, str(p) + " (" + p.unit.label + ")") for p in programs]
else:
program_choices = [(p.id, str(p)) for p in programs]
programhistory = GradProgramHistory.objects.filter(student=grad, program__unit__in=request.units).order_by('starting')
if request.method == 'POST':
form = GradProgramHistoryForm(request.POST)
form.fields['program'].choices = program_choices
if form.is_valid():
gph = form.save(commit=False)
gph.student = grad
gph.save()
grad.update_status_fields()
messages.success(request, "Updated program info for %s." % (grad.person))
l = LogEntry(userid=request.user.username,
description="Updated grad program for %s." % (grad),
related_object=gph)
l.save()
return HttpResponseRedirect(reverse('grad:view', kwargs={'grad_slug':grad.slug}))
else:
form = GradProgramHistoryForm(initial={'program': grad.program, 'semester': Semester.current()})
form.fields['program'].choices = program_choices
context = {
'form': form,
'grad': grad,
'programhistory': programhistory,
}
return render(request, 'grad/manage_program.html', context)
def manage_progress(request, grad_slug):
grad = get_object_or_404(GradStudent, slug = grad_slug)
progress_reports = ProgressReport.objects.filter(student=grad).order_by('date')
if request.method == 'POST':
form = ProgressReportForm(request.POST)
if form.is_valid():
report = form.save(commit=False)
report.student = grad
report.save()
messages.success(request, "Progress Report for %s sucessfully saved." % (grad))
l = LogEntry(userid=request.user.username,
description="added progress report for %s" % (grad.slug,),
related_object=report )
l.save()
return HttpResponseRedirect(reverse('grad:manage_progress', kwargs={'grad_slug':grad.slug}))
else:
form = ProgressReportForm()
context = {
'grad':grad,
'form': form,
'progress_reports': progress_reports,
'can_edit': True,
}
return render(request, 'grad/manage_progress.html', context)
def new_contract(request):
if request.method == 'POST':
form = SessionalContractForm(request, request.POST)
if form.is_valid():
contract = form.save(commit=False)
# Let's convert the person in there to an AnyPerson
person = form.cleaned_data['person']
contract.sessional = AnyPerson.get_or_create_for(person=person)
contract.save()
messages.add_message(request,
messages.SUCCESS,
'Contract was created.'
)
l = LogEntry(userid=request.user.username,
description="added sessional contract for: %s" % contract.sessional,
related_object=contract
)
l.save()
return HttpResponseRedirect(reverse('sessionals:sessionals_index'))
else:
form = SessionalContractForm(request)
# Everyone except a sysadmin most likely has only one unit they have admin roles for. Let's try to
# find the config matching that unit, and if it exists, use it for default values.
config = SessionalConfig.objects.filter(unit__in=request.units).first()
if config:
form.fields['appointment_start'].initial = config.appointment_start
form.fields['appointment_end'].initial = config.appointment_end
form.fields['pay_start'].initial = config.pay_start
form.fields['pay_end'].initial = config.pay_end
form.fields['course_hours_breakdown'].initial = config.course_hours_breakdown
return render(request, 'sessionals/new_contract.html', {'form': form})
def manage_otherfunding(request, grad_slug):
grad = get_object_or_404(GradStudent, slug = grad_slug)
otherfunding = OtherFunding.objects.filter(student=grad).order_by('semester__name')
if request.method == 'POST':
form = OtherFundingForm(request.POST)
if form.is_valid():
fund = form.save(commit=False)
fund.student = grad
fund.save()
messages.success(request, "Other funding for %s sucessfully saved." % (grad))
l = LogEntry(userid=request.user.username,
description="added other funding \"%s\" for %s" % (fund.description, grad.slug),
related_object=fund )
l.save()
return HttpResponseRedirect(reverse('grad.views.manage_otherfunding', kwargs={'grad_slug':grad.slug}))
else:
form = OtherFundingForm(initial={'student':grad, 'semester':Semester.get_semester(), 'amount':'0.00'})
context = {
'grad':grad,
'form': form,
'otherfunding': otherfunding,
}
return render(request, 'grad/manage_otherfunding.html', context)
def new_visa(request, emplid=None):
if request.method == 'POST':
form = VisaForm(request, request.POST)
if form.is_valid():
visa = form.save(commit=False)
visa.save()
messages.add_message(request,
messages.SUCCESS,
'Visa was created.'
)
l = LogEntry(userid=request.user.username,
description="added visa: %s" % (visa),
related_object=visa.person
)
l.save()
return HttpResponseRedirect(reverse('visas:list_all_visas'))
else:
if emplid:
person = Person.objects.get(find_userid_or_emplid(emplid))
form = VisaForm(request, initial={'person': person})
else:
form = VisaForm(request)
return render(request, 'visas/new_visa.html', {'form': form})
def manage_documents(request, grad_slug):
grad = get_object_or_404(GradStudent, slug = grad_slug)
documents = ExternalDocument.objects.filter(student=grad).order_by('date')
if request.method == 'POST':
form = ExternalDocumentForm(request.POST, request.FILES)
if form.is_valid():
document = form.save(commit=False)
document.student = grad
if 'file_attachment' in request.FILES:
upfile = request.FILES['file_attachment']
document.file_mediatype = upfile.content_type
document.save()
messages.success(request,
"Document for %s sucessfully saved." % (grad))
l = LogEntry(userid=request.user.username,
description="added document for %s" % (grad.slug,),
related_object=document )
l.save()
return HttpResponseRedirect(reverse('grad.views.manage_documents',
kwargs={'grad_slug':grad.slug}))
else:
form = ExternalDocumentForm()
context = {
'grad':grad,
'form': form,
'documents': documents,
}
return render(request, 'grad/manage_documents.html', context)
def manage_scholarships(request, grad_slug):
grad = get_object_or_404(GradStudent, slug = grad_slug)
scholarship_type_choices = [(st.id, st.name) for st in ScholarshipType.objects.filter(unit__in=request.units, hidden=False).order_by('unit__slug', 'name')]
scholarships = Scholarship.objects.filter(student=grad).select_related('scholarship_type').order_by('start_semester__name')
comments = FinancialComment.objects.filter(student=grad, comment_type='SCO', removed=False).order_by('created_at')
if request.method == 'POST':
form = ScholarshipForm(request.POST)
form.fields['scholarship_type'].choices = scholarship_type_choices
if form.is_valid():
schol = form.save(commit=False)
schol.student = grad
schol.save()
messages.success(request, "Scholarship for %s sucessfully saved." % (grad))
l = LogEntry(userid=request.user.username,
description="added scholarship of $%f for %s" % (schol.amount, grad.slug),
related_object=schol )
l.save()
return HttpResponseRedirect(reverse('grad.views.manage_scholarships', kwargs={'grad_slug':grad.slug}))
else:
form = ScholarshipForm(initial={'student':grad, 'start_semester':get_semester(), 'end_semester':get_semester(), 'amount':'0.00'})
form.fields['scholarship_type'].choices = scholarship_type_choices
context = {
'grad':grad,
'form': form,
'scholarships': scholarships,
'scholarship_comments': comments
}
return render(request, 'grad/manage_scholarships.html', context)
def new_letter_template(request):
unit_choices = [(u.id, u.name) for u in request.units]
if request.method == 'POST':
form = LetterTemplateForm(request.POST)
form.fields['unit'].choices = unit_choices
if form.is_valid():
f = form.save(commit=False)
f.created_by = request.user.username
f.save()
messages.success(request, "Created new letter template %s for %s." % (form.instance.label, form.instance.unit))
l = LogEntry(userid=request.user.username,
description="Created new letter template %s for %s." % (form.instance.label, form.instance.unit),
related_object=form.instance)
l.save()
return HttpResponseRedirect(reverse('grad:letter_templates'))
else:
form = LetterTemplateForm()
form.fields['unit'].choices = unit_choices
page_title = 'New Letter Template'
crumb = 'New'
lt = sorted(LETTER_TAGS.items())
context = {
'form': form,
'page_title' : page_title,
'crumb' : crumb,
'LETTER_TAGS' : lt
}
return render(request, 'grad/new_letter_template.html', context)
def add_component(request, course_slug, activity_slug):
course = get_object_or_404(CourseOffering, slug=course_slug)
activity = get_object_or_404(course.activity_set, slug=activity_slug, deleted=False)
#default, Archive
typelabel = request.GET.get('type')
Type = find_type_by_label(typelabel)
if Type is None:
form = None
else:
form = Type.ComponentForm()
#if form is submitted, validate / add component
if request.method == 'POST':
new_form = Type.ComponentForm(request.POST)
if new_form.is_valid():
#add component
new_component = new_form.save(commit=False)
new_component.activity = activity
new_component.save()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=(u"added %s component %s for %s") % (Type.name, new_component.title, activity),
related_object=new_component)
l.save()
messages.add_message(request, messages.SUCCESS, 'New component "' + new_component.title + '" successfully added.')
return HttpResponseRedirect(reverse(show_components, args=[course_slug, activity_slug]))
else:
messages.add_message(request, messages.ERROR, 'Please correct the errors in the form.')
form = new_form
type_classes = ALL_TYPE_CLASSES
return render(request, "submission/component_add.html",
{"course":course, "activity":activity, "form":form, "type":Type, "types": type_classes})
def edit_file(request, course_slug, case_slug, fileid):
course = get_object_or_404(CourseOffering, slug=course_slug)
case = get_object_or_404(DisciplineCaseBase, slug=case_slug, offering__slug=course_slug)
case = case.subclass()
attach = get_object_or_404(CaseAttachment, case__slug=case_slug, case__offering__slug=course_slug, id=fileid)
if not case.can_edit('attach'):
# once case is closed, don't allow editing
return ForbiddenResponse(request)
if request.method == 'POST':
form = EditAttachFileForm(request.POST, request.FILES, instance=attach)
if form.is_valid():
f = form.save()
case.letter_review = False
case.letter_sent = 'WAIT'
case.penalty_implemented = False
case.save()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=("edit discipline case %s in %s: edited attachment %s") % (case.slug, case.offering, f.name),
related_object=case)
l.save()
messages.add_message(request, messages.SUCCESS, 'Updated file attachment "%s".' % (f.name))
return HttpResponseRedirect(reverse('discipline.views.edit_attach', kwargs={'course_slug': course_slug, 'case_slug': case.slug}))
else:
form = EditAttachFileForm(instance=attach)
context = {'course': course, 'case': case, 'attach': attach, 'form': form}
return render_to_response("discipline/edit_file.html", context, context_instance=RequestContext(request))
def new_nonstudent(request, course_slug):
course = get_object_or_404(CourseOffering, slug=course_slug)
group_choices = [('', u'\u2014')] + [(g.id, g.name) for g in DisciplineGroup.objects.filter(offering=course)]
if request.method == 'POST':
form = DisciplineInstrNonStudentCaseForm(data=request.POST)
form.fields['group'].choices = group_choices
if form.is_valid():
instructor = Person.objects.get(userid=request.user.username)
case = form.save(commit=False)
case.owner = instructor
case.offering = course
case.slug = defaultfilters.slugify(case.first_name + " " + case.last_name)
case.save()
form.save_m2m()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=("created a non-student discipline case for %s in %s") % (case.student.name(), course),
related_object=case)
l.save()
return HttpResponseRedirect(reverse('discipline.views.show', kwargs={'course_slug': course_slug, 'case_slug': case.slug}))
else:
form = DisciplineInstrNonStudentCaseForm()
form.fields['group'].choices = group_choices
context = {'course': course, 'form': form}
return render_to_response("discipline/new_nonstudent.html", context, context_instance=RequestContext(request))
def new(request, course_slug):
course = get_object_or_404(CourseOffering, slug=course_slug)
student_choices = [
(m.person.userid,
"%s (%s, %s)" % (m.person.sortname(), m.person.emplid, m.person.userid))
for m in
Member.objects.filter(offering=course, role="STUD").select_related('person')]
group_choices = [('', u'\u2014')] + [(g.id, g.name) for g in DisciplineGroup.objects.filter(offering=course)]
if request.method == 'POST':
form = DisciplineCaseForm(offering=course, data=request.POST)
form.fields['student'].choices = student_choices
form.fields['group'].choices = group_choices
if form.is_valid():
instructor = Person.objects.get(userid=request.user.username)
case = form.save(commit=False)
case.owner = instructor
case.offering = course
case.save()
form.save_m2m()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=("created a discipline case for %s in %s") % (case.student.name(), course),
related_object=case)
l.save()
return HttpResponseRedirect(reverse('discipline.views.show', kwargs={'course_slug': course_slug, 'case_slug': case.slug}))
else:
form = DisciplineCaseForm(offering=course)
form.fields['student'].choices = student_choices
form.fields['group'].choices = group_choices
context = {'course': course, 'form': form}
return render_to_response("discipline/new.html", context, context_instance=RequestContext(request))
def manage_financialcomments(request, grad_slug):
grad = get_object_or_404(GradStudent, slug = grad_slug)
financial_comments = FinancialComment.objects.filter(student=grad, removed=False).order_by('semester__name')
if request.method == 'POST':
form = FinancialCommentForm(request.POST)
if form.is_valid():
comment = form.save(commit=False)
comment.student = grad
comment.created_by = request.user.username
comment.save()
messages.success(request, "Financial Comment for %s sucessfully saved." % (grad))
l = LogEntry(userid=request.user.username,
description="added financial comment \"%s\" for %s" % (str(comment), grad.slug),
related_object=comment )
l.save()
return HttpResponseRedirect(reverse('grad:manage_financialcomments', kwargs={'grad_slug':grad.slug}))
else:
form = FinancialCommentForm(initial={
'student':grad,
'semester':Semester.get_semester(),
'created_by':request.user.username })
context = {
'grad':grad,
'form': form,
'financial_comments': financial_comments,
}
return render(request, 'grad/manage_financialcomments.html', context)
def course_home_admin(request, course_slug):
offering = get_object_or_404(CourseOffering, slug=course_slug, owner__in=request.units)
if request.method == 'POST':
form = CourseHomePageForm(data=request.POST)
if form.is_valid():
offering.set_url(form.cleaned_data['url'])
if 'maillist' in form.cleaned_data and form.cleaned_data['maillist']:
offering.set_maillist(form.cleaned_data['maillist'])
offering.save()
messages.success(request, 'Updated URL for %s.' % (offering.name()))
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=("Updated course URL for %s.") % (offering.name()),
related_object=offering)
l.save()
return HttpResponseRedirect(reverse(course_home_pages_unit, kwargs={'unit_slug': offering.owner.slug, 'semester': offering.semester.name}))
else:
form = CourseHomePageForm(initial={'url': offering.url(), 'maillist': offering.maillist()})
context = {
'offering': offering,
'form': form,
}
return render(request, "coredata/course_home_admin.html", context)
def edit_intention(request):
instructor = get_object_or_404(Person, userid=request.user.username)
semester_list = Semester.objects.filter(start__gt=datetime.now())
semester_choices = [(s.pk, s) for s in semester_list]
intention_list = TeachingIntention.objects.filter(instructor=instructor).order_by('semester')
if request.method == 'POST':
form = IntentionForm(request.POST)
form.fields['semester'].choices = semester_choices
form.instructor_id = instructor.id
if form.is_valid():
intention = form.save()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=("added teaching intention for %s") % (intention.semester),
related_object=intention)
l.save()
messages.add_message(request, messages.SUCCESS, 'Added semester plan for %s.' % (intention.semester))
return HttpResponseRedirect(reverse('planning.views.edit_intention', kwargs={}))
else:
form = IntentionForm(initial={'instructor': instructor})
form.fields['semester'].choices = semester_choices
return render(request, "planning/add_intention.html", {'form': form, 'intention_list': intention_list})
def merge_nonstudent(request, nonstudent_slug):
"""
Merge a nonstudent with an existing student
"""
nonstudent = get_object_or_404(NonStudent, slug=nonstudent_slug, unit__in=request.units)
if request.method == 'POST':
form = MergeStudentForm(request.POST)
if form.is_valid():
student = form.cleaned_data['student']
notes = AdvisorNote.objects.filter(nonstudent=nonstudent)
for note in notes:
note.nonstudent = None
note.student = student
note.save()
if nonstudent.high_school:
student.set_nonstudent_hs(nonstudent.high_school)
if nonstudent.college:
student.set_nonstudent_colg(nonstudent.college)
if nonstudent.notes:
student.set_nonstudent_notes(nonstudent.notes)
nonstudent.delete()
student.save()
l = LogEntry(userid=request.user.username,
description=(u"Nonstudent (%s, %s) has been merged with emplid #%s by %s") % (nonstudent.last_name, nonstudent.first_name, student.emplid, request.user),
related_object=student)
l.save()
messages.add_message(request, messages.SUCCESS, 'Advisor notes successfully merged.')
return _redirect_to_notes(student)
else:
form = MergeStudentForm()
return render(request, 'advisornotes/merge_nonstudent.html', {'form': form, 'nonstudent': nonstudent})
def planner_create_intention(request, semester=None):
instructors = Person.objects.filter(role__role__in=["FAC", "SESS", "COOP"], role__unit__in=request.units)
instructor_list = [(i.id, i) for i in instructors]
if request.method == 'POST':
form = PlannerIntentionForm(request.POST)
if form.is_valid():
intention = form.save()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=("added teaching intention for %s") % (intention.instructor),
related_object=intention)
l.save()
messages.add_message(request, messages.SUCCESS, 'Added semester plan for %s.' % (intention.instructor.name()))
return HttpResponseRedirect(reverse('planning.views.view_intentions', kwargs={}))
else:
semesterField = {}
if (semester != None):
semester = get_object_or_404(Semester, name=semester)
semesterField = {'semester': semester}
form = PlannerIntentionForm(initial=semesterField)
form.fields['instructor'].choices = instructor_list
return render_to_response("planning/planner_create_intention.html", {'form': form}, context_instance=RequestContext(request))
def new_temporary_person(request):
if request.method == 'POST':
form = TemporaryPersonForm(request.POST)
if form.is_valid():
p = Person( first_name = form.cleaned_data['first_name'],
last_name = form.cleaned_data['last_name'],
emplid = Person.next_available_temp_emplid(),
userid = Person.next_available_temp_userid(),
temporary = True)
if form.cleaned_data['email']:
p.config['email'] = form.cleaned_data['email']
if form.cleaned_data['sin']:
p.config['sin'] = form.cleaned_data['sin']
p.save()
messages.success(request, 'Added new temporary person %s' % (p,))
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=("new temporary person: %s") % (p,),
related_object=p)
l.save()
return HttpResponseRedirect(reverse(unit_admin))
else:
form = TemporaryPersonForm()
return render(request, 'coredata/new_temporary_person.html', {'form': form})
def new_program(request):
unit_choices = [(u.id, u.name) for u in request.units]
if request.method == 'POST':
form = GradProgramForm(request.POST)
form.fields['unit'].choices = unit_choices
if form.is_valid():
form.save()
messages.success(request, "Created new program %s for %s." % (form.instance.label, form.instance.unit))
l = LogEntry(userid=request.user.username,
description="Created new program %s for %s." % (form.instance.label, form.instance.unit),
related_object=form.instance)
l.save()
return HttpResponseRedirect(reverse('grad:programs'))
else:
form = GradProgramForm()
form.fields['unit'].choices = unit_choices
page_title = 'New Program'
crumb = 'New Program'
context = {
'form': form,
'page_title' : page_title,
'crumb' : crumb
}
return render(request, 'grad/new_program.html', context)
def new_requirement(request):
program_choices = [(p.id, p.label) for p in GradProgram.objects.filter(unit__in=request.units)]
if request.method == 'POST':
form = GradRequirementForm(request.POST)
form.fields['program'].choices = program_choices
if form.is_valid():
form.save()
messages.success(request, "Created new grad requirement %s in %s." % (form.instance.description, form.instance.program))
l = LogEntry(userid=request.user.username,
description="Created new grad requirement %s in %s." % (form.instance.description, form.instance.program),
related_object=form.instance)
l.save()
return HttpResponseRedirect(reverse('grad:requirements'))
else:
form = GradRequirementForm()
form.fields['program'].choices = program_choices
page_title = 'New Requirement'
crumb = 'New Requirement'
context = {
'form': form,
'page_title' : page_title,
'crumb' : crumb
}
return render(request, 'grad/new_requirement.html', context)
def edit_contract(request, contract_slug):
contract = get_object_or_404(SessionalContract, slug=contract_slug, unit__in=request.units)
if request.method == 'POST':
form = SessionalContractForm(request, request.POST, instance=contract)
if form.is_valid():
contract = form.save(commit=False)
# Let's convert the person in there to an AnyPerson
person = form.cleaned_data['person']
contract.sessional = AnyPerson.get_or_create_for(person=person)
contract.save()
messages.add_message(request,
messages.SUCCESS,
'Contract was edited.'
)
l = LogEntry(userid=request.user.username,
description="edited sessional contract for: %s" % contract.sessional,
related_object=contract
)
l.save()
return HttpResponseRedirect(reverse('sessionals:sessionals_index'))
else:
form = SessionalContractForm(request, instance=contract)
form.fields['person'].initial = contract.sessional.get_person().emplid
return render(request, 'sessionals/edit_contract.html', {'form': form, 'contract': contract})
def add_change_record(request, asset_slug):
asset = get_object_or_404(Asset, slug=asset_slug, unit__in=request.units)
if request.method == 'POST':
form = AssetChangeForm(request, request.POST)
if form.is_valid():
change = form.save(commit=False)
change.asset = asset
qty = int(form.cleaned_data['qty'])
# If no one has ever put in a quantity for the asset, make it 0 to avoid adding int to Nonetype
if not asset.quantity:
asset.quantity = 0
if qty + asset.quantity < 0:
messages.add_message(request, messages.WARNING, 'You tried to remove more of this asset than you '
'originally had. Asset quantity set to zero.')
asset.quantity = 0
else:
asset.quantity += qty
asset.save()
change.save(request.user.username)
messages.add_message(request, messages.SUCCESS, 'Asset change record added')
l = LogEntry(userid=request.user.username, description="Added change record %s for asset %s" %
(change, asset), related_object=change)
l.save()
return HttpResponseRedirect(reverse('inventory:view_asset', kwargs={'asset_slug': asset.slug}))
else:
form = AssetChangeForm(request)
return render(request, 'inventory/add_change_record.html', {'form': form, 'asset': asset})
def email_alert( request, alert_type, alert_id ):
alert = get_object_or_404(Alert, id=alert_id, alerttype__unit__in=request.units)
if request.method == 'POST':
form = EmailResolutionForm(request.POST)
if form.is_valid():
f = form.save(commit=False)
f.alert = alert
f.update_type = "EMAI"
f.save()
messages.success(request, "Emailed student and resolved alert %s." % str(alert) )
l = LogEntry(userid=request.user.username,
description="Resolved alert %s." % str(alert),
related_object=form.instance)
l.save()
send_mail( form.cleaned_data['subject'], f.comments, form.cleaned_data['from_email'], [form.cleaned_data['to_email']] )
return HttpResponseRedirect(reverse('alerts.views.view_alert', kwargs={'alert_type':alert_type, 'alert_id':alert_id}))
else:
form = EmailResolutionForm(initial={'resolved_until': datetime.date.today(), 'to_email': alert.person.email(), 'from_email': request.user.email})
return render(request, 'alerts/email_alert.html', { 'alert_type':alert.alerttype,
'alert':alert,
'form': form })
def edit_course(request, course_slug):
course = get_object_or_404(PlanningCourse, slug=course_slug)
units = [(u.id, str(u)) for u in request.units]
if request.method == 'POST':
form = CourseForm(request.POST, instance=course)
form.fields['owner'].choices = units
if form.is_valid():
course = form.save()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=("edited course %s %s") % (course.subject, course.number),
related_object=course)
l.save()
messages.add_message(request, messages.SUCCESS, 'Edited course %s.' % (course))
return HttpResponseRedirect(reverse('planning.views.manage_courses', kwargs={}))
else:
form = CourseForm(instance=course)
form.fields['owner'].choices = units
return render(request, "planning/edit_course.html", {'form': form, 'course': course})
def manage_promises(request, grad_slug):
grad = get_object_or_404(GradStudent, slug = grad_slug)
promises = Promise.objects.filter(student=grad).order_by('start_semester__name')
if request.method == 'POST':
form = PromiseForm(request.POST)
if form.is_valid():
try:
promise = promises.get(end_semester=form.cleaned_data['end_semester'], removed=False)
except Promise.DoesNotExist:
promise = None
if promise != None:
form._errors['end_semester'] = ErrorList([u"A Promise for this semester already exists."])
else:
promise = form.save(commit=False)
promise.student = grad
promise.save()
messages.success(request, "Promise for %s sucessfully saved." % (grad))
l = LogEntry(userid=request.user.username,
description="added promise of $%f for %s" % (promise.amount, grad.slug),
related_object=promise )
l.save()
return HttpResponseRedirect(reverse('grad.views.manage_promises', kwargs={'grad_slug':grad.slug}))
else:
form = PromiseForm(initial={'student':grad, 'start_semester':Semester.get_semester(), 'end_semester':Semester.get_semester(), 'amount':'0.00'})
context = {
'grad':grad,
'form': form,
'promises': promises,
}
return render(request, 'grad/manage_promises.html', context)
def manage_supervisors(request, grad_slug):
grad = get_object_or_404(GradStudent, slug=grad_slug, program__unit__in=request.units)
supervisors = Supervisor.objects.filter(student=grad).select_related('supervisor')
supervisor_people = [s.supervisor for s in supervisors if s.supervisor]
if request.method == 'POST':
form = SupervisorForm(request.POST)
form.set_supervisor_choices(possible_supervisors([grad.program.unit], extras=supervisor_people, null=True))
if form.is_valid():
s = form.save(commit=False)
s.modified_by = request.user.username
s.student = grad
s.save()
messages.success(request, "Added committee member for %s." % (grad))
l = LogEntry(userid=request.user.username,
description="Added committee member %s for %s." % (s, grad.person.userid),
related_object=s)
l.save()
return HttpResponseRedirect(reverse('grad:manage_supervisors', kwargs={'grad_slug':grad_slug}))
else:
form = SupervisorForm()
form.set_supervisor_choices(possible_supervisors([grad.program.unit], extras=supervisor_people, null=True))
context = {
'form': form,
'supervisors': supervisors,
'grad': grad,
'can_edit': True,
}
return render(request, 'grad/manage_supervisors.html', context)
def copy_plan(request):
if request.method == 'POST':
form = CopyPlanForm(request.POST)
if form.is_valid():
copied_plan_name = form.cleaned_data['copy_plan_from']
copied_plan = SemesterPlan.objects.get(name=copied_plan_name)
copied_courses = PlannedOffering.objects.filter(plan=copied_plan).order_by('course')
plan = form.save()
for i in copied_courses:
added_course = PlannedOffering(plan=plan, course=i.course, section=i.section, component=i.component, campus=i.campus, enrl_cap=i.enrl_cap)
added_course.save()
meeting_times = MeetingTime.objects.filter(offering=i)
for m in meeting_times:
added_meeting_time = MeetingTime(offering=added_course, weekday=m.weekday, start_time=m.start_time, end_time=m.end_time, room=m.room)
added_meeting_time.save()
l = LogEntry(userid=request.user.username,
description=("Copied course plan %s in %s") % (plan.name, plan.semester),
related_object=plan)
l.save()
messages.add_message(request, messages.SUCCESS, 'New plan "%s" created.' % (plan.name))
return HttpResponseRedirect(reverse('planning.views.admin_index', kwargs={}))
else:
form = CopyPlanForm()
return render_to_response("planning/copy_plan.html", {'form': form}, context_instance=RequestContext(request))
def manage_letter_template(request, letter_template_slug):
unit_choices = [(u.id, u.name) for u in request.units]
letter_template = get_object_or_404(LetterTemplate, slug=letter_template_slug)
if request.method == 'POST':
form = LetterTemplateForm(request.POST, instance=letter_template)
if form.is_valid():
f = form.save(commit=False)
f.created_by = request.user.username
if 'email_body' in form.cleaned_data:
f.set_email_body(form.cleaned_data['email_body'])
if 'email_subject' in form.cleaned_data:
f.set_email_subject(form.cleaned_data['email_subject'])
f.save()
messages.success(request, "Updated %s letter for %s." % (form.instance.label, form.instance.unit))
l = LogEntry(userid=request.user.username,
description="Updated new %s letter for %s." % (form.instance.label, form.instance.unit),
related_object=form.instance)
l.save()
return HttpResponseRedirect(reverse('grad:letter_templates'))
else:
form = LetterTemplateForm(instance=letter_template)
form.fields['unit'].choices = unit_choices
page_title = 'Manage Letter Template'
crumb = 'Manage'
lt = sorted(LETTER_TAGS.items())
context = {
'form': form,
'page_title' : page_title,
'crumb' : crumb,
'letter_template' : letter_template,
'LETTER_TAGS' : lt
}
return render(request, 'grad/manage_letter_template.html', context)
def fake_login(request, next_page=None):
"""
Fake login view for devel without access to the fake CAS server
"""
import socket
from django.contrib.auth import login
from django.contrib.auth.models import User
if not next_page and 'next' in request.GET:
next_page = request.GET['next']
if not next_page:
next_page = '/'
hostname = socket.gethostname()
if settings.DEPLOY_MODE == 'production' or hostname.startswith('courses'):
# make damn sure we're not in production
raise NotImplementedError
if 'userid' in request.GET:
username = request.GET['userid']
try:
user = User.objects.get(username__iexact=username)
except User.DoesNotExist:
user = User.objects.create_user(username, '')
user.save()
user.backend = 'django.contrib.auth.backends.ModelBackend'
login(request, user)
#LOG EVENT#
l = LogEntry(userid=user.username,
description=("fake login as %s from %s") %
(user.username, ip.get_ip(request)),
related_object=user)
l.save()
return HttpResponseRedirect(next_page)
response = HttpResponse(
'<h1>Fake Authenticator</h1><p>Who would you like to be today?</p><form action="">Userid: <input type="text" name="userid" /><br/><input type="submit" value=""Authenticate"" /><input type="hidden" name="next" value="%s" /></form>'
% (next_page))
return response
def new_nonstudent(request, course_slug):
course = get_object_or_404(CourseOffering, slug=course_slug)
group_choices = [('', '\u2014')] + [
(g.id, g.name) for g in DisciplineGroup.objects.filter(offering=course)
]
if request.method == 'POST':
form = DisciplineInstrNonStudentCaseForm(data=request.POST)
form.fields['group'].choices = group_choices
if form.is_valid():
instructor = Person.objects.get(userid=request.user.username)
case = form.save(commit=False)
case.owner = instructor
case.offering = course
case.slug = defaultfilters.slugify(case.first_name + " " +
case.last_name)
case.save()
form.save_m2m()
#LOG EVENT#
l = LogEntry(
userid=request.user.username,
description=(
"created a non-student discipline case for %s in %s") %
(case.student.name(), course),
related_object=case)
l.save()
return HttpResponseRedirect(
reverse('offering:discipline:show',
kwargs={
'course_slug': course_slug,
'case_slug': case.slug
}))
else:
form = DisciplineInstrNonStudentCaseForm()
form.fields['group'].choices = group_choices
context = {'course': course, 'form': form}
return render(request, "discipline/new_nonstudent.html", context)
def edit_config(request, config_slug):
config = get_object_or_404(SessionalConfig, slug=config_slug)
if not _has_unit_role(request.user, config):
return ForbiddenResponse(request)
if request.method == 'POST':
form = SessionalConfigForm(request, request.POST, instance=config)
if form.is_valid():
config = form.save(commit=False)
config.save()
messages.add_message(request,
messages.SUCCESS,
u'Configuration was edited.'
)
l = LogEntry(userid=request.user.username,
description="edited config: %s" % config,
related_object=config
)
l.save()
return HttpResponseRedirect(reverse('sessionals:manage_configs'))
else:
form = SessionalConfigForm(request, instance=config)
return render(request, 'sessionals/edit_config.html', {'form': form, 'config': config})
def edit_program(request, program_slug):
program = get_object_or_404(Program,
slug=program_slug,
unit__in=request.units)
if request.method == 'POST':
form = ProgramForm(request.POST, instance=program)
if form.is_valid():
program = form.save()
messages.add_message(request, messages.SUCCESS,
'Program was created')
l = LogEntry(userid=request.user.username,
description="Added program %s" % program,
related_object=program)
l.save()
return HttpResponseRedirect(reverse('ra:programs_index'))
else:
form = ProgramForm(instance=program)
form.fields['unit'].choices = [(u.id, u.name) for u in request.units]
return render(request, 'ra/edit_program.html', {
'form': form,
'program': program
})
def new_artifact(request):
"""
View to create a new artifact
"""
unit_choices = [(u.id, unicode(u)) for u in request.units]
if request.POST:
form = ArtifactForm(request.POST)
form.fields['unit'].choices = unit_choices
if form.is_valid():
artifact = form.save()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=(u"new artifact %s by %s") % (artifact, request.user.username),
related_object=form.instance)
l.save()
messages.add_message(request, messages.SUCCESS, u'Artifact "%s" created.' % artifact)
return HttpResponseRedirect(reverse('advisornotes.views.view_artifacts', kwargs={}))
else:
form = ArtifactForm()
form.fields['unit'].choices = unit_choices
return render(request, 'advisornotes/new_artifact.html', {'form': form})
def new_visa(request, emplid=None):
if request.method == 'POST':
form = VisaForm(request, request.POST)
if form.is_valid():
visa = form.save(commit=False)
visa.save()
messages.add_message(request, messages.SUCCESS,
'Visa was created.')
l = LogEntry(userid=request.user.username,
description="added visa: %s" % (visa),
related_object=visa.person)
l.save()
return HttpResponseRedirect(reverse('visas:list_all_visas'))
else:
if emplid:
person = Person.objects.get(find_userid_or_emplid(emplid))
form = VisaForm(request, initial={'person': person})
else:
form = VisaForm(request)
return render(request, 'visas/new_visa.html', {'form': form})
def create_plan(request):
unit_choices = [(u.id, unicode(u)) for u in request.units]
if request.method == 'POST':
form = PlanBasicsForm(request.POST)
if form.is_valid():
plan = form.save()
# update PlanningCourse objects for this unit
PlanningCourse.create_for_unit(plan.unit)
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=("Created course plan %s in %s") % (plan.name, plan.semester),
related_object=plan)
l.save()
messages.add_message(request, messages.SUCCESS, 'New plan "%s" created.' % (plan.name))
return HttpResponseRedirect(reverse('planning.views.admin_index', kwargs={}))
else:
form = PlanBasicsForm()
form.fields['unit'].choices = unit_choices
return render(request, "planning/create_plan.html", {'form': form})
def new_note(request, userid):
try:
student = Person.objects.get(find_userid_or_emplid(userid))
except Person.DoesNotExist:
student = get_object_or_404(NonStudent, slug=userid)
unit_choices = [(u.id, unicode(u)) for u in request.units]
if request.method == 'POST':
form = advisor_note_factory(student, request.POST, request.FILES)
form.fields['unit'].choices = unit_choices
if form.is_valid():
note = form.save(commit=False)
if isinstance(student, Person):
note.student = student
else:
note.nonstudent = student
note.advisor = Person.objects.get(userid=request.user.username)
if 'file_attachment' in request.FILES:
upfile = request.FILES['file_attachment']
note.file_mediatype = upfile.content_type
if isinstance(student, Person) and form.cleaned_data['email_student']:
_email_student_note(note)
note.emailed = True
note.save()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=(u"new note for %s by %s") % (form.instance.student, request.user.username),
related_object=form.instance)
l.save()
messages.add_message(request, messages.SUCCESS, 'Note created.')
return _redirect_to_notes(student)
else:
form = advisor_note_factory(student)
form.fields['unit'].choices = unit_choices
return render(request, 'advisornotes/new_note.html', {'form': form, 'student': student, 'userid': userid})
def edit_account(request, account_slug):
account = get_object_or_404(SessionalAccount, slug=account_slug)
if not _has_unit_role(request.user, account):
return ForbiddenResponse(request)
if request.method == 'POST':
form = SessionalAccountForm(request, request.POST, instance=account)
if form.is_valid():
account = form.save(commit=False)
account.save()
messages.add_message(request,
messages.SUCCESS,
u'Account was edited.'
)
l = LogEntry(userid=request.user.username,
description="edited account: %s" % account,
related_object=account
)
l.save()
return HttpResponseRedirect(reverse('sessionals:manage_accounts'))
else:
form = SessionalAccountForm(request, instance=account)
return render(request, 'sessionals/edit_account.html', {'form': form, 'account': account})
def new_combined(request):
offering_id = request.GET.get('offering', None)
offering = get_object_or_404(CourseOffering, id=offering_id)
if request.method == 'POST':
form = NewCombinedForm(request.POST)
if form.is_valid():
combined = form.save(commit=False)
combined.semester = offering.semester
combined.crse_id = offering.crse_id
combined.class_nbr = _new_fake_class_nbr(combined.semester)
combined.save()
combined.offerings.add(offering)
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=("created combined offering %i with %s") %
(combined.id, offering.slug),
related_object=combined)
l.save()
messages.success(request, 'Created combined offering.')
return HttpResponseRedirect(
reverse('coredata.views.combined_offerings', kwargs={}))
else:
# set up creation form from the offering given
initial = {
'subject': offering.subject,
'number': offering.number,
'section': 'X100',
'component': offering.component,
'instr_mode': offering.instr_mode,
'owner': offering.owner,
'title': offering.title,
'campus': offering.campus,
}
form = NewCombinedForm(initial=initial)
context = {
'form': form,
}
return render(request, 'coredata/edit_combined.html', context)
def add_change_record(request, asset_slug):
asset = get_object_or_404(Asset, slug=asset_slug)
if request.method == 'POST':
form = AssetChangeForm(request, request.POST)
if form.is_valid():
change = form.save(commit=False)
change.asset = asset
qty = int(form.cleaned_data['qty'])
# If no one has ever put in a quantity for the asset, make it 0 to avoid adding int to Nonetype
if not asset.quantity:
asset.quantity = 0
if qty + asset.quantity < 0:
messages.add_message(
request, messages.WARNING,
u'You tried to remove more of this asset than you '
u'originally had. Asset quantity set to zero.')
asset.quantity = 0
else:
asset.quantity += qty
asset.save()
print request.user.username
change.save(request.user.username)
messages.add_message(request, messages.SUCCESS,
u'Asset change record added')
l = LogEntry(userid=request.user.username,
description="Added change record %s for asset %s" %
(change, asset),
related_object=change)
l.save()
return HttpResponseRedirect(
reverse('inventory:view_asset',
kwargs={'asset_slug': asset.slug}))
else:
form = AssetChangeForm(request)
return render(request, 'inventory/add_change_record.html', {
'form': form,
'asset': asset
})
def add_booking(request, location_slug, from_index=0):
location = get_object_or_404(Location,
slug=location_slug,
unit__in=Unit.sub_units(request.units))
editor = get_object_or_404(Person, userid=request.user.username)
if request.method == 'POST':
form = BookingRecordForm(request.POST)
if form.is_valid():
booking = form.save(commit=False)
booking.location = location
booking.save(editor=editor)
location.mark_conflicts()
messages.add_message(request, messages.SUCCESS,
'Booking was created')
l = LogEntry(userid=request.user.username,
description="Added booking %s for location %s" %
(booking, location),
related_object=booking)
l.save()
if from_index == '1':
return HttpResponseRedirect(reverse('space:index'))
return view_location(request, location_slug)
else:
for field in [form.fields['start_time'], form.fields['end_time']]:
field.help_text = "Please enter date on the left and time on the right. Time should be in 24 hour " \
"format, HH:MM:SS. Seconds are optional."
else:
form = BookingRecordForm()
for field in [form.fields['start_time'], form.fields['end_time']]:
field.help_text = "Please enter date on the left and time on the right. Time should be in 24 hour " \
"format, HH:MM:SS. Seconds are optional."
return render(request, 'space/new_booking.html', {
'form': form,
'location': location,
'from_index': from_index
})
def manage_financialcomments(request, grad_slug):
grad = get_object_or_404(GradStudent, slug=grad_slug)
financial_comments = FinancialComment.objects.filter(
student=grad, removed=False).order_by('semester__name')
if request.method == 'POST':
form = FinancialCommentForm(request.POST)
if form.is_valid():
comment = form.save(commit=False)
comment.student = grad
comment.created_by = request.user.username
comment.save()
messages.success(
request,
"Financial Comment for %s sucessfully saved." % (grad))
l = LogEntry(userid=request.user.username,
description="added financial comment \"%s\" for %s" %
(str(comment), grad.slug),
related_object=comment)
l.save()
return HttpResponseRedirect(
reverse('grad:manage_financialcomments',
kwargs={'grad_slug': grad.slug}))
else:
form = FinancialCommentForm(
initial={
'student': grad,
'semester': Semester.get_semester(),
'created_by': request.user.username
})
context = {
'grad': grad,
'form': form,
'financial_comments': financial_comments,
}
return render(request, 'grad/manage_financialcomments.html', context)
def process_request(self, request):
if "__impersonate" in request.GET:
# impersonation requested: check if it's allowed
userid = request.GET["__impersonate"]
match = course_path_re.match(request.path)
if has_global_role('SYSA', request):
# for sysadmins: yes.
pass
elif match:
# for instructors of a course: yes, but only students, and only within that course's "directory".
course_slug = match.group('course_slug') # course slug from the URL
instructor = Member.objects.filter(person__userid=request.user.username, offering__slug=course_slug, role__in=["TA", "INST"])
if not instructor:
# this person is not an instructor: no
return self._generate_error(request, "you are not an instructor of this course")
student = Member.objects.filter(person__userid=userid, offering__slug=course_slug, role="STUD")
if not student:
# trying to impersonate a non-student: no
return self._generate_error(request, "requested user is not a student in this course")
else:
# anybody else: no
return self._generate_error(request, "do not have permission to impersonate others")
# handle the impersonation
try:
user = User.objects.get(username__iexact=userid)
except User.DoesNotExist:
# create user object if they have never logged in (same thing django_cas does)
user = User.objects.create_user(userid, '')
user.save()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=("impersonating %s on page %s") % (userid, request.path), related_object=user)
l.save()
request.user = user
def join(request, course_slug, group_slug):
course = get_object_or_404(CourseOffering, slug=course_slug)
group = get_object_or_404(Group, courseoffering=course, slug=group_slug)
person = get_object_or_404(Person, userid=request.user.username)
member = get_object_or_404(Member, person=person, offering=course)
if request.method != "POST":
return HttpResponseForbidden()
for groupMember in GroupMember.objects.filter(group=group, student=member):
groupMember.confirmed = True
groupMember.save()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description="joined group %s." % (group.name, ),
related_object=group)
l.save()
messages.add_message(request, messages.SUCCESS,
'You have joined the group "%s".' % (group.name))
return HttpResponseRedirect(
reverse('groups.views.groupmanage',
kwargs={'course_slug': course_slug}))
def edit_unit(request, unit_slug=None):
if unit_slug:
unit = get_object_or_404(Unit, slug=unit_slug)
else:
unit = Unit()
if request.method == 'POST':
form = UnitForm(instance=unit, data=request.POST)
if form.is_valid():
unit.slug = None
form.save()
messages.success(request, 'Edited unit %s.' % (unit.name))
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=("edited unit %s") % (form.instance.slug),
related_object=unit)
l.save()
return HttpResponseRedirect(reverse(unit_list))
else:
form = UnitForm(instance=unit)
context = {'form': form}
return render(request, 'coredata/edit_unit.html', context)
def unit_address(request, unit_slug):
unit = get_object_or_404(Unit, slug=unit_slug)
if unit not in Unit.sub_units(request.units):
return ForbiddenResponse(request, "Not an admin for this unit")
if request.method == 'POST':
form = UnitAddressForm(data=request.POST, unit=unit)
if form.is_valid():
#print form.cleaned_data
form.copy_to_unit()
unit.save()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=("updated contact info for %s") %
(unit.label),
related_object=unit)
l.save()
return HttpResponseRedirect(reverse('coredata.views.unit_admin'))
else:
form = UnitAddressForm(unit=unit)
context = {'unit': unit, 'form': form}
return render(request, "coredata/unit_address.html", context)
def reject(request, course_slug, group_slug):
course = get_object_or_404(CourseOffering, slug=course_slug)
group = get_object_or_404(Group, courseoffering=course, slug=group_slug)
person = get_object_or_404(Person, userid=request.user.username)
member = get_object_or_404(Member, person=person, offering=course)
if request.method != "POST":
return HttpResponseForbidden()
# delete membership on reject
GroupMember.objects.filter(group=group, student=member).delete()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description="rejected membership in group %s." %
(group.name, ),
related_object=group)
l.save()
messages.add_message(request, messages.SUCCESS,
'You have left the group "%s".' % (group.name))
return HttpResponseRedirect(
reverse('offering:groups:groupmanage',
kwargs={'course_slug': course_slug}))
def edit_asset(request, asset_slug):
asset = get_object_or_404(Asset, slug=asset_slug, unit__in=request.units)
if request.method == 'POST':
form = AssetForm(request, request.POST, instance=asset)
if form.is_valid():
asset = form.save()
messages.add_message(request, messages.SUCCESS,
'Asset was modified')
l = LogEntry(userid=request.user.username,
description="Modified asset %s" % asset.name,
related_object=asset)
l.save()
return HttpResponseRedirect(reverse('inventory:inventory_index'))
else:
if asset.user:
user = asset.user.emplid
else:
user = None
form = AssetForm(request, instance=asset, initial={'user': user})
return render(request, 'inventory/edit_asset.html', {
'form': form,
'asset_slug': asset_slug
})
def site_search(request):
# Things that would be nice:
# activities in your courses
# grad students you admin/supervise
# advisors: students/advisornote content
# marking comments
person = get_person(request.user)
query = request.GET.get('q', '')
if 'search-scope' in request.GET and request.GET['search-scope'] == 'sfu':
# redirect to SFU-wide search if appropriate
url = SEARCH_URL + urlencode({'q': query, 'search-scope': 'sfu'})
return HttpResponseRedirect(url)
results = _query_results(query, person)
if results:
maxscore = max(r.score for r in results)
else:
maxscore = 1
# strip out the really bad results: elasticsearch is pretty liberal
results = (r for r in results if r.score >= maxscore / 10)
if request.user.is_authenticated:
# record authenticated searches for A/B testing
l = LogEntry(userid=request.user.username,
description='User %i searched for %r' %
(request.user.id, query),
related_object=request.user)
l.save()
context = {
"query": query,
"results": results,
"maxscore": maxscore,
}
return render(request, "dashboard/site_search.html", context)
def login_2fa(request, next_page=None):
next_page, okay_auth, okay_2fa = _setup_view(request, next_page)
if not okay_auth:
# Stale standard-Django authentication: redirect to password login page.
return HttpResponseRedirect(settings.PASSWORD_LOGIN_URL + '?' + urlencode({'next': next_page}))
if not okay_2fa:
# Need to do 2FA for this user.
devices = list(all_otp_devices(request.maybe_stale_user))
if not devices:
messages.add_message(request, messages.WARNING, 'You are required to do two-factor authentication but have no device enabled. You must add one.')
return HttpResponseRedirect(reverse('otp:add_topt') + '?' + urlencode({'next': next_page}))
if request.method == 'POST':
form = TokenForm(data=request.POST, devices=devices)
if form.is_valid():
# OTP is valid: record last 2FA time in SessionInfo; have django_otp record what it needs in the session
SessionInfo.just_2fa(request)
request.user = request.maybe_stale_user # otp_login looks at request.user
otp_login(request, form.device)
l = LogEntry(userid=request.user.username,
description=("2FA as %s from %s") % (request.user.username, get_client_ip(request)),
related_object=request.user)
l.save()
return HttpResponseRedirect(next_page)
else:
form = TokenForm()
context = {
'form': form,
}
return render(request, 'otp/login_2fa.html', context)
return HttpResponseRedirect(next_page)
def edit_event(request, contact_slug, event_slug):
editor = get_object_or_404(Person, userid=request.user.username)
contact = get_object_or_404(Contact,
slug=contact_slug,
unit__in=request.units)
event = get_object_or_404(Event, slug=event_slug, contact=contact)
handler = event.get_handler()
event_name = handler.name
if request.method == 'POST':
form = handler.EntryForm(data=request.POST)
if form.is_valid():
# Set the config variables in the event to the form content
handler.load(form)
handler.save(editor=editor)
messages.add_message(request, messages.SUCCESS,
'Contact content was modified')
l = LogEntry(userid=request.user.username,
description="Modified contact %s for %s" %
(handler.name, handler.event.contact.full_name()),
related_object=handler.event)
l.save()
return HttpResponseRedirect(
reverse('relationships:view_contact',
kwargs={'contact_slug': contact_slug}))
else:
# Get a form from the handler and pass in the config data from the event.
form = handler.EntryForm()
handler.load_initial(form)
return render(
request, 'relationships/edit_event.html', {
'form': form,
'contact': contact,
'event_slug': event.slug,
'event_name': event_name
})
def edit_single(request, course_slug, activity_slug):
course = get_object_or_404(CourseOffering, slug=course_slug)
activity = get_object_or_404(course.activity_set, slug=activity_slug, deleted=False)
component_list = select_all_components(activity)
#get component
edit_id = request.GET.get('id')
component = get_component(activity=activity, id=edit_id)
if component is None:
return NotFoundResponse(request)
form = component.Type.ComponentForm(instance=component)
#if form submitted
if request.method == 'POST':
new_form = component.Type.ComponentForm(request.POST)
if new_form.is_valid():
new_component = new_form.save(commit=False)
new_component.activity = activity
new_component.id = component.id
if new_component.position == None:
count = len(select_all_components(activity))
new_component.position = count + 1
new_component.save()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=(u"edited component %s of %s") % (component.title, activity),
related_object=new_component)
l.save()
messages.add_message(request, messages.SUCCESS, 'Component "' + new_component.title + '" successfully updated.')
return HttpResponseRedirect(reverse(show_components, args=[course_slug, activity_slug]))
else:
form = new_form
messages.add_message(request, messages.ERROR, 'Please correct the errors in the form.')
return render(request, "submission/component_edit_single.html",
{"course":course, "activity":activity, "component":component, "edit_id":edit_id, "form":form})
def edit_capability(request):
instructor = get_object_or_404(Person, userid=request.user.username)
capability_list = TeachingCapability.objects.filter(instructor=instructor).order_by('course')
unit_choices = request.units
if capability_list.count() == 0:
# never seen this instructor? Auto-populate.
TeachingCapability.populate_from_history(instructor, years=2)
capability_list = TeachingCapability.objects.filter(instructor=instructor).order_by('course')
messages.add_message(request, messages.INFO, 'Since you had no teaching capabilities specified, the list has been automatically populated from your recent teaching history. If you want to make changes, you can do so below.')
# update PlanningCourse objects for this instructor's unit(s)
for u in request.units:
PlanningCourse.create_for_unit(u)
possible_courses = [(c.id, c.full_name()) for c in PlanningCourse.objects.filter(owner__in=unit_choices, status="OPEN").distinct()]
if request.method == 'POST':
form = CapabilityForm(request.POST)
form.fields['course'].choices = possible_courses
form.instructor_id = instructor.id
if form.is_valid():
capability = form.save()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=("Added teaching capability %s") % (capability.course.full_name()),
related_object=capability)
l.save()
messages.add_message(request, messages.SUCCESS, 'Added teaching capability %s.' % (capability.course.full_name()))
return HttpResponseRedirect(reverse('planning.views.edit_capability', kwargs={}))
else:
form = CapabilityForm(initial={'instructor': instructor})
form.fields['course'].choices = possible_courses
return render(request, "planning/edit_capability.html", {'capability_list': capability_list, 'form': form})
def planner_edit_intention(request, semester, userid):
instructor = get_object_or_404(Person, userid=userid)
semester = get_object_or_404(Semester, name=semester)
intention = get_object_or_404(TeachingIntention,
semester=semester,
instructor__userid=userid)
if request.method == 'POST':
form = IntentionForm(request.POST, instance=intention)
form.instructor_id = instructor.id
if form.is_valid():
intention = form.save()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=("edited teaching intention for %s") %
(intention.instructor),
related_object=intention)
l.save()
messages.add_message(
request, messages.SUCCESS,
'Edited semester teaching intention for %s.' %
(intention.instructor))
return HttpResponseRedirect(
reverse('planning.views.view_semester_intentions',
kwargs={'semester': semester.name}))
else:
form = IntentionForm(initial={'instructor': instructor},
instance=intention)
return render_to_response("planning/planner_edit_intention.html", {
'semester': semester,
'instructor': instructor,
'form': form
},
context_instance=RequestContext(request))
def copy_letter(request, grad_slug, letter_slug):
grad = get_object_or_404(GradStudent, slug=grad_slug, program__unit__in=request.units)
old_letter = get_object_or_404(Letter, slug=letter_slug, student=grad)
letter = Letter(student=grad, to_lines=old_letter.to_lines, content=old_letter.content, template=old_letter.template,
closing=old_letter.closing, from_person=old_letter.from_person,
from_lines=old_letter.from_lines)
letter.set_use_sig(old_letter.use_sig())
from_choices = [('', u'\u2014')] \
+ [(r.person.id, "%s. %s, %s" %
(r.person.get_title(), r.person.letter_name(), r.get_role_display()))
for r in Role.objects_fresh.filter(unit=grad.program.unit)]
if request.method == 'POST':
form = LetterForm(request.POST, instance=letter)
form.fields['from_person'].choices = from_choices
if form.is_valid():
f = form.save(commit=False)
f.created_by = request.user.username
f.config = grad.letter_info()
f.save()
messages.success(request, "Created %s letter for %s." % (form.instance.template.label, form.instance.student))
l = LogEntry(userid=request.user.username,
description="Copied %s letter for %s." % (form.instance.template.label, form.instance.student),
related_object=form.instance)
l.save()
return HttpResponseRedirect(reverse('grad:manage_letters', kwargs={'grad_slug':grad_slug}))
else:
form = LetterForm(instance=letter, initial={'date': datetime.date.today()})
form.fields['from_person'].choices = from_choices
context = {
'form': form,
'grad' : grad,
'letter': letter,
}
return render(request, 'grad/copy_letter.html', context)
def manage_status(request, grad_slug):
grad = get_object_or_404(GradStudent, slug=grad_slug, program__unit__in=request.units)
statuses = GradStatus.objects.filter(student=grad)
# remove obsolete statuses from the list (but not the model, so legacy data displays properly)
status_choices = [(k,v) for k,v in STATUS_CHOICES if k not in STATUS_OBSOLETE]
if request.method == 'POST':
form = GradStatusForm(request.POST)
form.fields['status'].choices = status_choices
if form.is_valid():
# Save new status
status = form.save(commit=False)
status.student = grad
status.save()
#change gradstudent's last updated/by info to newest
grad.updated_at = datetime.datetime.now()
grad.created_by = request.user.username
grad.save()
messages.success(request, "Updated Status History for %s." % (grad.person))
l = LogEntry(userid=request.user.username,
description="Updated Status History for %s." % (grad.person),
related_object=status)
l.save()
return HttpResponseRedirect(reverse('grad:manage_status', kwargs={'grad_slug':grad_slug}))
else:
form = GradStatusForm(initial={'start': Semester.current(), 'start_date': datetime.datetime.today()})
form.fields['status'].choices = status_choices
context = {
'form' : form,
'statuses' : statuses,
'grad' : grad,
'can_edit': True,
}
return render(request, 'grad/manage_status.html', context)
def resolve_alert(request, alert_type, alert_id):
"""
Resolve an alert
"""
alert = get_object_or_404(Alert,
id=alert_id,
alerttype__unit__in=request.units)
if request.method == 'POST':
form = ResolutionForm(request.POST)
if form.is_valid():
f = form.save(commit=False)
f.alert = alert
f.update_type = "RESO"
f.save()
messages.success(request, "Resolved alert %s." % str(alert))
l = LogEntry(userid=request.user.username,
description="Resolved alert %s." % str(alert),
related_object=form.instance)
l.save()
return HttpResponseRedirect(
reverse('alerts.views.view_alert',
kwargs={
'alert_type': alert_type,
'alert_id': alert_id
}))
else:
form = ResolutionForm(
initial={'resolved_until': datetime.date.today()})
return render(
request, 'alerts/resolve_alert.html', {
'alert_type': alert.alerttype,
'alert': alert,
'form': form,
'resolve_reopen_or_comment_on': 'Resolve'
})
def edit_visa(request, visa_id):
visa = get_object_or_404(Visa, pk=visa_id)
if request.method == 'POST':
form = VisaForm(request, request.POST, instance=visa)
if form.is_valid():
visa = form.save(commit=False)
visa.save()
messages.add_message(request,
messages.SUCCESS,
u'Visa was successfully modified.'
)
l = LogEntry(userid=request.user.username,
description="edited visa: %s" % (visa),
related_object=visa.person
)
l.save()
return HttpResponseRedirect(reverse('visas:list_all_visas'))
else:
# The initial value needs to be the person's emplid in the form.
# Django defaults to the pk, which is not human readable.
form = VisaForm(request, instance=visa, initial={'person': visa.person.emplid})
return render(request, 'visas/edit_visa.html', {'form': form, 'visa_id': visa_id})
def edit_artifact_note(request, note_id, unit_course_slug=None, course_slug=None, artifact_slug=None):
note = get_object_or_404(ArtifactNote, id=note_id, unit__in=request.units)
related = course = offering = artifact = None
form = EditArtifactNoteForm(instance=note)
if unit_course_slug != None:
related = course = get_object_or_404(Course, slug=unit_course_slug)
elif course_slug != None:
related = offering = get_object_or_404(CourseOffering, slug=course_slug)
else:
related = artifact = get_object_or_404(Artifact, slug=artifact_slug)
if request.method == 'POST':
form = EditArtifactNoteForm(request.POST, request.FILES, instance=note)
if form.is_valid():
note = form.save(commit=False)
note.save()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=(u"edit note for %s by %s") % (related, request.user.username),
related_object=form.instance)
l.save()
messages.add_message(request, messages.SUCCESS, u'Note for %s edited.' % related)
if course:
return HttpResponseRedirect(reverse('advisornotes.views.view_course_notes', kwargs={'unit_course_slug': course.slug}))
elif offering:
return HttpResponseRedirect(reverse('advisornotes.views.view_offering_notes', kwargs={'course_slug': offering.slug}))
else:
return HttpResponseRedirect(reverse('advisornotes.views.view_artifact_notes', kwargs={'artifact_slug': artifact.slug}))
return render(request, 'advisornotes/edit_artifact_note.html',
{'form': form, 'note': note, 'related': related, 'artifact': artifact, 'course': course, 'offering': offering})
