def evolveTimetables(app): # This import holds references to substitute classes # so that they can be pickled after modules are restored. from schooltool.generations.evolve36 import model modules = ModulesSnapshot() modules.mock_module('schooltool.timetable') modules.mock(model.substitutes) builders = [ SchoolTimetablesBuilder(), AppSchedulesBuilder(), AppTimetableCalendarBuilder(), ] for builder in builders: builder.read(app, BuildContext()) modules.restore() for builder in builders: builder.clean(app, BuildContext()) result = BuildContext() for builder in builders: built = builder.build(app, BuildContext(shared=result)) result.update(built) # Pickle stuff transaction.savepoint()
def build(self, timetables, context): # XXX: what if timezone is broken or outdated? if self.timezone is None: timezone = IApplicationPreferences(context.app).timezone else: timezone = self.timezone first, last = context.schoolyear.first, context.schoolyear.last timetable = Timetable( first, last, title=self.title, timezone=timezone) timetables[self.__name__] = timetable timetable.__parent__ = timetables built_periods = self.periods.build( timetable, context(timetables=timetables)) built_time_slots = self.time_slots.build( timetable, context(timetables=timetables)) built_exceptions = self.exceptions.build( timetable, context(timetables=timetables, period_map=built_periods.period_map)) if self.set_default: timetables.default = timetable return BuildContext(timetable=timetable, schema_id=self.__name__, period_map=built_periods.period_map)
def build(self, timetable, context): period_map = context.period_map tz = pytz.timezone(timetable.timezone) by_date = {} for day_templates in self.templates: for n, info in enumerate(day_templates): date, day_id, period_id, tstart, duration = info period_key = (day_id, period_id) period = period_map.get(period_key) dtstart = datetime.datetime.combine(date, tstart) dtstart = dtstart.replace(tzinfo=tz) if period is None: meeting_id = None else: meeting_id = timetable.periodMeetingId( date, period, n+1) meeting = MeetingException( dtstart, duration, period=period, meeting_id=meeting_id) if date not in by_date: by_date[date] = [] by_date[date].append(meeting) for date in by_date: timetable.exceptions[date] = PersistentList( sorted(by_date[date], key=lambda m: m.dtstart)) return BuildContext(exceptions=timetable.exceptions)
def build(self, timetable, context): schedule = createDayTemplates( timetable, SchoolDayTemplates, 'time_slots') for day in self.days: # XXX: title as key is not very safe, isn't it self.addDayTemplate(schedule.templates, day['title'], day) return BuildContext(schedule=schedule)
def build(self, timetable, context): schedule = createDayTemplates( timetable, WeekDayTemplates, 'time_slots') for weekday, day in enumerate(self.days): key = unicode(weekday) self.addDayTemplate(schedule.templates, key, day) return BuildContext(schedule=schedule)
def evolveTimetables(app): # This import holds references to substitute classes # so that they can be pickled after modules are restored. from schooltool.generations.evolve36 import model modules = ModulesSnapshot() modules.mock_module('schooltool.timetable') modules.mock(model.substitutes) builders = [ SchoolTimetablesBuilder(), AppSchedulesBuilder(), AppTimetableCalendarBuilder(), ] for builder in builders: builder.read(app, BuildContext()) modules.restore() for builder in builders: builder.clean(app, BuildContext()) result = BuildContext() for builder in builders: built = builder.build(app, BuildContext(shared=result)) result.update(built) # Pickle stuff transaction.savepoint()
def build(self, timetable, context): schedule = createDayTemplates( timetable, SchoolDayTemplates, 'periods') result = BuildContext(period_map={}) for day in self.days: # XXX: title as key is not very safe, isn't it built = self.addDayTemplate(schedule.templates, day['title'], day) result.period_map.update(built.period_map) return result(schedule=schedule)
def build(self, timetable, context): schedule = createDayTemplates( timetable, WeekDayTemplates, 'periods') result = BuildContext(period_map={}) for weekday in range(7): day = self.getDay(weekday) key = unicode(weekday) built = self.addDayTemplate(schedule.templates, key, day) result.period_map.update(built.period_map) return result(schedule=schedule)
def build(self, app, context): if APP_SCHEDULES_KEY not in app: app[APP_SCHEDULES_KEY] = SchoolToolSchedules() schedule_root = app[APP_SCHEDULES_KEY] result = BuildContext(schedule_map={}) for builder in self.builders: built = builder.build(schedule_root, context(app=app)) result.schedule_map.update(built.schedule_map) return result(schedule_root=schedule_root)
def addDayTemplate(self, templates, day_key, day): period_map = {} template = DayTemplate(title=day['title']) templates[day_key] = template name_chooser = INameChooser(template) for item in day['periods']: period = Period(title=item['title'], activity_type=item['activity_type']) key = name_chooser.chooseName('', period) template[key] = period period_map[(day['id'], item['title'])] = period return BuildContext(period_map=period_map)
def build(self, schedule_root, context): result = BuildContext(schedule_map={}) if not ISection.providedBy(self.owner): return result(schedules=None) owner_int_id = getUtility(IIntIds).getId(self.owner) key = unicode(owner_int_id) container = schedule_root[key] = ScheduleContainer() for builder in self.builders: built = builder.build( container, context(schedule_root=schedule_root, owner=self.owner)) result.schedule_map[built.unique_key] = built.schedule return result(schedules=container)
def build(self, app, context): if APP_TIMETABLES_KEY not in app: app[APP_TIMETABLES_KEY] = SchoolToolSchedules() timetable_root = app[APP_TIMETABLES_KEY] result = BuildContext(period_map={}) for builder in self.builders: built = builder.build(timetable_root, context(app=app)) year_period_map = dict( [((built.year_int_id, schema_id, day_id, period_id), period) for (schema_id, day_id, period_id), period in built.period_map.items()]) result.period_map.update(year_period_map) return result(timetable_root=timetable_root)
def build(self, timetable_root, context): key = unicode(self.year_int_id) container = timetable_root[key] = TimetableContainer() schoolyear = getUtility(IIntIds).getObject(self.year_int_id) result = BuildContext(period_map={}) for builder in self.timetables: built = builder.build( container, context(timetable_root=timetable_root, schoolyear=schoolyear)) schema_period_map = dict( [((built.schema_id, day_id, period_id), period) for (day_id, period_id), period in built.period_map.items()]) result.period_map.update(schema_period_map) return result(timetables=container, year_int_id=self.year_int_id)
def build(self, container, context): timetables = context.shared.timetable_root[unicode(self.year_int_id)] timetable = timetables[self.schema_id] schedule = SelectedPeriodsSchedule(timetable, self.data['first'], self.data['last'], timezone=self.data['timezone'] or 'UTC') result = BuildContext(schedule=schedule, unique_key=(self.data['term'], context.owner, self.data['__name__'])) schedule.consecutive_periods_as_one = \ self.data['consecutive_periods_as_one'] for key in self.selected_period_keys: period = context.shared.period_map[key] schedule.addPeriod(period) container[self.data['__name__']] = schedule return result(term=self.data['term'])
def build(self, app, context): result = BuildContext() for builder in self.builders: built = builder.build(context(app=app)) return result