def print_grades(self, ws, term_idx, total_terms):
row = 1
sections = ISectionContainer(self.term).values()
for ns, section in enumerate(sections):
jd = ISectionJournalData(section, None)
activities = IActivities(section)
students = sorted(section.members, key=lambda s: s.username)
if not students:
self.write(ws, row, 0, section.__name__)
row += 1
else:
for nstud, student in enumerate(students):
self.print_student(ws, row, section, jd, activities,
student)
row += 1
self.progress('worksheets', normalized_progress(
term_idx, total_terms,
ns, len(sections),
nstud, len(students),
))
self.progress('worksheets', normalized_progress(
term_idx, total_terms,
ns, len(sections),
))
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 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 export_term(self, wb, idx, total_terms):
self.progress('worksheets', normalized_progress(
idx, total_terms,
))
ws = wb.add_sheet(self.term.__name__)
self.print_headers(ws)
self.print_grades(ws, idx, total_terms)
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 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 progress(self, filename, file_n, total_files, file_progress=0.0):
self.manager.progress(
self.__name__,
filename,
normalized_progress(
file_n, total_files,
file_progress, 1.0,
))
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_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 format_table(self, fields, items, importer=None, major_progress=(),
sort=True):
headers = [Header(header)
for header, style, getter in fields]
rows = []
total_items = len(removeSecurityProxy(items))
for n, item in enumerate(items):
row = [style(getter(item))
for header, style, getter in fields]
rows.append(row)
if importer is not None:
self.progress(importer, normalized_progress(
*(major_progress + (n, total_items))))
if sort:
rows.sort()
return [headers] + rows
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 update(self):
self.task_progress.add('collecting', title=u'', progress=0.0)
event = zope.contentprovider.interfaces.BeforeUpdateEvent
total = len(self.viewlets)
for nv, viewlet in enumerate(self.viewlets):
title = format_message(self.collecting_title,
{'name': viewlet.title or _('files')})
self.task_progress.force('collecting',
title=title,
progress=normalized_progress(nv, total),
active=True)
zope.event.notify(event(viewlet, self.request))
viewlet.update()
title = format_message(self.collecting_title, {'name': _('files')})
self.task_progress.force('collecting',
title=title,
progress=None,
active=False)
self.addArchivers()
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 update(self):
self.task_progress.add('collecting',
title=u'', progress=0.0)
event = zope.contentprovider.interfaces.BeforeUpdateEvent
total = len(self.viewlets)
for nv, viewlet in enumerate(self.viewlets):
title = format_message(self.collecting_title,
{'name': viewlet.title or _('files')})
self.task_progress.force(
'collecting',
title=title,
progress=normalized_progress(nv, total),
active=True)
zope.event.notify(event(viewlet, self.request))
viewlet.update()
title = format_message(self.collecting_title,
{'name': _('files')})
self.task_progress.force('collecting', title=title, progress=None, active=False)
self.addArchivers()
def format_table(self,
fields,
items,
importer=None,
major_progress=(),
sort=True):
headers = [Header(header) for header, style, getter in fields]
rows = []
total_items = len(removeSecurityProxy(items))
for n, item in enumerate(items):
row = [style(getter(item)) for header, style, getter in fields]
rows.append(row)
if importer is not None:
self.progress(
importer,
normalized_progress(*(major_progress + (n, total_items))))
if sort:
rows.sort()
return [headers] + rows
