def create_fake_semester(strm):
"""
Create a close-enough Semester object for testing
"""
strm = str(strm)
if Semester.objects.filter(name=strm):
return
s = Semester(name=strm)
yr = int(strm[0:3]) + 1900
if strm[3] == '1':
mo = 1
elif strm[3] == '4':
mo = 5
elif strm[3] == '7':
mo = 9
s.start = datetime.date(yr,mo,5)
s.end = datetime.date(yr,mo+3,1)
s.save()
sw = SemesterWeek(semester=s, week=1)
mon = s.start
while mon.weekday() != 0:
mon -= datetime.timedelta(days=1)
sw.monday = mon
sw.save()
return s
def get_or_create_semester(strm):
if not (isinstance(strm, basestring) and strm.isdigit() and len(strm)==4):
raise ValueError, "Bad strm: " + repr(strm)
oldsem = Semester.objects.filter(name=strm)
if oldsem:
return oldsem[0]
db = SIMSConn()
db.execute("SELECT strm, term_begin_dt, term_end_dt FROM ps_term_tbl WHERE strm=%s", (strm,))
row = db.fetchone()
if row is None:
raise ValueError, "Not Found: %r" % (strm)
strm, st, en = row
# create Semester object
st = datetime.datetime.strptime(st, "%Y-%m-%d").date()
en = datetime.datetime.strptime(en, "%Y-%m-%d").date()
sem = Semester(name=strm, start=st, end=en)
sem.save()
# also create SemesterWeek object for the first week
first_monday = st
while first_monday.weekday() != 0:
first_monday += datetime.timedelta(days=1)
wk = SemesterWeek(semester=sem, week=1, monday=first_monday)
wk.save()
return sem
def old_semester_test_data( ):
sems = [{'start': datetime.date(1990, 1, 1), 'end': datetime.date(1990, 4, 30), 'name': '0901'}, {'start': datetime.date(1991, 1, 1), 'end': datetime.date(1991, 4, 30), 'name': '0911'}, {'start': datetime.date(1991, 9, 1), 'end': datetime.date(1991, 12, 31), 'name': '0917'}, {'start': datetime.date(1992, 1, 1), 'end': datetime.date(1992, 4, 30), 'name': '0921'}, {'start': datetime.date(1992, 9, 1), 'end': datetime.date(1992, 12, 31), 'name': '0927'}, {'start': datetime.date(1993, 1, 1), 'end': datetime.date(1993, 4, 30), 'name': '0931'}, {'start': datetime.date(1993, 9, 1), 'end': datetime.date(1993, 12, 31), 'name': '0937'}, {'start': datetime.date(1994, 1, 1), 'end': datetime.date(1994, 4, 30), 'name': '0941'}, {'start': datetime.date(1994, 5, 1), 'end': datetime.date(1994, 8, 31), 'name': '0944'}, {'start': datetime.date(1994, 9, 1), 'end': datetime.date(1994, 12, 31), 'name': '0947'}, {'start': datetime.date(1995, 1, 1), 'end': datetime.date(1995, 4, 30), 'name': '0951'}, {'start': datetime.date(1995, 5, 1), 'end': datetime.date(1995, 8, 31), 'name': '0954'}, {'start': datetime.date(1995, 9, 1), 'end': datetime.date(1995, 12, 31), 'name': '0957'}, {'start': datetime.date(1996, 1, 1), 'end': datetime.date(1996, 4, 30), 'name': '0961'}, {'start': datetime.date(1996, 5, 1), 'end': datetime.date(1996, 8, 31), 'name': '0964'}, {'start': datetime.date(1996, 9, 1), 'end': datetime.date(1996, 12, 31), 'name': '0967'}, {'start': datetime.date(1997, 1, 1), 'end': datetime.date(1997, 4, 30), 'name': '0971'}, {'start': datetime.date(1997, 5, 1), 'end': datetime.date(1997, 8, 31), 'name': '0974'}, {'start': datetime.date(1997, 9, 1), 'end': datetime.date(1997, 12, 31), 'name': '0977'}, {'start': datetime.date(1998, 1, 1), 'end': datetime.date(1998, 4, 30), 'name': '0981'}, {'start': datetime.date(1998, 5, 1), 'end': datetime.date(1998, 8, 31), 'name': '0984'}, {'start': datetime.date(1998, 9, 1), 'end': datetime.date(1998, 12, 31), 'name': '0987'}, {'start': datetime.date(1999, 1, 1), 'end': datetime.date(1999, 4, 30), 'name': '0991'}, {'start': datetime.date(1999, 5, 1), 'end': datetime.date(1999, 8, 31), 'name': '0994'}, {'start': datetime.date(1999, 9, 1), 'end': datetime.date(1999, 12, 31), 'name': '0997'}, {'start': datetime.date(2000, 1, 1), 'end': datetime.date(2000, 4, 30), 'name': '1001'}, {'start': datetime.date(2000, 5, 1), 'end': datetime.date(2000, 8, 31), 'name': '1004'}, {'start': datetime.date(2000, 9, 1), 'end': datetime.date(2000, 12, 31), 'name': '1007'}, {'start': datetime.date(2001, 1, 1), 'end': datetime.date(2001, 4, 30), 'name': '1011'}, {'start': datetime.date(2001, 5, 1), 'end': datetime.date(2001, 8, 31), 'name': '1014'}, {'start': datetime.date(2001, 9, 1), 'end': datetime.date(2001, 12, 31), 'name': '1017'}, {'start': datetime.date(2002, 1, 3), 'end': datetime.date(2002, 4, 30), 'name': '1021'}, {'start': datetime.date(2002, 5, 6), 'end': datetime.date(2002, 8, 31), 'name': '1024'}, {'start': datetime.date(2002, 9, 1), 'end': datetime.date(2002, 12, 31), 'name': '1027'}, {'start': datetime.date(2003, 1, 1), 'end': datetime.date(2003, 4, 30), 'name': '1031'}, {'start': datetime.date(2003, 5, 1), 'end': datetime.date(2003, 8, 31), 'name': '1034'}, {'start': datetime.date(2003, 9, 1), 'end': datetime.date(2003, 12, 31), 'name': '1037'}, {'start': datetime.date(2004, 1, 1), 'end': datetime.date(2004, 4, 30), 'name': '1041'}, {'start': datetime.date(2004, 5, 1), 'end': datetime.date(2004, 8, 31), 'name': '1044'}, {'start': datetime.date(2004, 9, 1), 'end': datetime.date(2004, 12, 31), 'name': '1047'}, {'start': datetime.date(2005, 1, 10), 'end': datetime.date(2005, 4, 30), 'name': '1051'}, {'start': datetime.date(2005, 5, 2), 'end': datetime.date(2005, 8, 31), 'name': '1054'}, {'start': datetime.date(2005, 9, 6), 'end': datetime.date(2005, 12, 31), 'name': '1057'}, {'start': datetime.date(2006, 1, 9), 'end': datetime.date(2006, 4, 30), 'name': '1061'}, {'start': datetime.date(2006, 5, 8), 'end': datetime.date(2006, 8, 31), 'name': '1064'}, {'start': datetime.date(2006, 9, 5), 'end': datetime.date(2006, 12, 31), 'name': '1067'}, {'start': datetime.date(2007, 1, 8), 'end': datetime.date(2007, 4, 30), 'name': '1071'}, {'start': datetime.date(2007, 5, 7), 'end': datetime.date(2007, 8, 31), 'name': '1074'}, {'start': datetime.date(2007, 9, 4), 'end': datetime.date(2007, 12, 31), 'name': '1077'}, {'start': datetime.date(2008, 1, 7), 'end': datetime.date(2008, 4, 30), 'name': '1081'}, {'start': datetime.date(2008, 5, 5), 'end': datetime.date(2008, 8, 31), 'name': '1084'}, {'start': datetime.date(2008, 9, 2), 'end': datetime.date(2008, 12, 31), 'name': '1087'}, {'start': datetime.date(2009, 1, 5), 'end': datetime.date(2009, 4, 30), 'name': '1091'}, {'start': datetime.date(2009, 5, 4), 'end': datetime.date(2009, 8, 4), 'name': '1094'}, {'start': datetime.date(2009, 9, 8), 'end': datetime.date(2009, 12, 7), 'name': '1097'}, {'start': datetime.date(2010, 1, 4), 'end': datetime.date(2010, 4, 16), 'name': '1101'}, {'start': datetime.date(2010, 5, 12), 'end': datetime.date(2010, 8, 11), 'name': '1104'}, {'start': datetime.date(2010, 9, 7), 'end': datetime.date(2010, 12, 6), 'name': '1107'}, {'start': datetime.date(2011, 1, 4), 'end': datetime.date(2011, 4, 7), 'name': '1111'}, {'start': datetime.date(2011, 5, 9), 'end': datetime.date(2011, 8, 8), 'name': '1114'}, {'start': datetime.date(2011, 9, 6), 'end': datetime.date(2011, 12, 5), 'name': '1117'}, {'start': datetime.date(2012, 1, 5), 'end': datetime.date(2012, 4, 11), 'name': '1121'}, {'start': datetime.date(2012, 5, 7), 'end': datetime.date(2012, 8, 3), 'name': '1124'}, {'start': datetime.date(2012, 9, 4), 'end': datetime.date(2012, 12, 3), 'name': '1127'}, {'start': datetime.date(2013, 1, 7), 'end': datetime.date(2013, 4, 12), 'name': '1131'}, {'start': datetime.date(2013, 5, 6), 'end': datetime.date(2013, 8, 2), 'name': '1134'}, {'start': datetime.date(2013, 9, 1), 'end': datetime.date(2013, 12, 31), 'name': '1137'}, {'start': datetime.date(2014, 1, 1), 'end': datetime.date(2014, 4, 30), 'name': '1141'}, {'start': datetime.date(2014, 5, 1), 'end': datetime.date(2014, 8, 30), 'name': '1144'}, {'start': datetime.date(2014, 9, 1), 'end': datetime.date(2014, 12, 30), 'name': '1147'}, {'start': datetime.date(2015, 1, 1), 'end': datetime.date(2015, 4, 30), 'name': '1151'}, {'start': datetime.date(2015, 5, 1), 'end': datetime.date(2015, 8, 30), 'name': '1154'}, {'start': datetime.date(2015, 9, 1), 'end': datetime.date(2015, 12, 30), 'name': '1157'}, {'start': datetime.date(2016, 1, 1), 'end': datetime.date(2016, 4, 30), 'name': '1161'}, {'start': datetime.date(2016, 5, 1), 'end': datetime.date(2016, 8, 30), 'name': '1164'}, {'start': datetime.date(2016, 9, 1), 'end': datetime.date(2016, 12, 30), 'name': '1167'}, {'start': datetime.date(2017, 1, 1), 'end': datetime.date(2017, 4, 30), 'name': '1171'}, {'start': datetime.date(2017, 5, 1), 'end': datetime.date(2017, 8, 30), 'name': '1174'}, {'start': datetime.date(2017, 9, 1), 'end': datetime.date(2017, 12, 30), 'name': '1177'}]
for sem in sems:
try:
s = Semester.objects.get(name=sem['name'])
except Semester.DoesNotExist:
s = Semester(name=sem['name'], start=sem['start'], end=sem['end'])
print('Creating ', s)
s.save()
def __init__(self, *args, **kwargs):
flags = kwargs.pop('flags', [])
super(CourseAccreditationForm, self).__init__(*args, **kwargs)
if 'start_semester' not in self.data:
self.data['start_semester'] = Semester.current().name
if 'end_semester' not in self.data:
self.data['end_semester'] = Semester.current().name
self.fields['flag'].choices = flags
def __init__(self, *args, **kwargs):
flags = kwargs.pop('flags', [])
super(CourseAccreditationForm, self).__init__(*args, **kwargs)
if 'start_semester' not in self.data:
self.data['start_semester'] = Semester.current().name
if 'end_semester' not in self.data:
self.data['end_semester'] = Semester.current().name
self.fields['flag'].choices = flags
def run(self):
AcceptedStudentsQuery = AcceptedQuery({'strm': Semester.current().offset_name(1), 'acad_plans':
['CMPTMAJ', 'DCMPT', 'CMPTMIN', 'CMPTHON', 'CMPTJMA', 'CMPTJHO',
'SOSYMAJ', 'ZUSFU']})
AcceptedStudents = AcceptedStudentsQuery.result()
EnrolledStudentsQuery = EnrolledQuery({'strm': Semester.current().offset_name(1), 'acad_progs':
['CMPT', 'CMPT2']})
EnrolledStudents = EnrolledStudentsQuery.result()
# Let's calculate our totals so we can display those numbers as well.
accepted_list = AcceptedStudents.column_as_list("SEX")
accepted_total = len(accepted_list)
accepted_m_count = len([i for i in accepted_list if i=='M'])
accepted_f_count = len([i for i in accepted_list if i=='F'])
accepted_u_count = len([i for i in accepted_list if i=='U'])
enrolled_list = EnrolledStudents.column_as_list("SEX")
enrolled_total = len(enrolled_list)
enrolled_m_count = len([i for i in enrolled_list if i == 'M'])
enrolled_f_count = len([i for i in enrolled_list if i == 'F'])
enrolled_u_count = len([i for i in enrolled_list if i == 'U'])
# Let's create two new tables to display these results.
accepted_totals = Table()
accepted_totals.append_column('TOTAL_COUNT')
accepted_totals.append_column('M_COUNT')
accepted_totals.append_column('M_PERCENT')
accepted_totals.append_column('F_TOTAL')
accepted_totals.append_column('F_PERCENT')
accepted_totals.append_column('U_COUNT')
accepted_totals.append_column('U_PERCENT')
accepted_totals.append_row([accepted_total, accepted_m_count, 100.0 * accepted_m_count/accepted_total,
accepted_f_count, 100.0 * accepted_f_count/accepted_total, accepted_u_count,
100.0 * accepted_u_count/accepted_total])
enrolled_totals = Table()
enrolled_totals.append_column('TOTAL_COUNT')
enrolled_totals.append_column('M_COUNT')
enrolled_totals.append_column('M_PERCENT')
enrolled_totals.append_column('F_TOTAL')
enrolled_totals.append_column('F_PERCENT')
enrolled_totals.append_column('U_COUNT')
enrolled_totals.append_column('U_PERCENT')
enrolled_totals.append_row([enrolled_total, enrolled_m_count, 100.0 * enrolled_m_count / enrolled_total,
enrolled_f_count, 100.0 * enrolled_f_count / enrolled_total, enrolled_u_count,
100.0 * enrolled_u_count / enrolled_total])
self.artifacts.append(AcceptedStudents)
self.artifacts.append(accepted_totals)
self.artifacts.append(EnrolledStudents)
self.artifacts.append(enrolled_totals)
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(
["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: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,
'can_edit': True,
}
return render(request, 'grad/manage_promises.html', context)
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 make_entry_field(self, fieldsubmission=None):
queryset = Semester.objects.all().order_by('name')
allowed = self.config.get('allowed_semesters', 'AL')
current = Semester.current().name
if allowed == 'AL':
pass
elif allowed == 'LT':
queryset = queryset.filter(name__lt=current).order_by('-name')
elif allowed == 'LE':
queryset = queryset.filter(name__lte=current).order_by('-name')
elif allowed == 'GT':
queryset = queryset.filter(name__gt=current)
elif allowed == 'GE':
queryset = queryset.filter(name__gte=current)
the_choices = [(s.name, s.label()) for s in queryset]
widget = forms.Select
if self.config.get('format', 'D') == 'R':
widget = forms.RadioSelect
c = forms.ChoiceField(required=self.config['required'],
label=self.config['label'],
help_text=self.config['help_text'],
choices=the_choices,
widget=widget,)
if fieldsubmission:
c.initial = fieldsubmission.data['info']
if not self.config['required']:
c.choices.insert(0, ('', u'\u2014'))
return c
def create_reminder_messages(self, start_date=None, end_date=None, allow_stale=True):
"""
Create any ReminderMessages that don't already exist, between startdate and enddate.
Idempotent.
"""
if self.status == 'D':
return
if not start_date or not end_date:
start_date, end_date = self.reminder_message_range(allow_stale=allow_stale)
if self.date_type == 'YEAR':
next1 = datetime.date(year=start_date.year, month=int(self.month), day=self.day)
next2 = datetime.date(year=start_date.year+1, month=int(self.month), day=self.day)
self.create_reminder_on(next1, start_date, end_date)
self.create_reminder_on(next2, start_date, end_date)
elif self.date_type == 'SEM':
if self.reminder_type == 'INST':
# limit to semesters actually teaching
instructors = Member.objects.filter(role='INST', person=self.person, offering__course=self.course) \
.exclude(offering__component='CAN').select_related('offering__course')
semesters = {m.offering.semester for m in instructors}
else:
semesters = None
this_sem = Semester.current()
for sem in [this_sem.previous_semester(), this_sem, this_sem.next_semester()]:
if semesters is None or sem in semesters:
next = sem.duedate(self.week, int(self.weekday), time=None)
self.create_reminder_on(next, start_date, end_date)
else:
raise ValueError()
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 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 test_advanced_search_3(self):
client = Client()
client.login_user('dzhao')
this_sem = Semester.current()
units = [
r.unit for r in Role.objects_fresh.filter(person__userid='dzhao',
role='GRAD')
]
gs = self.__make_test_grad()
gs.gradstatus_set.all().delete()
s1 = GradStatus(student=gs, status='COMP', start=this_sem.offset(-4))
s1.save()
s2 = GradStatus(student=gs, status='ACTI', start=this_sem.offset(-3))
s2.save()
s3 = GradStatus(student=gs, status='LEAV', start=this_sem.offset(2))
s3.save()
gs.update_status_fields()
# test current-status searching
form = SearchForm(
QueryDict('student_status=ACTI&columns=person.emplid'))
active_now = form.search_results(units)
self.assertIn(gs, active_now)
form = SearchForm(
QueryDict('student_status=LEAV&columns=person.emplid'))
leave_now = form.search_results(units)
self.assertNotIn(gs, leave_now)
def __init__(self, query_args):
for arg in list(EnrolledQuery.default_arguments.keys()):
if arg not in query_args:
query_args[arg] = EnrolledQuery.default_arguments[arg]
self.title = "Enrolled Students and Genders - " + Semester(
query_args["strm"]).label()
super(EnrolledQuery, self).__init__(query_args)
def XXX_import_applic(request):
unit_choices = [(u.id, u.name) for u in request.units]
semester_choices = [(s.id, s.label()) for s in Semester.objects.filter()]
if request.method == 'POST':
form = UploadApplicantsForm(data=request.POST, files=request.FILES)
form.fields['unit'].choices = unit_choices
form.fields['semester'].choices = semester_choices
if form.is_valid():
data = form.cleaned_data['csvfile'].read()
unit_id = form.cleaned_data['unit']
semester_id = form.cleaned_data['semester']
user = Person.objects.get(userid=request.user.username)
if settings.USE_CELERY:
from grad.tasks import process_pcs_task
process_pcs_task.delay(data, unit_id, semester_id, user)
messages.success(request, "Importing applicant data. You will receive an email with the results in a few minutes.")
else:
from grad.forms import process_pcs_export
res = process_pcs_export(data, unit_id, semester_id, user)
messages.success(request, "Imported applicant data.")
return HttpResponse('<pre>'+res+'</pre>')
return HttpResponseRedirect(reverse(index))
else:
next_sem = Semester.next_starting()
form = UploadApplicantsForm(initial={'semester': next_sem.id})
form.fields['unit'].choices = unit_choices
form.fields['semester'].choices = semester_choices
context = {
'form': form,
}
return render(request, 'grad/import_applic.html', context)
def reappoint(request, ra_slug):
appointment = get_object_or_404(RAAppointment,
slug=ra_slug,
deleted=False,
unit__in=request.units)
semester = Semester.next_starting()
semesterconfig = SemesterConfig.get_config(request.units, semester)
raform = RAForm(instance=appointment,
initial={
'person': appointment.person.emplid,
'reappointment': True,
'start_date': semesterconfig.start_date(),
'end_date': semesterconfig.end_date(),
'hours': 80,
'use_hourly': appointment.use_hourly()
})
scholarship_choices, hiring_faculty_choices, unit_choices, project_choices, account_choices, program_choices = \
_appointment_defaults(request.units, emplid=appointment.person.emplid)
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/new.html', {
'raform': raform,
'appointment': appointment
})
def run(self):
sems = Semester.objects.filter(name__gte='1001', name__lte=Semester.next_starting().name)
u = Unit.objects.get(label='ENSC')
courses = CourseOffering.objects.prefetch_related('meeting_time').filter(semester__in=sems, owner=u,
graded=True).exclude(
flags=CourseOffering.flags.combined).exclude(subject='DDP').order_by('semester', 'subject', 'number')
course_history = Table()
course_history.append_column('Semester')
course_history.append_column('Course')
course_history.append_column('Instructor')
course_history.append_column('Enrolment')
course_history.append_column('Campus')
course_history.append_column('Joint With')
course_history.append_column('Lecture Times')
course_history.append_column('Instructor(s) Rank(s)')
for course in courses:
semester = course.semester.label()
label = course.name()
instr = course.instructors_printing_str()
enrl = '%i/%i' % (course.enrl_tot, course.enrl_cap)
if course.campus in CAMPUSES_SHORT:
campus = CAMPUSES_SHORT[course.campus]
else:
campus = 'Unknown'
if course.config.get('joint_with'):
joint = str(', '.join(course.config.get('joint_with')))
else:
joint = ''
meeting_times = ''
mt = [t for t in course.meeting_time.all() if t.meeting_type == 'LEC']
if mt:
meeting_times = ', '.join(str("%s %s-%s" % (WEEKDAYS[t.weekday], t.start_time, t.end_time)) for t in mt)
ranks = "; ".join(CareerEvent.ranks_as_of_semester(p.id, course.semester) for p in course.instructors())
course_history.append_row([semester, label, instr, enrl, campus, joint, meeting_times, ranks])
self.artifacts.append(course_history)
def run(self):
cmpt_progs, eng_progs = get_fas_programs()
fas_progs = cmpt_progs + eng_progs
# collect student data for every semester in the last year.
# Do it here because I'm not smart enough to do it in SQL.
semester = Semester.current()
last_yr = [semester.offset_name(-2), semester.offset_name(-1), semester.name]
student_data = {}
for strm in last_yr:
students = InternationalGPAQuery({
'acad_progs': fas_progs,
'strm': strm,
}).result()
for r in students.rows:
emplid = r[0]
student_data[emplid] = r
students.rows = student_data.values()
visits = AdvisorVisits(unit_slugs=['apsc']).result()
notes = AdvisorNotes(unit_slugs=['apsc']).result()
students.left_join(visits, 'EMPLID')
students.left_join(notes, 'EMPLID')
self.artifacts.append(students)
def run(self):
current_semester = Semester.current()
semesters = [current_semester.name, current_semester.offset_name(-1), current_semester.offset_name(-2)]
cmpt_acad_progs = AcadProgsOwnedByUnit({'acad_org': 'COMP SCI'}) \
.result() \
.column_as_list('ACAD_PROG')
eng_acad_progs = DegreeAcadProgs() \
.result() \
.column_as_list('ACAD_PROG')
cmpt_gpas = self.bad_gpa_for(cmpt_acad_progs, semesters, '2.4')
eng_gpas = self.bad_gpa_for(eng_acad_progs, semesters, '2.5')
bad_gpas = cmpt_gpas
for r in (eng_gpas.rows):
bad_gpas.append_row(r)
name_query = NameQuery()
names = name_query.result()
email_query = EmailQuery()
email = email_query.result()
email.filter( EmailQuery.preferred_email )
bad_gpas.left_join( names, "EMPLID" )
bad_gpas.left_join( email, "EMPLID" )
bad_gpas.remove_column('E_ADDR_TYPE')
bad_gpas.remove_column('PREF_EMAIL_FLAG')
self.artifacts.append(bad_gpas)
class AcceptedQuery(DB2_Query):
title = "Accepted Students and Genders"
description = "The list of students we accepted in specific plans who start next semester, and their gender."
query = string.Template("""
SELECT pers.emplid, pers.sex, c.descrshort AS citizen
FROM PS_PERSONAL_DATA pers
JOIN ps_citizenship cit ON cit.emplid=pers.emplid
JOIN ps_country_tbl c ON cit.country=c.country
WHERE
pers.emplid IN
(SELECT DISTINCT (plan.EMPLID) from PS_ACAD_PLAN plan where REQ_TERM=$strm AND ACAD_PLAN IN $acad_plans);
""")
plans_list = [
'CMPTMAJ', 'DCMPT', 'CMPTMIN', 'CMPTHON', 'CMPTJMA', 'CMPTJHO',
'SOSYMAJ', 'ZUSFU'
]
default_arguments = {
'strm': Semester.current().offset_name(1),
'acad_plans': plans_list
}
def __init__(self, query_args):
for arg in list(AcceptedQuery.default_arguments.keys()):
if arg not in query_args:
query_args[arg] = AcceptedQuery.default_arguments[arg]
self.title = "Accepted Students and Genders - " + Semester(
query_args["strm"]).label()
super(AcceptedQuery, self).__init__(query_args)
def get_bad_gpa(self):
current_semester = Semester.current()
semesters = [
current_semester.name,
current_semester.offset_name(-1),
current_semester.offset_name(-2)
]
cmpt_acad_progs, eng_acad_progs = get_fas_programs()
cmpt_gpas = BadGPAsQuery(query_args={
'acad_progs': cmpt_acad_progs,
'strms': semesters,
'gpa': '2.4',
})
low_gpas = cmpt_gpas.result()
self.artifacts.append(low_gpas)
rows = low_gpas.rows
rows.sort()
groups = itertools.groupby(rows, CSGenderExplorationReport.group_bin)
out_rows = [[
prog_gpa[0], prog_gpa[1], prog_gpa[2],
len(list(students))
] for prog_gpa, students in groups]
bins = Table()
bins.append_column('ACAD_PROG_PRIMARY')
bins.append_column('GENDER')
bins.append_column('GPA')
bins.append_column('COUNT')
bins.rows = out_rows
self.artifacts.append(bins)
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.views.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 new_teaching_equivalent_inst(request):
"""
Instructors form to create a new teaching equivalent
"""
instructor = get_object_or_404(Person, userid=request.user.username)
if request.method == 'POST':
form = TeachingEquivForm(request.POST)
if form.is_valid():
equivalent = form.save(commit=False)
equivalent.credits_numerator = form.cleaned_data[
'credits_numerator']
equivalent.credits_denominator = form.cleaned_data[
'credits_denominator']
equivalent.instructor = instructor
equivalent.status = 'UNCO'
equivalent.save()
messages.add_message(request, messages.SUCCESS,
"Teaching Equivalent successfully created")
return HttpResponseRedirect(
reverse('planning.views.view_teaching_credits_inst'))
else:
form = TeachingEquivForm(
initial={'semester': Semester.current().next_semester()})
return render(request, 'planning/new_teaching_equiv_inst.html',
{'form': form})
class EnrolledQuery(DB2_Query):
title = "Enrolled Students and Genders"
description = "The list of students enrolled in specific programs who start next semester, and their gender."
query = string.Template("""
SELECT pers.emplid, pers.sex, c.descrshort AS citizentest
FROM PS_PERSONAL_DATA pers
JOIN ps_citizenship cit ON cit.emplid=pers.emplid
JOIN ps_country_tbl c ON cit.country=c.country
WHERE pers.EMPLID IN (SELECT
DISTINCT (EMPLID) from PS_ACAD_PROG
WHERE REQ_TERM=$strm AND PROG_STATUS='AC' AND PROG_ACTION='MATR' AND ACAD_PROG in $acad_progs );
""")
progs_list = ['CMPT', 'CMPT2']
default_arguments = {
'strm': Semester.current().offset_name(1),
'acad_progrs': progs_list
}
def __init__(self, query_args):
for arg in list(EnrolledQuery.default_arguments.keys()):
if arg not in query_args:
query_args[arg] = EnrolledQuery.default_arguments[arg]
self.title = "Enrolled Students and Genders - " + Semester(
query_args["strm"]).label()
super(EnrolledQuery, self).__init__(query_args)
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 run(self):
cmpt_progs, eng_progs = get_fas_programs()
fas_progs = cmpt_progs + eng_progs
# collect student data for every semester in the last year.
# Do it here because I'm not smart enough to do it in SQL.
semester = Semester.current()
last_yr = [
semester.offset_name(-2),
semester.offset_name(-1), semester.name
]
student_data = {}
for strm in last_yr:
students = InternationalGPAQuery({
'acad_progs': fas_progs,
'strm': strm,
}).result()
for r in students.rows:
emplid = r[0]
student_data[emplid] = r
students.rows = list(student_data.values())
visits = AdvisorVisits(unit_slugs=['apsc']).result()
notes = AdvisorNotes(unit_slugs=['apsc']).result()
students.left_join(visits, 'EMPLID')
students.left_join(notes, 'EMPLID')
self.artifacts.append(students)
def course_home_pages_unit(request, unit_slug, semester=None):
if semester:
semester = get_object_or_404(Semester, name=semester)
else:
semester = Semester.current()
unit = get_object_or_404(Unit, slug=unit_slug)
offerings = CourseOffering.objects.filter(semester=semester, owner=unit, graded=True) \
.exclude(component='CAN') \
.exclude(instr_mode__in=['CO', 'GI'])
if request.user.is_authenticated():
is_admin = Role.objects.filter(unit=unit,
person__userid=request.user.username,
role='ADMN').exists()
else:
is_admin = False
context = {
'semester': semester,
'unit': unit,
'offerings': offerings,
'is_admin': is_admin,
}
return render(request, "coredata/course_home_pages_unit.html", context)
def new_student(request, userid):
person = get_object_or_404(Person, find_userid_or_emplid(userid))
semester = Semester.next_starting()
semesterconfig = SemesterConfig.get_config(request.units, semester)
student = get_object_or_404(Person, find_userid_or_emplid(userid))
initial = {
'person': student.emplid,
'start_date': semesterconfig.start_date(),
'end_date': semesterconfig.end_date(),
'hours': 80
}
scholarship_choices, hiring_faculty_choices, unit_choices, project_choices, account_choices = _appointment_defaults(
request.units, emplid=student.emplid)
gss = GradStudent.objects.filter(person=student)
if gss:
gradstudent = gss[0]
initial['sin'] = gradstudent.person.sin()
raform = RAForm(initial=initial)
raform.fields['person'] = forms.CharField(widget=forms.HiddenInput())
raform.fields['scholarship'].choices = scholarship_choices
raform.fields['hiring_faculty'].choices = hiring_faculty_choices
raform.fields['unit'].choices = unit_choices
raform.fields['project'].choices = project_choices
raform.fields['account'].choices = account_choices
return render(request, 'ra/new.html', {'raform': raform, 'person': person})
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 testApplication(self):
p = Person.objects.get(emplid=210012345)
# Create three visas, one that should be expired, one that will soon, and one that is valid.
v1 = Visa(person=p,
status=VISA_STATUSES[0][0],
start_date=date(2000, 01, 01),
end_date=date(2000, 01, 01))
v2 = Visa(person=p,
status=VISA_STATUSES[0][0],
start_date=date(2000, 01, 01),
end_date=date(2099, 01, 01))
next_semester = Semester.next_starting()
almost_expired_date = next_semester.end - timedelta(days=5)
v3 = Visa(person=p,
status=VISA_STATUSES[0][0],
start_date=date(2000, 01, 01),
end_date=almost_expired_date)
self.assertEqual(v1.is_valid(), False)
self.assertEqual(v1.is_expired(), True)
self.assertEqual(v1.is_almost_expired(), False)
self.assertEqual(v2.is_valid(), True)
self.assertEqual(v2.is_expired(), False)
self.assertEqual(v2.is_almost_expired(), False)
self.assertEqual(v3.is_valid(), True)
self.assertEqual(v3.is_expired(), False)
self.assertEqual(v3.is_almost_expired(), True)
def new(request):
scholarship_choices, hiring_faculty_choices, unit_choices, project_choices, account_choices =_appointment_defaults(request.units)
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)
raform.fields['hiring_faculty'].choices = hiring_faculty_choices
raform.fields['unit'].choices = unit_choices
raform.fields['project'].choices = project_choices
raform.fields['account'].choices = account_choices
if raform.is_valid():
userid = raform.cleaned_data['person'].userid_or_emplid()
appointment = raform.save(commit=False)
appointment.set_use_hourly(raform.cleaned_data['use_hourly'])
appointment.save()
messages.success(request, 'Created RA Appointment for ' + appointment.person.name())
return HttpResponseRedirect(reverse(student_appointments, kwargs=({'userid': userid})))
else:
semester = Semester.next_starting()
semesterconfig = SemesterConfig.get_config(request.units, semester)
raform = RAForm(initial={'start_date': semesterconfig.start_date(), 'end_date': semesterconfig.end_date(), 'hours': 80 })
raform.fields['scholarship'].choices = scholarship_choices
raform.fields['hiring_faculty'].choices = hiring_faculty_choices
raform.fields['unit'].choices = unit_choices
raform.fields['project'].choices = project_choices
raform.fields['account'].choices = account_choices
return render(request, 'ra/new.html', { 'raform': raform })
def test_semester(self):
"""
Create and test a semester object
"""
s = create_semester()
wk = SemesterWeek(semester=s, week=1, monday=date(2007,9,3))
wk.save()
wk = SemesterWeek(semester=s, week=5, monday=date(2007,10,8)) # pretend there is a Oct 1-5 break
wk.save()
self.assertEquals(s.label(), "Fall 2007")
self.assertEquals(str(wk), "1077 week 5")
# test semester arithmetic
s = Semester.objects.get(name='1131')
self.assertEqual(s.previous_semester().name, '1127')
self.assertEqual(s.offset(1).name, '1134')
self.assertEqual(s.offset(-1).name, '1127')
self.assertEqual(s.offset(2).name, '1137')
self.assertEqual(s.offset(-2).name, '1124')
self.assertEqual(s - s.offset(-2), 2)
self.assertEqual(s.offset(-2) - s, -2)
self.assertEqual(s.offset_name(1), '1134')
self.assertEqual(s.offset_name(-1), '1127')
self.assertEqual(s.offset_name(2), '1137')
self.assertEqual(s.offset_name(-2), '1124')
self.assertEqual(s.offset_name(3), '1141')
self.assertEqual(s.offset_name(-3), '1121')
self.assertEqual(s.offset_name(4), '1144')
self.assertEqual(s.offset_name(-4), '1117')
s2 = Semester(name="1077", start=date(2007,9,4), end=date(2007,12,3))
self.assertRaises(IntegrityError, s2.save)
def XXX_import_applic(request):
unit_choices = [(u.id, u.name) for u in request.units]
semester_choices = [(s.id, s.label()) for s in Semester.objects.filter()]
if request.method == 'POST':
form = UploadApplicantsForm(data=request.POST, files=request.FILES)
form.fields['unit'].choices = unit_choices
form.fields['semester'].choices = semester_choices
if form.is_valid():
data = form.cleaned_data['csvfile'].read()
unit_id = form.cleaned_data['unit']
semester_id = form.cleaned_data['semester']
user = Person.objects.get(userid=request.user.username)
if settings.USE_CELERY:
from grad.tasks import process_pcs_task
process_pcs_task.delay(data, unit_id, semester_id, user)
messages.success(request, "Importing applicant data. You will receive an email with the results in a few minutes.")
else:
from grad.forms import process_pcs_export
res = process_pcs_export(data, unit_id, semester_id, user)
messages.success(request, "Imported applicant data.")
return HttpResponse('<pre>'+res+'</pre>')
return HttpResponseRedirect(reverse('grad:index'))
else:
next_sem = Semester.next_starting()
form = UploadApplicantsForm(initial={'semester': next_sem.id})
form.fields['unit'].choices = unit_choices
form.fields['semester'].choices = semester_choices
context = {
'form': form,
}
return render(request, 'grad/import_applic.html', context)
def semester_config(request, semester_name=None):
if semester_name:
semester = get_object_or_404(Semester, name=semester_name)
else:
semester = Semester.next_starting()
unit_choices = [(u.id, u.name) for u in request.units]
if request.method == 'POST':
form = SemesterConfigForm(request.POST)
form.fields['unit'].choices = unit_choices
if form.is_valid():
config = SemesterConfig.get_config(
units=[form.cleaned_data['unit']], semester=semester)
config.set_start_date(form.cleaned_data['start_date'])
config.set_end_date(form.cleaned_data['end_date'])
config.save()
messages.success(
request,
'Updated semester configuration for %s.' % (semester.name))
return HttpResponseRedirect(reverse('ra.views.search'))
else:
config = SemesterConfig.get_config(units=request.units,
semester=semester)
form = SemesterConfigForm(initial={
'start_date': config.start_date(),
'end_date': config.end_date()
})
form.fields['unit'].choices = unit_choices
return render(request, 'ra/semester_config.html', {
'semester': semester,
'form': form
})
def manage_otherfunding(request, grad_slug):
grad = get_object_or_404(GradStudent, slug=grad_slug)
otherfunding = OtherFunding.objects.filter(
student=grad).order_by('semester__name')
if request.method == 'POST':
form = OtherFundingForm(request.POST)
if form.is_valid():
fund = form.save(commit=False)
fund.student = grad
fund.save()
messages.success(
request, "Other funding for %s sucessfully saved." % (grad))
l = LogEntry(userid=request.user.username,
description="added other funding \"%s\" for %s" %
(fund.description, grad.slug),
related_object=fund)
l.save()
return HttpResponseRedirect(
reverse('grad: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 run(self):
current_semester = Semester.current()
semesters = [current_semester.name, current_semester.offset_name(-1), current_semester.offset_name(-2)]
cmpt_acad_progs, eng_acad_progs = get_fas_programs()
cmpt_gpas = self.bad_gpa_for(cmpt_acad_progs, semesters, '2.4')
eng_gpas = self.bad_gpa_for(eng_acad_progs, semesters, '2.5')
bad_gpas = cmpt_gpas
for r in (eng_gpas.rows):
bad_gpas.append_row(r)
name_query = NameQuery()
names = name_query.result()
email_query = EmailQuery()
email = email_query.result()
email.filter( EmailQuery.preferred_email )
bad_gpas.left_join( names, "EMPLID" )
bad_gpas.left_join( email, "EMPLID" )
bad_gpas.remove_column('E_ADDR_TYPE')
bad_gpas.remove_column('PREF_EMAIL_FLAG')
self.artifacts.append(bad_gpas)
def new(request):
scholarship_choices, hiring_faculty_choices, unit_choices, project_choices, account_choices = _appointment_defaults(request.units)
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)
raform.fields['hiring_faculty'].choices = hiring_faculty_choices
raform.fields['unit'].choices = unit_choices
raform.fields['project'].choices = project_choices
raform.fields['account'].choices = account_choices
if raform.is_valid():
userid = raform.cleaned_data['person'].userid_or_emplid()
appointment = raform.save(commit=False)
appointment.set_use_hourly(raform.cleaned_data['use_hourly'])
appointment.save()
messages.success(request, 'Created RA Appointment for ' + appointment.person.name())
return HttpResponseRedirect(reverse(student_appointments, kwargs=({'userid': userid})))
else:
semester = Semester.next_starting()
semesterconfig = SemesterConfig.get_config(request.units, semester)
raform = RAForm(initial={'start_date': semesterconfig.start_date(), 'end_date': semesterconfig.end_date(), 'hours': 80 })
raform.fields['scholarship'].choices = scholarship_choices
raform.fields['hiring_faculty'].choices = hiring_faculty_choices
raform.fields['unit'].choices = unit_choices
raform.fields['project'].choices = project_choices
raform.fields['account'].choices = account_choices
return render(request, 'ra/new.html', { 'raform': raform })
def manage_requirements(request, grad_slug):
grad = get_object_or_404(GradStudent, slug=grad_slug, program__unit__in=request.units)
# find completed/missing requirements
completed_req = CompletedRequirement.objects.filter(student=grad)
completed_gradreq_id = [cr.requirement_id for cr in completed_req if cr.removed==False]
req = GradRequirement.objects.filter(program=grad.program, hidden=False)
missing_req = req.exclude(id__in=completed_gradreq_id)
req_choices = [(u'', u'\u2014')] + [(r.id, r.description) for r in missing_req]
if request.method == 'POST':
form = CompletedRequirementForm(request.POST)
form.fields['requirement'].choices = req_choices
if form.is_valid():
req = form.save(commit=False)
req.student = grad
req.save()
messages.success(request, "Completed requirement for %s sucessfully saved." % (grad))
l = LogEntry(userid=request.user.username,
description="added completed requirement of %s for %s" % (req.requirement.description, grad.slug),
related_object=req )
l.save()
return HttpResponseRedirect(reverse('grad.views.manage_requirements', kwargs={'grad_slug':grad.slug}))
else:
form = CompletedRequirementForm(initial={'student':grad, 'semester':Semester.get_semester()})
form.fields['requirement'].choices = req_choices
context = {
'grad':grad,
'form': form,
'completed_req': completed_req,
'missing_req': missing_req,
}
return render(request, 'grad/manage_requirements.html', context)
def setUp(self):
p1 = Person(emplid=210012345,
userid="test1",
last_name="Lname",
first_name="Fname",
pref_first_name="Fn",
middle_name="M")
p1.save()
s = Semester(name="1077",
start=date(2007, 9, 4),
end=date(2007, 12, 3))
s.save()
unit = Unit.objects.get(label="CMPT")
self.co1 = CourseOffering(owner=unit,
subject="CMPT",
number="120",
section="D100",
semester=s,
component="LEC",
graded=True,
crse_id=11111,
class_nbr=22222,
campus='BRNBY',
title="Computer Stuff",
enrl_cap=100,
enrl_tot=99,
wait_tot=2)
self.co2 = CourseOffering(owner=unit,
subject="CMPT",
number="165",
section="D100",
semester=s,
component="LEC",
graded=True,
crse_id=22222,
class_nbr=11111,
campus='SURRY',
title="Web Stuff",
enrl_cap=85,
enrl_tot=80,
wait_tot=4)
self.co1.save()
self.co2.save()
def all_promises(request, semester_name=None):
if semester_name is None:
semester = Semester.next_starting()
else:
semester = get_object_or_404(Semester, name=semester_name)
promises = Promise.objects.filter(end_semester=semester,
student__program__unit__in=request.units)
context = {'promises': promises, 'semester': semester}
return render(request, 'grad/all_promises.html', context)
def _build_semester_lookup():
"""
Build data structure to let us easily look up date -> strm.
"""
all_semesters = Semester.objects.all()
intervals = ((s.name, Semester.start_end_dates(s)) for s in all_semesters)
intervals = (intervaltree.Interval(st, en + ONE_DAY, name)
for (name, (st, en)) in intervals)
return intervaltree.IntervalTree(intervals)
def course_home_pages(request):
semester = Semester.current()
units = Unit.objects.all().order_by('label')
units = [u for u in units if _has_homepages(u.id, semester.id)]
context = {
'semester': semester,
'units': units,
}
return render(request, "coredata/course_home_pages.html", context)
def course_home_pages(request):
semester = Semester.current()
units = Unit.objects.all().order_by('label')
units = [u for u in units if _has_homepages(u.id, semester.id)]
context = {
'semester': semester,
'units': units,
}
return render(request, "coredata/course_home_pages.html", context)
def all_promises(request, semester_name=None):
if semester_name is None:
semester = Semester.next_starting()
else:
semester = get_object_or_404(Semester, name=semester_name)
promises = Promise.objects.filter(end_semester=semester,
student__program__unit__in=request.units)
context = {'promises': promises, 'semester': semester}
return render(request, 'grad/all_promises.html', context)
def edit_semester(request, semester_name=None):
if semester_name:
semester = get_object_or_404(Semester, name=semester_name)
newsem = False
else:
semester = Semester()
newsem = True
if request.method == 'POST':
form = SemesterForm(instance=semester, prefix='sem', data=request.POST)
week_formset = SemesterWeekFormset(
queryset=SemesterWeek.objects.filter(semester=semester),
prefix='week',
data=request.POST)
holiday_formset = HolidayFormset(
queryset=Holiday.objects.filter(semester=semester),
prefix='holiday',
data=request.POST)
if form.is_valid() and week_formset.is_valid(
) and holiday_formset.is_valid():
sem = form.save()
weeks = week_formset.save(commit=False)
for week in weeks:
week.semester = sem
week.save()
holidays = holiday_formset.save(commit=False)
for holiday in holidays:
holiday.semester = sem
holiday.save()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=("edited semester %s") % (sem.name),
related_object=sem)
l.save()
messages.success(request, 'Edited semester %s.' % (sem.name))
return HttpResponseRedirect(
reverse('coredata.views.semester_list', kwargs={}))
else:
form = SemesterForm(instance=semester, prefix='sem')
week_formset = SemesterWeekFormset(
queryset=SemesterWeek.objects.filter(semester=semester),
prefix='week')
holiday_formset = HolidayFormset(
queryset=Holiday.objects.filter(semester=semester),
prefix='holiday')
context = {
'semester': semester,
'form': form,
'newsem': newsem,
'week_formset': week_formset,
'holiday_formset': holiday_formset
}
return render(request, 'coredata/edit_semester.html', context)
def setUp(self):
p1 = Person(emplid=210012345, userid="test1",
last_name="Lname", first_name="Fname", pref_first_name="Fn", middle_name="M")
p1.save()
s = Semester(name="1077", start=date(2007,9,4), end=date(2007,12,3))
s.save()
unit = Unit.objects.get(label="CMPT")
self.co1 = CourseOffering(owner=unit, subject="CMPT", number="120", section="D100", semester=s, component="LEC",
graded=True, crse_id=11111, class_nbr=22222, campus='BRNBY', title="Computer Stuff",
enrl_cap=100, enrl_tot=99, wait_tot=2)
self.co2 = CourseOffering(owner=unit, subject="CMPT", number="165", section="D100", semester=s, component="LEC",
graded=True, crse_id=22222, class_nbr=11111, campus='SURRY', title="Web Stuff",
enrl_cap=85, enrl_tot=80, wait_tot=4)
self.co1.save()
self.co2.save()
def _build_semester_lookup():
"""
Build data structure to let us easily look up date -> strm.
"""
all_semesters = Semester.objects.all()
intervals = ((s.name, Semester.start_end_dates(s)) for s in all_semesters)
intervals = (
intervaltree.Interval(st, en+ONE_DAY, name)
for (name, (st, en)) in intervals)
return intervaltree.IntervalTree(intervals)
def __make_test_grad(self):
gs = self.gs
sem = Semester.current()
# put some data there so there's something to see in the tests (also, the empty <tbody>s don't validate)
req = GradRequirement(program=gs.program,
description="Some Requirement")
req.save()
st = ScholarshipType(unit=gs.program.unit, name="Some Scholarship")
st.save()
Supervisor(student=gs,
supervisor=Person.objects.get(userid='ggbaker'),
supervisor_type='SEN').save()
GradProgramHistory(student=gs,
program=gs.program,
start_semester=Semester.current()).save()
GradStatus(student=gs, status='ACTI', start=sem).save()
CompletedRequirement(student=gs, requirement=req, semester=sem).save()
Scholarship(student=gs,
scholarship_type=st,
amount=1000,
start_semester=sem,
end_semester=sem).save()
OtherFunding(student=gs,
amount=100,
semester=sem,
description="Some Other Funding",
comments="Other Funding\n\nComment").save()
Promise(student=gs,
amount=10000,
start_semester=sem,
end_semester=sem.next_semester()).save()
FinancialComment(student=gs,
semester=sem,
comment_type='SCO',
comment='Some comment.\nMore.',
created_by='ggbaker').save()
Supervisor(student=gs,
supervisor=Person.objects.get(userid='ggbaker'),
supervisor_type='SEN').save()
return gs
def create_grads():
"""
Put the grad students created before into GradStudent records.
"""
gp = GradProgram(unit=Unit.objects.get(slug='cmpt'), label='MSc Project', description='MSc Project option')
gp.save()
req = GradRequirement(program=gp, description='Formed Committee')
req.save()
gp = GradProgram(unit=Unit.objects.get(slug='cmpt'), label='MSc Thesis', description='MSc Thesis option')
gp.save()
req = GradRequirement(program=gp, description='Formed Committee')
req.save()
gp = GradProgram(unit=Unit.objects.get(slug='cmpt'), label='PhD', description='PhD')
gp.save()
req = GradRequirement(program=gp, description='Defended Thesis')
req.save()
req = GradRequirement(program=gp, description='Formed Committee')
req.save()
gp = GradProgram(unit=Unit.objects.get(slug='ensc'), label='MEng', description='Masters in Engineering')
gp.save()
gp = GradProgram(unit=Unit.objects.get(slug='ensc'), label='PhD', description='PhD')
gp.save()
st = ScholarshipType(unit=Unit.objects.get(slug='cmpt'), name="Some Scholarship")
st.save()
gf = GradFlag(unit=Unit.objects.get(slug='cmpt'), label='Special Specialist Program')
gf.save()
programs = list(GradProgram.objects.all())
supervisors = list(set([m.person for m in Member.objects.filter(offering__owner__slug='cmpt', role='INST')]))
for p in Person.objects.filter(userid__endswith='grad'):
gp = random.choice(programs)
campus = random.choice(list(CAMPUSES))
gs = GradStudent(person=p, program=gp, campus=campus)
gs.save()
startsem = random.choice(list(Semester.objects.filter(name__lt=Semester.current().name)))
st = GradStatus(student=gs, status='COMP', start=startsem)
st.save()
st = GradStatus(student=gs, status=random.choice(['ACTI', 'ACTI', 'LEAV']), start=startsem.next_semester())
st.save()
if random.random() > 0.5:
st = GradStatus(student=gs, status=random.choice(['GRAD', 'GRAD', 'WIDR']), start=startsem.next_semester().next_semester().next_semester())
st.save()
if random.random() > 0.25:
sup = Supervisor(student=gs, supervisor=random.choice(supervisors), supervisor_type='SEN')
sup.save()
sup = Supervisor(student=gs, supervisor=random.choice(supervisors), supervisor_type='COM')
sup.save()
if random.random() > 0.5:
sup = Supervisor(student=gs, supervisor=random.choice(supervisors), supervisor_type='COM')
sup.save()
else:
sup = Supervisor(student=gs, external="Some External Supervisor", supervisor_type='COM', config={'email': '*****@*****.**'})
sup.save()
def test_advanced_search_3(self):
client = Client()
test_auth(client, 'ggbaker')
this_sem = Semester.current()
units = [
r.unit
for r in Role.objects.filter(person__userid='ggbaker', role='GRAD')
]
gs = self.__make_test_grad()
gs.gradstatus_set.all().delete()
s1 = GradStatus(student=gs, status='COMP', start=this_sem.offset(-4))
s1.save()
s2 = GradStatus(student=gs, status='ACTI', start=this_sem.offset(-3))
s2.save()
s3 = GradStatus(student=gs, status='LEAV', start=this_sem.offset(2))
s3.save()
# test current-status searching
form = SearchForm(
QueryDict('student_status=ACTI&columns=person.emplid'))
active_now = form.search_results(units)
self.assertIn(gs, active_now)
form = SearchForm(
QueryDict('student_status=LEAV&columns=person.emplid'))
leave_now = form.search_results(units)
self.assertNotIn(gs, leave_now)
# test status-as-of searching
form = SearchForm(
QueryDict(
'student_status=ACTI&status_asof=%s&columns=person.emplid' %
(this_sem.offset(-4).name)))
active_past = form.search_results(units)
self.assertNotIn(gs, active_past)
form = SearchForm(
QueryDict(
'student_status=COMP&status_asof=%s&columns=person.emplid' %
(this_sem.offset(-4).name)))
applic_past = form.search_results(units)
#self.assertIn(gs, applic_past)
form = SearchForm(
QueryDict(
'student_status=ACTI&status_asof=%s&columns=person.emplid' %
(this_sem.offset(3).name)))
active_later = form.search_results(units)
self.assertNotIn(gs, active_later)
form = SearchForm(
QueryDict(
'student_status=LEAV&status_asof=%s&columns=person.emplid' %
(this_sem.offset(3).name)))
leave_later = form.search_results(units)
self.assertIn(gs, leave_later)
def create_grads():
"""
Put the grad students created before into GradStudent records.
"""
gp = GradProgram(unit=Unit.objects.get(slug='cmpt'), label='MSc Project', description='MSc Project option')
gp.save()
req = GradRequirement(program=gp, description='Formed Committee')
req.save()
gp = GradProgram(unit=Unit.objects.get(slug='cmpt'), label='MSc Thesis', description='MSc Thesis option')
gp.save()
req = GradRequirement(program=gp, description='Formed Committee')
req.save()
gp = GradProgram(unit=Unit.objects.get(slug='cmpt'), label='PhD', description='PhD')
gp.save()
req = GradRequirement(program=gp, description='Defended Thesis')
req.save()
req = GradRequirement(program=gp, description='Formed Committee')
req.save()
gp = GradProgram(unit=Unit.objects.get(slug='ensc'), label='MEng', description='Masters in Engineering')
gp.save()
gp = GradProgram(unit=Unit.objects.get(slug='ensc'), label='PhD', description='PhD')
gp.save()
st = ScholarshipType(unit=Unit.objects.get(slug='cmpt'), name="Some Scholarship")
st.save()
gf = GradFlag(unit=Unit.objects.get(slug='cmpt'), label='Special Specialist Program')
gf.save()
programs = list(GradProgram.objects.all())
supervisors = list(set([m.person for m in Member.objects.filter(offering__owner__slug='cmpt', role='INST')]))
for p in Person.objects.filter(userid__endswith='grad'):
gp = random.choice(programs)
campus = random.choice(list(CAMPUSES))
gs = GradStudent(person=p, program=gp, campus=campus)
gs.save()
startsem = random.choice(list(Semester.objects.filter(name__lt=Semester.current().name)))
st = GradStatus(student=gs, status='COMP', start=startsem)
st.save()
st = GradStatus(student=gs, status=random.choice(['ACTI', 'ACTI', 'LEAV']), start=startsem.next_semester())
st.save()
if random.random() > 0.5:
st = GradStatus(student=gs, status=random.choice(['GRAD', 'GRAD', 'WIDR']), start=startsem.next_semester().next_semester().next_semester())
st.save()
if random.random() > 0.25:
sup = Supervisor(student=gs, supervisor=random.choice(supervisors), supervisor_type='SEN')
sup.save()
sup = Supervisor(student=gs, supervisor=random.choice(supervisors), supervisor_type='COM')
sup.save()
if random.random() > 0.5:
sup = Supervisor(student=gs, supervisor=random.choice(supervisors), supervisor_type='COM')
sup.save()
else:
sup = Supervisor(student=gs, external="Some External Supervisor", supervisor_type='COM', config={'email': '*****@*****.**'})
sup.save()
def progress_reports(request):
last_semester = Semester.current().previous_semester()
CS_UNIT=Unit.objects.get(label='CMPT')
grads = GradStudent.objects.filter(program__unit=CS_UNIT, start_semester__name__lte=last_semester.name,
#grads = GradStudent.objects.filter(program__unit__in=request.units, start_semester__name__lte=last_semester.name,
end_semester=None, current_status__in=['ACTI', 'LEAV', 'PART']) \
.select_related('person', 'program__unit').order_by('person')
#grads = grads[:50]
query_text = generate_queries(['queried students starting in %s or before: %i students'%(last_semester.name, grads.count())], grads)
query_text = ''.join(query_text)
return HttpResponse(query_text, content_type='text/plain')
def update_grads():
"""
Update any currently-relevant grad students
"""
active = GradStudent.objects.filter(current_status__in=STATUS_ACTIVE).select_related('person')
applicants = GradStudent.objects.filter(current_status__in=STATUS_APPLICANT,
updated_at__gt=datetime.datetime.now()-datetime.timedelta(days=7)).select_related('person')
s = Semester.current().offset(1)
far_applicants = GradStudent.objects.filter(start_semester__name__gte=s.name).select_related('person')
for gs in set(itertools.chain(active, applicants, far_applicants)):
get_person_grad(gs.person.emplid)
def list_all_semesters(request):
semesters = HiringSemester.objects.visible(request.units)
# if you have access to more than one unit,
# you can see more than one unit
display_units = False
if len(request.units) > 1:
display_units = True
try:
current_semester = Semester.current()
except Semester.DoesNotExist:
current_semester = None
try:
next_semester = Semester.current().offset(1)
except Semester.DoesNotExist:
next_semester = None
# If the user has multiple request.units, it's possible that they may
# have to deal with more than one HiringSemester per Semester
if current_semester:
current_hiring_semesters = HiringSemester.objects.semester\
(current_semester.name, request.units)
else:
current_hiring_semesters = []
if next_semester:
next_hiring_semesters = HiringSemester.objects.semester\
(next_semester.name, request.units)
else:
next_hiring_semesters = []
return render(request, 'tacontracts/list_all_semesters.html', {
'display_units':display_units,
'semesters':semesters,
'current_semester': current_semester,
'current_hiring_semesters':current_hiring_semesters,
'next_semester': next_semester,
'next_hiring_semesters':next_hiring_semesters
})
def create_for_unit(cls, unit):
"""
Populate PlanningCourse objects for this unit, with any Course this unit has offered
in the last two years.
"""
old_sem = Semester.get_semester(datetime.date.today()-datetime.timedelta(days=365*2))
offerings = CourseOffering.objects.filter(owner=unit, semester__name__gte=old_sem.name)
existing = set((pc.subject, pc.number) for pc in PlanningCourse.objects.filter(owner=unit))
for crs in set(c.course for c in offerings.select_related('course')):
if (crs.subject, crs.number) not in existing:
# found a missing PlanningCourse: add it.
pc = PlanningCourse(subject=crs.subject, number=crs.number, title=crs.title, owner=unit)
pc.save()
def funding_report(request, semester_name=None):
if semester_name is None:
semester = Semester.next_starting()
else:
semester = get_object_or_404(Semester, name=semester_name)
programs = GradProgram.objects.filter(unit__in=request.units, hidden=False).order_by('label')
programs = _build_funding_totals(semester, programs, request.units)
these_units = ', '.join(u.name for u in request.units)
context = {'semester': semester, 'programs': programs, 'these_units': these_units}
return render(request, 'grad/funding_report.html', context)
def populate_from_history(cls, person, years=2):
"""
Create TeachingCapability objects for any courses this person has
taught in recent years.
"""
old_sem = Semester.get_semester(datetime.date.today()-datetime.timedelta(days=365*years))
members = Member.objects.filter(person=person, role='INST', offering__semester__name__gte=old_sem.name)
courses = set(m.offering.course for m in members.select_related('offering__course'))
existing = set(tc.course_id for tc in TeachingCapability.objects.filter(instructor=person))
for crs in courses:
if crs.id not in existing:
# found a course that has been taught but not listed as capable
tc = TeachingCapability(instructor=person, course=crs)
tc.save()
def reappoint(request, ra_slug):
appointment = get_object_or_404(RAAppointment, slug=ra_slug, deleted=False)
semester = Semester.next_starting()
semesterconfig = SemesterConfig.get_config(request.units, semester)
raform = RAForm(instance=appointment, initial={'person': appointment.person.emplid, 'reappointment': True,
'start_date': semesterconfig.start_date(), 'end_date': semesterconfig.end_date(), 'hours': 80,
'use_hourly': appointment.use_hourly() })
raform.fields['hiring_faculty'].choices = possible_supervisors(request.units)
scholarship_choices = [("", "---------")]
for s in Scholarship.objects.filter(student__person__emplid = appointment.person.emplid):
scholarship_choices.append((s.pk, s.scholarship_type.unit.label + ": " + s.scholarship_type.name + " (" + s.start_semester.name + " to " + s.end_semester.name + ")"))
raform.fields['scholarship'].choices = scholarship_choices
raform.fields['unit'].choices = [(u.id, u.name) for u in request.units]
raform.fields['project'].choices = [(p.id, unicode(p.project_number)) for p in Project.objects.filter(unit__in=request.units)]
raform.fields['account'].choices = [(a.id, u'%s (%s)' % (a.account_number, a.title)) for a in Account.objects.filter(unit__in=request.units)]
return render(request, 'ra/new.html', { 'raform': raform, 'appointment': appointment })
