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