" % value
else:
klass = ' class="selected-column"'
input = """"""
return input % {'class': klass, 'name':name, 'value':value}
def renderSelectedCell(self, item, formatter):
selected = self.hasMeeting(item)
return self.template(item, selected)
def renderCell(self, item, formatter):
selected = self.selected and self.hasMeeting(item)
return self.template(item, selected)
class SectionTermGradesColumn(GradesColumn):
implements(IColumn)
def __init__(self, journal, term):
self.term = term
self.name = term.__name__ + "grades"
self.journal = journal
def renderCell(self, person, formatter):
grades = []
for score in self.getGrades(person):
grade = score.value
if grade is UNSCORED:
continue
grades.append(grade)
if not grades:
return ""
else:
return ",".join(["%s" % grade for grade in grades])
def renderHeader(self, formatter):
return '%s' % translate(_("Scores"),
context=formatter.request)
class SectionTermAverageGradesColumn(GradesColumn):
implements(IColumn)
def __init__(self, journal, term):
self.term = term
self.name = term.__name__ + "average"
self.journal = journal
def renderCell(self, person, formatter):
grades = []
for score in self.getGrades(person):
grade = score.value
if grade is UNSCORED:
continue
try:
grade = score.scoreSystem.getNumericalValue(grade)
except KeyError:
continue
grades.append(grade)
if not grades:
return ""
else:
return "%.3f" % (float(sum(grades)) / float(len(grades)))
def renderHeader(self, formatter):
return '%s' % translate(_("Average"),
context=formatter.request)
class SectionTermAttendanceColumn(GradesColumn):
implements(IColumn)
def __init__(self, journal, term):
self.term = term
self.name = term.__name__ + "attendance"
self.journal = journal
def renderCell(self, person, formatter):
absences = 0
for score in self.getAbsences(person):
if (IAttendanceScoreSystem.providedBy(score.scoreSystem) and
score.scoreSystem.isAbsent(score)):
absences += 1
if absences == 0:
return ""
else:
return str(absences)
def renderHeader(self, formatter):
return '%s' % translate(_("Absences"),
context=formatter.request)
class SectionTermTardiesColumn(GradesColumn):
implements(IColumn)
def __init__(self, journal, term):
self.term = term
self.name = term.__name__ + "tardies"
self.journal = journal
def renderCell(self, person, formatter):
tardies = 0
for score in self.getAbsences(person):
if (IAttendanceScoreSystem.providedBy(score.scoreSystem) and
score.scoreSystem.isTardy(score)):
tardies += 1
if tardies == 0:
return ""
else:
return str(tardies)
def renderHeader(self, formatter):
return '%s' % translate(_("Tardies"),
context=formatter.request)
class SectionTermExcusedColumn(GradesColumn):
implements(IColumn)
def __init__(self, journal, term):
self.term = term
self.name = term.__name__ + "excused"
self.journal = journal
def renderCell(self, person, formatter):
excusable = 0
excused = 0
for score in self.getAbsences(person):
if (score.value is UNSCORED or
not IAttendanceScoreSystem.providedBy(score.scoreSystem)):
continue
ss = score.scoreSystem
if (ss.isAbsent(score) or
ss.isTardy(score) or
ss.isExcused(score)):
excusable += 1
if ss.isExcused(score):
excused += 1
if excusable == 0:
return ""
else:
return "%d / %d" % (excusable, excused)
def renderHeader(self, formatter):
return '%s' % translate(_("Excused"),
context=formatter.request)
class StudentSelectionMixin(object):
selected_students = None
def selectStudents(self, table_formatter):
self.selected_students = []
if 'student' in self.request:
student_id = self.request['student']
app = ISchoolToolApplication(None)
student = app['persons'].get(student_id)
self.selected_students = [student]
if IIndexedTableFormatter.providedBy(table_formatter):
self.selected_students = table_formatter.indexItems(
self.selected_students)
class LyceumSectionJournalView(StudentSelectionMixin):
template = ViewPageTemplateFile("templates/journal.pt")
no_timetable_template = ViewPageTemplateFile("templates/no_timetable_journal.pt")
no_periods_template = ViewPageTemplateFile("templates/no_periods_journal.pt")
def __init__(self, context, request):
self.context, self.request = context, request
def __call__(self):
schedules = IScheduleContainer(self.context.section)
if not schedules:
return self.no_timetable_template()
meetings = self.all_meetings
if not meetings:
return self.no_periods_template()
if 'UPDATE_SUBMIT' in self.request:
self.updateGradebook()
app = ISchoolToolApplication(None)
person_container = app['persons']
self.gradebook = queryMultiAdapter((person_container, self.request),
ITableFormatter)
self.selectStudents(self.gradebook)
columns_before = [StudentNumberColumn(title=_('Nr.'), name='nr')]
self.gradebook.setUp(items=self.members(),
formatters=[SelectStudentCellFormatter(self.context)] * 2,
columns_before=columns_before,
columns_after=self.gradeColumns(),
table_formatter=self.formatterFactory,
batch_size=0)
return self.template()
@Lazy
def timezone(self):
prefs = IApplicationPreferences(ISchoolToolApplication(None))
return pytz.timezone(prefs.timezone)
def encodedSelectedEventId(self):
event = self.selectedEvent()
if event:
return urllib.quote(base64.encodestring(event.unique_id.encode('utf-8')))
def formatterFactory(self, *args, **kwargs):
kwargs['selected_items'] = self.selected_students
return SelectableRowTableFormatter(*args, **kwargs)
def isJournalMeeting(self, term, meeting):
starts = meeting.dtstart.astimezone(self.timezone)
return starts.date() in term
def allMeetings(self):
term = removeSecurityProxy(self.selected_term)
if not term:
return ()
# maybe expand would be better in here
by_uid = dict([(removeSecurityProxy(e).unique_id, e)
for e in self.context.meetings])
insecure_events = [removeSecurityProxy(e)
for e in by_uid.values()]
insecure_events[:] = filter(lambda e: self.isJournalMeeting(term, e),
insecure_events)
meetings = [by_uid[e.unique_id] for e in sorted(insecure_events)]
return meetings
@Lazy
def all_meetings(self):
return self.allMeetings()
def meetings(self):
for event in self.all_meetings:
insecure_event = removeSecurityProxy(event)
meeting_start = insecure_event.dtstart.astimezone(self.timezone)
if meeting_start.month == self.active_month:
yield event
def members(self):
collator = ICollator(self.request.locale)
factory = getUtility(IPersonFactory)
sorting_key = lambda x: factory.getSortingKey(x, collator)
return sorted(self.context.members, key=sorting_key)
def updateGradebook(self):
members = self.members()
evaluator = getEvaluator(self.request)
for meeting in self.meetings():
for person in members:
cell_id = "%s.%s" % (person.__name__, meeting.__name__)
cell_value = self.request.get(cell_id, None)
if cell_value is not None:
try:
self.context.setGrade(
person, meeting, cell_value, evaluator=evaluator)
except ScoreValidationError:
self.context.setAbsence(
person, meeting, evaluator=evaluator, value=cell_value)
def gradeColumns(self):
columns = []
selected_meeting = self.selectedEvent()
for meeting in self.meetings():
# Arguably anyone who can look at this journal
# should be able to look at meeting grades
insecure_meeting = removeSecurityProxy(meeting)
selected = selected_meeting and selected_meeting == insecure_meeting
columns.append(PersonGradesColumn(insecure_meeting, self.context,
selected=selected))
columns.append(SectionTermAverageGradesColumn(self.context,
self.selected_term))
columns.append(SectionTermAttendanceColumn(self.context,
self.selected_term))
columns.append(SectionTermTardiesColumn(self.context,
self.selected_term))
columns.append(SectionTermExcusedColumn(self.context,
self.selected_term))
return columns
def getSelectedTerm(self):
terms = ITermContainer(self.context)
term_id = self.request.get('TERM', None)
if term_id and term_id in terms:
term = terms[term_id]
if term in self.scheduled_terms:
return term
return self.getCurrentTerm()
@Lazy
def selected_term(self):
return self.getSelectedTerm()
def selectedEvent(self):
event_id = self.request.get('event_id', None)
if event_id is not None:
try:
return self.context.findMeeting(event_id)
except KeyError:
pass
def selectedDate(self):
event = self.selectedEvent()
if event:
app = ISchoolToolApplication(None)
tzinfo = pytz.timezone(IApplicationPreferences(app).timezone)
date = event.dtstart.astimezone(tzinfo).date()
return date
else:
return getUtility(IDateManager).today
def getCurrentTerm(self):
event = self.selectedEvent()
if event:
calendar = event.__parent__
owner = calendar.__parent__
term = ITerm(owner)
return term
return self.scheduled_terms[-1]
@property
def scheduled_terms(self):
linked_sections = self.context.section.linked_sections
linked_sections = [section for section in linked_sections
if IScheduleContainer(section)]
terms = [ITerm(section) for section in linked_sections]
return sorted(terms, key=lambda term: term.last)
def monthsInSelectedTerm(self):
month = -1
for meeting in self.all_meetings:
insecure_meeting = removeSecurityProxy(meeting)
meeting_start = insecure_meeting.dtstart.astimezone(self.timezone)
if meeting_start.month != month:
yield meeting_start.month
month = meeting_start.month
@Lazy
def selected_months(self):
return list(self.monthsInSelectedTerm())
def monthTitle(self, number):
return translate(month_names[number], context=self.request)
def monthURL(self, month_id):
url = absoluteURL(self.context, self.request)
url = "%s/index.html?%s" % (
url,
urllib.urlencode([('month', month_id)] +
self.extra_parameters(self.request)))
return url
@Lazy
def active_year(self):
event = self.selectedEvent()
if event:
return event.dtstart.year
available_months = list(self.selected_months)
selected_month = None
if 'month' in self.request:
month = int(self.request['month'])
if month in available_months:
selected_month = month
if not selected_month:
selected_month = available_months[0]
for meeting in self.all_meetings:
insecure_meeting = removeSecurityProxy(meeting)
meeting_start = insecure_meeting.dtstart.astimezone(self.timezone)
if meeting_start.month == selected_month:
return meeting_start.year
@Lazy
def active_month(self):
available_months = list(self.selected_months)
if 'month' in self.request:
month = int(self.request['month'])
if month in available_months:
return month
term = self.selected_term
date = self.selectedDate()
if (term is not None and
term.first <= date <= term.last):
month = date.month
if month in available_months:
return month
return available_months[0]
def extra_parameters(self, request):
parameters = []
for info in ['TERM', 'student']:
if info in request:
parameters.append((info, request[info].encode('utf-8')))
return parameters
class SectionJournalAjaxView(BrowserView):
def __call__(self):
person_id = self.request['person_id']
app = ISchoolToolApplication(None)
person = app['persons'].get(person_id)
if not person:
raise UserError('Person was invalid!')
event_id = base64.decodestring(urllib.unquote(self.request['event_id'])).decode("utf-8")
meeting = self.context.findMeeting(event_id)
grade = self.request['grade']
evaluator = getEvaluator(self.request)
try:
self.context.setGrade(person, meeting, grade, evaluator=evaluator)
except ScoreValidationError:
pass
try:
self.context.setAbsence(person, meeting, evaluator=evaluator, value=grade)
except ScoreValidationError:
pass
return ""
class SectionListView(BrowserView):
def getSectionsForPerson(self, person):
current_term = getUtility(IDateManager).current_term
sections = IInstructor(person).sections()
results = []
for section in sections:
term = ITerm(section)
if sameProxiedObjects(current_term, term):
url = "%s/journal/" % absoluteURL(section, self.request)
results.append({'title': removeSecurityProxy(section).title,
'url': url})
collator = ICollator(self.request.locale)
results.sort(key=lambda s: collator.key(s['title']))
return results
class TeacherJournalView(SectionListView):
"""A view that lists all the sections teacher is teaching to.
The links go to the journals of these sections and only sections
in the current term are displayed.
"""
def getSections(self):
return self.getSectionsForPerson(self.context)
class TeacherJournalTabViewlet(SectionListView):
implements(IViewlet)
def enabled(self):
person = IPerson(self.request.principal, None)
if not person:
return False
return bool(list(self.getSectionsForPerson(person)))
class JournalNavViewlet(flourish.page.LinkViewlet, SectionListView):
@property
def person(self):
return IPerson(self.request.principal, None)
@property
def enabled(self):
person = self.person
if person is None:
return False
if inCrowd(self.request.principal, 'clerks',
context=self.context):
return True
taught_sections = list(self.getSectionsForPerson(person))
learner_sections = list(ILearner(person).sections())
return taught_sections or learner_sections
@property
def url(self):
if self.person is None:
return ''
base_url = absoluteURL(self.person, self.request)
return '%s/journal.html' % base_url
def getSectionsForPerson(self, person):
return list(IInstructor(person).sections())
class StudentGradebookTabViewlet(object):
implements(IViewlet)
def enabled(self):
person = IPerson(self.request.principal, None)
if not person:
return False
return bool(list(ILearner(person).sections()))
class FlourishLyceumSectionJournalBase(flourish.page.WideContainerPage,
LyceumSectionJournalView):
no_timetable = False
no_periods = False
render_journal = True
journal_mode = None
no_periods_text = _("No periods have been assigned in timetables of this section.")
def __init__(self, *args, **kw):
self._grade_cache = {}
super(FlourishLyceumSectionJournalBase, self).__init__(*args, **kw)
@property
def page_class(self):
if self.render_journal:
return 'page grid'
else:
return 'page'
@property
def has_header(self):
return not self.render_journal
def monthURL(self, month_id):
url = absoluteURL(self, self.request)
url = "%s?%s" % (
url,
urllib.urlencode([('month', month_id)] +
self.extra_parameters(self.request)))
return url
def update(self):
schedules = IScheduleContainer(self.context.section)
if not schedules:
self.no_timetable = True
self.render_journal = False
return
meetings = self.all_meetings
if not meetings:
self.no_periods = True
self.render_journal = False
return
person = IPerson(self.request.principal, None)
if person is not None:
setCurrentSectionTaught(person, self.context.section)
self.updateJournalMode()
if 'UPDATE_SUBMIT' in self.request:
self.updateGradebook()
app = ISchoolToolApplication(None)
self.tzinfo = pytz.timezone(IApplicationPreferences(app).timezone)
@Lazy
def activities(self):
result = []
scores = None
ss = self.getDefaultScoreSystem()
if ss is not None:
scores = self.getJSONScores(ss)
for meeting in self.meetings:
info = {
'hash': meeting.__name__,
'cssClass': 'scorable',
'scores': scores,
}
insecure_meeting = removeSecurityProxy(meeting)
meetingDate = insecure_meeting.dtstart.astimezone(self.tzinfo).date()
info['shortTitle'] = meetingDate.strftime("%d")
info['longTitle'] = meetingDate.strftime("%Y-%m-%d")
try:
if meeting.period is not None:
short_title = meeting.period.title[:3]
else:
short_title = ''
period = short_title
if period[-1] == ':':
period = period[:-1]
except:
period = ''
info['period'] = period
result.append(info)
return result
def getDefaultScoreSystem(self):
return None
def makeRequirement(self, meeting):
return None
def getSelectedTerm(self):
term = ITerm(self.context.section)
if term in self.scheduled_terms:
return term
def breakJSString(self, origstr):
newstr = unicode(origstr)
newstr = newstr.replace('\n', '')
newstr = newstr.replace('\r', '')
newstr = "\\'".join(newstr.split("'"))
newstr = '\\"'.join(newstr.split('"'))
return newstr
def scorableActivities(self):
return self.activities
@property
def warningText(self):
return _('You have some changes that have not been saved. Click OK to save now or CANCEL to continue without saving.')
@Lazy
def meetings(self):
result = []
for event in self.all_meetings:
insecure_event = removeSecurityProxy(event)
meeting_start = insecure_event.dtstart.astimezone(self.timezone)
if meeting_start.month == self.active_month:
result.append(event)
return result
def validate_score(self, activity_id=None, score=None):
"""Intended to be used from AJAX calls."""
if score is None:
score = self.request.get('score')
if activity_id is None:
activity_id = self.request.get('activity_id')
result = {'is_valid': True,
'is_extracredit': False}
meeting = None
meetings = dict([(meeting.__name__, meeting)
for meeting in self.context.meetings])
if activity_id is not None and activity_id in meetings:
meeting = meetings[activity_id]
if (meeting is not None and
score and score.strip()):
requirement = self.makeRequirement(meeting)
if requirement is not None:
result['is_valid'] = requirement.score_system.isValidScore(score)
response = self.request.response
response.setHeader('Content-Type', 'application/json')
encoder = flourish.tal.JSONEncoder()
json = encoder.encode(result)
return json
def getScores(self, person):
if person in self._grade_cache:
return list(self._grade_cache[person])
self._grade_cache[person] = result = []
unique_meetings = set()
term = self.selected_term
calendar = ISchoolToolCalendar(self.context.section)
events = [e for e in calendar if e.dtstart.date() in term]
sorted_events = sorted(events, key=lambda e: e.dtstart)
unproxied_person = removeSecurityProxy(person)
for event in sorted_events:
if event.dtstart.date() not in term:
continue
unproxied_event = removeSecurityProxy(event)
requirement = self.makeRequirement(unproxied_event)
score = IEvaluateRequirement(requirement).getEvaluation(
unproxied_person, requirement, default=UNSCORED)
if (event.meeting_id not in unique_meetings and
score is not UNSCORED):
result.append(score)
unique_meetings.add(event.meeting_id)
return result
def getGrade(self, person, meeting):
requirement = self.makeRequirement(meeting)
score = IEvaluateRequirement(requirement).getEvaluation(
person, requirement, default=UNSCORED)
if score is UNSCORED:
return None
grade = score.value
if grade is UNSCORED:
return None
return score.value
def getHint(self, person, meeting):
# grade hint is homeroom attendance by default
requirement = HomeroomRequirement(meeting)
score = IEvaluateRequirement(requirement).getEvaluation(
person, requirement, default=UNSCORED)
if (score is UNSCORED or
score.value is UNSCORED):
return None
return score.value
def updateJournalMode(self):
if self.journal_mode is None:
return
person = IPerson(self.request.principal, None)
if person is None:
return
mode = getCurrentJournalMode(person) or ''
if mode == self.journal_mode:
return
setCurrentJournalMode(person, self.journal_mode)
@Lazy
def name_sorting_columns(self):
return getUtility(IPersonFactory).columns()
class FlourishLyceumSectionJournalGrades(FlourishLyceumSectionJournalBase):
journal_mode = 'journal-mode-grades'
@property
def title(self):
if self.render_journal:
return _('Enter Scores')
else:
if self.no_timetable:
return _('Section is not scheduled')
else:
return _('No periods assigned for this section')
def getDefaultScoreSystem(self):
prefs = IJournalScoreSystemPreferences(self.context)
ss = prefs.grading_scoresystem
if ss is not None:
return ss
return GradeRequirement.score_system
def makeRequirement(self, meeting):
ss = self.getDefaultScoreSystem()
return GradeRequirement(meeting, ss)
def updateGradebook(self):
evaluator = getEvaluator(self.request)
members = self.members()
for meeting in self.meetings:
for person in members:
cell_id = "%s_%s" % (meeting.__name__, person.__name__)
cell_value = self.request.get(cell_id, None)
if cell_value is not None:
requirement = self.makeRequirement(removeSecurityProxy(meeting))
try:
IEvaluateRequirement(requirement).evaluate(
person, requirement, cell_value,
evaluator=evaluator)
except ScoreValidationError:
pass
except:
IEvaluateRequirement(requirement).evaluate(
person, requirement, cell_value,
evaluator=evaluator)
def table(self):
result = []
collator = ICollator(self.request.locale)
factory = getUtility(IPersonFactory)
self.sortBy = self.request.get('sort_by')
if self.sortBy == 'last_name':
sorting_key = lambda x: (collator.key(x.last_name),
collator.key(x.first_name))
elif self.sortBy == 'first_name':
sorting_key = lambda x: (collator.key(x.first_name),
collator.key(x.last_name))
else:
sorting_key = lambda x: factory.getSortingKey(x, collator)
for person in self.members():
grades = []
for meeting in self.meetings:
insecure_meeting = removeSecurityProxy(meeting)
grade = self.getGrade(person, insecure_meeting) or ''
hint = self.getHint(person, insecure_meeting) or ''
grade_data = {
'id': '%s_%s' % (meeting.__name__, person.__name__),
'sortKey': meeting.__name__,
'value': grade,
'hint': hint,
'editable': True,
}
grades.append(grade_data)
if flourish.canView(person):
person = removeSecurityProxy(person)
result.append(
{'student': {'title': person.title,
'first_name': person.first_name,
'last_name': person.last_name,
'id': person.username,
'sortKey': sorting_key(person),
'url': absoluteURL(person, self.request)},
'grades': grades,
'has_hints': any([g['hint'] for g in grades]),
'average': self.average(person),
})
return sorted(result, key=self.sortKey)
def sortKey(self, row):
if self.sortBy in ('student', 'first_name', 'last_name'):
return row['student']['sortKey']
elif self.sortBy == 'average':
try:
return (float(row['average']), row['student']['sortKey'])
except (ValueError,):
return ('', row['student']['sortKey'])
else:
grades = dict([(grade['sortKey'], grade['value'])
for grade in row['grades']])
if self.sortBy in grades:
grade = grades.get(self.sortBy)
if grade:
return (0, grade, row['student']['sortKey'])
return (1, row['student']['sortKey'])
def average(self, person):
grades = []
scores = self.getScores(person)
for score in scores:
if score.value is UNSCORED:
continue
try:
grade = score.scoreSystem.getNumericalValue(score.value)
except KeyError:
continue
grades.append(grade)
if not grades:
return _('N/A')
else:
return "%.1f" % (float(sum(grades)) / float(len(grades)))
def getJSONScores(self, scoresystem):
encoder = flourish.tal.JSONEncoder()
result = []
for label, abbr, value, percent in scoresystem.scores:
title = label
if abbr:
title += ': %s' % translate(abbr, context=self.request)
result.append({
'label': title,
'value': label,
})
json = encoder.encode(result)
return json
class FlourishLyceumSectionJournalAttendance(FlourishLyceumSectionJournalBase):
journal_mode = 'journal-mode-attendance'
@property
def title(self):
if self.render_journal:
return _('Enter Attendance')
else:
if self.no_timetable:
return _('Section is not scheduled')
else:
return _('No periods assigned for this section')
def getDefaultScoreSystem(self):
prefs = IJournalScoreSystemPreferences(self.context)
ss = prefs.attendance_scoresystem
if ss is not None:
return ss
return AttendanceRequirement.score_system
def makeRequirement(self, meeting):
ss = self.getDefaultScoreSystem()
return AttendanceRequirement(meeting, ss)
def getJSONScores(self, scoresystem):
encoder = flourish.tal.JSONEncoder()
result = []
for label, abbr in scoresystem.scores:
title = label
if abbr:
title += ': %s' % translate(abbr, context=self.request)
result.append({
'label': title,
'value': label,
})
json = encoder.encode(result)
return json
def table(self):
result = []
collator = ICollator(self.request.locale)
factory = getUtility(IPersonFactory)
self.sortBy = self.request.get('sort_by')
if self.sortBy == 'last_name':
sorting_key = lambda x: (collator.key(x.last_name),
collator.key(x.first_name))
elif self.sortBy == 'first_name':
sorting_key = lambda x: (collator.key(x.first_name),
collator.key(x.last_name))
else:
sorting_key = lambda x: factory.getSortingKey(x, collator)
for person in self.members():
grades = []
for meeting in self.meetings:
insecure_meeting = removeSecurityProxy(meeting)
attendance = self.getGrade(person, insecure_meeting) or ''
hint = self.getHint(person, insecure_meeting) or ''
grade_data = {
'id': '%s_%s' % (meeting.__name__, person.__name__),
'sortKey': meeting.__name__,
'value': attendance,
'hint': hint,
'editable': True,
}
grades.append(grade_data)
if flourish.canView(person):
person = removeSecurityProxy(person)
excused, excusable = self.excused(person)
result.append(
{'student': {'title': person.title,
'first_name': person.first_name,
'last_name': person.last_name,
'id': person.username,
'sortKey': sorting_key(person),
'url': absoluteURL(person, self.request)},
'grades': grades,
'absences': self.absences(person),
'tardies': self.tardies(person),
'excused': (
'%s / %s' % (excused, excusable)
if excusable
else ''),
'unexcused': excused - excusable if excusable else 1,
'has_hints': any([g['hint'] for g in grades]),
})
return sorted(result, key=self.sortKey)
def sortKey(self, row):
if self.sortBy in ('student', 'first_name', 'last_name'):
return row['student']['sortKey']
elif self.sortBy == 'absences':
return (int(row['absences']), row['student']['sortKey'])
elif self.sortBy == 'tardies':
return (int(row['tardies']), row['student']['sortKey'])
elif self.sortBy == 'excused':
return (row['unexcused'], row['student']['sortKey'])
else:
grades = dict([(grade['sortKey'], grade['value'])
for grade in row['grades']])
if self.sortBy in grades:
grade = grades.get(self.sortBy)
if grade:
return (0, grade, row['student']['sortKey'])
return (1, row['student']['sortKey'])
def absences(self, person):
absences = 0
for score in self.getScores(person):
if (score.value is not UNSCORED and
IAttendanceScoreSystem.providedBy(score.scoreSystem) and
score.scoreSystem.isAbsent(score)):
absences += 1
if absences == 0:
return "0"
else:
return str(absences)
def tardies(self, person):
tardies = 0
for score in self.getScores(person):
if (score.value is not UNSCORED and
IAttendanceScoreSystem.providedBy(score.scoreSystem) and
score.scoreSystem.isTardy(score)):
tardies += 1
if tardies == 0:
return "0"
else:
return str(tardies)
def excused(self, person):
excusable = 0
excused = 0
for score in self.getScores(person):
if (score.value is UNSCORED or
not IAttendanceScoreSystem.providedBy(score.scoreSystem)):
continue
ss = score.scoreSystem
if (ss.isAbsent(score) or
ss.isTardy(score) or
ss.isExcused(score)):
excusable += 1
if ss.isExcused(score):
excused += 1
if not excusable:
return 0, 0
return excused, excusable
def updateGradebook(self):
evaluator = getEvaluator(self.request)
members = self.members()
for meeting in self.meetings:
for person in members:
cell_id = "%s_%s" % (meeting.__name__, person.__name__)
cell_value = self.request.get(cell_id, None)
if cell_value is not None:
requirement = self.makeRequirement(removeSecurityProxy(meeting))
try:
IEvaluateRequirement(requirement).evaluate(
person, requirement, cell_value,
evaluator=evaluator)
except ScoreValidationError:
pass
def validate_score(self, activity_id=None, score=None):
if score is None:
score = self.request.get('score')
return FlourishLyceumSectionJournalBase.validate_score(
self, activity_id=activity_id, score=score)
class FlourishSectionHomeroomAttendance(FlourishLyceumSectionJournalAttendance):
journal_mode = 'journal-mode-homeroom'
no_periods_text = _("This section is not scheduled for any homeroom periods.")
def getHint(self, person, meeting):
return None
def isJournalMeeting(self, term, meeting):
if not FlourishLyceumSectionJournalAttendance.isJournalMeeting(self, term, meeting):
return False
period = getattr(meeting, 'period', None)
if period is None:
return False
if period.activity_type == 'homeroom':
return True
return False
def getDefaultScoreSystem(self):
prefs = IJournalScoreSystemPreferences(self.context)
ss = prefs.attendance_scoresystem
if ss is not None:
return ss
return HomeroomRequirement.score_system
def makeRequirement(self, meeting):
ss = self.getDefaultScoreSystem()
return HomeroomRequirement(meeting, ss)
class JournalTertiaryNavigationManager(flourish.page.TertiaryNavigationManager):
template = ViewPageTemplateFile('templates/f_journal_tertiary_nav.pt')
@Lazy
def items(self):
result = []
for month_id in self.view.selected_months:
url = self.view.monthURL(month_id)
title = self.view.monthTitle(month_id)
result.append({
'class': month_id == self.view.active_month and 'active' or None,
'viewlet': u'%s' % (url, title, title),
})
return result
class FlourishJournalNavigationViewletBase(flourish.viewlet.Viewlet):
@property
def person(self):
return IPerson(self.request.principal)
def render(self, *args, **kw):
return self.template(*args, **kw)
def getUserSections(self):
return list(IInstructor(self.person).sections())
@Lazy
def user_sections(self):
return self.getUserSections()
class TeacherNavigationViewletBase(flourish.page.RefineLinksViewlet):
@property
def person(self):
return IPerson(self.request.principal)
@property
def section(self):
return self.context.section
def render(self, *args, **kw):
if self.person in self.section.instructors:
return super(TeacherNavigationViewletBase,
self).render(*args, **kw)
class FlourishJournalYearNavigation(TeacherNavigationViewletBase):
"""Journal year navigation viewlet."""
class FlourishJournalYearNavigationViewlet(FlourishJournalNavigationViewletBase):
template = InlineViewPageTemplate('''
''')
def getYears(self):
currentSection = self.context.section
currentYear = ISchoolYear(ITerm(currentSection))
years = []
for section in self.user_sections:
year = ISchoolYear(ITerm(section))
if year not in years:
years.append(year)
return [{'title': year.title,
'section_url': self.getSectionURL(year),
'selected': year is currentYear and 'selected' or None}
for year in sorted(years, key=lambda x:x.first)]
def getSectionURL(self, year):
result = None
for section in self.user_sections:
term = ITerm(section)
if ISchoolYear(term).__name__ == year.__name__:
result = section
break
url = '%s/journal' % absoluteURL(result, self.request)
return url
class FlourishJournalTermNavigation(TeacherNavigationViewletBase):
"""Journal term navigation viewlet."""
class FlourishJournalTermNavigationViewlet(FlourishJournalNavigationViewletBase):
template = InlineViewPageTemplate('''
''')
def getTerms(self):
currentSection = self.context.section
currentTerm = ITerm(currentSection)
currentYear = ISchoolYear(currentTerm)
terms = []
for section in self.user_sections:
term = ITerm(section)
if ISchoolYear(term) == currentYear and term not in terms:
terms.append(term)
return [{'title': term.title,
'section_url': self.getSectionURL(term),
'selected': term is currentTerm and 'selected' or None}
for term in sorted(terms, key=lambda x:x.first)]
def getCourse(self, section):
try:
return list(section.courses)[0]
except (IndexError,):
return None
def getSectionURL(self, term):
result = None
currentSection = self.context.section
currentCourse = self.getCourse(currentSection)
for section in self.user_sections:
if term == ITerm(section):
if currentCourse == self.getCourse(section):
result = section
break
elif result is None:
result = section
url = '%s/journal' % absoluteURL(result, self.request)
return url
class FlourishJournalSectionNavigation(TeacherNavigationViewletBase):
"""Journal section navigation viewlet."""
class FlourishJournalSectionNavigationViewlet(FlourishJournalNavigationViewletBase):
template = InlineViewPageTemplate('''
''')
def getSections(self):
result = []
currentSection = self.context.section
currentTerm = ITerm(currentSection)
for section in self.user_sections:
term = ITerm(section)
if term != currentTerm:
continue
result.append({
'url': '%s/journal' % absoluteURL(section, self.request),
'title': section.title,
'selected': section == currentSection and 'selected' or None,
})
return result
class FlourishJournalRedirectView(flourish.page.Page):
@Lazy
def person(self):
person = IPerson(self.request.principal, None)
return person
def getModeUrl(self):
content = self.providers.get('lyceum-journal-modes')
if content is None:
return
modes = content.modes
if not modes:
return
url = modes[0]['url']
current = getCurrentJournalMode(self.person) or ''
if not current:
return url
for mode in content.modes:
if mode['id'] == current:
return mode['url']
return url
def getSchoolYearUrl(self):
sections = list(ILearner(self.person).sections())
if sections:
current_term = getUtility(IDateManager).current_term
if current_term is not None:
schoolyear = ISchoolYear(current_term)
url = (absoluteURL(schoolyear, self.request) +
'/myjournal.html')
return url
def render(self):
url = self.getModeUrl()
if not url:
url = self.getSchoolYearUrl()
if not url:
self.request.response.redirect(
absoluteURL(self.context, self.request))
else:
self.request.response.redirect(url)
class FlourishJournalActionsLinks(flourish.page.RefineLinksViewlet):
"""Journal action links viewlet."""
class FlourishJournalHelpLinks(flourish.page.RefineLinksViewlet):
"""Journal help links viewlet."""
class FlourishJournalHelpViewlet(flourish.page.ModalFormLinkViewlet):
@property
def url(self):
return "%s/%s" % (absoluteURL(self.view, self.request),
self.link)
@property
def dialog_title(self):
title = _(u'Journal Help')
return translate(title, context=self.request)
class FlourishJournalHelpView(flourish.form.Dialog):
template = InlineViewPageTemplate('''
''')
def updateDialog(self):
# XXX: fix the width of dialog content in css
if self.ajax_settings['dialog'] != 'close':
self.ajax_settings['dialog']['width'] = 192 + 16
def initDialog(self):
self.ajax_settings['dialog'] = {
'autoOpen': True,
'modal': False,
'resizable': False,
'draggable': True,
'position': ['center','middle'],
'width': 'auto',
}
class AbsenceScoreSystemLegend(flourish.content.ContentProvider):
title = _('Attendance')
def getLegendItems(self):
score_system = self.context
for grade, title in score_system.scores:
meaning = []
if grade in score_system.tag_absent:
meaning.append(translate(_('Absent'), context=self.request))
if grade in score_system.tag_tardy:
meaning.append(translate(_('Tardy'), context=self.request))
if not meaning:
meaning.append(translate(_('Present'), context=self.request))
if grade in score_system.tag_excused:
meaning.append(translate(_('Excused'), context=self.request))
yield {'value': grade,
'description': title,
'meaning': ', '.join(meaning)
}
class CustomScoreSystemLegend(flourish.content.ContentProvider):
@property
def scoresystem(self):
return self.context
def getGrades(self):
result = []
scoresystem = self.scoresystem
scores = sorted(scoresystem.scores, key=lambda s: s[3])
for score, abbr, val, percent in scores:
result.append({
'value': score,
'points': val,
'passing': scoresystem.isPassingScore(score),
})
return result
class SectionJournalLinkViewlet(flourish.page.LinkViewlet):
@Lazy
def journal(self):
journal = ISectionJournal(self.context, None)
return journal
@property
def url(self):
journal = self.journal
if journal is None:
return None
return absoluteURL(journal, self.request)
@property
def enabled(self):
if not super(SectionJournalLinkViewlet, self).enabled:
return False
journal = self.journal
if journal is None:
return None
can_view = flourish.canView(journal)
return can_view
class FlourishActivityPopupMenuView(flourish.content.ContentProvider):
def __init__(self, view, request):
flourish.content.ContentProvider.__init__(self, view.context, request, view)
def translate(self, message):
return translate(message, context=self.request)
def __call__(self):
result = {}
app = ISchoolToolApplication(None)
tzinfo = pytz.timezone(IApplicationPreferences(app).timezone)
activity_id = self.request.get('activity_id')
meetings = dict([(meeting.__name__, meeting)
for meeting in self.context.meetings])
if activity_id is not None and activity_id in meetings:
meeting = meetings[activity_id]
meetingDate = meeting.dtstart.astimezone(tzinfo).date()
info = {
'longTitle': meetingDate.strftime("%Y-%m-%d"),
'hash': activity_id,
}
url = absoluteURL(self.view, self.request)
result['header'] = info['longTitle']
result['options'] = [
{
'label': self.translate(_('Fill down')),
'url': '#',
'css_class': 'filldown',
},
{
'label': self.translate(_('Sort by')),
'url': '%s?sort_by=%s&month=%s' % (
url, info['hash'], meetingDate.month),
}
]
response = self.request.response
response.setHeader('Content-Type', 'application/json')
encoder = flourish.tal.JSONEncoder()
json = encoder.encode(result)
return json
class FlourishStudentPopupMenuView(flourish.content.ContentProvider):
def __init__(self, view, request):
flourish.content.ContentProvider.__init__(self, view.context, request, view)
def translate(self, message):
return translate(message, context=self.request)
def __call__(self):
result = {}
student_id = self.request.get('student_id')
if student_id is not None:
app = ISchoolToolApplication(None)
student = app['persons'].get(student_id)
if student is not None and student in self.context.members:
journal_url = absoluteURL(self.view, self.request)
student_url = absoluteURL(student, self.request)
result['header'] = student.title
result['options'] = [
{
'label': self.translate(_('Student')),
'url': student_url,
},
{
'label': self.translate(_('History')),
'url': '%s/score_history?student_id=%s&month=%s' % (
journal_url, student_id, self.view.active_month),
},
]
response = self.request.response
response.setHeader('Content-Type', 'application/json')
encoder = flourish.tal.JSONEncoder()
json = encoder.encode(result)
return json
class FlourishNamePopupMenuView(flourish.content.ContentProvider):
def __init__(self, view, request):
flourish.content.ContentProvider.__init__(self, view.context, request, view)
def translate(self, message):
return translate(message, context=self.request)
@Lazy
def name_sorting_columns(self):
return getUtility(IPersonFactory).columns()
def __call__(self):
column_id = self.request.get('column_id')
for column in self.name_sorting_columns:
if column.name == column_id:
break
result = {
'header': self.translate(column.title),
'options': [
{
'label': self.translate(_('Sort by')),
'url': '?sort_by=%s' % column_id,
}
],
}
response = self.request.response
response.setHeader('Content-Type', 'application/json')
encoder = flourish.tal.JSONEncoder()
json = encoder.encode(result)
return json
class FlourishTotalPopupMenuView(flourish.content.ContentProvider):
def __init__(self, view, request):
flourish.content.ContentProvider.__init__(self, view.context, request, view)
titles = {
'total': _('Total'),
'average': _('Ave.'),
'tardies': _('Trd.'),
'absences': _('Abs.'),
'excused': _('Exc.'),
}
def translate(self, message):
return translate(message, context=self.request)
def __call__(self):
result = {}
column_id = self.request.get('column_id')
if column_id in self.titles:
result['header'] = self.translate(self.titles[column_id])
result['options'] = [
{
'label': self.translate(_('Sort by')),
'url': '?sort_by=%s' % column_id,
},
]
response = self.request.response
response.setHeader('Content-Type', 'application/json')
encoder = flourish.tal.JSONEncoder()
json = encoder.encode(result)
return json
class FlourishRequestJournalExportGrades(RequestXLSReportDialog):
report_builder = 'grades.xls'
task_factory = JournalXLSReportTask
class FlourishRequestJournalExportAttendance(RequestXLSReportDialog):
report_builder = 'attendance.xls'
task_factory = JournalXLSReportTask
class DateHeader(export.Header):
@property
def style(self):
result = super(DateHeader, self).style.copy()
result['format_str'] = 'YYYY-MM-DD'
return result
class FlourishJournalExportBase(export.ExcelExportView):
def print_headers(self, ws):
row_1_headers = [export.Header(label)
for label in ['ID', 'First name', 'Last name']]
row_2_headers = [export.Header('') for i in range(3)]
for activity_info in self.activities:
row_1_headers.append(DateHeader(activity_info['date']))
row_2_headers.append(export.Header(activity_info['period']))
for col, header in enumerate(row_1_headers):
self.write(ws, 0, col, header.data, **header.style)
for col, header in enumerate(row_2_headers):
self.write(ws, 1, col, header.data, **header.style)
def studentSortKey(self, value):
student = self.persons[value['student']['id']]
return IDemographics(student).get('ID', '')
def print_grades(self, ws, nmonth, total_months):
starting_row = 2
table = sorted(self.table(), key=lambda x:self.studentSortKey)
for i, row in enumerate(table):
student = self.persons[row['student']['id']]
cells = [export.Text(IDemographics(student).get('ID', '')),
export.Text(student.first_name),
export.Text(student.last_name)]
for grade in row['grades']:
value = grade['value']
cells.append(export.Text(value))
for col, cell in enumerate(cells):
self.write(ws, starting_row+i, col, cell.data, **cell.style)
self.progress('journal', normalized_progress(
nmonth, total_months,
i, len(table),
))
def export_month_worksheets(self, wb):
months = list(self.selected_months)
for nm, month_id in enumerate(months):
self._active_month = month_id
title = self.monthTitle(month_id)
ws = wb.add_sheet(title)
self.print_headers(ws)
self.print_grades(ws, nm, len(months))
self.progress('journal', normalized_progress(
nm, len(months),
))
self.finish('journal')
def addImporters(self, progress):
self.task_progress.add(
'journal',
title=_('Journal'), progress=0.0)
def __call__(self):
self.makeProgress()
self.task_progress.title = _("Exporting")
self.addImporters(self.task_progress)
app = ISchoolToolApplication(None)
self.persons = app['persons']
self.tzinfo = pytz.timezone(IApplicationPreferences(app).timezone)
workbook = xlwt.Workbook()
self.export_month_worksheets(workbook)
return workbook
@property
def active_month(self):
return self._active_month
@property
def meetings(self):
result = []
for event in self.all_meetings:
insecure_event = removeSecurityProxy(event)
meeting_start = insecure_event.dtstart.astimezone(self.tzinfo)
if meeting_start.month == self.active_month:
result.append(event)
return result
@property
def activities(self):
result = []
for meeting in self.meetings:
info = {}
insecure_meeting = removeSecurityProxy(meeting)
meetingDate = insecure_meeting.dtstart.astimezone(self.tzinfo).date()
info['date'] = meetingDate
try:
if meeting.period is not None:
short_title = meeting.period.title
else:
short_title = ''
period = short_title
if period[-1] == ':':
period = period[:-1]
except:
period = ''
info['period'] = period
result.append(info)
return result
class FlourishJournalExportGrades(FlourishJournalExportBase,
FlourishLyceumSectionJournalGrades):
@property
def base_filename(self):
section = ISection(self.context)
filename = '%s journal scores' % section.title
filename = filename.replace(' ', '_')
return filename
class FlourishJournalExportAttendance(FlourishJournalExportBase,
FlourishLyceumSectionJournalAttendance):
@property
def base_filename(self):
section = ISection(self.context)
filename = '%s attendance' % section.title
filename = filename.replace(' ', '_')
return filename
class JournalModes(flourish.page.RefineLinksViewlet):
pass
def getSectionJournalModes(person, section, request):
journal_url = absoluteURL(section, request) + '/journal'
result = []
result.append({
'id': 'journal-mode-attendance',
'label': _('Attendance'),
'url': journal_url,
})
takes_day_attendance = True
journal = ISectionJournal(section)
homerooms = queryMultiAdapter(
(journal, request), name='homeroom.html')
if (homerooms is None or
not homerooms.all_meetings):
takes_day_attendance = False
if takes_day_attendance:
result.append({
'id': 'journal-mode-homeroom',
'label': _('Homeroom'),
'url': journal_url + '/homeroom.html',
})
result.append({
'id': 'journal-mode-grades',
'label': _('Scores'),
'url': journal_url + '/grades.html',
})
return result
class JournalModeContent(flourish.content.ContentProvider, SectionFinder):
@Lazy
def person(self):
person = IPerson(self.request.principal, None)
return person
@Lazy
def section(self):
person = self.person
if person is None:
return None
section = getCurrentSectionTaught(person)
if section is None:
sections = list(IInstructor(person).sections())
if not sections:
return None
schoolyears = ISchoolYearContainer(ISchoolToolApplication(None))
active = schoolyears.getActiveSchoolYear()
section = self.getFromYear(sections, active)
return section
def getSchoolModes(self):
if not inCrowd(self.request.principal, 'clerks', context=self.context):
return []
app = ISchoolToolApplication(None)
persons = app['persons']
persons_url = absoluteURL(persons, self.request)
result = []
result.append({
'id': 'journal-mode-school-attendance',
'label': _('School Attendance'),
'url': persons_url + '/attendance.html',
})
return result
def getSectionModes(self):
section = self.section
if section is None:
return []
person = self.person
if person is None:
return []
result = getSectionJournalModes(person, section, self.request)
return result
@Lazy
def modes(self):
result = []
result.extend(self.getSchoolModes())
result.extend(self.getSectionModes())
return result
def render(self):
return ''
class JournalModeSelector(flourish.viewlet.Viewlet):
list_class = 'filter'
template = InlineViewPageTemplate('''
''')
@Lazy
def items(self):
content = self.manager.view.providers.get('lyceum-journal-modes')
if not content:
return []
current = getCurrentJournalMode(IPerson(self.request.principal, None)) or ''
result = list(content.modes)
for mode in result:
mode['selected'] = bool(mode['id'] == current)
return result
def render(self, *args, **kw):
if len(self.items) < 2:
return ''
return self.template(*args, **kw)
class SubPage(flourish.content.ContentProvider,
flourish.page.Page):
update = flourish.page.Page.update
render = flourish.page.Page.render
__call__ = flourish.page.Page.__call__
def __init__(self, context, request):
view = context
flourish.content.ContentProvider.__init__(
self, view.context, request, view)
class SectionJournalGradeHistory(SubPage):
@property
def title(self):
section = self.context.section
return section.title
@Lazy
def student(self):
student_id = self.request.get('student_id')
if student_id is None:
return None
app = ISchoolToolApplication(None)
student = app['persons'].get(student_id)
return student
@property
def meetings(self):
calendar = ISchoolToolCalendar(self.context.section)
sorted_events = sorted(calendar, key=lambda e: e.dtstart)
return sorted_events
@property
def timezone(self):
app = ISchoolToolApplication(None)
return pytz.timezone(IApplicationPreferences(app).timezone)
@property
def timeformat(self):
app = ISchoolToolApplication(None)
prefs = IApplicationPreferences(app)
return prefs.timeformat
def formatScoreValue(self, requirement, score):
if (score is None or score.value is UNSCORED):
return ''
return score.value
def table(self):
if self.student is None:
return []
persons = ISchoolToolApplication(None)['persons']
evaluations = removeSecurityProxy(IEvaluations(self.student))
result = []
meetings = self.meetings
timezone = self.timezone
timeformat = self.timeformat
for meeting in meetings:
requirement = self.view.makeRequirement(removeSecurityProxy(meeting))
scores = list(evaluations.getHistory(requirement))
current = evaluations.get(requirement)
if (scores or current is not None):
scores.append(current)
if not scores:
continue
scores.reverse()
meeting_time = meeting.dtstart.astimezone(timezone)
activity = {
'date': meeting_time.date(),
'time': meeting_time.time().strftime(timeformat),
'period': '',
'grades': [],
}
if meeting.period is not None:
activity['period'] = meeting.period.title
for score in scores:
record = {'date': '',
'time': '',
'value': '',
'evaluator': None}
record['value'] = self.formatScoreValue(requirement, score)
if score is not None:
if score.evaluator:
record['evaluator'] = persons.get(score.evaluator)
if (getattr(score, 'time', None) is not None):
time_utc = pytz.utc.localize(score.time)
time = time_utc.astimezone(timezone)
record['date'] = time.date()
record['time'] = time.strftime(timeformat)
activity['grades'].append(record)
result.append(activity)
return result
@property
def done_url(self):
month = None
try:
month = int(self.request.get('month'))
except TypeError:
pass
except ValueError:
pass
if month is not None:
return self.view.monthURL(month)
return absoluteURL(self.view, self.request)
class SectionJournalAttendanceHistory(SectionJournalGradeHistory):
def formatScoreValue(self, requirement, score):
if (score is None or score.value is UNSCORED):
return ''
grade = score.value
if IAttendanceScoreSystem.providedBy(requirement.score_system):
description = dict(requirement.score_system.scores).get(grade, u'')
else:
description = ''
result = ' - '.join([translate(i, context=self.request)
for i in (grade, description)])
return result
class FlourishSchoolYearMyJournalView(flourish.page.Page):
@property
def subtitle(self):
return self.context.title
@property
def person(self):
return IPerson(self.request.principal, None)
@property
def sections(self):
if self.person is None:
return []
result = []
for section in ILearner(self.person).sections():
term = ITerm(section)
if ISchoolYear(term) != self.context:
continue
result.append([term.first, section.title, term, section])
return [(term, section)
for first, title, term, section in sorted(result)]
def getEventGrades(self, section):
person = self.person
if person is None:
return
section_journal_data = ISectionJournalData(section)
for event in ISchoolToolCalendar(section):
grade = section_journal_data.getGrade(person, event)
if not grade:
continue
yield event, grade
def getEventAttendanceScores(self, section):
person = self.person
if person is None:
return
evaluations = removeSecurityProxy(IEvaluations(person))
for event in ISchoolToolCalendar(section):
requirement = AttendanceRequirement(removeSecurityProxy(event))
score = evaluations.get(requirement)
if not score:
continue
yield event, score
def collectAttendance(self, attr):
days = {}
for term, section in self.sections:
for event, score in self.getEventAttendanceScores(section):
if (not IAttendanceScoreSystem.providedBy(score.scoreSystem) or
not getattr(score.scoreSystem, attr)(score)):
continue
days.setdefault(event.dtstart.date(), []).append(
(event.dtstart, event.period.title))
result = []
for day, periods in sorted(days.items()):
result.append({
'day': day,
'period': ', '.join([period for dt, period in sorted(periods)]),
})
return result
@property
def absences(self):
result = self.collectAttendance('isAbsent')
return result
@property
def tardies(self):
result = self.collectAttendance('isTardy')
return result
@property
def participation(self):
result = []
for term, section in self.sections:
average, count = 0, 0
for event, grade in self.getEventGrades(section):
if grade is None:
continue
try:
grade = int(grade)
except ValueError:
continue
average += grade
count += 1
if not count:
continue
average /= float(count)
result.append({
'term': term.title,
'section': section.title,
'average': '%.1f' % average,
})
return result
class FlourishSchoolAttendanceView(flourish.page.Page):
content_template = InlineViewPageTemplate('''
''')
container_class = 'container widecontainer'
@Lazy
def year(self):
year = self.request.get('year', '').strip()
if year:
try:
year = int(year)
except ValueError:
pass
if not year:
dateman = getUtility(IDateManager)
year = dateman.today.year
return year
@Lazy
def month(self):
month = self.request.get('month', '').strip()
if month:
try:
month = int(month)
except ValueError:
pass
if not month:
dateman = getUtility(IDateManager)
month = dateman.today.month
return month
@Lazy
def schoolyears(self):
years = []
for term in self.terms:
year = term.__parent__
if year not in years:
years.append(year)
return years
@Lazy
def terms(self):
terms = ITermContainer(None, {})
selected = set()
year = self.year
month = self.month
for day in filter(None, calendar.Calendar().itermonthdays(year, month)):
date = datetime.date(year, month, day)
for term in terms.values():
if date in term and term not in selected:
selected.add(term)
return sorted(selected, key=lambda term: term.first)
@Lazy
def group(self):
params = self.request.get('group', '').strip().split('.')
if len(params) != 2:
return None
year_id, group_id = params
if year_id not in [year.__name__ for year in self.schoolyears]:
return None
app = ISchoolToolApplication(None)
year = ISchoolYearContainer(app).get(year_id)
if year is None:
return None
group = IGroupContainer(year).get(group_id)
return group
@Lazy
def instructor(self):
username = self.request.get('instructor', '').strip()
app = ISchoolToolApplication(None)
return app['persons'].get(username)
def updateJournalMode(self):
person = IPerson(self.request.principal, None)
if person is None:
return
mode = getCurrentJournalMode(person) or ''
if mode == 'journal-mode-school-attendance':
return
setCurrentJournalMode(person, 'journal-mode-school-attendance')
def update(self):
self.updateJournalMode()
super(FlourishSchoolAttendanceView, self).update()
@Lazy
def name_sorting_columns(self):
return getUtility(IPersonFactory).columns()
class AttendanceFilter(table.ajax.IndexedTableFilter):
def instructorSections(self, instructor, terms):
sections = set()
for section in Instruction.query(instructor=self.view.instructor):
term = ITerm(section)
if term not in terms:
continue
sections.add(section)
return sections
def termSections(self, terms):
sections = set()
for term in self.view.terms:
container = ISectionContainer(term)
for section in container.values():
if section not in sections:
sections.add(section)
return sections
def availableSections(self):
instructor = self.view.instructor
terms = set([removeSecurityProxy(term) for term in self.view.terms])
if instructor:
sections = self.instructorSections(instructor, terms)
return sections
if terms:
sections = self.termSections(terms)
return sections
return None
@Lazy
def section_student_ids(self):
sections = self.availableSections()
if sections is None:
return None
int_ids = getUtility(IIntIds)
ids = {}
for section in sections:
unsecure_section = removeSecurityProxy(section)
for person in unsecure_section.members:
if person in ids:
continue
intid = int_ids.queryId(person, None)
if intid is None:
continue
ids[person] = intid
return set(ids.values())
def filterBySection(self, items):
available_ids = self.section_student_ids
if available_ids is None:
return items
return [item for item in items if item['id'] in available_ids]
def filterByGroup(self, items):
if not self.view.group:
return items
int_ids = getUtility(IIntIds)
group_person_ids = set([
int_ids.queryId(person)
for person in self.view.group.members
])
items = [item for item in items
if item['id'] in group_person_ids]
return items
def filter(self, items):
items = self.filterBySection(items)
items = self.filterByGroup(items)
if self.ignoreRequest:
return items
return table.ajax.IndexedTableFilter.filter(self, items)
class AttendanceTable(table.ajax.IndexedTable):
no_default_url_cell_formatter = True
form_class = 'grid-form'
form_id = 'grid-form'
def columns(self):
return getUtility(IPersonFactory).columns()
def sortOn(self):
return getUtility(IPersonFactory).sortOn()
class AttendanceTableTable(flourish.viewlet.Viewlet):
template = flourish.templates.HTMLFile('templates/f_school_attendance.pt')
persons = None
def extractItems(self):
formatter = self.manager.makeFormatter()
self.persons = [
table.catalog.unindex(item)
for item in formatter.getItems()
]
def render(self, *args, **kw):
self.extractItems()
return self.template()
@Lazy
def batch(self):
params = {'start': None,
'size': None,
'postfix': self.manager.__name__}
batch = self.manager.get('batch')
if batch is not None:
params['start'] = getattr(batch, 'start', None)
params['size'] = getattr(batch, 'size', None)
return params
class FlourishSchoolAttendanceGradebook(flourish.content.ContentProvider,
FlourishSectionHomeroomAttendance):
no_periods_text = _("There are no school days this month.")
def __init__(self, context, request, view):
flourish.content.ContentProvider.__init__(self, context, request, view)
FlourishSectionHomeroomAttendance.__init__(self, context, request)
def update(self):
app = ISchoolToolApplication(None)
self.tzinfo = pytz.timezone(IApplicationPreferences(app).timezone)
meetings = self.all_meetings
if not meetings:
self.no_periods = True
self.render_journal = False
return
self.updateJournalMode()
if 'UPDATE_SUBMIT' in self.request:
self.updateGradebook()
def getSelectedTerm(self):
return None
@Lazy
def selected_terms(self):
table = self.view
return table.view.terms
@property
def selected_year(self):
table = self.view
return table.view.year
@property
def selected_month(self):
table = self.view
return table.view.month
def members(self):
return self.view.persons
def allMeetings(self):
terms = removeSecurityProxy(self.selected_terms)
if not terms:
return ()
year = self.selected_year
month = self.selected_month
dates = [self.tzinfo.localize(datetime.datetime(year, month, day))
for day in calendar.Calendar().itermonthdays(year, month)
if day]
meetings = []
for dt in dates:
date = dt.date()
for term in terms:
if date in term and term.isSchoolday(date):
# meeting duration is not precise - some days are not 24 hours long
meetings.append(makeSchoolAttendanceMeeting(dt))
return meetings
def getScores(self, person):
if person in self._grade_cache:
return list(self._grade_cache[person])
self._grade_cache[person] = result = []
unique_meetings = set()
terms = self.selected_terms
events = list(self.all_meetings)
sorted_events = sorted(events, key=lambda e: e.dtstart)
unproxied_person = removeSecurityProxy(person)
for event in sorted_events:
date = event.dtstart.date()
if not any([date in term for term in terms]):
continue
unproxied_event = removeSecurityProxy(event)
requirement = self.makeRequirement(unproxied_event)
score = IEvaluateRequirement(requirement).getEvaluation(
unproxied_person, requirement, default=UNSCORED)
if (event.meeting_id not in unique_meetings and
score is not UNSCORED):
result.append(score)
unique_meetings.add(event.meeting_id)
return result
class FlourishAttendanceValidateScoreView(flourish.ajax.AJAXPart):
def render(self):
if not self.fromPublication:
return ''
data = self.validate_score()
json = self.setJSONResponse(data)
return json
@property
def requirement(self):
activity_id = self.request.get('activity_id')
if activity_id is None:
return None
dts = base64.decodestring(activity_id.strip())
try:
dt = dateutil.parser.parse(dts)
except ValueError:
return None
meeting = makeSchoolAttendanceMeeting(dt)
requirement = HomeroomRequirement(meeting)
return requirement
def validate_score(self):
score = self.request.get('score')
result = {'is_valid': True,
'is_extracredit': False}
requirement = self.requirement
if requirement is None:
result['is_valid'] = False
else:
result['is_valid'] = requirement.score_system.isValidScore(score)
return result
class RefineFormManager(flourish.page.ContentViewletManager):
template = flourish.templates.Inline("""
""")
class OptionalViewlet(flourish.viewlet.Viewlet):
enabled = True
def render(self, *args, **kw):
if not self.enabled:
return ''
return self.template(*args, **kw)
class FlourishSchoolAttendanceDateNavigation(flourish.page.RefineLinksViewlet):
"""School attendance date navigation viewlet."""
class FlourishSchoolAttendanceYearMonthPicker(OptionalViewlet):
template = InlineViewPageTemplate('''
''')
def years(self):
this_year = self.view.year
terms = ITermContainer(None)
min_year = min([this_year] +
[term.first.year for term in terms.values() if term.first])
max_year = max([this_year] +
[term.last.year for term in terms.values() if term.last])
years = [{'selected': year == this_year,
'title': str(year),
'value': str(year)}
for year in range(min_year, max_year+1)]
return years
def months(self):
this_month = self.view.month
months = [{'selected': month == this_month,
'title': title,
'value': str(month)}
for month, title in month_names.items()]
return months
def terms(self):
return self.view.terms
class FlourishSchoolAttendanceTermNavigation(flourish.page.RefineLinksViewlet):
"""School attendance date navigation viewlet."""
class FlourishSchoolAttendanceCurrentTerm(OptionalViewlet):
@property
def enabled(self):
return bool(self.view.terms)
class FlourishSchoolAttendanceGroupNavigation(flourish.page.RefineLinksViewlet):
"""School attendance date navigation viewlet."""
class FlourishSchoolAttendanceGroupPicker(OptionalViewlet):
@property
def enabled(self):
return any([len(year['groups']) for year in self.groups_by_year])
@Lazy
def groups_by_year(self):
result = []
selected_group = self.view.group
selected_key = None
if self.view.group:
selected_key = '%s.%s' % (
ISchoolYear(selected_group.__parent__).__name__,
selected_group.__name__)
collator = ICollator(self.request.locale)
for year in self.view.schoolyears:
key = lambda g: '%s.%s' % (year.__name__, g.__name__)
groups = sorted(IGroupContainer(year).values(),
key=lambda g: collator.key(g.title))
result.append({
'title': year.title,
'groups': [
{'title': group.title,
'value': key(group),
'selected': key(group) == selected_key}
for group in groups],
})
return result
class FlourishSchoolAttendanceInstructorNavigation(flourish.page.RefineLinksViewlet):
"""School attendance date navigation viewlet."""
class FlourishSchoolAttendanceInstructorPicker(OptionalViewlet):
@property
def enabled(self):
return len(self.instructors)
@Lazy
def instructors(self):
instructors = set()
selected_instructor = self.view.instructor
selected_username = selected_instructor and selected_instructor.__name__
for term in self.view.terms:
sections = ISectionContainer(term)
for section in sections.values():
if len(section.members):
instructors.update(section.instructors)
collator = ICollator(self.request.locale)
factory = getUtility(IPersonFactory)
sorting_key = lambda x: factory.getSortingKey(x, collator)
instructors = sorted(instructors, key=sorting_key)
result = [
{'title': instructor.title,
'value': instructor.__name__,
'selected': instructor.__name__ == selected_username,
}
for instructor in instructors]
return result
class SSValidationError(Exception):
message = None
def __init__(self, msg):
self.message = msg
Exception.__init__(self)
class FlourishAttendanceScoreSystemAddView(BrowserView):
"""A view for adding a custom score system"""
def update(self):
self.message = ''
if 'form-submitted' in self.request:
if 'CANCEL' in self.request:
self.request.response.redirect(self.nextURL())
try:
self.validateForm()
except SSValidationError, e:
self.message = e.message
return
if 'UPDATE_SUBMIT' in self.request:
try:
self.validateScores()
except SSValidationError, e:
self.message = e.message
return
target = self.createScoreSystem()
self.addScoreSystem(target)
self.request.response.redirect(self.nextURL())
def addScoreSystem(self, target):
chooser = INameChooser(self.context)
name = chooser.chooseName(target.title, target)
self.context[name] = target
def nextURL(self):
return absoluteURL(self.context, self.request)
def scores(self):
rownum = 1
results = []
for value, title, absence, excused in self.getRequestScores():
results.append(self.buildScoreRow(rownum, value, title, absence, excused))
rownum += 1
results.append(self.buildScoreRow(rownum, '', '', '', ''))
return results
def buildScoreRow(self, rownum, value, title, absence, excused):
return {
'value_name': 'value' + unicode(rownum),
'value': value,
'title_name': 'title' + unicode(rownum),
'title_value': title,
'absence_name': 'absence' + unicode(rownum),
'present': not absence and 'selected',
'absent': absence == 'a' and 'selected',
'tardy': absence == 't' and 'selected',
'excused_name': 'excused' + unicode(rownum),
'excused': excused and 'checked',
}
def getRequestScores(self):
rownum = 0
results = []
while True:
rownum += 1
value_name = 'value' + unicode(rownum)
title_name = 'title' + unicode(rownum)
absence_name = 'absence' + unicode(rownum)
excused_name = 'excused' + unicode(rownum)
if value_name not in self.request:
break
if not len(self.request[value_name]):
continue
results.append((self.request[value_name],
self.request[title_name],
self.request[absence_name],
bool(self.request.get(excused_name))))
return results
def validateForm(self):
title = self.request.get('title', '').strip()
if not len(title):
raise SSValidationError(_('The title field must not be empty'))
self.validTitle = title
scores = []
for value, title, absence, excused in self.getRequestScores():
value = value.strip()
title = title.strip()
scores.append([value, title, absence, excused])
self.validScores = scores
def validateScores(self):
if len(self.validScores) < 1:
raise SSValidationError(_('A score system must have at least one value.'))
all_values = set()
all_titles = set()
for value, title, absence, excused in self.validScores:
if value.lower() in all_values:
raise SSValidationError(_('Duplicate value: ${value}',
mapping={'value': value}))
all_values.add(value.lower())
if not title.strip():
raise SSValidationError(_('Title required for: ${value}',
mapping={'value': value}))
if title in all_titles:
raise SSValidationError(_('Duplicate title: ${title}',
mapping={'title': title}))
all_titles.add(title)
def createScoreSystem(self):
scores = tuple([(s[0], s[1]) for s in self.validScores])
tag_absent = tuple([s[0] for s in self.validScores if s[2] == 'a'])
tag_tardy = tuple([s[0] for s in self.validScores if s[2] == 't'])
tag_excused = tuple([s[0] for s in self.validScores if s[3]])
target = PersistentAttendanceScoreSystem(self.validTitle,
scores=scores,
tag_absent=tag_absent,
tag_tardy=tag_tardy,
tag_excused=tag_excused)
return target
class FlourishAttendanceScoreSystemView(BrowserView):
"""A view for adding a custom score system"""
@property
def subtitle(self):
return self.scoresystem.title
@property
def scoresystem(self):
return self.context
def scores(self):
scoresystem = self.scoresystem
results = []
for score in self.context.scores:
tags = []
value = score[0]
if value in scoresystem.tag_absent:
tags.append(_('Absent'))
if value in scoresystem.tag_tardy:
tags.append(_('Tardy'))
if not tags:
tags.append(_('Present'))
if value in scoresystem.tag_excused:
tags.append(_('Excused'))
tags = ', '.join([translate(t, self.request)
for t in tags])
results.append({
'value': score[0],
'description': score[1],
'tags': tags,
})
return results
def done_link(self):
return absoluteURL(self.context.__parent__, self.request)
class EditDefaultJournalScoreSystems(flourish.form.Form, z3c.form.form.EditForm):
fields = z3c.form.field.Fields(IJournalScoreSystemPreferences)
legend = _('Customize')
def updateActions(self):
super(EditDefaultJournalScoreSystems, self).updateActions()
self.actions['apply'].addClass('button-ok')
self.actions['cancel'].addClass('button-cancel')
@z3c.form.button.buttonAndHandler(s_('Save'), name="apply")
def handle_apply_action(self, action):
super(EditDefaultJournalScoreSystems,self).handleApply.func(self, action)
if (self.status == self.successMessage or
self.status == self.noChangesMessage):
self.request.response.redirect(self.nextURL())
@z3c.form.button.buttonAndHandler(s_('Cancel'))
def handle_cancel_action(self, action):
self.request.response.redirect(self.nextURL())
def nextURL(self):
return absoluteURL(self.context, self.request)
def getContent(self):
app = ISchoolToolApplication(None)
prefs = IJournalScoreSystemPreferences(app)
return prefs
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/browser/__init__.py 0000644 0001750 0001750 00000000002 12270520456 031521 0 ustar menesis menesis 0000000 0000000 #
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/browser/resources/ 0000775 0001750 0001750 00000000000 12331774365 031444 5 ustar menesis menesis 0000000 0000000 schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/browser/resources/journal_non_ie.css 0000644 0001750 0001750 00000000215 12270520456 035143 0 ustar menesis menesis 0000000 0000000 /* styles for the gradebook that IE should not be seeing */
.gradebook TABLE.data {
border-spacing: 0px;
border-collapse: separate;
}
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/browser/resources/journal.css 0000644 0001750 0001750 00000002763 12270520456 033626 0 ustar menesis menesis 0000000 0000000 /* styles for the gradebook */
.gradebook TABLE {
border-top: solid 1px #bbb;
border-bottom: solid 1px #bbb;
}
.gradebook TABLE.data {
border-spacing: 0px;
}
.gradebook TABLE.data TD
{
border-left: 1px solid #BBB;
}
.gradebook TD span.today {
background-color: #EAFAE3;
}
.gradebook TABLE.data TD.selected-column
{
border-left: 1px dashed #000;
border-right: 1px dashed #000;
}
.gradebook TABLE.data TD.selected-cell
{
border: solid 1px #000;
}
.gradebook TABLE.data TD.selected-row
{
border-top: 1px dashed #000;
border-bottom: 1px dashed #000;
}
div.gradebook_content {
float: left;
}
.gradebook_content div.month_tabs {
padding-top: 1ex;
padding-bottom: .5ex;
}
.gradebook_content span.active_tab {
border-left: solid 1px #bbb;
border-top: solid 1px #bbb;
border-bottom: solid 1px #bbb;
padding: .5ex;
background-color: #eee;
width: 90px;
text-align: center;
}
.gradebook_content span.inactive_tab {
border-left: solid 1px #bbb;
border-top: solid 1px #bbb;
border-bottom: solid 1px #bbb;
padding: .5ex;
background-color: #ddd;
width: 90px;
text-align: center;
}
.gradebook_content span.term_tab {
border-right: solid 1px #bbb;
}
.gradebook table th {
border-left: 1px solid #BBB;
background: #ddd;
}
/* overrides colors in schooltool.css to match other gradebooks */
.gradebook_content tr.odd {
background-color: #eee;
}
.gradebook_content tr.even {
background-color: #ddd;
}
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/browser/resources/f_journal.css 0000644 0001750 0001750 00000000071 12270520456 034121 0 ustar menesis menesis 0000000 0000000 .grades thead th, .grades tbody td {
width: 2.5em;
}
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/browser/flourish.zcml 0000644 0001750 0001750 00000047131 12270520456 032150 0 ustar menesis menesis 0000000 0000000
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/browser/table.py 0000644 0001750 0001750 00000010462 12270520456 031064 0 ustar menesis menesis 0000000 0000000 #
# SchoolTool - common information systems platform for school administration
# Copyright (c) 2007 Shuttleworth Foundation
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
#
"""
Common code for journal view table display.
"""
import urllib
from zope.formlib.widget import quoteattr
from zope.interface import implementer
from zope.component import adapter
from zope.traversing.browser.absoluteurl import absoluteURL
from zc.table import table
from schooltool.table.interfaces import IIndexedColumn
from schooltool.table.catalog import makeIndexedColumn
from schooltool.table.catalog import RenderUnindexingMixin, unindex
from schooltool.lyceum.journal.browser.interfaces import IIndependentColumn
from schooltool.lyceum.journal.browser.interfaces import ISelectableColumn
class SelectStudentCellFormatter(object):
extra_info = ['event_id', 'month', 'date', 'TERM']
def __init__(self, context):
self.context = context
def extra_parameters(self, request):
parameters = []
for info in self.extra_info:
if info in request:
parameters.append((info, request[info].encode('utf-8')))
return parameters
def __call__(self, value, item, formatter):
request = formatter.request
url = absoluteURL(self.context, request)
url = "%s/index.html?%s" % (
url,
urllib.urlencode([('student', item.__name__.encode('utf-8'))] +
self.extra_parameters(request)))
return '%s' % (url, value)
class SelectableRowTableFormatter(table.FormFullFormatter):
def __init__(self, *args, **kwargs):
self.selected_items = kwargs.pop("selected_items", [])
super(SelectableRowTableFormatter, self).__init__(*args, **kwargs)
def renderCell(self, item, column):
sc = IIndependentColumn(column, None)
if sc:
return self.getCell(item, column)
return super(SelectableRowTableFormatter, self).renderCell(item, column)
def renderSelectedCells(self, item):
return ''.join([self.renderSelectedCell(item, col)
for col in self.visible_columns])
def renderSelectedCell(self, item, column):
sc = ISelectableColumn(column, None)
if sc:
ic = IIndependentColumn(sc, None)
if ic:
return sc.renderSelectedCell(item, self)
else:
return ' \n%s \n' % (
self._getCSSClass('td'), sc.renderSelectedCell(item, self))
return self.renderCell(item, column)
def _renderRow(self, item):
return super(SelectableRowTableFormatter, self).renderRow(item)
def renderSelectedRow(self, item):
self.row += 1
klass = self.cssClasses.get('tr', '')
if klass:
klass += ' '
return '
\n%s
\n' % (
quoteattr(klass + self.row_classes[self.row % 2]),
self.renderSelectedCells(item))
def renderRow(self, item):
if item in self.selected_items:
return self.renderSelectedRow(item)
return self._renderRow(item)
def viewURL(context, request, name, parameters=[]):
url = absoluteURL(context, request)
return "%s/%s?%s" % (url, name, urllib.urlencode(parameters))
class SelectableColumnUnindexingMixin(object):
def renderSelectedCell(self, indexed_item, formatter):
return super(SelectableColumnUnindexingMixin, self).renderSelectedCell(
unindex(indexed_item), formatter)
@adapter(ISelectableColumn)
@implementer(IIndexedColumn)
def getIndexedSelectableColumn(column):
column = makeIndexedColumn(
[RenderUnindexingMixin, SelectableColumnUnindexingMixin], column)
return column
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/browser/attendance.py 0000644 0001750 0001750 00000036577 12270520456 032122 0 ustar menesis menesis 0000000 0000000 #
# SchoolTool - common information systems platform for school administration
# Copyright (c) 2007 Shuttleworth Foundation
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
#
"""
Lyceum attendance views.
"""
from zope.browserpage.viewpagetemplatefile import ViewPageTemplateFile
from zope.cachedescriptors.property import CachedProperty
from zope.component import getUtility
from zope.component import queryMultiAdapter
from zope.i18n import translate
from zope.interface import implements
from zope.formlib.widget import quoteattr
from zope.cachedescriptors.property import Lazy
from zc.table.interfaces import IColumn
from schooltool.app.interfaces import ISchoolToolApplication
from schooltool.app.interfaces import ISchoolToolCalendar
from schooltool.common import parse_date
from schooltool.course.interfaces import ILearner
from schooltool.table.interfaces import ITableFormatter
from schooltool.term.interfaces import ITermContainer
from schooltool.term.interfaces import IDateManager
from schooltool.lyceum.journal.browser.interfaces import IIndependentColumn
from schooltool.lyceum.journal.browser.interfaces import ISelectableColumn
from schooltool.lyceum.journal.browser.journal import LyceumSectionJournalView
from schooltool.lyceum.journal.browser.table import viewURL
from schooltool.lyceum.journal.browser.table import SelectableRowTableFormatter
from schooltool.lyceum.journal.browser.table import SelectStudentCellFormatter
from schooltool.lyceum.journal.browser.journal import StudentSelectionMixin
from schooltool.lyceum.journal.interfaces import ISectionJournal
from schooltool.lyceum.journal.interfaces import ISectionJournalData
from schooltool.lyceum.journal import LyceumMessage as _
class AttendanceTableFormatter(SelectableRowTableFormatter):
def renderSelectedCells(self, item):
cells = ''.join([self.renderSelectedCell(item, col)
for col in self.visible_columns[1:]])
return "
' % absences
def extra_parameters(self, request):
parameters = []
for info in ['TERM', 'month', 'student']:
if info in request:
parameters.append((info, request[info]))
return parameters
def renderHeader(self, formatter):
header = self.date.strftime("%d")
parameters = [('date', self.date)] + self.extra_parameters(formatter.request)
url = viewURL(self.group, formatter.request,
name='attendance.html',
parameters=parameters)
header = '%s' % (url, header)
return '%s' % (
self.date.strftime("%Y-%m-%d"), header)
def renderSelectedCell(self, student, formatter):
absences = 0
for meeting in self.meetings:
journal = ISectionJournal(meeting)
if journal.isAbsent(student, meeting):
absences += 1
name = student.__name__ + "." + self.date.strftime("%Y-%m-%d")
value = True
for meeting in self.meetings:
calendar = meeting.__parent__
owner = calendar.__parent__
if student in owner.members:
value = value and ISectionJournalData(owner).getAbsence(student, meeting)
if absences == 0:
return '
'
else:
cell_content = '' % (name, value and 'checked="checked"' or '')
if value:
cell_content += '' % name
return '
%s
' % cell_content
class AttendanceTotalColumn(object):
implements(IColumn, IIndependentColumn)
def __init__(self, days):
self.days = days
self.name = "total"
def renderCell(self, student, formatter):
absences = 0
for date, meetings in self.days.items():
for meeting in meetings:
journal = ISectionJournal(meeting)
if journal.isAbsent(student, meeting):
absences += 1
if absences == 0:
return '
'
else:
return '
%s
' % str(absences)
def renderHeader(self, formatter):
return '%s' % translate(_("Total"), context=formatter.request)
class PeriodAttendanceColumn(object):
implements(ISelectableColumn, IIndependentColumn)
def __init__(self, meeting_id, meetings):
self.meetings = meetings
self.name = meeting_id
def renderCell(self, student, formatter):
absences = []
for meeting in self.meetings:
journal = ISectionJournal(meeting)
if journal.isAbsent(student, meeting):
absences.append(meeting)
if absences == []:
return '
'
else:
calendar = meeting.__parent__
owner = calendar.__parent__
absence_titles = [translate(owner.label, context=formatter.request)
for meeting in absences]
return '
n
'
def renderSelectedCell(self, student, formatter):
absences = []
for meeting in self.meetings:
journal = ISectionJournal(meeting)
if journal.isAbsent(student, meeting):
absences.append(meeting)
if absences == []:
return '
'
else:
name = student.__name__ + "." + self.name
value = False
for meeting in self.meetings:
calendar = meeting.__parent__
owner = calendar.__parent__
if student in owner.members:
value = value or ISectionJournalData(owner).getAbsence(student, meeting)
absence_titles = [translate(owner.label, context=formatter.request)
for meeting in absences]
cell_content = '' % (name, value and 'checked="checked"' or '')
if value:
cell_content += '' % name
return '
%s
' % cell_content
def renderHeader(self, formatter):
title = None
for meeting in self.meetings:
period = getattr(meeting, 'period', None)
if period is not None:
title = period.title
break
if title is None:
for meeting in self.meetings:
m_title = getattr(meeting, 'title', None)
if m_title is not None:
title = m_title
break
title = title or self.name
return '%s' % title
class GroupAttendanceView(LyceumSectionJournalView, StudentSelectionMixin):
"""A view for a section journal."""
template = ViewPageTemplateFile("templates/attendance.pt")
@property
def scheduled_terms(self):
terms = ITermContainer(self.context)
return sorted(terms.values(), key=lambda t: t.last)
def monthsInSelectedTerm(self):
month = -1
for date, meetings in sorted(self.allDays.items()):
if (date in self.getSelectedTerm() and
date.month != month):
yield date.month
month = date.month
def _setAbsence(self, student, meeting, id):
calendar = meeting.__parent__
owner = calendar.__parent__
marker = id + ".marker"
if id in self.request:
if student in owner.members:
ISectionJournal(meeting).setAbsence(student, meeting,
explained=True)
elif marker in self.request:
if student in owner.members:
ISectionJournal(meeting).setAbsence(student, meeting,
explained=False)
def updateDayAttendance(self, student):
for meeting in self.allDays[self.selectedDate()]:
id = student.__name__ + "." + meeting.meeting_id
self._setAbsence(student, meeting, id)
def updateMonthAttendance(self, student):
for date, meetings in self.days():
id = student.__name__ + "." + date.strftime("%Y-%m-%d")
for meeting in meetings:
self._setAbsence(student, meeting, id)
def updateAttendance(self):
student_id = self.request.get('student', None)
student = None
if student_id:
app = ISchoolToolApplication(None)
student = app['persons'].get(student_id)
if student:
if self.selectedDate():
self.updateDayAttendance(student)
else:
self.updateMonthAttendance(student)
def __call__(self):
if 'UPDATE_SUBMIT' in self.request:
self.updateAttendance()
app = ISchoolToolApplication(None)
person_container = app['persons']
self.attendance_table = queryMultiAdapter((person_container, self.request),
ITableFormatter)
self.selectStudents(self.attendance_table)
self.attendance_table.setUp(items=self.context.members,
formatters=[AttendanceSelectStudentCellFormatter(self.context)] * 2,
columns_after=self.attendanceColumns(),
batch_size=0,
table_formatter=self.createAttendanceTableFormatter)
return self.template()
def createAttendanceTableFormatter(self, *args, **kwargs):
kwargs['selected_items'] = self.selected_students
return AttendanceTableFormatter(*args, **kwargs)
@CachedProperty
def allDays(self):
students = list(self.context.members)
sections = set()
for person in students:
for section in ILearner(person).sections():
sections.add(section)
calendars = [ISchoolToolCalendar(section)
for section in list(sections)]
days = {}
for calendar in calendars:
for event in calendar:
date = event.dtstart.date()
days.setdefault(date, [])
days[date].append(event)
return days
def days(self):
for date, meetings in sorted(self.allDays.items()):
if date.month == self.active_month:
yield (date, meetings)
def attendanceColumns(self):
columns = []
if self.selectedDate():
for date, meetings in self.days():
if date == self.selectedDate():
meetings = sorted(meetings)
periods = []
period = []
meeting_id = meetings[0].meeting_id
for meeting in meetings:
if meeting_id == meeting.meeting_id:
period.append(meeting)
else:
periods.append((meeting_id, period))
meeting_id = meeting.meeting_id
period = [meeting]
if period:
periods.append((meeting_id, period))
for meeting_id, meetings in periods:
columns.append(PeriodAttendanceColumn(meeting_id, meetings))
else:
for date, meetings in self.days():
columns.append(AttendanceColumn(self.context, date, meetings))
columns.append(AttendanceTotalColumn(self.allDays))
return columns
def getSelectedTerm(self):
terms = ITermContainer(self.context)
term_id = self.request.get('TERM', None)
if term_id:
term = terms[term_id]
if term in self.scheduled_terms:
return term
return self.getCurrentTerm()
def monthURL(self, month_id):
parameters = [('month', month_id)] + self.extra_parameters(self.request)
return viewURL(self.context, self.request,
name='attendance.html',
parameters=parameters)
def selectedDate(self):
str_date = self.request.get('date', None)
if str_date:
return parse_date(str_date)
return None
def getCurrentTerm(self):
date = self.selectedDate()
if not date:
date = getUtility(IDateManager).today
for term in self.scheduled_terms:
if date in term:
return term
# should return last term closest to the selectedDate()
return self.scheduled_terms[-1]
@Lazy
def active_month(self):
available_months = list(self.monthsInSelectedTerm())
if 'month' in self.request:
month = int(self.request['month'])
if month in available_months:
return month
term = self.getSelectedTerm()
date = self.selectedDate()
if not date:
date = getUtility(IDateManager).today
if term.first <= date <= term.last:
month = date.month
if month in available_months:
return month
if not available_months:
return None
return available_months[-1]
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/browser/configure.zcml 0000644 0001750 0001750 00000006471 12270520456 032300 0 ustar menesis menesis 0000000 0000000
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/browser/templates/ 0000775 0001750 0001750 00000000000 12331774365 031430 5 ustar menesis menesis 0000000 0000000 schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/browser/templates/f_journal_history.pt0000644 0001750 0001750 00000003232 12270520456 035523 0 ustar menesis menesis 0000000 0000000
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/browser/templates/journal_js.pt 0000644 0001750 0001750 00000015425 12270520456 034140 0 ustar menesis menesis 0000000 0000000 var selected_cell = null;
var old_grade = null;
var grade = null;
function unselectCell() {
if (selected_cell) {
var cell = selected_cell;
if (grade != old_grade) {
$.ajax({
url: here + 'ajax.xml',
type: 'POST',
timeout: 5000,
data: {event_id: cell.event_id,
person_id: cell.person_id,
grade: grade},
error: function() {
changeBackgroundColor(cell, 'error_bg');
cell.modified_failure = true;
},
success: function(xml){
changeBackgroundColor(cell, 'changed_bg');
cell.modified_success = true;
}
});
}
$(cell).removeClass('selected-cell');
selected_cell = null;
old_grade = null;
grade = null;
}
}
function selectCell(cell) {
unselectCell();
//var value = $.trim(cell.textContent);
var value = $.trim(cell.innerHTML);
old_grade = value;
grade = value;
$(cell).addClass('selected-cell');
selected_cell = cell;
}
function changeBackgroundColor(obj, klass) {
$(obj).removeClass('default_bg');
$(obj).removeClass('changed_bg');
$(obj).removeClass('error_bg');
$(obj).addClass(klass);
}
$(document).ready(function(){
$(".data").click(function(event){
if (event.target.person_id &&
event.target.event_id)
{
if (selected_cell != event.target) {
selectCell(event.target);
return false;
}
}
});
$(".select-column").click(function(event){
var cell_index = this.parentNode.cellIndex;
$(".gradebook .data .selected-column").removeClass('selected-column');
$(".gradebook .data .selected-row").removeClass('selected-row');
$(".gradebook .data TR").each(function (index) {
var cell = this.getElementsByTagName('td')[cell_index];
if (cell) {
$(cell).addClass("selected-column");
}
});
var event_id = null;
var inputs = $(event.target.parentNode).children(".event_id");
if (inputs.length > 0) {
event_id = inputs[0].value;
}
return false;
});
$(".select-column").each(function (index) {
$(this).css('cursor', 'pointer');
if ($(this).children().length > 0) {
$(this).html($($(this).children()[0]).html());
}
});
$(".select-row").click(function (event) {
$(".gradebook .data .selected-column").removeClass('selected-column');
$(".gradebook .data .selected-row").removeClass('selected-row');
$(event.target.parentNode.parentNode).children("TD").each(function (index) {
if (this.event_id && this.person_id) {
$(this).addClass("selected-row");
}
});
return false;
});
$(document).keydown(function (event) {
if (selected_cell && !event.ctrlKey && !event.altKey) {
if (event.which == 37) { // left
index = selected_cell.cellIndex;
tr = selected_cell.parentNode;
new_td = tr.getElementsByTagName('td')[index-1];
if (new_td.event_id && new_td.person_id) {
selectCell(new_td);
return false;
}
}
if (event.which == 38) { // up
index = selected_cell.cellIndex;
tr = selected_cell.parentNode;
next_tr = null;
next_tr = tr.previousSibling;
if (next_tr.nodeName != 'TR')
next_tr = next_tr.previousSibling;
if (!next_tr) return true;
new_td = next_tr.getElementsByTagName('td')[index];
if (new_td.event_id && new_td.person_id) {
selectCell(new_td);
return false;
}
}
if (event.which == 39) { // right
index = selected_cell.cellIndex;
tr = selected_cell.parentNode;
new_td = tr.getElementsByTagName('td')[index+1];
if (new_td.event_id && new_td.person_id) {
selectCell(new_td);
return false;
}
}
if (event.which == 40) { // down
index = selected_cell.cellIndex;
tr = selected_cell.parentNode;
next_tr = tr.nextSibling;
if (next_tr.nodeName != 'TR')
next_tr = next_tr.nextSibling;
if (!next_tr) return true;
new_td = next_tr.getElementsByTagName('td')[index];
if (new_td.event_id && new_td.person_id) {
selectCell(new_td);
return false;
}
}
if (event.which == 8 || event.which == 46) { // Backspace, Del
grade = '';
$(selected_cell).html(grade);
return false;
}
}
});
$(document).keypress(function (event) {
if (selected_cell && !event.ctrlKey && !event.altKey) {
if (event.which == 13) { // enter
var selection = $(".selected-column");
var selected_rows = $(".selected-row");
if (selected_rows.length > selection.length) {
selection = selected_rows;
}
var item = 0;
if (selection.length != 0) {
selection.each(function (index) {
if (this == selected_cell) {
item = index + 1;
}
});
unselectCell();
if (item < selection.length)
selectCell(selection[item]);
} else {
unselectCell();
}
return false;
}
if (event.which == 27) { // esc
grade = old_grade;
$(selected_cell).html(grade);
unselectCell();
return false;
}
if (event.which == 32) { // Space
grade = '';
$(selected_cell).html(grade);
return false;
}
// Grade assignment event handling
if () {
grade = ;
$(selected_cell).html(grade);
return false;
}
}
return true;
});
table = $('.data')[0];
rows = table.getElementsByTagName('tr');
var event_ids = Array();
for (var i = 0; i < rows.length; i++) {
row = rows[i];
if (i == 0) {
cells = row.getElementsByTagName('th');
for (var j = 0; j < cells.length; j++) {
cell = cells[j];
inputs = $(cells[j]).children(".event_id");
if (inputs.length > 0) {
event_ids[j] = inputs[0].value;
}
}
}
else
{
cells = row.getElementsByTagName('td');
var person_id = null;
if (cells.length > 0) {
inputs = $(cells[0]).children(".person_id");
if (inputs.length > 0) {
person_id = inputs[0].value;
}
}
for (var j = 0; j < cells.length; j++) {
cell = cells[j];
cell.person_id = person_id;
cell.event_id = event_ids[j];
}
}
}
$(".data INPUT").each(function (index) {
if (this.type == 'text') {
$(this.parentNode).html(this.value);
}
});
});
././@LongLink 0000000 0000000 0000000 00000000147 00000000000 011217 L ustar 0000000 0000000 schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/browser/templates/f_school_attendance.pt schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/browser/templates/f_school_attendance.0000644 0001750 0001750 00000005660 12270520456 035410 0 ustar menesis menesis 0000000 0000000
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/browser/student.py 0000644 0001750 0001750 00000013644 12270520456 031470 0 ustar menesis menesis 0000000 0000000 #
# SchoolTool - common information systems platform for school administration
# Copyright (c) 2007 Shuttleworth Foundation
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
#
"""
Lyceum student journal views.
"""
import urllib
from zope.browserpage.viewpagetemplatefile import ViewPageTemplateFile
from zope.component import queryMultiAdapter
from zope.i18n import translate
from zope.interface import implements
from zope.traversing.browser.absoluteurl import absoluteURL
from zc.table.interfaces import IColumn
from schooltool.term.interfaces import ITermContainer
from schooltool.table.interfaces import ITableFormatter
from schooltool.course.interfaces import ICourseContainer
from schooltool.course.interfaces import ILearner
from schooltool.requirement.scoresystem import UNSCORED
from schooltool.lyceum.journal.browser.journal import LyceumSectionJournalView
from schooltool.lyceum.journal.interfaces import ISectionJournalData
from schooltool.lyceum.journal import LyceumMessage as _
class CourseGradesColumn(object):
implements(IColumn)
def __init__(self, date, student, courses):
self.date = date
self.name = date.strftime("%d")
self.student = student
self.courses = courses
def renderCell(self, course, formatter):
grades = []
for section in self.courses[course.__name__]:
journal = ISectionJournalData(section)
for meeting, score in journal.gradedMeetings(self.student):
if meeting.dtstart.date() == self.date:
if score:
grades.append(unicode(score.value))
return ", ".join(grades)
def renderHeader(self, formatter):
return '%s' % (
self.date.strftime("%Y-%m-%d"), self.date.strftime("%d"))
class CourseTermAverageGradesColumn(object):
def __init__(self, term, student, courses):
self.term = term
self.name = term.__name__ + "average"
self.courses = courses
self.student = student
def courseGrades(self, course):
grades = []
for section in self.courses[course.__name__]:
journal = ISectionJournalData(section)
for meeting, score in journal.gradedMeetings(self.student):
if meeting.dtstart.date() in self.term:
if score:
grade = score.value
try:
grade = score.scoreSystem.getNumericalValue(grade)
except ValueError:
continue
grades.append(grade)
return grades
def renderCell(self, course, formatter):
grades = self.courseGrades(course)
if grades:
return "%.3f" % (sum(grades) / len(grades))
return ""
def renderHeader(self, formatter):
return '%s' % translate(_("Average"),
context=formatter.request)
class LyceumStudentJournalView(LyceumSectionJournalView):
"""A view for a student journal."""
template = ViewPageTemplateFile("templates/student_journal.pt")
def __init__(self, context, request):
self.context, self.request = context, request
self.courses = set()
learner = ILearner(self.context)
for section in learner.sections():
for course in section.courses:
self.courses.add(course)
def __call__(self):
term = self.getSelectedTerm()
course_container = ICourseContainer(term)
self.gradebook = queryMultiAdapter((course_container, self.request),
ITableFormatter)
self.gradebook.setUp(items=self.courses,
columns_after=self.gradeColumns(),
batch_size=0)
return self.template()
def allMeetings(self):
for date in self.getSelectedTerm():
yield date
def meetings(self):
for meeting in self.allMeetings():
if meeting.month == self.active_month:
yield meeting
def gradeColumns(self):
columns = []
learner = ILearner(self.context)
courses = {}
for section in learner.sections():
for course in section.courses:
courses.setdefault(course.__name__, [])
courses[course.__name__].append(section)
for meeting in self.meetings():
columns.append(CourseGradesColumn(meeting, self.context, courses))
columns.append(CourseTermAverageGradesColumn(self.getSelectedTerm(),
self.context, courses))
return columns
@property
def scheduled_terms(self):
terms = ITermContainer(self.context)
scheduled_terms = list(terms.values())
return sorted(scheduled_terms, key=lambda t: t.last)
def monthsInSelectedTerm(self):
month = -1
for meeting in self.allMeetings():
if meeting.month != month:
yield meeting.month
month = meeting.month
def monthURL(self, month_id):
url = absoluteURL(self.context, self.request)
url = "%s/gradebook.html?%s" % (
url,
urllib.urlencode([('month', month_id)] +
self.extra_parameters(self.request)))
return url
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/browser/interfaces.py 0000644 0001750 0001750 00000002252 12270520456 032116 0 ustar menesis menesis 0000000 0000000 #
# SchoolTool - common information systems platform for school administration
# Copyright (c) 2007 Shuttleworth Foundation
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
#
"""
Lyceum journal interfaces.
"""
from zc.table.interfaces import IColumn
from zope.interface import Interface
class IIndependentColumn(Interface):
"""A marker interface for columns that render their own TD tags."""
class ISelectableColumn(IColumn):
"""A column that renders in a special way when the row gets selected."""
def renderSelectedCell(item, formatter):
"""Render the cell for a selected row."""
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/browser/tests/ 0000775 0001750 0001750 00000000000 12331774365 030574 5 ustar menesis menesis 0000000 0000000 schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/browser/tests/__init__.py 0000644 0001750 0001750 00000000002 12270520456 032663 0 ustar menesis menesis 0000000 0000000 #
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/browser/tests/test_journal.py 0000644 0001750 0001750 00000051634 12270520456 033656 0 ustar menesis menesis 0000000 0000000 # -*- coding: utf-8 -*-
#
# SchoolTool - common information systems platform for school administration
# Copyright (c) 2007 Shuttleworth Foundation
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
#
"""
Unit tests for lyceum journal.
"""
import unittest, doctest
from pytz import utc
from datetime import datetime, date
from zope.app.testing import setup
from zope.component import provideAdapter
from zope.interface import implements
from zope.publisher.browser import TestRequest
from zope.traversing.interfaces import IContainmentRoot
from zope.interface import directlyProvides
def doctest_JournalCalendarEventViewlet():
"""Tests for JournalCalendarEventViewlet.
>>> from schooltool.lyceum.journal.browser.journal import JournalCalendarEventViewlet
>>> viewlet = JournalCalendarEventViewlet()
>>> class ManagerStub(object):
... pass
>>> class EFDStub(object):
... pass
>>> class EventStub(object):
... pass
>>> manager = ManagerStub()
>>> manager.event = EFDStub()
>>> manager.event.context = EventStub()
If the event is not adaptable to a journal, nothing is shown:
>>> viewlet.manager = manager
>>> viewlet.attendanceLink() is None
True
Though if it has a journal, you should get a URL for the journal
with the event id passed as a parameter:
>>> from zope.location.location import Location
>>> from schooltool.timetable.interfaces import IScheduleCalendarEvent
>>> from schooltool.lyceum.journal.interfaces import ISectionJournal
>>> class JournalStub(Location):
... __name__ = 'journal'
>>> class TTEventStub(object):
... implements(IScheduleCalendarEvent)
... def __init__(self):
... self.unique_id = "unique&id"
... def __conform__(self, iface):
... if iface == ISectionJournal:
... journal = JournalStub()
... journal.__parent__ = self
... return journal
>>> manager.event.context = TTEventStub()
>>> viewlet.request = TestRequest()
>>> directlyProvides(manager.event.context, IContainmentRoot)
>>> viewlet.attendanceLink()
'http://127.0.0.1/journal/index.html?event_id=unique%26id'
"""
def doctest_StudentNumberColumn_renderCell():
"""Tests for StudentNumberColumn
>>> def print_u(str):
... '''If we want unicode output, we have to convert ALL
... unicode ouput strings to UTF-8, even if they only
... have ASCII characters in them. Stupid doctest.'''
... print unicode(str).encode('UTF-8')
>>> class FormatterStub(object):
... request = TestRequest()
... _row = 0
... @property
... def row(self):
... self._row += 1
... return self._row
>>> formatter = FormatterStub()
>>> class PersonStub(object):
... def __init__(self, name):
... self.__name__ = name
>>> from schooltool.lyceum.journal.browser.journal import StudentNumberColumn
>>> column = StudentNumberColumn("journal", None)
>>> print_u(column.renderCell(PersonStub("john"), formatter))
1
>>> print_u(column.renderCell(PersonStub("bob"), formatter))
2
Does not crash with unicode usernames
>>> print_u(column.renderCell(PersonStub(u"\u017eivil\u0117"), formatter))
3
"""
def doctest_PersonGradesColumn_meetingDate():
"""Tests for PersonGradesColumn.meetingDate
Let's set up an application and it's preferences:
>>> from schooltool.app.interfaces import IApplicationPreferences
>>> from schooltool.app.interfaces import ISchoolToolApplication
>>> class PrefStub(object):
... @property
... def timezone(self):
... return "Europe/Vilnius"
>>> class STAppStub(dict):
... def __init__(self, context):
... pass
... def __conform__(self, iface):
... if iface == IApplicationPreferences:
... return PrefStub()
>>> provideAdapter(STAppStub, adapts=[None], provides=ISchoolToolApplication)
And create a meeting:
>>> class MeetingStub(object):
... 'Meeting Stub'
>>> meeting = MeetingStub()
>>> meeting.unique_id = "unique-id-2006-01-01"
>>> meeting.dtstart = utc.localize(datetime(2006, 1, 1, 10, 15))
Meeting date should be computed according to the timezone that is
set in application preferences:
>>> from schooltool.lyceum.journal.browser.journal import PersonGradesColumn
>>> column = PersonGradesColumn(meeting, "journal")
>>> column.meetingDate()
datetime.date(2006, 1, 1)
So if we shift it close ebough to the day boundary, we get the
next day, because of the timezone difference:
>>> meeting.dtstart = utc.localize(datetime(2006, 1, 1, 23, 15))
>>> column.meetingDate()
datetime.date(2006, 1, 2)
"""
def doctest_PersonGradesColumn_extra_parameters():
"""Tests for PersonGradesColumn.extra_parameters
If there is not data in the request, extra parameter list is
empty:
>>> from schooltool.lyceum.journal.browser.journal import PersonGradesColumn
>>> column = PersonGradesColumn("meeting", "journal")
>>> request = TestRequest()
>>> column.extra_parameters(request)
[]
If we add TERM to the request, it will appear in the list of extra
parameters:
>>> request.form = {'TERM': '2006 Spring'}
>>> column.extra_parameters(request)
[('TERM', '2006 Spring')]
As well as month:
>>> request.form['month'] = 'July'
>>> column.extra_parameters(request)
[('TERM', '2006 Spring'),
('month', 'July')]
Though parameters irrelevant to the person grades column will be
ignored:
>>> request.form['some-other-parameter'] = 'some-value'
>>> column.extra_parameters(request)
[('TERM', '2006 Spring'),
('month', 'July')]
"""
def doctest_PersonGradesColumn_journalUrl():
"""Tests for PersonGradesColumn.journalUrl
>>> from schooltool.lyceum.journal.browser.journal import PersonGradesColumn
>>> class SectionJournalStub(object):
... implements(IContainmentRoot)
... def __init__(self):
... self.__name__ = "section-journal"
... self.__parent__ = None
>>> from schooltool.lyceum.journal.interfaces import ISectionJournal
>>> class MeetingStub(object):
... def __conform__(self, iface):
... if iface == ISectionJournal:
... return SectionJournalStub()
Journal url is the url of the SectionJournal of the context
meeting for this column:
>>> meeting = MeetingStub()
>>> column = PersonGradesColumn(meeting, SectionJournalStub())
>>> request = TestRequest()
>>> column.journalUrl(request)
'http://127.0.0.1/section-journal'
"""
def doctest_PersonGradesColumn_renderHeader():
"""Tests for PersonGradesColumn.renderHeader
>>> from schooltool.lyceum.journal.browser.journal import PersonGradesColumn
>>> class MeetingStub(object):
... pass
>>> meeting = MeetingStub()
>>> meeting.unique_id = 'unique-id-2006-01-01'
>>> column = PersonGradesColumn(meeting, "journal")
>>> class FormatterStub(object):
... request = TestRequest()
>>> formatter = FormatterStub()
>>> column.meetingDate = lambda: date(2006, 1, 1)
>>> column.today = lambda: date(2006, 1, 2)
>>> column.journalUrl = lambda request: 'http://127.0.0.1/section-journal'
>>> column.renderHeader(formatter)
'01'
>>> column.selected = True
>>> column.renderHeader(formatter)
'01'
>>> column.meetingDate = lambda: date(2006, 1, 2)
>>> column.renderHeader(formatter)
'02'
"""
def doctest_PersonGradesColumn_renderCell_renderSelectedCell():
"""Tests for PersonGradesColumn.renderCell
>>> from schooltool.lyceum.journal.browser.journal import PersonGradesColumn
>>> class MeetingStub(object):
... pass
>>> has_meeting = True
>>> class JournalStub(object):
... def hasMeeting(self, student, meeting):
... return has_meeting
>>> meeting = MeetingStub()
>>> meeting.__name__ = 'unique-id-2006-01-01'
>>> column = PersonGradesColumn(meeting, JournalStub())
>>> column.getCellValue = lambda person: "%s 5" % person.__name__
>>> class FormatterStub(object):
... request = TestRequest()
>>> formatter = FormatterStub()
>>> class PersonStub(object):
... def __init__(self):
... self.__name__ = "John"
If there is a meeting for that date:
>>> print column.renderCell(PersonStub(), formatter)
"""
def doctest_SectionTermAverageGradesColumn_getGrades():
"""Tests for SectionTermAverageGradesColumn.getGrades
>>> from schooltool.requirement.scoresystem import UNSCORED
>>> from schooltool.lyceum.journal.browser.journal import SectionTermAverageGradesColumn
>>> class JournalStub(object):
... def getGrade(self, person, meeting, default=None):
... return meeting.grade or default
>>> class TermStub(list):
... __name__ = "2006-Spring"
... def __init__(self):
... self.append(date(2006, 1, 1))
... self.append(date(2006, 1, 2))
... self.append(date(2006, 1, 3))
... self.append(date(2006, 1, 4))
>>> journal = JournalStub()
>>> term = TermStub()
>>> column = SectionTermAverageGradesColumn(journal, term)
>>> column.name
'2006-Springaverage'
>>> class PersonStub(object):
... pass
>>> item = PersonStub()
>>> journal.gradedMeetings = lambda person: []
>>> column.getGrades(item)
[]
>>> class MeetingStub(object):
... def __init__(self, datetime, grade=None):
... self.dtstart = datetime
... self.grade = grade
>>> class ScoreStub(object):
... def __init__(self, value):
... self.value = value
... def __repr__(self):
... return '' % self.value
>>> MS = MeetingStub
>>> SS = ScoreStub
>>> dt = datetime
>>> journal.gradedMeetings = lambda person: [
... (MS(dt(2006, 1, 2, 10, 15)), SS('4')),
... (MS(dt(2006, 1, 3, 10, 15)), SS(UNSCORED)),
... (MS(dt(2006, 2, 1, 10, 15)), SS('3'))]
>>> column.getGrades(item)
[]
"""
def doctest_SectionTermAverageGradesColumn_renderCell_renderHeader():
"""Tests for SectionTermAverageGradesColumn renderCell and renderHeader
>>> def print_u(str):
... '''If we want unicode output, we have to convert ALL
... unicode ouput strings to UTF-8, even if they only
... have ASCII characters in them. Stupid doctest.'''
... print unicode(str).encode('UTF-8')
>>> from schooltool.lyceum.journal.browser.journal import SectionTermAverageGradesColumn
>>> class TermStub(object):
... __name__ = "2006-Spring"
>>> class ScoreSystemStub(object):
... getNumericalValue = lambda self, x: int(x)
>>> class ScoreStub(object):
... scoreSystem = ScoreSystemStub()
... def __init__(self, value):
... self.value = value
... def __repr__(self):
... return '' % self.value
>>> s = ScoreStub
>>> column = SectionTermAverageGradesColumn("journal", TermStub())
>>> column.getGrades = lambda person: [s("1"), s("2")]
>>> print_u(column.renderCell("john", "formatter"))
1.500
>>> class FormatterStub(object):
... request = TestRequest()
>>> print_u(column.renderHeader(FormatterStub()))
Average
"""
def doctest_SectionTermAttendanceColumn_renderCell_renderHeader():
"""Tests for SectionTermAttendanceColumn renderCell and renderHeader
>>> from schooltool.lyceum.journal.browser.journal import SectionTermAttendanceColumn
>>> class TermStub(object):
... __name__ = "2006-Spring"
>>> from schooltool.requirement.evaluation import Score
>>> from schooltool.lyceum.journal.journal import AbsenceScoreSystem
>>> s = lambda x: Score(AbsenceScoreSystem, x)
>>> column = SectionTermAttendanceColumn("journal", TermStub())
>>> column.getAbsences = lambda person: [s("a")]
>>> column.renderCell("john", "formatter")
'1'
>>> column.getAbsences = lambda person: [s("a"), s("a"), s("a")]
>>> column.renderCell("john", "formatter")
'3'
>>> class FormatterStub(object):
... request = TestRequest()
>>> column.renderHeader(FormatterStub())
u'Absences'
"""
def doctest_StudentSelectionMixin():
"""Tests for StudentSelectionMixin.
>>> from schooltool.lyceum.journal.browser.journal import StudentSelectionMixin
>>> from schooltool.app.interfaces import IApplicationPreferences
>>> from schooltool.app.interfaces import ISchoolToolApplication
>>> class PrefStub(object):
... @property
... def timezone(self):
... return "Europe/Vilnius"
>>> class STAppStub(dict):
... def __init__(self, context):
... self['persons'] = {'stud1': '', 'stud2': ''}
... def __conform__(self, iface):
... if iface == IApplicationPreferences:
... return PrefStub()
>>> provideAdapter(STAppStub, adapts=[None], provides=ISchoolToolApplication)
This mixin is intended for a view, so it has to have self.request.
>>> mixin = StudentSelectionMixin()
>>> mixin.request = {}
No students are selected by default.
>>> print mixin.selected_students
None
>>> mixin.selectStudents('table formatter')
>>> print mixin.selected_students
[]
If 'student' is set in the request, it gets selected.
>>> mixin.request = {'student': 'stud2'}
>>> mixin.selectStudents('table formatter')
>>> print mixin.selected_students
['']
If an indexed table formatter is passed, selected students get indexed.
>>> from schooltool.table.interfaces import IIndexedTableFormatter
>>> class Formatter(object):
... implements(IIndexedTableFormatter)
... def indexItems(self, items):
... return ['indexed %s' % i for i in items]
>>> mixin.request = {'student': 'stud1'}
>>> mixin.selectStudents(Formatter())
>>> print mixin.selected_students
['indexed ']
"""
def doctest_SectionListView():
"""Test for the SectionListView
SectionListView lists all the sections a person is teaching that
are in the current term.
>>> from schooltool.term.term import Term
>>> from schooltool.term.tests import setUpDateManagerStub
>>> term1 = Term("2001", date(2001, 1, 1), date(2001, 2, 1))
>>> term2 = Term("2002", date(2002, 1, 1), date(2002, 2, 1))
>>> setUpDateManagerStub(current_term=term1)
>>> from zope.ucol.localeadapter import LocaleCollator
>>> from zope.i18n.interfaces.locales import ICollator
>>> from zope.component import provideAdapter
>>> provideAdapter(LocaleCollator, adapts=[None], provides=ICollator)
>>> from schooltool.lyceum.journal.browser.journal import SectionListView
>>> view = SectionListView(None, TestRequest())
>>> section_list = []
>>> class InstructorStub(object):
... def sections(self):
... return section_list
>>> terms = []
>>> class TimetablesStub(object):
... def __init__(self, terms):
... self.terms = terms
>>> from zope.traversing.interfaces import IContainmentRoot
>>> from schooltool.term.interfaces import ITerm
>>> class SectionStub(object):
... implements(IContainmentRoot)
... def __init__(self, name, term):
... self.term = term
... self.__name__ = self.title = name
... def __conform__(self, interface):
... if interface == ITerm:
... return self.term
>>> from schooltool.course.interfaces import IInstructor
>>> class TeacherStub(object):
... def __conform__(self, interface):
... if interface == IInstructor:
... return InstructorStub()
If the person is not related to any sections - it returns an empty
list:
>>> teacher = TeacherStub()
>>> view.getSectionsForPerson(teacher)
[]
>>> section_list = [SectionStub("section1", term1),
... SectionStub("section2", term1),
... SectionStub("section2", term2),
... SectionStub("section3", term2)]
If there are sections associated with the teacher, only the
sections in the current term will get returned:
>>> view.getSectionsForPerson(teacher)
[{'url': 'http://127.0.0.1/section1/journal/', 'title': 'section1'},
{'url': 'http://127.0.0.1/section2/journal/', 'title': 'section2'}]
>>> setUpDateManagerStub(current_term=term2)
>>> view.getSectionsForPerson(teacher)
[{'url': 'http://127.0.0.1/section2/journal/', 'title': 'section2'},
{'url': 'http://127.0.0.1/section3/journal/', 'title': 'section3'}]
If there is no current term - no sections will be returned:
>>> setUpDateManagerStub(current_term=None)
>>> view.getSectionsForPerson(teacher)
[]
"""
def setUp(test):
setup.placelessSetUp()
setup.setUpTraversal()
def tearDown(test):
setup.placelessTearDown()
def test_suite():
optionflags = doctest.NORMALIZE_WHITESPACE | doctest.ELLIPSIS
return doctest.DocTestSuite(optionflags=optionflags,
setUp=setUp, tearDown=tearDown)
if __name__ == '__main__':
unittest.main(defaultTest='test_suite')
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/browser/tests/test_table.py 0000644 0001750 0001750 00000015365 12270520456 033274 0 ustar menesis menesis 0000000 0000000 #
#
# SchoolTool - common information systems platform for school administration
# Copyright (c) 2007 Shuttleworth Foundation
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
#
"""
Unit tests for lyceum journal.
"""
import unittest, doctest
from zope.app.testing import setup
from zope.interface import implements
from zope.publisher.browser import TestRequest
def doctest_SelectStudentCellFormatter():
"""Tests for SelectStudentCellFormatter.
>>> from schooltool.lyceum.journal.browser.table import SelectStudentCellFormatter
>>> formatter = SelectStudentCellFormatter(None)
>>> request = TestRequest()
SelectStudentCellFormatter takes some parameters from the request,
and adds them to the url that has the person displayed in the row
selected:
>>> request.form = {'event_id': "some-event-id",
... 'month': "july"}
>>> formatter.extra_parameters(request)
[('event_id', 'some-event-id'),
('month', 'july')]
Parameters that are not relevant to the state of the view get
ignored:
>>> request.form = {'event_id': "some-event-id",
... 'month': "july",
... 'some-thing-else': 'is-ignored'}
>>> formatter.extra_parameters(request)
[('event_id', 'some-event-id'),
('month', 'july')]
The formatter renders the url of the journal, and adds student
parameter set to the __name__ of the student that is being
rendered:
>>> class TableFormatterStub(object):
... pass
>>> table_formatter = TableFormatterStub()
>>> table_formatter.request = request
>>> class PersonStub(object):
... __name__ = "john"
>>> item = PersonStub()
>>> formatter("John", item, table_formatter)
'John'
"""
def doctest_SelectableRowTableFormatter():
r"""Tests for SelectableRowTableFormatter.
SelectableRowTableFormatter is a special table formatter that
allows you to select items, and have rows for these items
displayed in some special way when rendering the table.
>>> from schooltool.lyceum.journal.browser.table import SelectableRowTableFormatter
>>> request = TestRequest()
>>> class ColumnStub(object):
... def renderCell(self, item, formatter):
... return "I am %s" % item
It still works with simple columns that have no way to get
selected:
>>> columns = [ColumnStub()]
>>> formatter = SelectableRowTableFormatter("context", request, [],
... selected_items=["Pete"],
... columns=columns)
>>> formatter.row = 0
>>> print formatter.renderRow("John")
I am John
As this table formatter inherits from AlternatingRowFormatter the
next row is "even":
>>> print formatter.renderRow("Pete")
I am Pete
If column implements ISelectableColumn, and the row being rendered
is for a selected item - cells will be rendered in a special way:
>>> from schooltool.lyceum.journal.browser.interfaces import ISelectableColumn
>>> class SelectableColumnStub(ColumnStub):
... implements(ISelectableColumn)
... def renderSelectedCell(self, item, formatter):
... return "I am Selected %s" % item
John is not selected:
>>> columns[0] = SelectableColumnStub()
>>> print formatter.renderRow("John")
I am John
But Pete is:
>>> print formatter.renderRow("Pete")
I am Selected Pete
Another type of columns is IIndependentColumn, "independent"
columns render their own TD tags, so they can style themselves any
way they want:
>>> from schooltool.lyceum.journal.browser.interfaces import IIndependentColumn
>>> class IndependentColumnStub(ColumnStub):
... implements(IIndependentColumn)
... def renderCell(self, item, formatter):
... return '
The column did not implement ISelectableColumn, so Pete is
rendered the same way as John was:
>>> print formatter.renderRow("Pete")
I am Pete
Columns can implement both interfaces ISelectableColumn and
IIndependentColumn at the same time, so they will render their own
TD tags, and get displayed differently when the row is selected:
>>> class SelectableIndependentColumn(IndependentColumnStub):
... implements(ISelectableColumn)
... def renderSelectedCell(self, item, formatter):
... return '
The TD for Pete gets it's class set to "selected":
>>> print formatter.renderRow("Pete")
I am Pete
"""
def setUp(test):
setup.placelessSetUp()
setup.setUpTraversal()
def tearDown(test):
setup.placelessTearDown()
def test_suite():
optionflags = doctest.NORMALIZE_WHITESPACE | doctest.ELLIPSIS
return doctest.DocTestSuite(optionflags=optionflags,
setUp=setUp, tearDown=tearDown)
if __name__ == '__main__':
unittest.main(defaultTest='test_suite')
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/meta.zcml 0000644 0001750 0001750 00000000232 12270520456 027547 0 ustar menesis menesis 0000000 0000000
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/generations/ 0000775 0001750 0001750 00000000000 12331774365 030265 5 ustar menesis menesis 0000000 0000000 schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/generations/evolve3.py 0000644 0001750 0001750 00000011736 12270520456 032220 0 ustar menesis menesis 0000000 0000000 #
# - common information systems platform for school administration
# Copyright (c) 2013 Shuttleworth Foundation
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
#
"""
Move grades from overlapped journal schedules to respective journals.
"""
from zope.app.generations.utility import findObjectsProviding
from zope.app.publication.zopepublication import ZopePublication
from zope.component.hooks import getSite, setSite
from zope.component import getUtility
from zope.intid.interfaces import IIntIds
from schooltool.app.interfaces import ISchoolToolApplication
from schooltool.app.interfaces import ISchoolToolCalendar
from schooltool.course.interfaces import ISection
from schooltool.person.interfaces import IPerson
from schooltool.lyceum.journal.interfaces import ISectionJournalData
from schooltool.term.interfaces import ITerm
def student_sections(students):
sections = set()
for student in students:
for section in student.groups:
if ISection.providedBy(section):
sections.add(section)
return sections
def adjacent_sections(section):
courses = section.courses
instructors = section.instructors
sections = set()
sections.add(section)
members = [member for member in section.members
if IPerson.providedBy(member)]
for section in student_sections(members):
for course in section.courses:
if course in courses:
for instructor in section.instructors:
if instructor in instructors:
sections.add(section)
break
return sections
def collect_meeting_ids(section):
calendar = ISchoolToolCalendar(section)
unique_meeting_ids = set()
for event in sorted(calendar, key=lambda e: e.dtstart):
entry_id = event.meeting_id
if entry_id is None:
entry_id = event.unique_id
if entry_id not in unique_meeting_ids:
unique_meeting_ids.add(entry_id)
return unique_meeting_ids
def collect_student_names(section):
return set([person.__name__ for person in section.members])
def evolveSectionJournal(section, journal):
if not getattr(journal, '__grade_data__', {}):
return
adjacent_journals = sorted([
(ITerm(adj_sec).first,
ISectionJournalData(adj_sec),
collect_meeting_ids(adj_sec),
collect_student_names(adj_sec))
for adj_sec in adjacent_sections(section)
if ITerm(adj_sec).first > ITerm(section).first
])
for key in journal.__grade_data__:
person_name, grade_date = key
for adj_date, adj_journal, adj_eids, adj_students in reversed(adjacent_journals):
if adj_date > grade_date:
continue # journal starts later then grade recorded
if person_name not in adj_students:
continue # person is not attending this section
# process day records
recorded_entries = list(journal.__grade_data__.get(key, ()))
for eid, entries in recorded_entries:
# is the move possible for this grade?
if eid not in adj_eids:
continue
journal.__grade_data__[key] = tuple([
(k, v)
for k, v in journal.__grade_data__[key]
if k != eid])
if not getattr(adj_journal, '__grade_data__', {}):
continue
adj_journal.__grade_data__[key] = tuple(sorted(
[(k, v)
for k, v in adj_journal.__grade_data__.get(key, ())
if k != eid] +
[(eid, entries)]
))
def evolveJournals(app):
container = app['schooltool.lyceum.journal']
int_ids = getUtility(IIntIds)
for section_id, journal in container.items():
section = int_ids.queryObject(int(section_id))
if section:
evolveSectionJournal(section, journal)
else:
# Section was deleted, delete journal data for it
del container[section_id]
def evolve(context):
root = context.connection.root().get(ZopePublication.root_name, None)
old_site = getSite()
apps = findObjectsProviding(root, ISchoolToolApplication)
for app in apps:
setSite(app)
if 'schooltool.lyceum.journal' in app:
evolveJournals(app)
setSite(old_site)
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/generations/__init__.py 0000644 0001750 0001750 00000001760 12270520456 032370 0 ustar menesis menesis 0000000 0000000 #
# SchoolTool - common information systems platform for school administration
# Copyright (c) 2008 Shuttleworth Foundation
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
#
"""
Generations for database version upgrades.
"""
from zope.app.generations.generations import SchemaManager
schemaManager = SchemaManager(
minimum_generation=4,
generation=4,
package_name='schooltool.lyceum.journal.generations')
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/generations/evolve4.py 0000644 0001750 0001750 00000015433 12270520456 032217 0 ustar menesis menesis 0000000 0000000 #
# SchoolTool - common information systems platform for school administration
# Copyright (c) 2011 Shuttleworth Foundation
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
#
"""
Evolve database to generation 4.
Move scores and attendance to scoresystems.
"""
import datetime
import pytz
from zope.app.generations.utility import findObjectsProviding
from zope.app.publication.zopepublication import ZopePublication
from zope.intid.interfaces import IIntIds
from zope.component import getUtility
from zope.component.hooks import getSite, setSite
from schooltool.app.interfaces import ISchoolToolApplication
from schooltool.app.interfaces import ISchoolToolCalendar
from schooltool.course.interfaces import ISectionContainer
from schooltool.schoolyear.interfaces import ISchoolYearContainer
from schooltool.lyceum.journal.journal import AttendanceRequirement
from schooltool.lyceum.journal.journal import GradeRequirement
from schooltool.lyceum.journal.journal import JournalScoreSystemsStartup
from schooltool.term.interfaces import ITermContainer
def iterJournals(app):
jc = app['schooltool.lyceum.journal']
syc = ISchoolYearContainer(app)
int_ids = getUtility(IIntIds)
for sy in syc.values():
terms = ITermContainer(sy)
for term in terms.values():
sections = ISectionContainer(term)
for section in sections.values():
section_id = str(int_ids.getId(section))
journal = jc.get(section_id, None)
if journal is not None:
yield journal
def findMeeting(calendar, date, meeting_id, guessmap):
search_id = guessmap.get(meeting_id, meeting_id)
try:
return calendar.find(search_id)
except KeyError:
pass
start = pytz.UTC.localize(datetime.datetime(
date.year, date.month, date.day))
end = pytz.UTC.localize(datetime.datetime(
date.year, date.month, date.day) + datetime.timedelta(1))
events = list(calendar.expand(start, end))
for event in events:
meeting_id = getattr(event, 'meeting_id')
if meeting_id == search_id:
return event
# No meeting yet. We've likely found a lost grade
# Try asigning to the first unique
used = set(guessmap.values())
for event in events:
if event.unique_id not in used:
guessmap[search_id] = event.unique_id
return event
for event in calendar:
if event.unique_id not in used:
guessmap[search_id] = event.unique_id
return event
# Last resort, try using first meeting in the day
if events:
guessmap[search_id] = events[0].unique_id
return events[0]
return
def getAttendanceScores(app):
ss_prefs = app['schooltool.lyceum.journal-ss-prefs']
absent_score = None
scores = sorted(set(ss_prefs.attendance_scoresystem.tag_absent).difference(
ss_prefs.attendance_scoresystem.tag_excused))
if scores:
absent_score = scores[0]
else:
scores = sorted(ss_prefs.attendance_scoresystem.tag_absent)
if scores:
absent_score = scores[0]
tardy_score = None
scores = sorted(set(ss_prefs.attendance_scoresystem.tag_tardy).difference(
ss_prefs.attendance_scoresystem.tag_excused))
if scores:
tardy_score = scores[0]
else:
scores = sorted(ss_prefs.attendance_scoresystem.tag_tardy)
if scores:
tardy_score = scores[0]
attendance_scores = dict.fromkeys(('n', 'N', 'a', 'A'), absent_score)
attendance_scores.update(dict.fromkeys(('p', 'P', 't', 'T'), tardy_score))
return attendance_scores
def evolveJournal(app, journal):
ss_prefs = app['schooltool.lyceum.journal-ss-prefs']
attendance_scores = getAttendanceScores(app)
persons = app['persons']
calendar = ISchoolToolCalendar(journal.section)
meeting_guessmap = {}
grade_data = getattr(journal, '__grade_data__', {})
for key, grades in grade_data.items():
username, date = key
student = persons.get(username)
if student is None:
continue
for meeting_id, entries in grades:
if isinstance(meeting_id, tuple):
meeting_id = meeting_id[1]
entries = list(entries)
meeting = None
last_requirement = None
while entries:
if meeting is None:
meeting = findMeeting(calendar, date, meeting_id, meeting_guessmap)
if meeting is None:
raise Exception('No meeting %s found in calendar' % meeting_id)
entry = entries.pop(0)
if entry in attendance_scores:
requirement = AttendanceRequirement(
meeting, ss_prefs.attendance_scoresystem)
journal.evaluate(student, requirement,
attendance_scores[entry],
evaluator=None)
last_requirement = requirement
elif entry:
requirement = GradeRequirement(
meeting, ss_prefs.grading_scoresystem)
try:
journal.evaluate(student, requirement,
entry,
evaluator=None)
except:
pass
last_requirement = requirement
elif last_requirement is not None:
journal.evaluate(student, last_requirement, '', evaluator=None)
try:
del journal.__grade_data__
# Also delete these two, because they've been unused for a long time now
del journal.__attendance_data__
del journal.__description_data__
except AttributeError:
pass
def evolve(context):
root = context.connection.root().get(ZopePublication.root_name, None)
old_site = getSite()
apps = list(findObjectsProviding(root, ISchoolToolApplication))
for app in apps:
setSite(app)
# Initialize score systems
JournalScoreSystemsStartup(app)()
journals = iterJournals(app)
for journal in journals:
evolveJournal(app, journal)
setSite(old_site)
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/generations/install.py 0000644 0001750 0001750 00000001724 12270520456 032277 0 ustar menesis menesis 0000000 0000000 #
# SchoolTool - common information systems platform for school administration
# Copyright (c) 2011 Shuttleworth Foundation
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
#
"""
Initial deployment of generations to schooltool.lyceum.journal.
Manually evolves to generation 1.
"""
import evolve1
import evolve2
def evolve(context):
evolve1.evolve(context)
evolve2.evolve(context)
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/generations/evolve1.py 0000644 0001750 0001750 00000002701 12270520456 032206 0 ustar menesis menesis 0000000 0000000 #
# SchoolTool - common information systems platform for school administration
# Copyright (c) 2011 Shuttleworth Foundation
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
#
"""
Evolve database to generation 1.
Remove LyceumTermDataContainer from app root.
"""
from zope.app.generations.utility import findObjectsProviding
from zope.app.publication.zopepublication import ZopePublication
from zope.component.hooks import getSite, setSite
from schooltool.app.interfaces import ISchoolToolApplication
TERM_GRADES_KEY = 'schooltool.lyceum.journal.term_grades'
def evolve(context):
root = context.connection.root().get(ZopePublication.root_name, None)
old_site = getSite()
apps = findObjectsProviding(root, ISchoolToolApplication)
for app in apps:
setSite(app)
if TERM_GRADES_KEY in app:
del app[TERM_GRADES_KEY]
setSite(old_site)
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/generations/evolve2.py 0000644 0001750 0001750 00000013434 12270520456 032214 0 ustar menesis menesis 0000000 0000000 #
# SchoolTool - common information systems platform for school administration
# Copyright (c) 2011 Shuttleworth Foundation
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
#
"""
Evolve recorded meeting keys to a new format.
Evolution caused by timetable remake.
"""
import pytz
import re
from datetime import datetime
from zope.app.generations.utility import findObjectsProviding
from zope.app.publication.zopepublication import ZopePublication
from zope.component.hooks import getSite, setSite
from zope.component import getUtility
from zope.intid.interfaces import IIntIds
from schooltool.app.interfaces import ISchoolToolApplication
from schooltool.app.interfaces import ISchoolToolCalendar
from schooltool.term.interfaces import ITerm
meeting_pattern = re.compile(
'(?P-?\d+)-(?P.+)@(?P.+)')
def makeEventMap(section):
event_map = {}
activity_title = ''.join(
[course.title for course in section.courses])
calendar = ISchoolToolCalendar(section)
for event in calendar:
schedule = getattr(event, 'schedule', None)
if schedule is None:
continue
hashed_id = unicode(hash(
(activity_title, event.dtstart, event.duration)))
event_map[hashed_id] = event
return event_map
def extractMeetingEventKey(section, meeting_key):
parts = meeting_pattern.match(meeting_key).groupdict()
split_path = filter(None, parts['timetable_path'].strip().split('/'))
app_key, term_intid, section_id, timetables, tt_id = split_path
assert app_key == 'schooltool.course.section', app_key
assert term_intid == section.__parent__.__name__, '%s != %s' % (
term_intid, section.__parent__.__name__)
assert section_id == section.__name__, '%s != %s' % (
section_id, section.__name__)
assert timetables == 'timetables', timetables
return unicode(parts['hashed_id'])
class MisplacedMeeting(object):
meeting_id = None
def __init__(self, dtstart, unique_id, meeting_id=None):
self.dtstart = dtstart
self.unique_id = unique_id
self.meeting_id = meeting_id
def __reduce__(self, proto=None):
raise TypeError("Not picklable")
__reduce_ex__ = __reduce__
def evolveRecords(section, records, default_date, event_map):
records_by_event = {}
for record_key, record in records.items():
username, meeting_key = record_key
old_key = extractMeetingEventKey(section, meeting_key)
event = event_map.get(old_key)
if event is None:
event = event_map.get(meeting_key)
if event is None:
event = MisplacedMeeting(default_date, record_key)
if event in records_by_event:
# An edge case when two events for the section have
# identical times (a schedule conflict, generated
# from two different timetables) and both of them
# had a record.
event = MisplacedMeeting(
event.dtstart, event.unique_id,
meeting_id=event.meeting_id)
records_by_event[event] = username, record
records.clear()
for event, (username, record) in records_by_event.items():
key = (username, event.dtstart.date())
entries = dict(records.get(key, ()))
entry_id = event.meeting_id
if entry_id is None:
entry_id = event.unique_id
entries[entry_id] = record
records[key] = tuple(sorted(entries.items()))
def evolveDescriptions(section, descriptions, event_map):
new_descriptions = {}
for meeting_key, description in descriptions.items():
old_key = extractMeetingEventKey(section, meeting_key)
event = event_map.get(old_key)
if event is None:
continue
date = event.dtstart.date()
entry_id = event.meeting_id
if entry_id is None:
entry_id = event.unique_id
new_descriptions[(date, entry_id)] = description
descriptions.clear()
for key, description in new_descriptions.items():
descriptions[key] = description
def evolveSectionJournal(section, journal):
event_map = makeEventMap(section)
first = ITerm(section).first
default_date = datetime(first.year, first.month, first.day)
evolveRecords(section, journal.__grade_data__,
default_date, event_map)
evolveRecords(section, journal.__attendance_data__,
default_date, event_map)
evolveDescriptions(section, journal.__description_data__,
event_map)
def evolveJournals(app):
container = app['schooltool.lyceum.journal']
int_ids = getUtility(IIntIds)
for section_id, journal in container.items():
section = int_ids.queryObject(int(section_id))
if section:
evolveSectionJournal(section, journal)
else:
# Section was deleted, delete journal data for it
del container[section_id]
def evolve(context):
root = context.connection.root().get(ZopePublication.root_name, None)
old_site = getSite()
apps = findObjectsProviding(root, ISchoolToolApplication)
for app in apps:
setSite(app)
if 'schooltool.lyceum.journal' in app:
evolveJournals(app)
setSite(old_site)
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/generations/tests/ 0000775 0001750 0001750 00000000000 12331774365 031427 5 ustar menesis menesis 0000000 0000000 schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/generations/tests/__init__.py 0000644 0001750 0001750 00000005063 12270520456 033532 0 ustar menesis menesis 0000000 0000000 #
# SchoolTool - common information systems platform for school administration
# Copyright (c) 2011 Shuttleworth Foundation
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
#
"""
Tests for generation scripts.
"""
import datetime
from persistent.interfaces import IPersistent
from zope.keyreference.interfaces import IKeyReference
from zope.app.publication.zopepublication import ZopePublication
from zope.app.testing.setup import setUpAnnotations
from zope.component import provideAdapter, provideUtility
from zope.interface import implements
from schooltool.app.app import SchoolToolApplication
from schooltool.term.interfaces import IDateManager
class ContextStub(object):
"""Stub for the context argument passed to evolve scripts.
>>> from zope.app.generations.utility import getRootFolder
>>> context = ContextStub()
>>> getRootFolder(context) is context.root_folder
True
"""
class ConnectionStub(object):
def __init__(self, root_folder):
self.root_folder = root_folder
def root(self):
return {ZopePublication.root_name: self.root_folder}
def __init__(self):
self.root_folder = SchoolToolApplication()
self.connection = self.ConnectionStub(self.root_folder)
_d = {}
class StupidKeyReference(object):
implements(IKeyReference)
key_type_id = 'StupidKeyReference'
def __init__(self, ob):
global _d
self.id = id(ob)
_d[self.id] = ob
def __call__(self):
return _d[self.id]
def __hash__(self):
return self.id
def __cmp__(self, other):
return cmp(hash(self), hash(other))
class DateManagerStub(object):
implements(IDateManager)
def __init__(self):
self.current_term = None
self.today = datetime.date(2011, 1, 23)
def provideAdapters():
setUpAnnotations()
provideAdapter(StupidKeyReference, [IPersistent], IKeyReference)
def provideUtilities():
provideUtility(DateManagerStub(), IDateManager, '')
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/generations/tests/test_evolve1.py 0000644 0001750 0001750 00000004336 12270520456 034415 0 ustar menesis menesis 0000000 0000000 #
# SchoolTool - common information systems platform for school administration
# Copyright (c) 2011 Shuttleworth Foundation
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
#
"""
Unit tests for schooltool.lyceum.journal.generations.evolve1
"""
import unittest, doctest
from zope.app.generations.utility import getRootFolder
from zope.app.testing import setup
from zope.site import LocalSiteManager
from schooltool.lyceum.journal.generations.tests import (
ContextStub, provideAdapters, provideUtilities)
from schooltool.lyceum.journal.generations.evolve1 import (evolve,
TERM_GRADES_KEY)
def doctest_evolve1():
"""Evolution to generation 1.
First, we'll set up the app object:
>>> context = ContextStub()
>>> app = getRootFolder(context)
>>> sm = LocalSiteManager(app)
>>> app.setSiteManager(sm)
We'll set up our test with data that will be effected by running the
evolve script:
>>> app[TERM_GRADES_KEY] = {}
Finally, we'll run the evolve script, testing the effected values before and
after:
>>> TERM_GRADES_KEY in app
True
>>> evolve(context)
>>> TERM_GRADES_KEY in app
False
"""
def setUp(test):
setup.placefulSetUp()
setup.setUpTraversal()
provideAdapters()
provideUtilities()
def tearDown(test):
setup.placefulTearDown()
def test_suite():
optionflags = (doctest.ELLIPSIS |
doctest.NORMALIZE_WHITESPACE)
return doctest.DocTestSuite(setUp=setUp, tearDown=tearDown,
optionflags=optionflags)
if __name__ == '__main__':
unittest.main(defaultTest='test_suite')
schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/ftests/ 0000775 0001750 0001750 00000000000 12331774365 027257 5 ustar menesis menesis 0000000 0000000 schooltool.lyceum.journal-2.6.4/src/schooltool/lyceum/journal/ftests/attendance.txt 0000644 0001750 0001750 00000042032 12270520456 032115 0 ustar menesis menesis 0000000 0000000 Functional doctest for SchoolTool Journal Attendance
====================================================
Let's log in with the manager account:
>>> from schooltool.lyceum.journal.ftests import printGradebookTable
>>> manager = Browser('manager', 'schooltool')
Set up a basic school year:
>>> manager.getLink('Manage').click()
>>> manager.getLink('School Years').click()
>>> manager.getLink('New School Year').click()
>>> manager.getControl('Title').value = '2005'
>>> manager.getControl('First day').value = '2005-09-01'
>>> manager.getControl('Last day').value = '2006-07-31'
>>> manager.getControl('Add').click()
Add some teachers:
>>> from schooltool.basicperson.browser.ftests.setup import addPerson
>>> addPerson('Pete', 'Teacher', username='pete', password='pwd', groups=['teachers'])
A class:
>>> manager.getLink('2005').click()
>>> manager.getLink('Groups').click()
>>> manager.getLink('New Group').click()
>>> manager.getControl('Title').value = "2a"
>>> manager.getControl('Add').click()
And some students:
>>> addPerson('Frum', 'Student', username='frum', password='pwd', groups=['students', '2a'])
>>> addPerson('Grum', 'Student', username='grum', password='pwd', groups=['students', '2a'])
Add a term:
>>> manager.getLink('2005').click()
>>> manager.getLink('Add a new term').click()
>>> manager.getControl('Title').value = '2005 Fall 1'
>>> manager.getControl('Start date').value = '2005-09-01'
>>> manager.getControl('End date').value = '2005-10-31'
>>> manager.getControl('Next').click()
>>> manager.getControl('Saturday').click()
>>> manager.getControl('Sunday').click()
>>> manager.getControl('Add term').click()
Timetable schema:
>>> manager.getLink('2005').click()
>>> manager.getLink('School Timetables').click()
>>> manager.getLink('New Timetable').click()
>>> manager.getControl('Next').click()
>>> manager.getControl('Days of the week').click()
>>> manager.getControl('Same time each day').click()
>>> manager.getControl(name='field.times').value = '9:00-10:00\n10:30-11:30'
>>> manager.getControl('Next').click()
>>> manager.getControl('Have names').click()
>>> manager.getControl(name='field.periods').value = 'A\nB'
>>> manager.getControl('Next').click()
>>> manager.getControl('Same').click()
>>> manager.getControl('Next').click()
>>> manager.getControl('No').click()
A couple of sections:
>>> from schooltool.app.browser.ftests.setup import addSection
>>> from schooltool.app.browser.ftests.setup import addCourse
>>> addCourse("History", "2005")
>>> addSection("History", "2005", "2005 Fall 1",
... title="History (1a)",
... instructors=['Pete'],
... members=['Grum', 'Frum'])
>>> addSection("History", "2005", "2005 Fall 1",
... title="History (1a)",
... instructors=['Pete'],
... members=['Grum', 'Frum'])
Let's schedule the sections:
>>> manager.getLink('2005').click()
>>> manager.getLink('2005 Fall 1').click()
>>> manager.getLink('Sections').click()
>>> manager.getLink(url='sections/1').click()
>>> manager.getLink('Schedule').click()
>>> manager.getLink('Add Timetable').click()
>>> manager.getControl('Add').click()
>>> manager.getControl(name='period.1-.Period-').value = True
>>> manager.getControl(name='period.1-.Period-2-').value = True
>>> manager.getControl(name='period.2-.Period-').value = True
>>> manager.getControl('Save').click()
Let's log in with the teacher account:
>>> teacher = Browser()
>>> teacher.handleErrors = False
>>> teacher.open('http://localhost/')
>>> teacher.getLink('Log In').click()
>>> teacher.getControl('Username').value = 'pete'
>>> teacher.getControl('Password').value = 'pwd'
>>> teacher.getControl('Log in').click()
Let's mark Frum as if he has skipped some lessons:
>>> teacher.open('http://localhost/persons/frum/calendar/2005-09-06')
>>> teacher.getLink('Journal', index=1).click()
>>> teacher.getLink('Frum').click()
>>> printGradebookTable(teacher.contents)
+-----+------------+-----------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+----------+---------+---------+
| Nr. | First Name | Last Name | 06 | 06 B | 07 A | 13 A | 13 B | 14 A | 20 A | 20 B | 21 A | 27 A | 27 B | 28 A | Average | Absences | Tardies | Excused |
+-----+------------+-----------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+----------+---------+---------+
| 1 | Frum | Student | [_____] | [_____] | [_____] | [_____] | [_____] | [_____] | [_____] | [_____] | [_____] | [_____] | [_____] | [_____] | | | | |
| 2 | Grum | Student | [_____] | | | | | | | | | | | | | | | |
+-----+------------+-----------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+----------+---------+---------+
>>> cells = analyze.queryHTML('//table[@class="data"]//input[@type="text"]/@name', teacher.contents)
>>> for i in range(8):
... teacher.getControl(name=cells[i]).value = 'a'
>>> teacher.getControl('Update').click()
>>> printGradebookTable(teacher.contents)
+-----+------------+-----------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+----------+---------+---------+
| Nr. | First Name | Last Name | 06 | 06 B | 07 A | 13 A | 13 B | 14 A | 20 A | 20 B | 21 A | 27 A | 27 B | 28 A | Average | Absences | Tardies | Excused |
+-----+------------+-----------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+----------+---------+---------+
| 1 | Frum | Student | [a____] | [a____] | [a____] | [a____] | [a____] | [a____] | [a____] | [a____] | [_____] | [_____] | [_____] | [_____] | | 8 | | 8 / 0 |
| 2 | Grum | Student | [_____] | | | | | | | | | | | | | | | |
+-----+------------+-----------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+----------+---------+---------+
>>> teacher.getLink('07').click()
>>> printGradebookTable(teacher.contents)
+-----+------------+-----------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+----------+---------+---------+
| Nr. | First Name | Last Name | 06 A | 06 B | 07 | 13 A | 13 B | 14 A | 20 A | 20 B | 21 A | 27 A | 27 B | 28 A | Average | Absences | Tardies | Excused |
+-----+------------+-----------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+----------+---------+---------+
| 1 | Frum | Student | [a____] | [a____] | [a____] | [a____] | [a____] | [a____] | [a____] | [a____] | [_____] | [_____] | [_____] | [_____] | | 8 | | 8 / 0 |
| 2 | Grum | Student | | | [_____] | | | | | | | | | | | | | |
+-----+------------+-----------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+----------+---------+---------+
>>> manager.open('http://localhost/schoolyears/2005/groups/2a/attendance.html')
>>> manager.getLink('September').click()
>>> printGradebookTable(manager.contents)
+------------+-----------+----+----+----+----+----+----+----+----+-------+
| First Name | Last Name | 06 | 07 | 13 | 14 | 20 | 21 | 27 | 28 | Total |
+------------+-----------+----+----+----+----+----+----+----+----+-------+
| Frum | Student | 2 | 1 | 2 | 1 | 2 | | | | 8 |
| Grum | Student | | | | | | | | | |
+------------+-----------+----+----+----+----+----+----+----+----+-------+
>>> manager.getLink('Frum').click()
>>> printGradebookTable(manager.contents)
+------------+-----------+-----+-----+-----+-----+-----+----+----+----+-------+
| First Name | Last Name | 06 | 07 | 13 | 14 | 20 | 21 | 27 | 28 | Total |
+------------+-----------+-----+-----+-----+-----+-----+----+----+----+-------+
| Frum | Student | 2 | 1 | 2 | 1 | 2 | | | | 8 |
...
| Grum | Student | | | | | | | | | |
+------------+-----------+-----+-----+-----+-----+-----+----+----+----+-------+
XXX: Explaining absences not yet implemented, expected result is:
| Explained: | | [ ] | [ ] | [ ] | [ ] | [ ] | | | | |
>>> cells = analyze.queryHTML('//table[@class="data"]//input[@type="checkbox"]/@name', manager.contents)
>>> manager.getControl(name=cells[0]).value = ["checked"]
>>> manager.getControl(name=cells[2]).value = ["checked"]
>>> manager.getControl('Update').click()
>>> printGradebookTable(manager.contents)
+------------+-----------+-----+-----+-----+-----+-----+----+----+----+-------+
| First Name | Last Name | 06 | 07 | 13 | 14 | 20 | 21 | 27 | 28 | Total |
+------------+-----------+-----+-----+-----+-----+-----+----+----+----+-------+
| Frum | Student | 2 | 1 | 2 | 1 | 2 | | | | 8 |
...
| Grum | Student | | | | | | | | | |
+------------+-----------+-----+-----+-----+-----+-----+----+----+----+-------+
XXX: Explaining absences not yet implemented, expected result is:
| Explained: | | [V] | [ ] | [V] | [ ] | [ ] | | | | |
>>> manager.getLink('13').click()
>>> printGradebookTable(manager.contents)
+------------+-----------+-----+-----+
| First Name | Last Name | A | B |
+------------+-----------+-----+-----+
| Frum | Student | n | n |
| Explained: | | [V] | [V] |
| Grum | Student | | |
+------------+-----------+-----+-----+
>>> cells = analyze.queryHTML('//table[@class="data"]//input[@type="checkbox"]/@name', manager.contents)
>>> manager.getControl(name=cells[1]).value = ["checked"]
>>> manager.getControl('Update').click()
>>> printGradebookTable(manager.contents)
+------------+-----------+-----+-----+
| First Name | Last Name | A | B |
+------------+-----------+-----+-----+
| Frum | Student | n | n |
| Explained: | | [V] | [V] |
| Grum | Student | | |
+------------+-----------+-----+-----+
>>> manager.getLink('Show the whole month').click()
>>> printGradebookTable(manager.contents)
+------------+-----------+-----+-----+-----+-----+-----+----+----+----+-------+
| First Name | Last Name | 06 | 07 | 13 | 14 | 20 | 21 | 27 | 28 | Total |
+------------+-----------+-----+-----+-----+-----+-----+----+----+----+-------+
| Frum | Student | 2 | 1 | 2 | 1 | 2 | | | | 8 |
...
| Grum | Student | | | | | | | | | |
+------------+-----------+-----+-----+-----+-----+-----+----+----+----+-------+
XXX: Explaining absences not yet implemented, expected result is:
| Explained: | | [V] | [ ] | [V] | [ ] | [ ] | | | | |
>>> cells = analyze.queryHTML('//table[@class="data"]//input[@type="checkbox"]/@name', manager.contents)
>>> manager.getControl(name=cells[0]).value = []
>>> manager.getControl('Update').click()
>>> printGradebookTable(manager.contents)
+------------+-----------+-----+-----+-----+-----+-----+----+----+----+-------+
| First Name | Last Name | 06 | 07 | 13 | 14 | 20 | 21 | 27 | 28 | Total |
+------------+-----------+-----+-----+-----+-----+-----+----+----+----+-------+
| Frum | Student | 2 | 1 | 2 | 1 | 2 | | | | 8 |
...
| Grum | Student | | | | | | | | | |
+------------+-----------+-----+-----+-----+-----+-----+----+----+----+-------+
XXX: Explaining absences not yet implemented, expected result is:
| Explained: | | [ ] | [ ] | [V] | [ ] | [ ] | | | | |
>>> manager.getLink('13').click()
>>> printGradebookTable(manager.contents)
+------------+-----------+-----+-----+
| First Name | Last Name | A | B |
+------------+-----------+-----+-----+
| Frum | Student | n | n |
...
| Grum | Student | | |
+------------+-----------+-----+-----+
XXX: Explaining absences not yet implemented, expected result is:
| Explained: | | [V] | [V] |
>>> cells = analyze.queryHTML('//table[@class="data"]//input[@type="checkbox"]/@name', manager.contents)
>>> manager.getControl(name=cells[0]).value = ["checked"]
>>> manager.getControl(name=cells[1]).value = []
>>> manager.getControl('Update').click()
>>> printGradebookTable(manager.contents)
+------------+-----------+-----+-----+
| First Name | Last Name | A | B |
+------------+-----------+-----+-----+
| Frum | Student | n | n |
...
| Grum | Student | | |
+------------+-----------+-----+-----+
XXX: Explaining absences not yet implemented, expected result is:
| Explained: | | [V] | [ ] |
>>> cells = analyze.queryHTML('//table[@class="data"]//input[@type="checkbox"]/@name', manager.contents)
>>> manager.getControl(name=cells[1]).value = ["checked"]
>>> manager.getControl('Update').click()
>>> printGradebookTable(manager.contents)
+------------+-----------+-----+-----+
| First Name | Last Name | A | B |
+------------+-----------+-----+-----+
| Frum | Student | n | n |
...
| Grum | Student | | |
+------------+-----------+-----+-----+
XXX: Explaining absences not yet implemented, expected result is:
| Explained: | | [V] | [V] |
>>> manager.getLink('Show the whole month').click()
>>> printGradebookTable(manager.contents)
+------------+-----------+-----+-----+-----+-----+-----+----+----+----+-------+
| First Name | Last Name | 06 | 07 | 13 | 14 | 20 | 21 | 27 | 28 | Total |
+------------+-----------+-----+-----+-----+-----+-----+----+----+----+-------+
| Frum | Student | 2 | 1 | 2 | 1 | 2 | | | | 8 |
...
| Grum | Student | | | | | | | | | |
+------------+-----------+-----+-----+-----+-----+-----+----+----+----+-------+
XXX: Explaining absences not yet implemented
| Explained: | | [ ] | [ ] | [V] | [ ] | [ ] | | | | |
Attendance should keep working even if there are no meetings scheduled
for the current term:
>>> manager.getLink('2005').click()
>>> manager.getLink('Add a new term').click()
>>> manager.getControl('Title').value = '2005 Fall 2'
>>> manager.getControl('Start date').value = '2005-11-01'
>>> manager.getControl('End date').value = '2005-12-31'
>>> manager.getControl('Next').click()
>>> manager.getControl('Saturday').click()
>>> manager.getControl('Sunday').click()
>>> manager.getControl('Add term').click()
We will not see any meetings in the table though...
>>> manager.open('http://localhost/schoolyears/2005/groups/2a/attendance.html')
>>> print analyze.queryHTML('//div[@id="content-body"]', manager.contents)[0]