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 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 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 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 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 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(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 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 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 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 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_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_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 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 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_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 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 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 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 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_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 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 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 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 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 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=("edit note for %s by %s") %
(related, request.user.username),
related_object=form.instance)
l.save()
messages.add_message(request, messages.SUCCESS,
'Note for %s edited.' % related)
if course:
return HttpResponseRedirect(
reverse('advising:view_course_notes',
kwargs={'unit_course_slug': course.slug}))
elif offering:
return HttpResponseRedirect(
reverse('advising:view_offering_notes',
kwargs={'course_slug': offering.slug}))
else:
return HttpResponseRedirect(
reverse('advising: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
})
def remove_account(request, account_slug):
account = get_object_or_404(Account, slug=account_slug, unit__in=request.units)
account.delete()
messages.success(request, "Removed account %s." % str(account.account_number))
l = LogEntry(userid=request.user.username,
description="Removed account %s" % (str(account.account_number)),
related_object=account)
l.save()
return HttpResponseRedirect(reverse('ra.views.accounts_index'))
def delete_asset(request, asset_id):
asset = get_object_or_404(Asset, pk=asset_id, unit__in=request.units)
if request.method == 'POST':
asset.delete()
messages.success(request, 'Hid asset %s' % asset)
l = LogEntry(userid=request.user.username,
description="Deleted asset: %s" % asset,
related_object=asset)
l.save()
return HttpResponseRedirect(reverse('inventory:inventory_index'))
def remove_project(request, project_slug):
project = get_object_or_404(Project, slug=project_slug, unit__in=request.units)
project.delete()
messages.success(request, "Removed project %s." % str(project.project_number))
l = LogEntry(userid=request.user.username,
description="Removed project %s" % (str(project.project_number)),
related_object=project)
l.save()
return HttpResponseRedirect(reverse('ra.views.projects_index'))
def delete_attachment(request, asset_id, attach_slug):
asset = get_object_or_404(Asset, pk=asset_id, unit__in=request.units)
attachment = get_object_or_404(asset.attachments.all(), slug=attach_slug)
attachment.hide()
messages.add_message(request, messages.SUCCESS, 'Attachment deleted.')
l = LogEntry(userid=request.user.username,
description="Hid attachment %s" % attachment,
related_object=attachment)
l.save()
return HttpResponseRedirect(
reverse('inventory:view_asset', kwargs={'asset_slug': asset.slug}))
def delete_attachment(request, contract_slug, attach_slug):
contract = get_object_or_404(SessionalContract, slug=contract_slug, unit__in=request.units)
attachment = get_object_or_404(contract.attachments.all(), slug=attach_slug)
attachment.hide()
messages.add_message(request,
messages.SUCCESS,
'Attachment deleted.'
)
l = LogEntry(userid=request.user.username, description="Hid attachment %s" % attachment, related_object=attachment)
l.save()
return HttpResponseRedirect(reverse('sessionals:view_contract', kwargs={'contract_slug': contract.slug}))
def delete_attachment(request, visa_id, attach_slug):
visa = get_object_or_404(Visa, pk=visa_id)
attachment = get_object_or_404(visa.attachments.all(), slug=attach_slug)
attachment.hide()
messages.add_message(request,
messages.SUCCESS,
u'Attachment deleted.'
)
l = LogEntry(userid=request.user.username, description="Hid attachment %s" % attachment, related_object=attachment)
l.save()
return HttpResponseRedirect(reverse('visas:view_visa', kwargs={'visa_id':visa.id}))
def delete_template(request, template_id):
template = get_object_or_404(DisciplineTemplate, id=template_id)
if request.method == 'POST':
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=("deleted discipline template %i") % (template.id),
related_object=template)
l.save()
messages.add_message(request, messages.SUCCESS, 'Deleted template "%s".' % (template.label))
template.delete()
return HttpResponseRedirect(reverse('sysadmin:show_templates'))
def edit(request, ra_slug):
appointment = get_object_or_404(RAAppointment,
slug=ra_slug,
deleted=False,
unit__in=request.units)
scholarship_choices, hiring_faculty_choices, unit_choices, project_choices, account_choices, program_choices = \
_appointment_defaults(request.units, emplid=appointment.person.emplid)
if request.method == 'POST':
data = request.POST.copy()
if data['pay_frequency'] == 'L':
# force legal values into the non-submitted (and don't-care) fields for lump sum pay
data['biweekly_pay'] = 1
data['hourly_pay'] = 1
data['hours'] = 1
data['pay_periods'] = 1
raform = RAForm(data, instance=appointment)
if raform.is_valid():
userid = raform.cleaned_data['person'].userid
appointment = raform.save(commit=False)
appointment.set_use_hourly(raform.cleaned_data['use_hourly'])
appointment.save()
l = LogEntry(userid=request.user.username,
description="Edited RA appointment %s." % appointment,
related_object=appointment)
l.save()
messages.success(
request,
'Updated RA Appointment for ' + appointment.person.first_name +
" " + appointment.person.last_name)
return HttpResponseRedirect(
reverse('ra:student_appointments', kwargs=({
'userid': userid
})))
else:
#The initial value needs to be the person's emplid in the form. Django defaults to the pk, which is not human readable.
raform = RAForm(instance=appointment,
initial={
'person': appointment.person.emplid,
'use_hourly': appointment.use_hourly()
})
#As in the new method, choices are restricted to relevant options.
raform.fields['person'] = forms.CharField(widget=forms.HiddenInput())
raform.fields['hiring_faculty'].choices = hiring_faculty_choices
raform.fields['scholarship'].choices = scholarship_choices
raform.fields['unit'].choices = unit_choices
raform.fields['project'].choices = project_choices
raform.fields['account'].choices = account_choices
raform.fields['program'].choices = program_choices
return render(request, 'ra/edit.html', {
'raform': raform,
'appointment': appointment,
'person': appointment.person
})
def delete_ra(request, ra_slug):
appointment = get_object_or_404(RAAppointment, slug=ra_slug, unit__in=request.units)
if request.method == 'POST':
appointment.deleted = True
appointment.save()
messages.success(request, "Deleted RA appointment." )
l = LogEntry(userid=request.user.username,
description="Deleted RA appointment %s." % (str(appointment),),
related_object=appointment)
l.save()
return HttpResponseRedirect(reverse('ra.views.student_appointments', kwargs={'userid': appointment.person.emplid}))
def delete_event(request, event_id):
event = get_object_or_404(OutreachEvent,
pk=event_id,
unit__in=request.units)
if request.method == 'POST':
event.delete()
messages.success(request, 'Hid event %s' % event)
l = LogEntry(userid=request.user.username,
description="Deleted event: %s" % event,
related_object=event)
l.save()
return HttpResponseRedirect(reverse('outreach:outreach_index'))
def delete_visa(request, visa_id):
if request.method == 'POST':
visa = get_object_or_404(Visa, pk=visa_id)
messages.success(request, 'Hid visa for %s' % (visa.person.name()))
l = LogEntry(userid=request.user.username,
description="deleted visa: %s" % (visa),
related_object=visa.person)
l.save()
visa.hide()
visa.save()
return HttpResponseRedirect(reverse('visas:list_all_visas'))
def delete_change_record(request, record_id):
record = get_object_or_404(AssetChangeRecord, pk=record_id, asset__unit__in=request.units)
asset = record.asset
record.delete(request.user.username)
messages.success(request, 'Successfully hid record')
l = LogEntry(userid=request.user.username,
description="Deleted record: %s" % record,
related_object=record)
l.save()
messages.warning(request, 'WARNING: Quantity for this asset has not been changed. If deleting this '
'record implies quantity changes, please adjust the asset quantity now.')
return HttpResponseRedirect(reverse('inventory:view_asset', kwargs={'asset_slug': asset.slug}))
def toggle_requirement(request, requirement_id):
requirement = get_object_or_404(GradRequirement, pk=requirement_id)
if request.method == 'POST':
requirement.hidden = not requirement.hidden
requirement.save()
messages.add_message(request, messages.SUCCESS,
'Requirement visibility was changed')
l = LogEntry(userid=request.user.username,
description="Changed requirement visibility",
related_object=requirement)
l.save()
return HttpResponseRedirect(reverse('grad:requirements'))
def manage_start_end_semesters(request, grad_slug):
grad = get_object_or_404(GradStudent,
slug=grad_slug,
program__unit__in=request.units)
if request.method == 'POST':
form = GradSemesterForm(request.POST)
if form.is_valid():
if 'ignore' in form.cleaned_data and form.cleaned_data['ignore']:
# we have been asked to revert to the default behaviour: clear user-set values
if 'start_semester' in grad.config:
del grad.config['start_semester']
if 'end_semester' in grad.config:
del grad.config['end_semester']
else:
# apply the user-set values
if form.cleaned_data['start_semester']:
grad.config['start_semester'] = form.cleaned_data[
'start_semester'].name
else:
grad.config['start_semester'] = None
if form.cleaned_data['end_semester']:
grad.config['end_semester'] = form.cleaned_data[
'end_semester'].name
else:
grad.config['end_semester'] = None
grad.save()
grad.update_status_fields()
messages.success(
request,
"Updated start/end semester info for %s." % (grad.person))
l = LogEntry(userid=request.user.username,
description="Updated start/end semester for %s." %
(grad),
related_object=grad)
l.save()
return HttpResponseRedirect(
reverse('grad.views.view', kwargs={'grad_slug': grad.slug}))
else:
form = GradSemesterForm(
initial={
'start_semester': grad.start_semester,
'end_semester': grad.end_semester
})
context = {
'form': form,
'grad': grad,
}
return render(request, 'grad/manage_start_end_semesters.html', context)
def delete_contact(request, contact_slug):
contact = get_object_or_404(Contact,
slug=contact_slug,
unit__in=request.units)
if request.method == 'POST':
contact.delete()
messages.add_message(request, messages.SUCCESS, 'Contact was deleted')
l = LogEntry(userid=request.user.username,
description="Deleted contact %s" % contact,
related_object=contact)
l.save()
return HttpResponseRedirect(reverse('relationships:index'))
def delete_booking_attachment(request, booking_slug, attachment_id):
booking = get_object_or_404(BookingRecord, slug=booking_slug, location__unit__in=Unit.sub_units(request.units))
attachment = get_object_or_404(BookingRecordAttachment, booking_record=booking, pk=attachment_id)
attachment.hide()
messages.add_message(request,
messages.SUCCESS,
'Attachment was deleted')
l = LogEntry(userid=request.user.username,
description="Deleted attachment in booking %s" % booking,
related_object=attachment)
l.save()
return HttpResponseRedirect(reverse('space:view_booking', kwargs={'booking_slug': booking.slug}))
def newgroup(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')
]
if request.method == 'POST':
form = DisciplineGroupForm(offering=course, data=request.POST)
form.fields['students'].choices = student_choices
if form.is_valid():
instructor = Person.objects.get(userid=request.user.username)
group = form.save()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=("created a discipline cluster in %s") %
(course),
related_object=group)
l.save()
for userid in form.cleaned_data['students']:
# create case for each student in the group
student = Member.objects.get(offering=course,
person__userid=userid)
case = DisciplineCaseInstrStudent(student=student.person,
group=group,
owner=instructor,
offering=course)
case.save()
#LOG EVENT#
l = LogEntry(
userid=request.user.username,
description=(
"created a discipline case for %s in cluster %s") %
(userid, group.name),
related_object=case)
l.save()
return HttpResponseRedirect(
reverse('discipline.views.showgroup',
kwargs={
'course_slug': course_slug,
'group_slug': group.slug
}))
else:
form = DisciplineGroupForm(offering=course)
form.fields['students'].choices = student_choices
context = {'course': course, 'form': form}
return render_to_response("discipline/newgroup.html",
context,
context_instance=RequestContext(request))
def toggle_scholarshiptype(request, st_id):
st = get_object_or_404(ScholarshipType, pk=st_id, unit__in=request.units)
if request.method == 'POST':
st.hidden = not st.hidden
st.save()
messages.add_message(request, messages.SUCCESS,
'Scholarship type visibility was changed')
l = LogEntry(userid=request.user.username,
description="Changed scholarship type visibility",
related_object=st)
l.save()
return HttpResponseRedirect(reverse('grad:manage_scholarshiptypes'))
def new_automation(request, alert_type):
alert_type = get_object_or_404(AlertType,
slug=alert_type,
unit__in=request.units)
if request.method == 'POST':
form = EmailForm(request.POST)
if form.is_valid():
if AlertEmailTemplate.objects.filter(
alerttype=alert_type,
hidden=False,
threshold=form.cleaned_data['threshold']).count() > 0:
errors = form._errors.setdefault("threshold", ErrorList())
errors.append(u'An e-mail with this threshold already exists.')
else:
f = form.save(commit=False)
f.alerttype = alert_type
f.created_by = request.user.username
f.save()
messages.success(
request,
"Created new automated email for %s." % alert_type.code)
l = LogEntry(userid=request.user.username,
description="Created new automated email %s." %
alert_type.code,
related_object=form.instance)
l.save()
return HttpResponseRedirect(
reverse('alerts.views.view_automation',
kwargs={'alert_type': alert_type.slug}))
else:
form = EmailForm()
sample_alert = Alert.objects.filter(alerttype=alert_type, hidden=False)[0]
email_tags = [("person.name",
"The name of the student that has triggered the alert"),
("person.first_name", "The first name of the student."),
("person.last_name", "The last name of the student."),
("person.middle_name", "The middle name of the student."),
("person.emplid", "The student's emplid."),
("person.email", "The student's email."),
("person.title", "The student's title."),
("description", "The description of the alert.")]
for k, v in sample_alert.details.iteritems():
email_tags.append(("details." + k, "For example, (" + str(v) + ")"))
return render(request, 'alerts/new_automation.html', {
'alert_type': alert_type,
'form': form,
'email_tags': email_tags
})
def new_letter(request, grad_slug, letter_template_slug):
grad = get_object_or_404(GradStudent,
slug=grad_slug,
program__unit__in=request.units)
template = get_object_or_404(LetterTemplate,
slug=letter_template_slug,
unit__in=request.units)
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.filter(unit=grad.program.unit, role__in=['GRPD','GRAD','TAAD','TADM','FUND','ADMN'])]
directors = Role.objects.filter(unit=grad.program.unit,
role='GRPD').order_by('-id')
if directors:
default_from = directors[0].person.id
else:
default_from = None
ls = grad.letter_info()
if request.method == 'POST':
form = LetterForm(request.POST)
form.fields['from_person'].choices = from_choices
if form.is_valid():
f = form.save(commit=False)
f.created_by = request.user.username
f.config.update(ls)
f.template = template
f.save()
messages.success(
request, "Created new %s letter for %s." %
(form.instance.template.label, form.instance.student))
l = LogEntry(userid=request.user.username,
description="Created new %s letter for %s." %
(form.instance.template.label, form.instance.student),
related_object=form.instance)
l.save()
return HttpResponseRedirect(
reverse('grad.views.manage_letters',
kwargs={'grad_slug': grad_slug}))
else:
form = LetterForm(
initial={
'student': grad,
'date': datetime.date.today(),
'from_person': default_from
})
form.fields['from_person'].choices = from_choices
context = {'form': form, 'grad': grad, 'template': template}
return render(request, 'grad/new_letter.html', context)
def delete_roomtype(request, roomtype_id):
roomtype = get_object_or_404(RoomType, pk=roomtype_id, unit__in=Unit.sub_units(request.units))
if request.method == 'POST':
roomtype.hidden = True
roomtype.save()
messages.add_message(request,
messages.SUCCESS,
'Room type was deleted')
l = LogEntry(userid=request.user.username,
description="Deleted roomtype %s" % roomtype,
related_object=roomtype)
l.save()
return HttpResponseRedirect(reverse('space:list_roomtypes'))
def delete_automation(request, alert_type, automation_id):
auto = get_object_or_404(AlertEmailTemplate, id=automation_id)
auto.hidden = True
auto.save()
messages.success(request, "Removed automation")
l = LogEntry(userid=request.user.username,
description="Removed automation.",
related_object=auto)
l.save()
return HttpResponseRedirect(
reverse('alerts.views.view_automation',
kwargs={'alert_type': alert_type}))
def remove_financialcomment(request, grad_slug, f_id):
grad = get_object_or_404(GradStudent, slug=grad_slug, program__unit__in=request.units)
fin = get_object_or_404(FinancialComment, student=grad, id=f_id)
if request.method == 'POST':
fin.removed = True
fin.save()
messages.success(request, "Removed financial comment %s." % str(fin))
l = LogEntry(userid=request.user.username,
description="Removed financial comment %s for %s." % (str(fin), grad.person.userid),
related_object=fin)
l.save()
return HttpResponseRedirect(reverse('grad.views.manage_financialcomments', kwargs={'grad_slug':grad_slug}))
def remove_scholarship(request, grad_slug, s_id):
grad = get_object_or_404(GradStudent, slug=grad_slug, program__unit__in=request.units)
scholarship = get_object_or_404(Scholarship, student=grad, id=s_id)
if request.method == 'POST':
scholarship.removed = True
scholarship.save()
messages.success(request, "Removed scholarship %s." % str(scholarship) )
l = LogEntry(userid=request.user.username,
description="Removed scholarship %s for %s." % (str(scholarship), grad.person.userid),
related_object=scholarship)
l.save()
return HttpResponseRedirect(reverse('grad:manage_scholarships', kwargs={'grad_slug':grad_slug}))
def delete_location(request, location_id):
location = get_object_or_404(Location,
pk=location_id,
unit__in=Unit.sub_units(request.units))
if request.method == 'POST':
location.hidden = True
location.save()
messages.add_message(request, messages.SUCCESS, 'Location was deleted')
l = LogEntry(userid=request.user.username,
description="Deleted location %s" % location,
related_object=location)
l.save()
return HttpResponseRedirect(reverse('space:index'))
def delete_room_safety_item(request, safety_item_slug):
safety_item = get_object_or_404(RoomSafetyItem,
unit__in=Unit.sub_units(request.units),
slug=safety_item_slug)
if request.method == 'POST':
safety_item.delete()
messages.add_message(request, messages.SUCCESS,
'Safety item was deleted')
l = LogEntry(userid=request.user.username,
description="Deleted safety item %s" % safety_item,
related_object=safety_item)
l.save()
return HttpResponseRedirect(reverse('space:manage_safety_items'))
def delete_plan(request, semester, plan_slug):
plan = get_object_or_404(SemesterPlan, semester__name=semester, slug=plan_slug)
if request.method == 'POST':
plan.delete()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=("deleted course plan %s in %s") % (plan.name, plan.semester),
related_object=request.user)
l.save()
messages.add_message(request, messages.SUCCESS, 'Plan deleted.')
return HttpResponseRedirect(reverse(admin_index))
def remove_otherfunding(request, grad_slug, o_id):
grad = get_object_or_404(GradStudent, slug=grad_slug, program__unit__in=request.units)
otherfunding = get_object_or_404(OtherFunding, student=grad, id=o_id)
if request.method == 'POST':
otherfunding.removed = True
otherfunding.save()
messages.success(request, "Removed other funding %s." % str(otherfunding) )
l = LogEntry(userid=request.user.username,
description="Removed otherfunding %s for %s." % (str(otherfunding), grad.person.userid),
related_object=otherfunding)
l.save()
return HttpResponseRedirect(reverse('grad.views.manage_otherfunding', kwargs={'grad_slug':grad_slug}))
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=("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('offering:submission: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
})
