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 _redirect_to_notes(student):
"""
Not all students have an active computing account: use userid if we can, or emplid if not.
"""
if type(student) is Person:
if student.userid:
return HttpResponseRedirect(reverse('advisornotes.views.student_notes', kwargs={'userid': student.userid}))
else:
return HttpResponseRedirect(reverse('advisornotes.views.student_notes', kwargs={'userid': student.emplid}))
else:
return HttpResponseRedirect(reverse('advisornotes.views.student_notes', kwargs={'nonstudent_slug': student.slug}))
def new_artifact_note(request, unit_course_slug=None, course_slug=None, artifact_slug=None):
unit_choices = [(u.id, unicode(u)) for u in request.units]
related = course = offering = artifact = None
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 = ArtifactNoteForm(request.POST, request.FILES)
form.fields['unit'].choices = unit_choices
if form.is_valid():
note = form.save(commit=False)
note.advisor = Person.objects.get(userid=request.user.username)
if 'file_attachment' in request.FILES:
upfile = request.FILES['file_attachment']
note.file_mediatype = upfile.content_type
if course:
note.course = course
elif offering:
note.course_offering = offering
else:
note.artifact = artifact
note.save()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=(u"new note for %s by %s") % (related, request.user.username),
related_object=form.instance)
l.save()
messages.add_message(request, messages.SUCCESS, u'Note for %s created.' % related)
if course:
return HttpResponseRedirect(reverse('advisornotes.views.view_course_notes', kwargs={'unit_course_slug': course.slug}))
elif offering:
return HttpResponseRedirect(reverse('advisornotes.views.view_offering_notes', kwargs={'course_slug': offering.slug}))
else:
return HttpResponseRedirect(reverse('advisornotes.views.view_artifact_notes', kwargs={'artifact_slug': artifact.slug}))
else:
form = ArtifactNoteForm(initial={})
form.fields['unit'].choices = unit_choices
return render(request, 'advisornotes/new_artifact_note.html',
{'form': form, 'related': related, 'artifact': artifact, 'course': course, 'offering': offering})
def delete_component(request, report, component_id):
report = get_object_or_404(Report, slug=report)
component = get_object_or_404(HardcodedReport, id=int(component_id))
component.delete()
messages.success(request, "Deleted component")
return HttpResponseRedirect(reverse('reports.views.view_report', kwargs={'report':report.slug}))
def delete_query(request, report, query_id):
report = get_object_or_404(Report, slug=report)
query = get_object_or_404(Query, id=int(query_id))
query.delete()
messages.success(request, "Deleted query")
return HttpResponseRedirect(reverse('reports.views.view_report', kwargs={'report':report.slug}))
def delete_access_rule(request, report, access_rule_id):
report = get_object_or_404(Report, slug=report)
access_rule = get_object_or_404(AccessRule, id=int(access_rule_id))
access_rule.delete()
messages.success(request, "Deleted access rule")
return HttpResponseRedirect(reverse('reports.views.view_report', kwargs={'report':report.slug}))
def view_course_offerings(request, semester=None):
"""
View to view all courses
"""
if semester:
semester = get_object_or_404(Semester, name=semester)
semesters = None
else:
semester = Semester.get_semester(date=datetime.date.today() +
datetime.timedelta(days=60))
semesters = Semester.objects.filter(
start__lte=datetime.date.today() +
datetime.timedelta(days=365)).order_by('-end')[:6]
if 'offeringsearch' in request.GET and request.GET[
'offeringsearch'] and request.GET['offeringsearch'].isdigit():
# handle the search for other offerings
offering = get_object_or_404(CourseOffering,
id=request.GET['offering'])
return HttpResponseRedirect(
reverse('advising:view_offering_notes',
kwargs={'course_slug': offering.slug}))
subunits = Unit.sub_unit_ids(request.units)
offerings = CourseOffering.objects.filter(owner__in=subunits,
semester=semester)
form = OfferingSearchForm()
return render(
request, 'advisornotes/view_course_offerings.html', {
'offerings': offerings,
'semester': semester,
'semesters': semesters,
'form': form
})
def reopen_or_comment_alert(request, alert_type, alert_id, update_code,
wording):
alert = get_object_or_404(Alert,
id=alert_id,
alerttype__unit__in=request.units)
if request.method == 'POST':
form = AlertUpdateForm(request.POST)
if form.is_valid():
f = form.save(commit=False)
f.alert = alert
f.update_type = update_code
f.save()
messages.success(request, "Updated alert %s." % str(alert))
l = LogEntry(userid=request.user.username,
description="Updated 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 = AlertUpdateForm()
return render(
request, 'alerts/resolve_alert.html', {
'alert_type': alert.alerttype,
'alert': alert,
'form': form,
'resolve_reopen_or_comment_on': wording
})
def edit_artifact(request, artifact_slug):
"""
View to edit a new artifact
"""
artifact = get_object_or_404(Artifact, slug=artifact_slug)
unit_choices = [(u.id, str(u)) for u in request.units]
if request.POST:
form = ArtifactForm(request.POST, instance=artifact)
form.fields['unit'].choices = unit_choices
if form.is_valid():
artifact = form.save()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=("edited artifact %s by %s") %
(artifact, request.user.username),
related_object=form.instance)
l.save()
messages.add_message(request, messages.SUCCESS,
'Artifact "%s" edited.' % artifact)
return HttpResponseRedirect(
reverse('advising:view_artifacts', kwargs={}))
else:
form = ArtifactForm(instance=artifact)
form.fields['unit'].choices = unit_choices
return render(request, 'advisornotes/edit_artifact.html', {
'form': form,
'artifact': artifact
})
def new_artifact(request):
"""
View to create a new artifact
"""
unit_choices = [(u.id, unicode(u)) for u in request.units]
if request.POST:
form = ArtifactForm(request.POST)
form.fields['unit'].choices = unit_choices
if form.is_valid():
artifact = form.save()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=(u"new artifact %s by %s") %
(artifact, request.user.username),
related_object=form.instance)
l.save()
messages.add_message(request, messages.SUCCESS,
u'Artifact "%s" created.' % artifact)
return HttpResponseRedirect(
reverse('advising:view_artifacts', kwargs={}))
else:
form = ArtifactForm()
form.fields['unit'].choices = unit_choices
return render(request, 'advisornotes/new_artifact.html', {'form': form})
def new_component(request, report):
report = get_object_or_404(Report, slug=report)
file_locations = [
component.file_location
for component in HardcodedReport.objects.filter(report=report)
]
if request.method == 'POST':
form = HardcodedReportForm(request.POST)
if form.is_valid():
f = form.save(commit=False)
if f.file_location in file_locations:
messages.error(
request,
'A ReportComponent with this file already exists.')
else:
f.report = report
f.created_by = request.user.username
f.save()
messages.success(
request,
"Created new report component: %s." % f.file_location)
return HttpResponseRedirect(
reverse('reports:view_report',
kwargs={'report': report.slug}))
else:
form = HardcodedReportForm()
return render(request, 'reports/new_component.html', {
'form': form,
'report': report
})
def delete_schedule_rule(request, report, schedule_rule_id):
report = get_object_or_404(Report, slug=report)
schedule_rule = get_object_or_404(ScheduleRule, id=int(schedule_rule_id))
schedule_rule.delete()
messages.success(request, "Deleted schedule rule")
return HttpResponseRedirect(reverse('reports.views.view_report', kwargs={'report':report.slug}))
def hide_alert(request, alert_type, alert_id):
alert = get_object_or_404(Alert,
pk=alert_id,
alerttype__unit__in=request.units)
alert.hidden = True
alert.save()
messages.success(request, "Deleted alert %s." % str(alert))
return HttpResponseRedirect(
reverse('alerts.views.view_resolved_alerts',
kwargs={'alert_type': alert_type}))
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_report(request):
if request.method == 'POST':
form = ReportForm(request.POST)
if form.is_valid():
f = form.save(commit=False)
f.created_by = request.user.username
f.save()
messages.success(request, "Created new report: %s." % f.name)
return HttpResponseRedirect(reverse('reports:view_report', kwargs={'report': f.slug}))
else:
form = ReportForm()
return render(request, 'reports/new_report.html', {'form': form })
def edit_report(request, report):
report = get_object_or_404(Report, slug=report)
if request.method == 'POST':
form = ReportForm(request.POST, instance=report)
if form.is_valid():
f = form.save(commit=False)
f.save()
messages.success(request, "Edited report: %s." % f.name)
return HttpResponseRedirect(reverse('reports:view_report', kwargs={'report': f.slug}))
else:
form = ReportForm(instance=report)
return render(request, 'reports/edit_report.html', {'form': form, 'report': report})
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 delete_run(request, report, run):
run = get_object_or_404(Run, slug=run)
report = run.report
runlines = RunLine.objects.filter( run=run )
results = Result.objects.filter( run=run )
for result in results:
result.delete()
for line in runlines:
line.delete()
run.delete()
messages.success(request, "Run Deleted!")
return HttpResponseRedirect(reverse('reports.views.view_report', kwargs={'report':report.slug}))
def privacy(request):
"""
View & sign the privacy statement.
"""
try:
you = Person.objects.get(userid=request.user.username)
except Person.DoesNotExist:
return HttpResponseRedirect("/")
next_page = '/'
if 'next' in request.GET:
next_page = request.GET['next']
privacy_date = ""
if 'privacy_date' in you.config:
privacy_date = you.config['privacy_date']
privacy_version = ""
if 'privacy_version' in you.config:
privacy_version = you.config['privacy_version']
good_to_go = False
if privacy_version == PRIVACY_VERSION:
good_to_go = True
if request.POST:
form = PrivacyForm(request.POST)
if form.is_valid():
set_privacy_signed(you)
messages.add_message(request, messages.SUCCESS, 'Privacy agreement recorded. Thank you.')
return HttpResponseRedirect(next_page)
else:
form = PrivacyForm()
return render(request, 'privacy/privacy.html', {
'form': form,
'privacy_date': privacy_date,
'good_to_go': good_to_go})
def record_advisor_visit(request, userid, unit_slug):
unit = get_object_or_404(Unit, slug=unit_slug, id__in=(u.id for u in request.units))
advisor = get_object_or_404(Person, userid=request.user.username)
try:
student = Person.objects.get(find_userid_or_emplid(userid))
nonstudent = None
except Person.DoesNotExist:
nonstudent = get_object_or_404(NonStudent, slug=userid)
student = None
av = AdvisorVisit(student=student, nonstudent=nonstudent, program=None, advisor=advisor, unit=unit)
av.save()
messages.add_message(request, messages.SUCCESS, u'%s advisor visit recorded on %s.' % (unit.informal_name(), datetime.date.today()))
return HttpResponseRedirect(reverse('advisornotes.views.student_notes', kwargs={'userid': userid}))
def new_schedule_rule(request, report):
report = get_object_or_404(Report, slug=report)
if request.method == 'POST':
form = ScheduleRuleForm(request.POST)
if form.is_valid():
f = form.save(commit=False)
f.report = report
f.save()
messages.success(request, "Created new schedule: %s." % str(f.next_run) )
return HttpResponseRedirect(reverse('reports.views.view_report', kwargs={'report':report.slug}))
else:
form = ScheduleRuleForm()
return render(request, 'reports/new_schedule_rule.html', {'form': form, 'report': report })
def new_alert(request, report):
report = get_object_or_404(Report, slug=report)
if request.method == 'POST':
form = AlertTypeForm(request.POST)
if form.is_valid():
f = form.save(commit=False)
f.save()
messages.success(request, "Created new alert type: %s." % str(f.code) )
report.alert = f
report.save()
return HttpResponseRedirect(reverse('reports.views.view_report', kwargs={'report':report.slug}))
else:
form = AlertTypeForm()
return render(request, 'reports/new_alert.html', {'form': form, 'report': report })
def new_query(request, report):
report = get_object_or_404(Report, slug=report)
if request.method == 'POST':
form = QueryForm(request.POST)
if form.is_valid():
f = form.save(commit=False)
f.report = report
f.created_by = request.user.username
f.save()
messages.success(request, "Created new report query: %s" % f.query)
return HttpResponseRedirect(reverse('reports.views.view_report', kwargs={'report':report.slug}))
else:
form = QueryForm()
return render(request, 'reports/new_query.html', {'form': form, 'report': report })
def send_emails(request, alert_type):
"""
Send all e-mails.
"""
alert_emails = AlertEmailTemplate.objects.all().order_by('threshold')
unresolved_alerts = Alert.objects.filter(alerttype__slug=alert_type,
resolved=False,
hidden=False)
alert_emails = AlertEmailTemplate.objects.filter(
hidden=False).order_by('threshold')
alert_email_dict = dict([(key, []) for key in alert_emails])
for alert in unresolved_alerts:
number_of_warnings_sent = alert.alertupdate_set.filter(
update_type='EMAI').count()
for email in alert_emails:
if number_of_warnings_sent < email.threshold:
alert_email_dict[email].append(alert)
break
alert_automations = []
for email in alert_emails:
for alert in alert_email_dict[email]:
email_context = build_context(alert)
t = Template(email.content)
email_context = build_context(alert)
email_context['details'] = {}
for k, v in alert.details.iteritems():
email_context['details'][k] = str(v)
rendered_text = t.render(Context(email_context))
# TODO Right here: this should DEFINITELY be a celery task.
send_mail(email.subject,
rendered_text,
"*****@*****.**", [alert.person.email()],
fail_silently=True)
update = AlertUpdate(alert=alert,
update_type="EMAI",
comments=rendered_text)
update.save()
return HttpResponseRedirect(reverse('alerts.views.view_alert_types'))
def edit_query(request, report, query_id):
report = get_object_or_404(Report, slug=report)
query = get_object_or_404(Query, id=int(query_id))
if request.method == 'POST':
form = QueryForm(request.POST)
if form.is_valid():
f = form.save(commit=False)
f.report = report
f.created_by = request.user.username
f.save()
query.delete()
messages.success(request, "Edited query: %s" % f.query)
return HttpResponseRedirect(reverse('reports.views.view_report', kwargs={'report':report.slug}))
else:
form = QueryForm(instance=query)
return render(request, 'reports/edit_query.html', {'form': form, 'report': report, 'query_id':query_id })
def view_courses(request):
"""
View to view all courses
"""
if 'coursesearch' in request.GET and 'course' in request.GET \
and request.GET['course'] and request.GET['course'].isdigit():
# handle the search for other courses
offering = get_object_or_404(Course, id=request.GET['course'])
return HttpResponseRedirect(
reverse('advising:view_course_notes',
kwargs={'unit_course_slug': offering.slug}))
# all courses where a recent offering was owned by relevant units
subunits = Unit.sub_unit_ids(request.units)
old_sem = Semester.get_semester(datetime.date.today() -
datetime.timedelta(days=365 * 2))
offerings = CourseOffering.objects.filter(owner__in=subunits, semester__name__gte=old_sem.name) \
.values('course').order_by().distinct()
# all courses where there are notes from relevant units
notes = ArtifactNote.objects.filter(unit__in=request.units).exclude(course__isnull=True) \
.values('course').order_by().distinct()
with_note_ids = set(n['course'] for n in notes)
course_ids = set(o['course'] for o in offerings)
course_ids |= with_note_ids
# all current CourseOfferings with notes: interested in those Courses too
offering_notes = ArtifactNote.objects.filter(unit__in=request.units, course_offering__semester__name__gte=old_sem.name) \
.values('course_offering__course').order_by().distinct()
offering_note_ids = set(n['course_offering__course']
for n in offering_notes)
with_note_ids |= offering_note_ids
course_ids |= offering_note_ids
courses = Course.objects.filter(id__in=course_ids)
form = CourseSearchForm()
return render(request, 'advisornotes/view_courses.html', {
'courses': courses,
'with_note_ids': with_note_ids,
'form': form
})
def sims_add_person(request):
if request.method == 'POST':
emplid = request.POST.get('emplid', None)
if emplid:
try:
p = add_person(emplid.strip())
except SIMSProblem:
p = None
if isinstance(p, Person):
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=(u"added %s (%s) from SIMS") % (p.name(), p.emplid),
related_object=p)
l.save()
messages.add_message(request, messages.SUCCESS, u'Record for %s created.' % (p.name()))
return _redirect_to_notes(p)
return HttpResponseRedirect(reverse('advisornotes.views.advising', kwargs={}))
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'
})