Esempio n. 1
0
    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]
Esempio n. 2
0
 def generate(self, app, seed=None):
     self.random = PortableRandom(seed)
     event_titles = self._readLines('event_titles.txt')
     person_ids = [person for person in app['persons'].keys()
                   if person.startswith('student') or
                      person.startswith('teacher')]
     dates = []
     for term in ITermContainer(app).values():
         dates.append(term.first)
         dates.append(term.last)
     first = min(dates)
     last = max(dates)
     days = DateRange(first, last)
     for person_id in person_ids:
         person = app['persons'][person_id]
         calendar = ISchoolToolCalendar(person)
         for day in days:
             if self.random.randrange(0, 100) < self.probability:
                 event_title = self.random.choice(event_titles)
                 time_hour = self.random.randint(6, 23)
                 time_min = self.random.choice((0, 30))
                 event_time = datetime.datetime(day.year,
                                                day.month,
                                                day.day,
                                                time_hour,
                                                time_min,
                                                tzinfo=utc)
                 event_duration = datetime.timedelta(
                                    minutes=self.random.randint(1, 12)*30)
                 event = CalendarEvent(event_time,
                                       event_duration,
                                       event_title)
                 calendar.addEvent(event)
Esempio n. 3
0
 def legend(self):
     numterms = 1
     legend = {}
     terms = ITermContainer(self.cursor, {})
     for quarter in self.getYear(self.cursor):
         for month in quarter:
             for week in month:
                 for day in week:
                     term = None
                     for term in terms.values():
                         if day.date in term:
                             break
                     if term and not term in legend:
                         legend[term] = self.numterms
                         numterms += 1
     return legend
Esempio n. 4
0
    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))
Esempio n. 5
0
 def legend(self):
     numterms = 1
     legend = {}
     terms = ITermContainer(self.cursor, {})
     for quarter in self.getYear(self.cursor):
         for month in quarter:
             for week in month:
                 for day in week:
                     term = None
                     for term in terms.values():
                         if day.date in term:
                             break
                     if term and not term in legend:
                         legend[term] = self.numterms
                         numterms += 1
     return legend
Esempio n. 6
0
    def test_getPeriodsForDayBetweenTerms(self):
        from schooltool.term.term import Term
        term3 = Term('Sample', date(2005, 6, 2), date(2005, 8, 1))
        ITermContainer(self.app)['2005-autumn'] = term3
        term3.schooldays = [('A', time(9, 0), timedelta(minutes=115))]
        self.term2.schooldays = [('B', time(10, 0), timedelta(minutes=115))]

        from schooltool.timetable.browser.cal import DailyTimetableCalendarRowsView

        view = DailyTimetableCalendarRowsView(None, TestRequest())
        # We need the start date and the end date different
        view.getPersonTimezone = lambda: timezone('America/Chicago')
        self.assertEquals(len(view.getPeriodsForDay(date(2005, 6, 1))), 1)
Esempio n. 7
0
    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
Esempio n. 8
0
    def renderRow(self, week, month):
        result = []

        terms = ITermContainer(self.cursor, {})

        for day in week:
            term = None
            for term in terms.values():
                if day.date in term:
                    break
            cssClass = "term%d" % self.legend.get(term, 0)
            result.append('<td class="cal_yearly_day">')
            if day.date.month == month:
                if day.today():
                    cssClass += ' today'
                # Let us hope that URLs will not contain < > & or "
                # This is somewhat related to
                # https://bugs.launchpad.net/schooltool/+bug/79781
                result.append(
                    '<a href="%s" class="%s">%s</a>' %
                    (self.calURL('daily', day.date), cssClass, day.date.day))
            result.append('</td>')

        return "\n".join(result)
Esempio n. 9
0
    def renderRow(self, week, month):
        result = []

        terms = ITermContainer(self.cursor, {})

        for day in week:
            term = None
            for term in terms.values():
                if day.date in term:
                    break
            cssClass = "term%d" % self.legend.get(term, 0)
            result.append('<td class="cal_yearly_day">')
            if day.date.month == month:
                if day.today():
                    cssClass += ' today'
                # Let us hope that URLs will not contain < > & or "
                # This is somewhat related to
                # https://bugs.launchpad.net/schooltool/+bug/79781
                result.append('<a href="%s" class="%s">%s</a>' %
                              (self.calURL('daily', day.date), cssClass,
                               day.date.day))
            result.append('</td>')

        return "\n".join(result)
Esempio n. 10
0
    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
Esempio n. 11
0
 def test_getNextTermForDate(self):
     self.assert_(term.getNextTermForDate(date(2004, 8, 31)) is self.term1)
     self.assert_(term.getNextTermForDate(date(2004, 9, 1)) is self.term1)
     self.assert_(term.getNextTermForDate(date(2004, 11, 5)) is self.term1)
     self.assert_(term.getNextTermForDate(date(2004, 12, 20)) is self.term1)
     self.assert_(term.getNextTermForDate(date(2004, 12, 21)) is self.term2)
     self.assert_(term.getNextTermForDate(date(2005, 3, 17)) is self.term2)
     self.assert_(term.getNextTermForDate(date(2005, 11, 5)) is self.term2)
     self.term3 = term.Term('Sample', date(2005, 9, 1), date(2005, 12, 20))
     terms = ITermContainer(self.app)
     terms['2005-fall'] = self.term3
     self.assert_(term.getNextTermForDate(date(2005, 8, 30)) is self.term3)
     self.assert_(term.getNextTermForDate(date(2004, 8, 31)) is self.term1)
     self.assert_(term.getNextTermForDate(date(2004, 12, 22)) is self.term2)
     del terms['2004-fall']
     del terms['2005-spring']
     del terms['2005-fall']
     self.assert_(term.getNextTermForDate(date(2004, 8, 31)) is None)
Esempio n. 12
0
    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
Esempio n. 13
0
    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
Esempio n. 14
0
 def findTerm(self, title):
     terms = ITermContainer(self.schoolyear)
     for term in terms.values():
         if term.title == title:
             return term
     return None
 def findTerm(self, title):
     terms = ITermContainer(self.schoolyear)
     for term in terms.values():
         if term.title == title:
             return term
     return None
Esempio n. 16
0
def getTermContainerForDate(date):
    app = ISchoolToolApplication(None)
    syc = ISchoolYearContainer(app)
    year = syc.getLastSchoolYearForDate(date)
    term_container = ITermContainer(year, None)
    return term_container
Esempio n. 17
0
 def terms(self):
     terms = ITermContainer(self.schoolyear, None)
     if terms is not None:
         return sorted(terms.values(), key=lambda t:t.first)