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 })