def setUpTimetables(): app = ISchoolToolApplication(None) TimetableStartUp(app)() syc = ISchoolYearContainer(app) sy = syc.getActiveSchoolYear() timetables = ITimetableContainer(sy) timetables[u'rotating'] = tt_rot = Timetable(sy.first, sy.last, title=u"Rotating") tt_rot.periods = CalendarDayTemplates() initTemplates(tt_rot.periods) tt_rot.time_slots = CalendarDayTemplates() initTemplates(tt_rot.time_slots) addTimetableDays(tt_rot, [('1', 'Day 1'), ('2', 'Day 2'), ('3', 'Day 3')], ['A', 'B', 'C']) timetables[u'weekly'] = tt_week = Timetable(sy.first, sy.last, title=u"Weekly") tt_week.periods = WeekDayTemplates() initTemplates(tt_week.periods) tt_week.time_slots = WeekDayTemplates() initTemplates(tt_week.time_slots) dows = [ 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday' ] week_days = [(unicode(n), title) for n, title in enumerate(dows)] addTimetableDays(tt_week, week_days, ['A', 'B', 'C'])
def export_sections_enrollment(self, wb): self.task_progress.force('export_sections_enrollment', active=True) ws = wb.add_sheet("SectionEnrollment") row = 0 years = ISchoolYearContainer(self.context) total_years = len(years) for ny, year in enumerate(sorted(years.values(), key=lambda year: year.first)): total_terms = len(year) for nt, term in enumerate(sorted(year.values(), key=lambda term: term.first)): sections = ISectionContainer(term) total_sections = len(sections) for ns, section in enumerate(sorted(sections.values(), key=lambda section: section.__name__)): row = self.export_section_enrollment( ws, year, term, section, row=row) self.progress( 'export_sections_enrollment', normalized_progress( ny, total_years, nt, total_terms, ns, total_sections, )) self.finish('export_sections_enrollment')
def setUpTimetables(): app = ISchoolToolApplication(None) TimetableStartUp(app)() syc = ISchoolYearContainer(app) sy = syc.getActiveSchoolYear() timetables = ITimetableContainer(sy) timetables[u'rotating'] = tt_rot = Timetable( sy.first, sy.last, title=u"Rotating") tt_rot.periods = CalendarDayTemplates() tt_rot.periods.initTemplates() tt_rot.time_slots = CalendarDayTemplates() tt_rot.time_slots.initTemplates() addTimetableDays( tt_rot, [('1', 'Day 1'), ('2', 'Day 2'), ('3', 'Day 3')], ['A', 'B', 'C']) timetables[u'weekly'] = tt_week = Timetable( sy.first, sy.last, title=u"Weekly") tt_week.periods = WeekDayTemplates() tt_week.periods.initTemplates() tt_week.time_slots = WeekDayTemplates() tt_week.time_slots.initTemplates() dows = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'] week_days = [(unicode(n), title) for n, title in enumerate(dows)] addTimetableDays( tt_week, week_days, ['A', 'B', 'C'])
def export_sections_enrollment(self, wb): self.task_progress.force('export_sections_enrollment', active=True) ws = wb.add_sheet("SectionEnrollment") row = 0 years = ISchoolYearContainer(self.context) total_years = len(years) for ny, year in enumerate( sorted(years.values(), key=lambda year: year.first)): total_terms = len(year) for nt, term in enumerate( sorted(year.values(), key=lambda term: term.first)): sections = ISectionContainer(term) total_sections = len(sections) for ns, section in enumerate( sorted(sections.values(), key=lambda section: section.__name__)): row = self.export_section_enrollment(ws, year, term, section, row=row) self.progress( 'export_sections_enrollment', normalized_progress( ny, total_years, nt, total_terms, ns, total_sections, )) self.finish('export_sections_enrollment')
def __call__(self): app = ISchoolToolApplication(None) syc = ISchoolYearContainer(app) activeSchoolyear = syc.getActiveSchoolYear() if activeSchoolyear is not None: self.importDefaultGroups(activeSchoolyear) else: self.initializeGroupContainer()
def schoolyears(self): app = ISchoolToolApplication(None) schoolyears = ISchoolYearContainer(app) active_schoolyear = schoolyears.getActiveSchoolYear() return [ schoolyear for schoolyear in schoolyears.values() if schoolyear.first >= active_schoolyear.first ]
def evolve(context): linkcatalogs.ensureEvolved(context) root = getRootFolder(context) old_site = getSite() app = root setSite(app) persons = ISchoolToolApplication(None)['persons'] manager = persons.super_user if manager is not None: syc = ISchoolYearContainer(app) for sy in syc.values(): makeManager(app, sy, manager) setSite(old_site)
def setUp(self): layeredTestSetup() app = ISchoolToolApplication(None) self.person = app['persons']['person'] = Person('person') # set up schoolyear from schooltool.schoolyear.schoolyear import SchoolYear from schooltool.schoolyear.interfaces import ISchoolYearContainer ISchoolYearContainer(app)['2004'] = SchoolYear("2004", date(2004, 9, 1), date(2004, 12, 31)) # set up the timetable schema days = ['A', 'B', 'C'] schema = self.createSchema(days, ['1', '2', '3', '4'], ['1', '2', '3', '4'], ['1', '2', '3', '4']) schema.timezone = 'Europe/London' template = SchooldayTemplate() template.add(SchooldaySlot(time(8, 0), timedelta(hours=1))) template.add(SchooldaySlot(time(10, 15), timedelta(hours=1))) template.add(SchooldaySlot(time(11, 30), timedelta(hours=1))) template.add(SchooldaySlot(time(12, 30), timedelta(hours=2))) schema.model = SequentialDaysTimetableModel(days, {None: template}) ITimetableSchemaContainer(app)['default'] = schema # set up terms from schooltool.term.term import Term terms = ITermContainer(app) terms['term'] = term = Term("Some term", date(2004, 9, 1), date(2004, 12, 31)) term.add(date(2004, 11, 5))
def export_sections(self, wb): self.task_progress.force('export_sections', active=True) ws = wb.add_sheet("Sections") headers = [ "School Year", "Courses", "Term", "Section ID", "Previous ID", "Next ID", "Title", "Description", "Resources" ] for index, header in enumerate(headers): self.write_header(ws, 0, index, header) sections = [] for year in ISchoolYearContainer(self.context).values(): for term in year.values(): for section in ISectionContainer(term).values(): if not list(section.courses): continue courses = ', '.join([c.__name__ for c in section.courses]) sections.append((year, courses, term.first, term, section.__name__, section)) row = 1 sections.sort() n_sections = len(sections) for n, (year, courses, first, term, section_id, section) in enumerate(sections): self.format_section(year, courses, term, section, ws, row) self.progress('export_sections', normalized_progress(n, n_sections)) row += 1 self.finish('export_sections')
def getTargets(self, keys): if not keys: return [] result = [] sy_groups = {} app = ISchoolToolApplication(None) schoolyears = ISchoolYearContainer(app) for key in keys: for sy_name, schoolyear in schoolyears.items(): if not key.startswith(sy_name+'.'): continue if sy_name not in sy_groups: sy_groups[sy_name] = IGroupContainer(schoolyear) group = sy_groups[sy_name].get(key[len(sy_name)+1:]) if group is not None: result.append(group) return result
def getTargets(self, keys): if not keys: return [] result = [] sy_groups = {} app = ISchoolToolApplication(None) schoolyears = ISchoolYearContainer(app) for key in keys: for sy_name, schoolyear in schoolyears.items(): if not key.startswith(sy_name + '.'): continue if sy_name not in sy_groups: sy_groups[sy_name] = IGroupContainer(schoolyear) group = sy_groups[sy_name].get(key[len(sy_name) + 1:]) if group is not None: result.append(group) return result
def evolve(context): root = context.connection.root().get(ZopePublication.root_name, None) old_site = getSite() apps = findObjectsProviding(root, ISchoolToolApplication) for app in apps: for year in ISchoolYearContainer(app).values(): fixYear(year, app) setSite(old_site)
def guessMostRecentLevels(app): container = app.get(LEVELS_APP_KEY) if (container is None or not isinstance(container, LevelContainerContainer)): return None levels = None syc = ISchoolYearContainer(app, None) int_ids = getUtility(IIntIds) years = list(reversed(syc.sorted_schoolyears)) active_year = syc.getActiveSchoolYear() if active_year is not None: years = [active_year] + years for year in years: sy_id = str(int_ids.getId(year)) levels = container.get(sy_id, None) if levels is not None: return levels return None
def evolve(context): linkcatalogs.ensureEvolved(context) root = getRootFolder(context) old_site = getSite() app = root setSite(app) syc = ISchoolYearContainer(app) if not syc.values(): setSite(old_site) return sy = syc.getActiveSchoolYear() if sy is None: sy = syc.values()[-1] for person in app['persons'].values(): evolvePerson(app, sy, person) setSite(old_site)
def format_school_years(self): fields = [('ID', Text, attrgetter('__name__')), ('Title', Text, attrgetter('title')), ('Start', Date, attrgetter('first')), ('End', Date, attrgetter('last'))] items = ISchoolYearContainer(self.context).values() result = self.format_table(fields, items, importer='export_school_years') return result
def setUpYear(): app = ISchoolToolApplication(None) syc = ISchoolYearContainer(app) syc['2010-2011'] = SchoolYear(u'2010-2011', datetime.date(2010, 9, 1), datetime.date(2011, 5, 30)) syc['2010-2011'][u'fall'] = Term(u'Fall', datetime.date(2010, 9, 1), datetime.date(2010, 11, 30)) syc['2010-2011'][u'winter'] = Term(u'Winter', datetime.date(2010, 12, 1), datetime.date(2011, 2, 28)) syc['2010-2011'][u'spring'] = Term(u'Spring', datetime.date(2011, 3, 1), datetime.date(2011, 5, 30))
def setUpSchool(app): sy = ISchoolYearContainer(app)['2005'] = SchoolYear( '2005', date(2005, 1, 1), date(2005, 1, 30)) term = sy['spring'] = Term('Spring', date(2005, 1, 1), date(2005, 1, 30)) term.addWeekdays(0, 1, 2, 3, 4) pc = app['persons'] teacher = pc['teacher'] = BasicPerson("teacher", "Mister", "T") s1 = pc['john'] = BasicPerson("john", "John", "Peterson") s2 = pc['pete'] = BasicPerson("pete", "Pete", "Johnson") contacts = IContactContainer(app) contact = Contact() contact.__name__ = 'pete_parent' contact.prefix = 'Ms.' contact.first_name = 'Susan' contact.middle_name = 'T.' contact.last_name = 'Johnson' contact.suffix = 'Jr.' contact.address_line_1 = '1 First St.' contact.address_line_2 = 'Apt. 1' contact.city = 'NY' contact.state = 'NY' contact.country = 'USA' contact.postal_code = '00000' contact.email = '*****@*****.**' contact.home_phone = '000-0000' contact.work_phone = '111-1111' contact.mobile_phone = '222-2222' contact.language = 'English' contacts['pete_parent'] = contact IContactable(s2).contacts.relate(contact, ACTIVE + PARENT, 'p') IContactable(s2).contacts.relate(IContact(teacher), ACTIVE + PARENT, 'p') d1 = IDemographics(s1) d1['ID'] = "112323" d1['ethnicity'] = u'Asian' d1['language'] = "English" d1['placeofbirth'] = "Humptington" d1['citizenship'] = "US" d2 = IDemographics(s2) d2['ID'] = "333655" d2['ethnicity'] = u'White' d2['language'] = "Brittish" d2['placeofbirth'] = "Providence" d2['citizenship'] = "UK" course = ICourseContainer(sy)['c1'] = Course("History")
def setUp(self): placefulSetUp() provideAdapter(getTermContainer, [Interface], ITermContainer) provideAdapter(getSchoolYearContainer) app = setup.setUpSchoolToolSite() schoolyear = SchoolYear("Sample", date(2004, 9, 1), date(2005, 12, 20)) ISchoolYearContainer(app)['2004-2005'] = schoolyear self.term1 = term.Term('Sample', date(2004, 9, 1), date(2004, 12, 20)) self.term2 = term.Term('Sample', date(2005, 1, 1), date(2005, 6, 1)) terms = ITermContainer(app) terms['2004-fall'] = self.term1 terms['2005-spring'] = self.term2 self.app = app
def calculate_holidays_and_weekdays(self): work_days = 0.0 days_of_week = {} for dow in range(7): days_of_week[dow] = [0, 0] school_years = ISchoolYearContainer(self.context).values() for school_year in school_years: terms = ITermContainer(school_year).values() for term in terms: for date in term: if term.isSchoolday(date): days_of_week[date.weekday()][0] += 1 work_days += 1 else: days_of_week[date.weekday()][1] += 1 if work_days == 0: return [[], list(range(7)), []] coefficients = [ counts[0] / work_days for day, counts in sorted(days_of_week.items()) ] # Weekends weekends = [] for n, k in enumerate(coefficients): if k < 0.1: weekends.append(n) # Weekend exceptions and holidays holidays = [] weekend_exceptions = [] for school_year in school_years: terms = ITermContainer(school_year).values() for term in terms: for date in term: if term.isSchoolday(date) and date.weekday() in weekends: weekend_exceptions.append(date) elif not term.isSchoolday(date) and date.weekday( ) not in weekends: holidays.append(date) holiday_ranges = merge_date_ranges(holidays) return [holiday_ranges, weekends, weekend_exceptions]
def format_terms(self): fields = [('SchoolYear', Text, lambda t: t.__parent__.__name__), ('ID', Text, attrgetter('__name__')), ('Title', Text, attrgetter('title')), ('Start', Date, attrgetter('first')), ('End', Date, attrgetter('last'))] school_years = ISchoolYearContainer(self.context).values() items = [] for year in school_years: items.extend([term for term in ITermContainer(year).values()]) terms_table = self.format_table(fields, items, importer='export_terms') holidays, weekends, exceptions = self.calculate_holidays_and_weekdays() terms_table.extend(self.format_holidays(holidays)) terms_table.extend(self.format_weekends(weekends)) terms_table.extend(self.format_weekend_exceptions(exceptions)) return terms_table
def export_groups(self, wb): self.task_progress.force('export_groups', active=True) ws = wb.add_sheet("Groups") school_years = sorted(ISchoolYearContainer(self.context).values(), key=lambda s: s.first) row = 0 for ny, school_year in enumerate( sorted(school_years, key=lambda i: i.last)): groups = IGroupContainer(school_year) for ng, group in enumerate( sorted(groups.values(), key=lambda i: i.__name__)): row = self.format_group(group, ws, row) + 1 self.progress( 'export_groups', normalized_progress(ny, len(school_years), ng, len(groups))) self.finish('export_groups')
def export_school_timetables(self, wb): self.task_progress.force('export_school_timetables', active=True) ws = wb.add_sheet("School Timetables") school_years = sorted(ISchoolYearContainer(self.context).values(), key=lambda s: s.first) row = 0 for ny, school_year in enumerate( sorted(school_years, key=lambda i: i.last)): timetables = ITimetableContainer(school_year) for nt, timetable in enumerate( sorted(timetables.values(), key=lambda i: i.__name__)): row = self.format_school_timetable(timetable, ws, row) + 1 self.progress( 'export_school_timetables', normalized_progress(ny, len(school_years), nt, len(timetables))) self.finish('export_school_timetables')
def export_section_timetables(self, wb): self.task_progress.force('export_section_timetables', active=True) ws = wb.add_sheet("SectionTimetables") year_sections = {} for year in ISchoolYearContainer(self.context).values(): sections = year_sections[year] = {} for term in year.values(): for section in ISectionContainer(term).values(): if not list(section.courses): continue timetables = [] for schedule in IScheduleContainer(section).values(): if schedule.timetable.__name__ is None: # LP: #1281335 continue parts = [schedule.timetable.__name__] if schedule.consecutive_periods_as_one: parts.append('yes') else: parts.append('no') for period in schedule.periods: day = period.__parent__ parts.append(day.title) parts.append(period.title) timetables.append(','.join(parts)) if not len(timetables): continue timetables = tuple(timetables) timetable_sections = sections.setdefault(timetables, []) timetable_sections.append( (term.first, term, section.__name__, section)) row = 0 for ny, (year, sections) in enumerate(sorted(year_sections.items())): for nt, (timetables, timetable_sections) in enumerate( sorted(sections.items())): row = self.format_timetable_sections(year, timetable_sections, ws, row) row = self.format_timetables_block(timetables, ws, row) self.progress( 'export_section_timetables', normalized_progress(ny, len(year_sections), nt, len(sections))) self.finish('export_section_timetables')
def format_courses(self): def get_course_level(course): return ', '.join([l.__name__ for l in course.levels]) fields = [('School Year', Text, lambda c: ISchoolYear(c).__name__), ('ID', Text, attrgetter('__name__')), ('Title', Text, attrgetter('title')), ('Description', Text, attrgetter('description')), ('Local ID', Text, attrgetter('course_id')), ('Government ID', Text, attrgetter('government_id')), ('Credits', Text, attrgetter('credits')), ('Grade Level ID', Text, get_course_level)] school_years = ISchoolYearContainer(self.context).values() items = [] for year in school_years: items.extend([term for term in ICourseContainer(year).values()]) return self.format_table(fields, items, importer='export_courses')
def generate(self, app, seed=None): date = datetime.date syc = ISchoolYearContainer(app) syc['2005-2006'] = SchoolYear("2005-2006", date(2005, 8, 22), date(2006, 12, 22)) fall = term.Term('2005-fall', date(2005, 8, 22), date(2005, 12, 23)) fall.addWeekdays(0, 1, 2, 3, 4) terms = ITermContainer(app) terms['2005-fall'] = fall spring = term.Term('2006-spring', date(2006, 1, 26), date(2006, 5, 31)) spring.addWeekdays(0, 1, 2, 3, 4) terms['2006-spring'] = spring fall = term.Term('2006-fall', date(2006, 8, 21), date(2006, 12, 22)) fall.addWeekdays(0, 1, 2, 3, 4) terms['2006-fall'] = fall
def setUp(self): layeredTestSetup() app = ISchoolToolApplication(None) from schooltool.schoolyear.schoolyear import SchoolYear from schooltool.schoolyear.interfaces import ISchoolYearContainer ISchoolYearContainer(app)['2004-2005'] = SchoolYear( "2004-2005", date(2004, 9, 1), date(2005, 8, 1)) from schooltool.term.term import Term self.term1 = Term('Sample', date(2004, 9, 1), date(2004, 12, 20)) self.term1.schooldays = [ ('A', time(9, 0), timedelta(minutes=115)), ('B', time(11, 0), timedelta(minutes=115)), ('C', time(13, 0), timedelta(minutes=115)), ('D', time(15, 0), timedelta(minutes=115)), ] self.term2 = Term('Sample', date(2005, 1, 1), date(2005, 6, 1)) self.term2.schooldays = [] terms = ITermContainer(app) terms['2004-fall'] = self.term1 terms['2005-spring'] = self.term2 class TimetableModelStub: def periodsInDay(this, schooldays, ttschema, date): if date not in schooldays: raise "This date is not in the current term!" if ttschema == self.tt: return schooldays.schooldays else: return [] tt = TimetableSchema([]) tt.model = TimetableModelStub() tt.timezone = 'Europe/London' self.tt = tt ttschemas = ITimetableSchemaContainer(app) ttschemas['default'] = tt self.app = app
def getGroupContainerForApp(app): syc = ISchoolYearContainer(app) sy = syc.getActiveSchoolYear() if sy is None: return None return IGroupContainer(sy)
def schoolyears(self): return ISchoolYearContainer(ISchoolToolApplication(None))
def getTermContainer(context): app = ISchoolToolApplication(None) syc = ISchoolYearContainer(app) return syc.getActiveSchoolYear()
def schoolyears(self): syc = ISchoolYearContainer(self.context) return syc
def url(self): schoolyears = ISchoolYearContainer(self.context) return absoluteURL(schoolyears, self.request) + '/add.html'
def activeSchoolYear(self): """Return the active school year.""" return ISchoolYearContainer( ISchoolToolApplication(None)).getActiveSchoolYear()
def nextSchoolYear(self): """Return the next school year.""" syc = ISchoolYearContainer(ISchoolToolApplication(None)) if checkPermission("schooltool.edit", syc): return syc.getNextSchoolYear()
def getCourseContainerForApp(app): syc = ISchoolYearContainer(app) sy = syc.getActiveSchoolYear() if sy is not None: return ICourseContainer(sy)
def get_active_year(): schoolyears = ISchoolYearContainer(ISchoolToolApplication(None)) return schoolyears.getActiveSchoolYear()
def schoolyears(self): app = ISchoolToolApplication(None) schoolyears = ISchoolYearContainer(app) active_schoolyear = schoolyears.getActiveSchoolYear() return [schoolyear for schoolyear in schoolyears.values() if schoolyear.first >= active_schoolyear.first]
def getTermContainerForDate(date): app = ISchoolToolApplication(None) syc = ISchoolYearContainer(app) year = syc.getLastSchoolYearForDate(date) term_container = ITermContainer(year, None) return term_container