Context navigation

source: main/waeup.kofa/trunk/src/waeup/kofa/students/browser.py @ 13501

Last change on this file since 13501 was 13480, checked in by Henrik Bettermann, 9 years ago
Display desired hostel.
Property svn:keywords set to `Id`
File size: 126.6 KB

Line
1	## $Id: browser.py 13480 2015-11-18 17:53:31Z henrik $
2	##
3	## Copyright (C) 2011 Uli Fouquet & Henrik Bettermann
4	## This program is free software; you can redistribute it and/or modify
5	## it under the terms of the GNU General Public License as published by
6	## the Free Software Foundation; either version 2 of the License, or
7	## (at your option) any later version.
8	##
9	## This program is distributed in the hope that it will be useful,
10	## but WITHOUT ANY WARRANTY; without even the implied warranty of
11	## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	## GNU General Public License for more details.
13	##
14	## You should have received a copy of the GNU General Public License
15	## along with this program; if not, write to the Free Software
16	## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17	##
18	"""UI components for students and related components.
19	"""
20	import sys
21	import grok
22	import pytz
23	from urllib import urlencode
24	from datetime import datetime
25	from zope.event import notify
26	from zope.i18n import translate
27	from zope.catalog.interfaces import ICatalog
28	from zope.component import queryUtility, getUtility, createObject
29	from zope.schema.interfaces import ConstraintNotSatisfied, RequiredMissing
30	from zope.formlib.textwidgets import BytesDisplayWidget
31	from zope.security import checkPermission
32	from hurry.workflow.interfaces import IWorkflowInfo, IWorkflowState
33	from waeup.kofa.accesscodes import (
34	invalidate_accesscode, get_access_code)
35	from waeup.kofa.accesscodes.workflow import USED
36	from waeup.kofa.browser.layout import (
37	KofaPage, KofaEditFormPage, KofaAddFormPage, KofaDisplayFormPage,
38	NullValidator, jsaction, action, UtilityView)
39	from waeup.kofa.browser.breadcrumbs import Breadcrumb
40	from waeup.kofa.browser.pages import (
41	ContactAdminFormPage, ExportCSVView, doll_up, exports_not_allowed)
42	from waeup.kofa.browser.interfaces import ICaptchaManager
43	from waeup.kofa.hostels.hostel import NOT_OCCUPIED
44	from waeup.kofa.interfaces import (
45	IKofaObject, IUserAccount, IExtFileStore, IPasswordValidator, IContactForm,
46	IKofaUtils, IUniversity, IObjectHistory, academic_sessions, ICSVExporter,
47	academic_sessions_vocab, IJobManager, IDataCenter, DOCLINK)
48	from waeup.kofa.interfaces import MessageFactory as _
49	from waeup.kofa.widgets.datewidget import (
50	FriendlyDateWidget, FriendlyDateDisplayWidget,
51	FriendlyDatetimeDisplayWidget)
52	from waeup.kofa.mandates.mandate import PasswordMandate
53	from waeup.kofa.university.interfaces import (
54	IDepartment, ICertificate, ICourse)
55	from waeup.kofa.university.faculty import VirtualFacultyExportJobContainer
56	from waeup.kofa.university.department import VirtualDepartmentExportJobContainer
57	from waeup.kofa.university.facultiescontainer import (
58	VirtualFacultiesExportJobContainer, FacultiesContainer)
59	from waeup.kofa.university.certificate import (
60	VirtualCertificateExportJobContainer,)
61	from waeup.kofa.university.course import (
62	VirtualCourseExportJobContainer,)
63	from waeup.kofa.university.vocabularies import course_levels
64	from waeup.kofa.utils.batching import VirtualExportJobContainer
65	from waeup.kofa.utils.helpers import get_current_principal, to_timezone, now
66	from waeup.kofa.students.interfaces import (
67	IStudentsContainer, IStudent,
68	IUGStudentClearance,IPGStudentClearance,
69	IStudentPersonal, IStudentPersonalEdit, IStudentBase, IStudentStudyCourse,
70	IStudentStudyCourseTransfer, IStudentStudyCourseTranscript,
71	IStudentAccommodation, IStudentStudyLevel,
72	ICourseTicket, ICourseTicketAdd, IStudentPaymentsContainer,
73	IStudentOnlinePayment, IStudentPreviousPayment, IStudentBalancePayment,
74	IBedTicket, IStudentsUtils, IStudentRequestPW, IStudentTranscript
75	)
76	from waeup.kofa.students.catalog import search, StudentQueryResultItem
77	from waeup.kofa.students.studylevel import StudentStudyLevel, CourseTicket
78	from waeup.kofa.students.vocabularies import StudyLevelSource
79	from waeup.kofa.students.workflow import (CREATED, ADMITTED, PAID,
80	CLEARANCE, REQUESTED, RETURNING, CLEARED, REGISTERED, VALIDATED,
81	GRADUATED, TRANSCRIPT, FORBIDDEN_POSTGRAD_TRANS)
82
83
84	grok.context(IKofaObject) # Make IKofaObject the default context
85
86	# Save function used for save methods in pages
87	def msave(view, **data):
88	changed_fields = view.applyData(view.context, **data)
89	# Turn list of lists into single list
90	if changed_fields:
91	changed_fields = reduce(lambda x,y: x+y, changed_fields.values())
92	# Inform catalog if certificate has changed
93	# (applyData does this only for the context)
94	if 'certificate' in changed_fields:
95	notify(grok.ObjectModifiedEvent(view.context.student))
96	fields_string = ' + '.join(changed_fields)
97	view.flash(_('Form has been saved.'))
98	if fields_string:
99	view.context.writeLogMessage(view, 'saved: %s' % fields_string)
100	return
101
102	def emit_lock_message(view):
103	"""Flash a lock message.
104	"""
105	view.flash(_('The requested form is locked (read-only).'), type="warning")
106	view.redirect(view.url(view.context))
107	return
108
109	def translated_values(view):
110	"""Translate course ticket attribute values to be displayed on
111	studylevel pages.
112	"""
113	lang = view.request.cookies.get('kofa.language')
114	for value in view.context.values():
115	# We have to unghostify (according to Tres Seaver) the __dict__
116	# by activating the object, otherwise value_dict will be empty
117	# when calling the first time.
118	value._p_activate()
119	value_dict = dict([i for i in value.__dict__.items()])
120	value_dict['url'] = view.url(value)
121	value_dict['removable_by_student'] = value.removable_by_student
122	value_dict['mandatory'] = translate(str(value.mandatory), 'zope',
123	target_language=lang)
124	value_dict['carry_over'] = translate(str(value.carry_over), 'zope',
125	target_language=lang)
126	value_dict['automatic'] = translate(str(value.automatic), 'zope',
127	target_language=lang)
128	value_dict['grade'] = value.grade
129	value_dict['weight'] = value.weight
130	semester_dict = getUtility(IKofaUtils).SEMESTER_DICT
131	value_dict['semester'] = semester_dict[
132	value.semester].replace('mester', 'm.')
133	yield value_dict
134
135	def addCourseTicket(view, course=None):
136	students_utils = getUtility(IStudentsUtils)
137	ticket = createObject(u'waeup.CourseTicket')
138	ticket.automatic = False
139	ticket.carry_over = False
140	max_credits = students_utils.maxCreditsExceeded(view.context, course)
141	if max_credits:
142	view.flash(_(
143	'Total credits exceed ${a}.',
144	mapping = {'a': max_credits}), type="warning")
145	return False
146	try:
147	view.context.addCourseTicket(ticket, course)
148	except KeyError:
149	view.flash(_('The ticket exists.'), type="warning")
150	return False
151	view.flash(_('Successfully added ${a}.',
152	mapping = {'a':ticket.code}))
153	view.context.writeLogMessage(
154	view,'added: %s\|%s\|%s' % (
155	ticket.code, ticket.level, ticket.level_session))
156	return True
157
158	def level_dict(studycourse):
159	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
160	level_dict = {}
161	studylevelsource = StudyLevelSource().factory
162	for code in studylevelsource.getValues(studycourse):
163	title = translate(studylevelsource.getTitle(studycourse, code),
164	'waeup.kofa', target_language=portal_language)
165	level_dict[code] = title
166	return level_dict
167
168	class StudentsBreadcrumb(Breadcrumb):
169	"""A breadcrumb for the students container.
170	"""
171	grok.context(IStudentsContainer)
172	title = _('Students')
173
174	@property
175	def target(self):
176	user = get_current_principal()
177	if getattr(user, 'user_type', None) == 'student':
178	return None
179	return self.viewname
180
181	class StudentBreadcrumb(Breadcrumb):
182	"""A breadcrumb for the student container.
183	"""
184	grok.context(IStudent)
185
186	def title(self):
187	return self.context.display_fullname
188
189	class SudyCourseBreadcrumb(Breadcrumb):
190	"""A breadcrumb for the student study course.
191	"""
192	grok.context(IStudentStudyCourse)
193
194	def title(self):
195	if self.context.is_current:
196	return _('Study Course')
197	else:
198	return _('Previous Study Course')
199
200	class PaymentsBreadcrumb(Breadcrumb):
201	"""A breadcrumb for the student payments folder.
202	"""
203	grok.context(IStudentPaymentsContainer)
204	title = _('Payments')
205
206	class OnlinePaymentBreadcrumb(Breadcrumb):
207	"""A breadcrumb for payments.
208	"""
209	grok.context(IStudentOnlinePayment)
210
211	@property
212	def title(self):
213	return self.context.p_id
214
215	class AccommodationBreadcrumb(Breadcrumb):
216	"""A breadcrumb for the student accommodation folder.
217	"""
218	grok.context(IStudentAccommodation)
219	title = _('Accommodation')
220
221	class BedTicketBreadcrumb(Breadcrumb):
222	"""A breadcrumb for bed tickets.
223	"""
224	grok.context(IBedTicket)
225
226	@property
227	def title(self):
228	return _('Bed Ticket ${a}',
229	mapping = {'a':self.context.getSessionString()})
230
231	class StudyLevelBreadcrumb(Breadcrumb):
232	"""A breadcrumb for course lists.
233	"""
234	grok.context(IStudentStudyLevel)
235
236	@property
237	def title(self):
238	return self.context.level_title
239
240	class StudentsContainerPage(KofaPage):
241	"""The standard view for student containers.
242	"""
243	grok.context(IStudentsContainer)
244	grok.name('index')
245	grok.require('waeup.viewStudentsContainer')
246	grok.template('containerpage')
247	label = _('Find students')
248	search_button = _('Find student(s)')
249	pnav = 4
250
251	def update(self, args, *kw):
252	form = self.request.form
253	self.hitlist = []
254	if form.get('searchtype', None) == 'suspended':
255	self.searchtype = form['searchtype']
256	self.searchterm = None
257	elif form.get('searchtype', None) == 'transcript':
258	self.searchtype = form['searchtype']
259	self.searchterm = None
260	elif 'searchterm' in form and form['searchterm']:
261	self.searchterm = form['searchterm']
262	self.searchtype = form['searchtype']
263	elif 'old_searchterm' in form:
264	self.searchterm = form['old_searchterm']
265	self.searchtype = form['old_searchtype']
266	else:
267	if 'search' in form:
268	self.flash(_('Empty search string'), type="warning")
269	return
270	if self.searchtype == 'current_session':
271	try:
272	self.searchterm = int(self.searchterm)
273	except ValueError:
274	self.flash(_('Only year dates allowed (e.g. 2011).'),
275	type="danger")
276	return
277	self.hitlist = search(query=self.searchterm,
278	searchtype=self.searchtype, view=self)
279	if not self.hitlist:
280	self.flash(_('No student found.'), type="warning")
281	return
282
283	class StudentsContainerManagePage(KofaPage):
284	"""The manage page for student containers.
285	"""
286	grok.context(IStudentsContainer)
287	grok.name('manage')
288	grok.require('waeup.manageStudent')
289	grok.template('containermanagepage')
290	pnav = 4
291	label = _('Manage students section')
292	search_button = _('Find student(s)')
293	remove_button = _('Remove selected')
294	doclink = DOCLINK + '/students.html'
295
296	def update(self, args, *kw):
297	form = self.request.form
298	self.hitlist = []
299	if form.get('searchtype', None) == 'suspended':
300	self.searchtype = form['searchtype']
301	self.searchterm = None
302	elif 'searchterm' in form and form['searchterm']:
303	self.searchterm = form['searchterm']
304	self.searchtype = form['searchtype']
305	elif 'old_searchterm' in form:
306	self.searchterm = form['old_searchterm']
307	self.searchtype = form['old_searchtype']
308	else:
309	if 'search' in form:
310	self.flash(_('Empty search string'), type="warning")
311	return
312	if self.searchtype == 'current_session':
313	try:
314	self.searchterm = int(self.searchterm)
315	except ValueError:
316	self.flash(_('Only year dates allowed (e.g. 2011).'),
317	type="danger")
318	return
319	if not 'entries' in form:
320	self.hitlist = search(query=self.searchterm,
321	searchtype=self.searchtype, view=self)
322	if not self.hitlist:
323	self.flash(_('No student found.'), type="warning")
324	if 'remove' in form:
325	self.flash(_('No item selected.'), type="warning")
326	return
327	entries = form['entries']
328	if isinstance(entries, basestring):
329	entries = [entries]
330	deleted = []
331	for entry in entries:
332	if 'remove' in form:
333	del self.context[entry]
334	deleted.append(entry)
335	self.hitlist = search(query=self.searchterm,
336	searchtype=self.searchtype, view=self)
337	if len(deleted):
338	self.flash(_('Successfully removed: ${a}',
339	mapping = {'a':', '.join(deleted)}))
340	return
341
342	class StudentAddFormPage(KofaAddFormPage):
343	"""Add-form to add a student.
344	"""
345	grok.context(IStudentsContainer)
346	grok.require('waeup.manageStudent')
347	grok.name('addstudent')
348	form_fields = grok.AutoFields(IStudent).select(
349	'firstname', 'middlename', 'lastname', 'reg_number')
350	label = _('Add student')
351	pnav = 4
352
353	@action(_('Create student'), style='primary')
354	def addStudent(self, **data):
355	student = createObject(u'waeup.Student')
356	self.applyData(student, **data)
357	self.context.addStudent(student)
358	self.flash(_('Student record created.'))
359	self.redirect(self.url(self.context[student.student_id], 'index'))
360	return
361
362	class LoginAsStudentStep1(KofaEditFormPage):
363	""" View to temporarily set a student password.
364	"""
365	grok.context(IStudent)
366	grok.name('loginasstep1')
367	grok.require('waeup.loginAsStudent')
368	grok.template('loginasstep1')
369	pnav = 4
370
371	def label(self):
372	return _(u'Set temporary password for ${a}',
373	mapping = {'a':self.context.display_fullname})
374
375	@action('Set password now', style='primary')
376	def setPassword(self, args, *data):
377	kofa_utils = getUtility(IKofaUtils)
378	password = kofa_utils.genPassword()
379	self.context.setTempPassword(self.request.principal.id, password)
380	self.context.writeLogMessage(
381	self, 'temp_password generated: %s' % password)
382	args = {'password':password}
383	self.redirect(self.url(self.context) +
384	'/loginasstep2?%s' % urlencode(args))
385	return
386
387	class LoginAsStudentStep2(KofaPage):
388	""" View to temporarily login as student with a temporary password.
389	"""
390	grok.context(IStudent)
391	grok.name('loginasstep2')
392	grok.require('waeup.Public')
393	grok.template('loginasstep2')
394	login_button = _('Login now')
395	pnav = 4
396
397	def label(self):
398	return _(u'Login as ${a}',
399	mapping = {'a':self.context.student_id})
400
401	def update(self, SUBMIT=None, password=None):
402	self.password = password
403	if SUBMIT is not None:
404	self.flash(_('You successfully logged in as student.'))
405	self.redirect(self.url(self.context))
406	return
407
408	class StudentBaseDisplayFormPage(KofaDisplayFormPage):
409	""" Page to display student base data
410	"""
411	grok.context(IStudent)
412	grok.name('index')
413	grok.require('waeup.viewStudent')
414	grok.template('basepage')
415	form_fields = grok.AutoFields(IStudentBase).omit(
416	'password', 'suspended', 'suspended_comment')
417	pnav = 4
418
419	@property
420	def label(self):
421	if self.context.suspended:
422	return _('${a}: Base Data (account deactivated)',
423	mapping = {'a':self.context.display_fullname})
424	return _('${a}: Base Data',
425	mapping = {'a':self.context.display_fullname})
426
427	@property
428	def hasPassword(self):
429	if self.context.password:
430	return _('set')
431	return _('unset')
432
433	class StudentBasePDFFormPage(KofaDisplayFormPage):
434	""" Page to display student base data in pdf files.
435	"""
436
437	def __init__(self, context, request, omit_fields=()):
438	self.omit_fields = omit_fields
439	super(StudentBasePDFFormPage, self).__init__(context, request)
440
441	@property
442	def form_fields(self):
443	form_fields = grok.AutoFields(IStudentBase)
444	for field in self.omit_fields:
445	form_fields = form_fields.omit(field)
446	return form_fields
447
448	class ContactStudentFormPage(ContactAdminFormPage):
449	grok.context(IStudent)
450	grok.name('contactstudent')
451	grok.require('waeup.viewStudent')
452	pnav = 4
453	form_fields = grok.AutoFields(IContactForm).select('subject', 'body')
454
455	def update(self, subject=u'', body=u''):
456	super(ContactStudentFormPage, self).update()
457	self.form_fields.get('subject').field.default = subject
458	self.form_fields.get('body').field.default = body
459	return
460
461	def label(self):
462	return _(u'Send message to ${a}',
463	mapping = {'a':self.context.display_fullname})
464
465	@action('Send message now', style='primary')
466	def send(self, args, *data):
467	try:
468	email = self.request.principal.email
469	except AttributeError:
470	email = self.config.email_admin
471	usertype = getattr(self.request.principal,
472	'user_type', 'system').title()
473	kofa_utils = getUtility(IKofaUtils)
474	success = kofa_utils.sendContactForm(
475	self.request.principal.title,email,
476	self.context.display_fullname,self.context.email,
477	self.request.principal.id,usertype,
478	self.config.name,
479	data['body'],data['subject'])
480	if success:
481	self.flash(_('Your message has been sent.'))
482	else:
483	self.flash(_('An smtp server error occurred.'), type="danger")
484	return
485
486	class ExportPDFAdmissionSlip(UtilityView, grok.View):
487	"""Deliver a PDF Admission slip.
488	"""
489	grok.context(IStudent)
490	grok.name('admission_slip.pdf')
491	grok.require('waeup.viewStudent')
492	prefix = 'form'
493
494	omit_fields = ('date_of_birth', 'current_level')
495
496	form_fields = grok.AutoFields(IStudentBase).select('student_id', 'reg_number')
497
498	@property
499	def label(self):
500	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
501	return translate(_('Admission Letter of'),
502	'waeup.kofa', target_language=portal_language) \
503	+ ' %s' % self.context.display_fullname
504
505	def render(self):
506	students_utils = getUtility(IStudentsUtils)
507	return students_utils.renderPDFAdmissionLetter(self,
508	self.context.student, omit_fields=self.omit_fields)
509
510	class StudentBaseManageFormPage(KofaEditFormPage):
511	""" View to manage student base data
512	"""
513	grok.context(IStudent)
514	grok.name('manage_base')
515	grok.require('waeup.manageStudent')
516	form_fields = grok.AutoFields(IStudentBase).omit(
517	'student_id', 'adm_code', 'suspended')
518	grok.template('basemanagepage')
519	label = _('Manage base data')
520	pnav = 4
521
522	def update(self):
523	super(StudentBaseManageFormPage, self).update()
524	self.wf_info = IWorkflowInfo(self.context)
525	return
526
527	@action(_('Save'), style='primary')
528	def save(self, **data):
529	form = self.request.form
530	password = form.get('password', None)
531	password_ctl = form.get('control_password', None)
532	if password:
533	validator = getUtility(IPasswordValidator)
534	errors = validator.validate_password(password, password_ctl)
535	if errors:
536	self.flash( ' '.join(errors), type="danger")
537	return
538	changed_fields = self.applyData(self.context, **data)
539	# Turn list of lists into single list
540	if changed_fields:
541	changed_fields = reduce(lambda x,y: x+y, changed_fields.values())
542	else:
543	changed_fields = []
544	if password:
545	# Now we know that the form has no errors and can set password
546	IUserAccount(self.context).setPassword(password)
547	changed_fields.append('password')
548	fields_string = ' + '.join(changed_fields)
549	self.flash(_('Form has been saved.'))
550	if fields_string:
551	self.context.writeLogMessage(self, 'saved: % s' % fields_string)
552	return
553
554	class StudentTriggerTransitionFormPage(KofaEditFormPage):
555	""" View to trigger student workflow transitions
556	"""
557	grok.context(IStudent)
558	grok.name('trigtrans')
559	grok.require('waeup.triggerTransition')
560	grok.template('trigtrans')
561	label = _('Trigger registration transition')
562	pnav = 4
563
564	def getTransitions(self):
565	"""Return a list of dicts of allowed transition ids and titles.
566
567	Each list entry provides keys ``name`` and ``title`` for
568	internal name and (human readable) title of a single
569	transition.
570	"""
571	wf_info = IWorkflowInfo(self.context)
572	allowed_transitions = [t for t in wf_info.getManualTransitions()
573	if not t[0].startswith('pay')]
574	if self.context.is_postgrad and not self.context.is_special_postgrad:
575	allowed_transitions = [t for t in allowed_transitions
576	if not t[0] in FORBIDDEN_POSTGRAD_TRANS]
577	return [dict(name='', title=_('No transition'))] +[
578	dict(name=x, title=y) for x, y in allowed_transitions]
579
580	@action(_('Save'), style='primary')
581	def save(self, **data):
582	form = self.request.form
583	if 'transition' in form and form['transition']:
584	transition_id = form['transition']
585	wf_info = IWorkflowInfo(self.context)
586	wf_info.fireTransition(transition_id)
587	return
588
589	class StudentActivateView(UtilityView, grok.View):
590	""" Activate student account
591	"""
592	grok.context(IStudent)
593	grok.name('activate')
594	grok.require('waeup.manageStudent')
595
596	def update(self):
597	self.context.suspended = False
598	self.context.writeLogMessage(self, 'account activated')
599	history = IObjectHistory(self.context)
600	history.addMessage('Student account activated')
601	self.flash(_('Student account has been activated.'))
602	self.redirect(self.url(self.context))
603	return
604
605	def render(self):
606	return
607
608	class StudentDeactivateView(UtilityView, grok.View):
609	""" Deactivate student account
610	"""
611	grok.context(IStudent)
612	grok.name('deactivate')
613	grok.require('waeup.manageStudent')
614
615	def update(self):
616	self.context.suspended = True
617	self.context.writeLogMessage(self, 'account deactivated')
618	history = IObjectHistory(self.context)
619	history.addMessage('Student account deactivated')
620	self.flash(_('Student account has been deactivated.'))
621	self.redirect(self.url(self.context))
622	return
623
624	def render(self):
625	return
626
627	class StudentClearanceDisplayFormPage(KofaDisplayFormPage):
628	""" Page to display student clearance data
629	"""
630	grok.context(IStudent)
631	grok.name('view_clearance')
632	grok.require('waeup.viewStudent')
633	pnav = 4
634
635	@property
636	def separators(self):
637	return getUtility(IStudentsUtils).SEPARATORS_DICT
638
639	@property
640	def form_fields(self):
641	if self.context.is_postgrad:
642	form_fields = grok.AutoFields(IPGStudentClearance)
643	else:
644	form_fields = grok.AutoFields(IUGStudentClearance)
645	if not getattr(self.context, 'officer_comment'):
646	form_fields = form_fields.omit('officer_comment')
647	else:
648	form_fields['officer_comment'].custom_widget = BytesDisplayWidget
649	return form_fields
650
651	@property
652	def label(self):
653	return _('${a}: Clearance Data',
654	mapping = {'a':self.context.display_fullname})
655
656	class ExportPDFClearanceSlip(grok.View):
657	"""Deliver a PDF slip of the context.
658	"""
659	grok.context(IStudent)
660	grok.name('clearance_slip.pdf')
661	grok.require('waeup.viewStudent')
662	prefix = 'form'
663	omit_fields = (
664	'suspended', 'phone',
665	'adm_code', 'suspended_comment',
666	'date_of_birth', 'current_level')
667
668	@property
669	def form_fields(self):
670	if self.context.is_postgrad:
671	form_fields = grok.AutoFields(IPGStudentClearance)
672	else:
673	form_fields = grok.AutoFields(IUGStudentClearance)
674	if not getattr(self.context, 'officer_comment'):
675	form_fields = form_fields.omit('officer_comment')
676	return form_fields
677
678	@property
679	def title(self):
680	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
681	return translate(_('Clearance Data'), 'waeup.kofa',
682	target_language=portal_language)
683
684	@property
685	def label(self):
686	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
687	return translate(_('Clearance Slip of'),
688	'waeup.kofa', target_language=portal_language) \
689	+ ' %s' % self.context.display_fullname
690
691	# XXX: not used in waeup.kofa and thus not tested
692	def _signatures(self):
693	isStudent = getattr(
694	self.request.principal, 'user_type', None) == 'student'
695	if not isStudent and self.context.state in (CLEARED, ):
696	return ([_('Student Signature')],
697	[_('Clearance Officer Signature')])
698	return
699
700	def _sigsInFooter(self):
701	isStudent = getattr(
702	self.request.principal, 'user_type', None) == 'student'
703	if not isStudent and self.context.state in (CLEARED, ):
704	return (_('Date, Student Signature'),
705	_('Date, Clearance Officer Signature'),
706	)
707	return ()
708
709	def render(self):
710	studentview = StudentBasePDFFormPage(self.context.student,
711	self.request, self.omit_fields)
712	students_utils = getUtility(IStudentsUtils)
713	return students_utils.renderPDF(
714	self, 'clearance_slip.pdf',
715	self.context.student, studentview, signatures=self._signatures(),
716	sigs_in_footer=self._sigsInFooter(),
717	omit_fields=self.omit_fields)
718
719	class StudentClearanceManageFormPage(KofaEditFormPage):
720	""" Page to manage student clearance data
721	"""
722	grok.context(IStudent)
723	grok.name('manage_clearance')
724	grok.require('waeup.manageStudent')
725	grok.template('clearanceeditpage')
726	label = _('Manage clearance data')
727	deletion_warning = _('Are you sure?')
728	pnav = 4
729
730	@property
731	def separators(self):
732	return getUtility(IStudentsUtils).SEPARATORS_DICT
733
734	@property
735	def form_fields(self):
736	if self.context.is_postgrad:
737	form_fields = grok.AutoFields(IPGStudentClearance).omit('clr_code')
738	else:
739	form_fields = grok.AutoFields(IUGStudentClearance).omit('clr_code')
740	return form_fields
741
742	@action(_('Save'), style='primary')
743	def save(self, **data):
744	msave(self, **data)
745	return
746
747	class StudentClearView(UtilityView, grok.View):
748	""" Clear student by clearance officer
749	"""
750	grok.context(IStudent)
751	grok.name('clear')
752	grok.require('waeup.clearStudent')
753
754	def update(self):
755	cdm = getUtility(IStudentsUtils).clearance_disabled_message(
756	self.context)
757	if cdm:
758	self.flash(cdm)
759	self.redirect(self.url(self.context,'view_clearance'))
760	return
761	if self.context.state == REQUESTED:
762	IWorkflowInfo(self.context).fireTransition('clear')
763	self.flash(_('Student has been cleared.'))
764	else:
765	self.flash(_('Student is in wrong state.'), type="warning")
766	self.redirect(self.url(self.context,'view_clearance'))
767	return
768
769	def render(self):
770	return
771
772	class StudentRejectClearancePage(KofaEditFormPage):
773	""" Reject clearance by clearance officers.
774	"""
775	grok.context(IStudent)
776	grok.name('reject_clearance')
777	label = _('Reject clearance')
778	grok.require('waeup.clearStudent')
779	form_fields = grok.AutoFields(
780	IUGStudentClearance).select('officer_comment')
781
782	def update(self):
783	cdm = getUtility(IStudentsUtils).clearance_disabled_message(
784	self.context)
785	if cdm:
786	self.flash(cdm, type="warning")
787	self.redirect(self.url(self.context,'view_clearance'))
788	return
789	return super(StudentRejectClearancePage, self).update()
790
791	@action(_('Save comment and reject clearance now'), style='primary')
792	def reject(self, **data):
793	if self.context.state == CLEARED:
794	IWorkflowInfo(self.context).fireTransition('reset4')
795	message = _('Clearance has been annulled.')
796	self.flash(message, type="warning")
797	elif self.context.state == REQUESTED:
798	IWorkflowInfo(self.context).fireTransition('reset3')
799	message = _('Clearance request has been rejected.')
800	self.flash(message, type="warning")
801	else:
802	self.flash(_('Student is in wrong state.'), type="warning")
803	self.redirect(self.url(self.context,'view_clearance'))
804	return
805	self.applyData(self.context, **data)
806	comment = data['officer_comment']
807	if comment:
808	self.context.writeLogMessage(
809	self, 'comment: %s' % comment.replace('\n', '<br>'))
810	args = {'subject':message, 'body':comment}
811	else:
812	args = {'subject':message,}
813	self.redirect(self.url(self.context) +
814	'/contactstudent?%s' % urlencode(args))
815	return
816
817
818	class StudentPersonalDisplayFormPage(KofaDisplayFormPage):
819	""" Page to display student personal data
820	"""
821	grok.context(IStudent)
822	grok.name('view_personal')
823	grok.require('waeup.viewStudent')
824	form_fields = grok.AutoFields(IStudentPersonal)
825	form_fields['perm_address'].custom_widget = BytesDisplayWidget
826	form_fields[
827	'personal_updated'].custom_widget = FriendlyDatetimeDisplayWidget('le')
828	pnav = 4
829
830	@property
831	def label(self):
832	return _('${a}: Personal Data',
833	mapping = {'a':self.context.display_fullname})
834
835	class StudentPersonalManageFormPage(KofaEditFormPage):
836	""" Page to manage personal data
837	"""
838	grok.context(IStudent)
839	grok.name('manage_personal')
840	grok.require('waeup.manageStudent')
841	form_fields = grok.AutoFields(IStudentPersonal)
842	form_fields['personal_updated'].for_display = True
843	form_fields[
844	'personal_updated'].custom_widget = FriendlyDatetimeDisplayWidget('le')
845	label = _('Manage personal data')
846	pnav = 4
847
848	@action(_('Save'), style='primary')
849	def save(self, **data):
850	msave(self, **data)
851	return
852
853	class StudentPersonalEditFormPage(KofaEditFormPage):
854	""" Page to edit personal data
855	"""
856	grok.context(IStudent)
857	grok.name('edit_personal')
858	grok.require('waeup.handleStudent')
859	form_fields = grok.AutoFields(IStudentPersonalEdit).omit('personal_updated')
860	label = _('Edit personal data')
861	pnav = 4
862
863	@action(_('Save/Confirm'), style='primary')
864	def save(self, **data):
865	msave(self, **data)
866	self.context.personal_updated = datetime.utcnow()
867	return
868
869	class StudyCourseDisplayFormPage(KofaDisplayFormPage):
870	""" Page to display the student study course data
871	"""
872	grok.context(IStudentStudyCourse)
873	grok.name('index')
874	grok.require('waeup.viewStudent')
875	grok.template('studycoursepage')
876	pnav = 4
877
878	@property
879	def form_fields(self):
880	if self.context.is_postgrad:
881	form_fields = grok.AutoFields(IStudentStudyCourse).omit(
882	'previous_verdict')
883	else:
884	form_fields = grok.AutoFields(IStudentStudyCourse)
885	return form_fields
886
887	@property
888	def label(self):
889	if self.context.is_current:
890	return _('${a}: Study Course',
891	mapping = {'a':self.context.__parent__.display_fullname})
892	else:
893	return _('${a}: Previous Study Course',
894	mapping = {'a':self.context.__parent__.display_fullname})
895
896	@property
897	def current_mode(self):
898	if self.context.certificate is not None:
899	studymodes_dict = getUtility(IKofaUtils).STUDY_MODES_DICT
900	return studymodes_dict[self.context.certificate.study_mode]
901	return
902
903	@property
904	def department(self):
905	if self.context.certificate is not None:
906	return self.context.certificate.__parent__.__parent__
907	return
908
909	@property
910	def faculty(self):
911	if self.context.certificate is not None:
912	return self.context.certificate.__parent__.__parent__.__parent__
913	return
914
915	@property
916	def prev_studycourses(self):
917	if self.context.is_current:
918	if self.context.__parent__.get('studycourse_2', None) is not None:
919	return (
920	{'href':self.url(self.context.student) + '/studycourse_1',
921	'title':_('First Study Course, ')},
922	{'href':self.url(self.context.student) + '/studycourse_2',
923	'title':_('Second Study Course')}
924	)
925	if self.context.__parent__.get('studycourse_1', None) is not None:
926	return (
927	{'href':self.url(self.context.student) + '/studycourse_1',
928	'title':_('First Study Course')},
929	)
930	return
931
932	class StudyCourseManageFormPage(KofaEditFormPage):
933	""" Page to edit the student study course data
934	"""
935	grok.context(IStudentStudyCourse)
936	grok.name('manage')
937	grok.require('waeup.manageStudent')
938	grok.template('studycoursemanagepage')
939	label = _('Manage study course')
940	pnav = 4
941	taboneactions = [_('Save'),_('Cancel')]
942	tabtwoactions = [_('Remove selected levels'),_('Cancel')]
943	tabthreeactions = [_('Add study level')]
944
945	@property
946	def form_fields(self):
947	if self.context.is_postgrad:
948	form_fields = grok.AutoFields(IStudentStudyCourse).omit(
949	'previous_verdict')
950	else:
951	form_fields = grok.AutoFields(IStudentStudyCourse)
952	return form_fields
953
954	def update(self):
955	if not self.context.is_current:
956	emit_lock_message(self)
957	return
958	super(StudyCourseManageFormPage, self).update()
959	return
960
961	@action(_('Save'), style='primary')
962	def save(self, **data):
963	try:
964	msave(self, **data)
965	except ConstraintNotSatisfied:
966	# The selected level might not exist in certificate
967	self.flash(_('Current level not available for certificate.'),
968	type="warning")
969	return
970	notify(grok.ObjectModifiedEvent(self.context.__parent__))
971	return
972
973	@property
974	def level_dicts(self):
975	studylevelsource = StudyLevelSource().factory
976	for code in studylevelsource.getValues(self.context):
977	title = studylevelsource.getTitle(self.context, code)
978	yield(dict(code=code, title=title))
979
980	@property
981	def session_dicts(self):
982	yield(dict(code='', title='--'))
983	for item in academic_sessions():
984	code = item[1]
985	title = item[0]
986	yield(dict(code=code, title=title))
987
988	@action(_('Add study level'), style='primary')
989	def addStudyLevel(self, **data):
990	level_code = self.request.form.get('addlevel', None)
991	level_session = self.request.form.get('level_session', None)
992	if not level_session:
993	self.flash(_('You must select a session for the level.'),
994	type="warning")
995	self.redirect(self.url(self.context, u'@@manage')+'#tab2')
996	return
997	studylevel = createObject(u'waeup.StudentStudyLevel')
998	studylevel.level = int(level_code)
999	studylevel.level_session = int(level_session)
1000	try:
1001	self.context.addStudentStudyLevel(
1002	self.context.certificate,studylevel)
1003	self.flash(_('Study level has been added.'))
1004	except KeyError:
1005	self.flash(_('This level exists.'), type="warning")
1006	self.redirect(self.url(self.context, u'@@manage')+'#tab2')
1007	return
1008
1009	@jsaction(_('Remove selected levels'))
1010	def delStudyLevels(self, **data):
1011	form = self.request.form
1012	if 'val_id' in form:
1013	child_id = form['val_id']
1014	else:
1015	self.flash(_('No study level selected.'), type="warning")
1016	self.redirect(self.url(self.context, '@@manage')+'#tab2')
1017	return
1018	if not isinstance(child_id, list):
1019	child_id = [child_id]
1020	deleted = []
1021	for id in child_id:
1022	del self.context[id]
1023	deleted.append(id)
1024	if len(deleted):
1025	self.flash(_('Successfully removed: ${a}',
1026	mapping = {'a':', '.join(deleted)}))
1027	self.context.writeLogMessage(
1028	self,'removed: %s' % ', '.join(deleted))
1029	self.redirect(self.url(self.context, u'@@manage')+'#tab2')
1030	return
1031
1032	class StudentTranscriptRequestPage(KofaPage):
1033	""" Page to request transcript by student
1034	"""
1035	grok.context(IStudent)
1036	grok.name('request_transcript')
1037	grok.require('waeup.handleStudent')
1038	grok.template('transcriptrequest')
1039	label = _('Request transcript')
1040	ac_prefix = 'TSC'
1041	notice = ''
1042	pnav = 4
1043	buttonname = _('Submit')
1044	with_ac = True
1045
1046	def update(self, SUBMIT=None):
1047	super(StudentTranscriptRequestPage, self).update()
1048	if not self.context.state == GRADUATED:
1049	self.flash(_("Wrong state"), type="danger")
1050	self.redirect(self.url(self.context))
1051	return
1052	if self.with_ac:
1053	self.ac_series = self.request.form.get('ac_series', None)
1054	self.ac_number = self.request.form.get('ac_number', None)
1055	if self.context.transcript_comment is not None:
1056	self.correspondence = self.context.transcript_comment.replace(
1057	'\n', '<br>')
1058	else:
1059	self.correspondence = ''
1060	if SUBMIT is None:
1061	return
1062	if self.with_ac:
1063	pin = '%s-%s-%s' % (self.ac_prefix, self.ac_series, self.ac_number)
1064	code = get_access_code(pin)
1065	if not code:
1066	self.flash(_('Activation code is invalid.'), type="warning")
1067	return
1068	if code.state == USED:
1069	self.flash(_('Activation code has already been used.'),
1070	type="warning")
1071	return
1072	# Mark pin as used (this also fires a pin related transition)
1073	# and fire transition request_transcript
1074	comment = _(u"invalidated")
1075	# Here we know that the ac is in state initialized so we do not
1076	# expect an exception, but the owner might be different
1077	if not invalidate_accesscode(pin, comment, self.context.student_id):
1078	self.flash(_('You are not the owner of this access code.'),
1079	type="warning")
1080	return
1081	self.context.clr_code = pin
1082	IWorkflowInfo(self.context).fireTransition('request_transcript')
1083	comment = self.request.form.get('comment', '').replace('\r', '')
1084	address = self.request.form.get('address', '').replace('\r', '')
1085	tz = getattr(queryUtility(IKofaUtils), 'tzinfo', pytz.utc)
1086	today = now(tz).strftime('%d/%m/%Y %H:%M:%S %Z')
1087	old_transcript_comment = self.context.transcript_comment
1088	if old_transcript_comment == None:
1089	old_transcript_comment = ''
1090	self.context.transcript_comment = '''On %s %s wrote:
1091
1092	%s
1093
1094	Dispatch Address:
1095	%s
1096
1097	%s''' % (today, self.request.principal.id, comment, address,
1098	old_transcript_comment)
1099	self.context.writeLogMessage(
1100	self, 'comment: %s' % comment.replace('\n', '<br>'))
1101	self.flash(_('Transcript processing has been started.'))
1102	self.redirect(self.url(self.context))
1103	return
1104
1105	class StudentTranscriptRequestProcessFormPage(KofaEditFormPage):
1106	""" Page to process transcript requests
1107	"""
1108	grok.context(IStudent)
1109	grok.name('process_transcript_request')
1110	grok.require('waeup.viewTranscript')
1111	grok.template('transcriptprocess')
1112	form_fields = grok.AutoFields(IStudentTranscript)
1113	label = _('Process transcript request')
1114	buttonname = _('Save comment and mark as processed')
1115	pnav = 4
1116
1117	def update(self, SUBMIT=None):
1118	super(StudentTranscriptRequestProcessFormPage, self).update()
1119	if self.context.state != TRANSCRIPT:
1120	self.flash(_('Student is in wrong state.'), type="warning")
1121	self.redirect(self.url(self.context))
1122	return
1123	if self.context.transcript_comment is not None:
1124	self.correspondence = self.context.transcript_comment.replace(
1125	'\n', '<br>')
1126	else:
1127	self.correspondence = ''
1128	if SUBMIT is None:
1129	return
1130	IWorkflowInfo(self.context).fireTransition('process_transcript')
1131	self.flash(_('Transcript request processed.'))
1132	comment = self.request.form.get('comment', '').replace('\r', '')
1133	tz = getattr(queryUtility(IKofaUtils), 'tzinfo', pytz.utc)
1134	today = now(tz).strftime('%d/%m/%Y %H:%M:%S %Z')
1135	old_transcript_comment = self.context.transcript_comment
1136	if old_transcript_comment == None:
1137	old_transcript_comment = ''
1138	self.context.transcript_comment = '''On %s %s wrote:
1139
1140	%s
1141
1142	%s''' % (today, self.request.principal.id, comment,
1143	old_transcript_comment)
1144	self.context.writeLogMessage(
1145	self, 'comment: %s' % comment.replace('\n', '<br>'))
1146	subject = _('Transcript processed')
1147	args = {'subject':subject, 'body':comment}
1148	self.redirect(self.url(self.context) +
1149	'/contactstudent?%s' % urlencode(args))
1150	return
1151
1152	class StudentTranscriptRequestManageFormPage(KofaEditFormPage):
1153	""" Page to edit personal data by student
1154	"""
1155	grok.context(IStudent)
1156	grok.name('manage_transcript_request')
1157	grok.require('waeup.manageStudent')
1158	form_fields = grok.AutoFields(IStudentTranscript)
1159	label = _('Manage transcript request')
1160	pnav = 4
1161
1162	@action(_('Save'), style='primary')
1163	def save(self, **data):
1164	msave(self, **data)
1165	return
1166
1167	class StudyCourseTranscriptPage(KofaDisplayFormPage):
1168	""" Page to display the student's transcript.
1169	"""
1170	grok.context(IStudentStudyCourseTranscript)
1171	grok.name('transcript')
1172	grok.require('waeup.viewTranscript')
1173	grok.template('transcript')
1174	pnav = 4
1175
1176	def update(self):
1177	if not self.context.student.transcript_enabled:
1178	self.flash(_('You are not allowed to view the transcript.'),
1179	type="warning")
1180	self.redirect(self.url(self.context))
1181	return
1182	super(StudyCourseTranscriptPage, self).update()
1183	self.semester_dict = getUtility(IKofaUtils).SEMESTER_DICT
1184	self.level_dict = level_dict(self.context)
1185	self.session_dict = dict(
1186	[(item[1], item[0]) for item in academic_sessions()])
1187	self.studymode_dict = getUtility(IKofaUtils).STUDY_MODES_DICT
1188	return
1189
1190	@property
1191	def label(self):
1192	# Here we know that the cookie has been set
1193	lang = self.request.cookies.get('kofa.language')
1194	return _('${a}: Transcript Data', mapping = {
1195	'a':self.context.student.display_fullname})
1196
1197	class ExportPDFTranscriptSlip(UtilityView, grok.View):
1198	"""Deliver a PDF slip of the context.
1199	"""
1200	grok.context(IStudentStudyCourse)
1201	grok.name('transcript.pdf')
1202	grok.require('waeup.viewTranscript')
1203	form_fields = grok.AutoFields(IStudentStudyCourseTranscript)
1204	prefix = 'form'
1205	omit_fields = (
1206	'department', 'faculty', 'current_mode', 'entry_session', 'certificate',
1207	'password', 'suspended', 'phone', 'email',
1208	'adm_code', 'suspended_comment', 'current_level')
1209
1210	def update(self):
1211	if not self.context.student.transcript_enabled:
1212	self.flash(_('You are not allowed to download the transcript.'),
1213	type="warning")
1214	self.redirect(self.url(self.context))
1215	return
1216	super(ExportPDFTranscriptSlip, self).update()
1217	self.semester_dict = getUtility(IKofaUtils).SEMESTER_DICT
1218	self.level_dict = level_dict(self.context)
1219	self.session_dict = dict(
1220	[(item[1], item[0]) for item in academic_sessions()])
1221	self.studymode_dict = getUtility(IKofaUtils).STUDY_MODES_DICT
1222	return
1223
1224	@property
1225	def label(self):
1226	# Here we know that the cookie has been set
1227	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
1228	return translate(_('Academic Transcript'),
1229	'waeup.kofa', target_language=portal_language)
1230
1231	def _sigsInFooter(self):
1232	return (_('CERTIFIED TRUE COPY'),)
1233
1234	def _signatures(self):
1235	return None
1236
1237	def render(self):
1238	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
1239	Term = translate(_('Term'), 'waeup.kofa', target_language=portal_language)
1240	Code = translate(_('Code'), 'waeup.kofa', target_language=portal_language)
1241	Title = translate(_('Title'), 'waeup.kofa', target_language=portal_language)
1242	Cred = translate(_('Credits'), 'waeup.kofa', target_language=portal_language)
1243	Score = translate(_('Score'), 'waeup.kofa', target_language=portal_language)
1244	Grade = translate(_('Grade'), 'waeup.kofa', target_language=portal_language)
1245	studentview = StudentBasePDFFormPage(self.context.student,
1246	self.request, self.omit_fields)
1247	students_utils = getUtility(IStudentsUtils)
1248
1249	tableheader = [(Code,'code', 2.5),
1250	(Title,'title', 7),
1251	(Term, 'semester', 1.5),
1252	(Cred, 'credits', 1.5),
1253	(Score, 'score', 1.5),
1254	(Grade, 'grade', 1.5),
1255	]
1256
1257	return students_utils.renderPDFTranscript(
1258	self, 'transcript.pdf',
1259	self.context.student, studentview,
1260	omit_fields=self.omit_fields,
1261	tableheader=tableheader,
1262	signatures=self._signatures(),
1263	sigs_in_footer=self._sigsInFooter(),
1264	)
1265
1266	class StudentTransferFormPage(KofaAddFormPage):
1267	"""Page to transfer the student.
1268	"""
1269	grok.context(IStudent)
1270	grok.name('transfer')
1271	grok.require('waeup.manageStudent')
1272	label = _('Transfer student')
1273	form_fields = grok.AutoFields(IStudentStudyCourseTransfer).omit(
1274	'entry_mode', 'entry_session')
1275	pnav = 4
1276
1277	@jsaction(_('Transfer'))
1278	def transferStudent(self, **data):
1279	error = self.context.transfer(**data)
1280	if error == -1:
1281	self.flash(_('Current level does not match certificate levels.'),
1282	type="warning")
1283	elif error == -2:
1284	self.flash(_('Former study course record incomplete.'),
1285	type="warning")
1286	elif error == -3:
1287	self.flash(_('Maximum number of transfers exceeded.'),
1288	type="warning")
1289	else:
1290	self.flash(_('Successfully transferred.'))
1291	return
1292
1293	class RevertTransferFormPage(KofaEditFormPage):
1294	"""View that reverts the previous transfer.
1295	"""
1296	grok.context(IStudent)
1297	grok.name('revert_transfer')
1298	grok.require('waeup.manageStudent')
1299	grok.template('reverttransfer')
1300	label = _('Revert previous transfer')
1301
1302	def update(self):
1303	if not self.context.has_key('studycourse_1'):
1304	self.flash(_('No previous transfer.'), type="warning")
1305	self.redirect(self.url(self.context))
1306	return
1307	return
1308
1309	@jsaction(_('Revert now'))
1310	def transferStudent(self, **data):
1311	self.context.revert_transfer()
1312	self.flash(_('Previous transfer reverted.'))
1313	self.redirect(self.url(self.context, 'studycourse'))
1314	return
1315
1316	class StudyLevelDisplayFormPage(KofaDisplayFormPage):
1317	""" Page to display student study levels
1318	"""
1319	grok.context(IStudentStudyLevel)
1320	grok.name('index')
1321	grok.require('waeup.viewStudent')
1322	form_fields = grok.AutoFields(IStudentStudyLevel).omit('level')
1323	form_fields[
1324	'validation_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
1325	grok.template('studylevelpage')
1326	pnav = 4
1327
1328	def update(self):
1329	super(StudyLevelDisplayFormPage, self).update()
1330	return
1331
1332	@property
1333	def translated_values(self):
1334	return translated_values(self)
1335
1336	@property
1337	def label(self):
1338	# Here we know that the cookie has been set
1339	lang = self.request.cookies.get('kofa.language')
1340	level_title = translate(self.context.level_title, 'waeup.kofa',
1341	target_language=lang)
1342	return _('${a}: Study Level ${b}', mapping = {
1343	'a':self.context.student.display_fullname,
1344	'b':level_title})
1345
1346	class ExportPDFCourseRegistrationSlip(UtilityView, grok.View):
1347	"""Deliver a PDF slip of the context.
1348	"""
1349	grok.context(IStudentStudyLevel)
1350	grok.name('course_registration_slip.pdf')
1351	grok.require('waeup.viewStudent')
1352	form_fields = grok.AutoFields(IStudentStudyLevel).omit('level')
1353	form_fields[
1354	'validation_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
1355	prefix = 'form'
1356	omit_fields = (
1357	'password', 'suspended', 'phone', 'date_of_birth',
1358	'adm_code', 'sex', 'suspended_comment', 'current_level')
1359
1360	@property
1361	def title(self):
1362	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
1363	return translate(_('Level Data'), 'waeup.kofa',
1364	target_language=portal_language)
1365
1366	@property
1367	def label(self):
1368	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
1369	lang = self.request.cookies.get('kofa.language', portal_language)
1370	level_title = translate(self.context.level_title, 'waeup.kofa',
1371	target_language=lang)
1372	return translate(_('Course Registration Slip'),
1373	'waeup.kofa', target_language=portal_language) \
1374	+ ' %s' % level_title
1375
1376	@property
1377	def tabletitle(self):
1378	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
1379	tabletitle = []
1380	tabletitle.append(translate(_('1st Semester Courses'), 'waeup.kofa',
1381	target_language=portal_language))
1382	tabletitle.append(translate(_('2nd Semester Courses'), 'waeup.kofa',
1383	target_language=portal_language))
1384	tabletitle.append(translate(_('Level Courses'), 'waeup.kofa',
1385	target_language=portal_language))
1386	return tabletitle
1387
1388	def render(self):
1389	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
1390	Term = translate(_('Term'), 'waeup.kofa', target_language=portal_language)
1391	Code = translate(_('Code'), 'waeup.kofa', target_language=portal_language)
1392	Title = translate(_('Title'), 'waeup.kofa', target_language=portal_language)
1393	Dept = translate(_('Dept.'), 'waeup.kofa', target_language=portal_language)
1394	Faculty = translate(_('Faculty'), 'waeup.kofa', target_language=portal_language)
1395	Cred = translate(_('Cred.'), 'waeup.kofa', target_language=portal_language)
1396	#Mand = translate(_('Requ.'), 'waeup.kofa', target_language=portal_language)
1397	Score = translate(_('Score'), 'waeup.kofa', target_language=portal_language)
1398	Grade = translate(_('Grade'), 'waeup.kofa', target_language=portal_language)
1399	studentview = StudentBasePDFFormPage(self.context.student,
1400	self.request, self.omit_fields)
1401	students_utils = getUtility(IStudentsUtils)
1402
1403	tabledata = []
1404	tableheader = []
1405	contenttitle = []
1406	for i in range(1,7):
1407	tabledata.append(sorted(
1408	[value for value in self.context.values() if value.semester == i],
1409	key=lambda value: str(value.semester) + value.code))
1410	tableheader.append([(Code,'code', 2.5),
1411	(Title,'title', 5),
1412	(Dept,'dcode', 1.5), (Faculty,'fcode', 1.5),
1413	(Cred, 'credits', 1.5),
1414	#(Mand, 'mandatory', 1.5),
1415	(Score, 'score', 1.5),
1416	(Grade, 'grade', 1.5),
1417	#('Auto', 'automatic', 1.5)
1418	])
1419	return students_utils.renderPDF(
1420	self, 'course_registration_slip.pdf',
1421	self.context.student, studentview,
1422	tableheader=tableheader,
1423	tabledata=tabledata,
1424	omit_fields=self.omit_fields
1425	)
1426
1427	class StudyLevelManageFormPage(KofaEditFormPage):
1428	""" Page to edit the student study level data
1429	"""
1430	grok.context(IStudentStudyLevel)
1431	grok.name('manage')
1432	grok.require('waeup.manageStudent')
1433	grok.template('studylevelmanagepage')
1434	form_fields = grok.AutoFields(IStudentStudyLevel).omit(
1435	'validation_date', 'validated_by', 'total_credits', 'gpa', 'level')
1436	pnav = 4
1437	taboneactions = [_('Save'),_('Cancel')]
1438	tabtwoactions = [_('Add course ticket'),
1439	_('Remove selected tickets'),_('Cancel')]
1440	placeholder = _('Enter valid course code')
1441
1442	def update(self, ADD=None, course=None):
1443	if not self.context.__parent__.is_current:
1444	emit_lock_message(self)
1445	return
1446	super(StudyLevelManageFormPage, self).update()
1447	if ADD is not None:
1448	if not course:
1449	self.flash(_('No valid course code entered.'), type="warning")
1450	self.redirect(self.url(self.context, u'@@manage')+'#tab2')
1451	return
1452	cat = queryUtility(ICatalog, name='courses_catalog')
1453	result = cat.searchResults(code=(course, course))
1454	if len(result) != 1:
1455	self.flash(_('Course not found.'), type="warning")
1456	else:
1457	course = list(result)[0]
1458	addCourseTicket(self, course)
1459	self.redirect(self.url(self.context, u'@@manage')+'#tab2')
1460	return
1461
1462	@property
1463	def translated_values(self):
1464	return translated_values(self)
1465
1466	@property
1467	def label(self):
1468	# Here we know that the cookie has been set
1469	lang = self.request.cookies.get('kofa.language')
1470	level_title = translate(self.context.level_title, 'waeup.kofa',
1471	target_language=lang)
1472	return _('Manage study level ${a}',
1473	mapping = {'a':level_title})
1474
1475	@action(_('Save'), style='primary')
1476	def save(self, **data):
1477	msave(self, **data)
1478	return
1479
1480	@jsaction(_('Remove selected tickets'))
1481	def delCourseTicket(self, **data):
1482	form = self.request.form
1483	if 'val_id' in form:
1484	child_id = form['val_id']
1485	else:
1486	self.flash(_('No ticket selected.'), type="warning")
1487	self.redirect(self.url(self.context, '@@manage')+'#tab2')
1488	return
1489	if not isinstance(child_id, list):
1490	child_id = [child_id]
1491	deleted = []
1492	for id in child_id:
1493	del self.context[id]
1494	deleted.append(id)
1495	if len(deleted):
1496	self.flash(_('Successfully removed: ${a}',
1497	mapping = {'a':', '.join(deleted)}))
1498	self.context.writeLogMessage(
1499	self,'removed: %s at %s' %
1500	(', '.join(deleted), self.context.level))
1501	self.redirect(self.url(self.context, u'@@manage')+'#tab2')
1502	return
1503
1504	class ValidateCoursesView(UtilityView, grok.View):
1505	""" Validate course list by course adviser
1506	"""
1507	grok.context(IStudentStudyLevel)
1508	grok.name('validate_courses')
1509	grok.require('waeup.validateStudent')
1510
1511	def update(self):
1512	if not self.context.__parent__.is_current:
1513	emit_lock_message(self)
1514	return
1515	if str(self.context.__parent__.current_level) != self.context.__name__:
1516	self.flash(_('This level does not correspond current level.'),
1517	type="danger")
1518	elif self.context.student.state == REGISTERED:
1519	IWorkflowInfo(self.context.student).fireTransition(
1520	'validate_courses')
1521	self.flash(_('Course list has been validated.'))
1522	else:
1523	self.flash(_('Student is in the wrong state.'), type="warning")
1524	self.redirect(self.url(self.context))
1525	return
1526
1527	def render(self):
1528	return
1529
1530	class RejectCoursesView(UtilityView, grok.View):
1531	""" Reject course list by course adviser
1532	"""
1533	grok.context(IStudentStudyLevel)
1534	grok.name('reject_courses')
1535	grok.require('waeup.validateStudent')
1536
1537	def update(self):
1538	if not self.context.__parent__.is_current:
1539	emit_lock_message(self)
1540	return
1541	if str(self.context.__parent__.current_level) != self.context.__name__:
1542	self.flash(_('This level does not correspond current level.'),
1543	type="danger")
1544	self.redirect(self.url(self.context))
1545	return
1546	elif self.context.student.state == VALIDATED:
1547	IWorkflowInfo(self.context.student).fireTransition('reset8')
1548	message = _('Course list request has been annulled.')
1549	self.flash(message)
1550	elif self.context.student.state == REGISTERED:
1551	IWorkflowInfo(self.context.student).fireTransition('reset7')
1552	message = _('Course list request has been rejected.')
1553	self.flash(message)
1554	else:
1555	self.flash(_('Student is in the wrong state.'), type="warning")
1556	self.redirect(self.url(self.context))
1557	return
1558	args = {'subject':message}
1559	self.redirect(self.url(self.context.student) +
1560	'/contactstudent?%s' % urlencode(args))
1561	return
1562
1563	def render(self):
1564	return
1565
1566	class CourseTicketAddFormPage(KofaAddFormPage):
1567	"""Add a course ticket.
1568	"""
1569	grok.context(IStudentStudyLevel)
1570	grok.name('add')
1571	grok.require('waeup.manageStudent')
1572	label = _('Add course ticket')
1573	form_fields = grok.AutoFields(ICourseTicketAdd)
1574	pnav = 4
1575
1576	def update(self):
1577	if not self.context.__parent__.is_current:
1578	emit_lock_message(self)
1579	return
1580	super(CourseTicketAddFormPage, self).update()
1581	return
1582
1583	@action(_('Add course ticket'), style='primary')
1584	def addCourseTicket(self, **data):
1585	course = data['course']
1586	success = addCourseTicket(self, course)
1587	if success:
1588	self.redirect(self.url(self.context, u'@@manage')+'#tab2')
1589	return
1590
1591	@action(_('Cancel'), validator=NullValidator)
1592	def cancel(self, **data):
1593	self.redirect(self.url(self.context))
1594
1595	class CourseTicketDisplayFormPage(KofaDisplayFormPage):
1596	""" Page to display course tickets
1597	"""
1598	grok.context(ICourseTicket)
1599	grok.name('index')
1600	grok.require('waeup.viewStudent')
1601	form_fields = grok.AutoFields(ICourseTicket)
1602	grok.template('courseticketpage')
1603	pnav = 4
1604
1605	@property
1606	def label(self):
1607	return _('${a}: Course Ticket ${b}', mapping = {
1608	'a':self.context.student.display_fullname,
1609	'b':self.context.code})
1610
1611	class CourseTicketManageFormPage(KofaEditFormPage):
1612	""" Page to manage course tickets
1613	"""
1614	grok.context(ICourseTicket)
1615	grok.name('manage')
1616	grok.require('waeup.manageStudent')
1617	form_fields = grok.AutoFields(ICourseTicket)
1618	form_fields['title'].for_display = True
1619	form_fields['fcode'].for_display = True
1620	form_fields['dcode'].for_display = True
1621	form_fields['semester'].for_display = True
1622	form_fields['passmark'].for_display = True
1623	form_fields['credits'].for_display = True
1624	form_fields['mandatory'].for_display = False
1625	form_fields['automatic'].for_display = True
1626	form_fields['carry_over'].for_display = True
1627	pnav = 4
1628	grok.template('courseticketmanagepage')
1629
1630	@property
1631	def label(self):
1632	return _('Manage course ticket ${a}', mapping = {'a':self.context.code})
1633
1634	@action('Save', style='primary')
1635	def save(self, **data):
1636	msave(self, **data)
1637	return
1638
1639	class PaymentsManageFormPage(KofaEditFormPage):
1640	""" Page to manage the student payments
1641
1642	This manage form page is for both students and students officers.
1643	"""
1644	grok.context(IStudentPaymentsContainer)
1645	grok.name('index')
1646	grok.require('waeup.viewStudent')
1647	form_fields = grok.AutoFields(IStudentPaymentsContainer)
1648	grok.template('paymentsmanagepage')
1649	pnav = 4
1650
1651	@property
1652	def manage_payments_allowed(self):
1653	return checkPermission('waeup.payStudent', self.context)
1654
1655	def unremovable(self, ticket):
1656	usertype = getattr(self.request.principal, 'user_type', None)
1657	if not usertype:
1658	return False
1659	if not self.manage_payments_allowed:
1660	return True
1661	return (self.request.principal.user_type == 'student' and ticket.r_code)
1662
1663	@property
1664	def label(self):
1665	return _('${a}: Payments',
1666	mapping = {'a':self.context.__parent__.display_fullname})
1667
1668	@jsaction(_('Remove selected tickets'))
1669	def delPaymentTicket(self, **data):
1670	form = self.request.form
1671	if 'val_id' in form:
1672	child_id = form['val_id']
1673	else:
1674	self.flash(_('No payment selected.'), type="warning")
1675	self.redirect(self.url(self.context))
1676	return
1677	if not isinstance(child_id, list):
1678	child_id = [child_id]
1679	deleted = []
1680	for id in child_id:
1681	# Students are not allowed to remove used payment tickets
1682	ticket = self.context.get(id, None)
1683	if ticket is not None and not self.unremovable(ticket):
1684	del self.context[id]
1685	deleted.append(id)
1686	if len(deleted):
1687	self.flash(_('Successfully removed: ${a}',
1688	mapping = {'a': ', '.join(deleted)}))
1689	self.context.writeLogMessage(
1690	self,'removed: %s' % ', '.join(deleted))
1691	self.redirect(self.url(self.context))
1692	return
1693
1694	#@action(_('Add online payment ticket'))
1695	#def addPaymentTicket(self, **data):
1696	# self.redirect(self.url(self.context, '@@addop'))
1697
1698	class OnlinePaymentAddFormPage(KofaAddFormPage):
1699	""" Page to add an online payment ticket
1700	"""
1701	grok.context(IStudentPaymentsContainer)
1702	grok.name('addop')
1703	grok.template('onlinepaymentaddform')
1704	grok.require('waeup.payStudent')
1705	form_fields = grok.AutoFields(IStudentOnlinePayment).select(
1706	'p_category')
1707	label = _('Add online payment')
1708	pnav = 4
1709
1710	@property
1711	def selectable_categories(self):
1712	categories = getUtility(IKofaUtils).SELECTABLE_PAYMENT_CATEGORIES
1713	return sorted(categories.items())
1714
1715	@action(_('Create ticket'), style='primary')
1716	def createTicket(self, **data):
1717	p_category = data['p_category']
1718	previous_session = data.get('p_session', None)
1719	previous_level = data.get('p_level', None)
1720	student = self.context.__parent__
1721	# The hostel_application payment category is temporarily used
1722	# by Uniben.
1723	if p_category in ('bed_allocation', 'hostel_application') and student[
1724	'studycourse'].current_session != grok.getSite()[
1725	'hostels'].accommodation_session:
1726	self.flash(
1727	_('Your current session does not match ' + \
1728	'accommodation session.'), type="danger")
1729	return
1730	if 'maintenance' in p_category:
1731	current_session = str(student['studycourse'].current_session)
1732	if not current_session in student['accommodation']:
1733	self.flash(_('You have not yet booked accommodation.'),
1734	type="warning")
1735	return
1736	students_utils = getUtility(IStudentsUtils)
1737	error, payment = students_utils.setPaymentDetails(
1738	p_category, student, previous_session, previous_level)
1739	if error is not None:
1740	self.flash(error, type="danger")
1741	return
1742	self.context[payment.p_id] = payment
1743	self.flash(_('Payment ticket created.'))
1744	self.context.writeLogMessage(self,'added: %s' % payment.p_id)
1745	self.redirect(self.url(self.context))
1746	return
1747
1748	@action(_('Cancel'), validator=NullValidator)
1749	def cancel(self, **data):
1750	self.redirect(self.url(self.context))
1751
1752	class PreviousPaymentAddFormPage(KofaAddFormPage):
1753	""" Page to add an online payment ticket for previous sessions.
1754	"""
1755	grok.context(IStudentPaymentsContainer)
1756	grok.name('addpp')
1757	grok.require('waeup.payStudent')
1758	form_fields = grok.AutoFields(IStudentPreviousPayment)
1759	label = _('Add previous session online payment')
1760	pnav = 4
1761
1762	def update(self):
1763	if self.context.student.before_payment:
1764	self.flash(_("No previous payment to be made."), type="warning")
1765	self.redirect(self.url(self.context))
1766	super(PreviousPaymentAddFormPage, self).update()
1767	return
1768
1769	@action(_('Create ticket'), style='primary')
1770	def createTicket(self, **data):
1771	p_category = data['p_category']
1772	previous_session = data.get('p_session', None)
1773	previous_level = data.get('p_level', None)
1774	student = self.context.__parent__
1775	students_utils = getUtility(IStudentsUtils)
1776	error, payment = students_utils.setPaymentDetails(
1777	p_category, student, previous_session, previous_level)
1778	if error is not None:
1779	self.flash(error, type="danger")
1780	return
1781	self.context[payment.p_id] = payment
1782	self.flash(_('Payment ticket created.'))
1783	self.redirect(self.url(self.context))
1784	return
1785
1786	@action(_('Cancel'), validator=NullValidator)
1787	def cancel(self, **data):
1788	self.redirect(self.url(self.context))
1789
1790	class BalancePaymentAddFormPage(KofaAddFormPage):
1791	""" Page to add an online payment which can balance s previous session
1792	payment.
1793	"""
1794	grok.context(IStudentPaymentsContainer)
1795	grok.name('addbp')
1796	grok.require('waeup.manageStudent')
1797	form_fields = grok.AutoFields(IStudentBalancePayment)
1798	label = _('Add balance')
1799	pnav = 4
1800
1801	@action(_('Create ticket'), style='primary')
1802	def createTicket(self, **data):
1803	p_category = data['p_category']
1804	balance_session = data.get('balance_session', None)
1805	balance_level = data.get('balance_level', None)
1806	balance_amount = data.get('balance_amount', None)
1807	student = self.context.__parent__
1808	students_utils = getUtility(IStudentsUtils)
1809	error, payment = students_utils.setBalanceDetails(
1810	p_category, student, balance_session,
1811	balance_level, balance_amount)
1812	if error is not None:
1813	self.flash(error, type="danger")
1814	return
1815	self.context[payment.p_id] = payment
1816	self.flash(_('Payment ticket created.'))
1817	self.context.writeLogMessage(self,'added: %s' % payment.p_id)
1818	self.redirect(self.url(self.context))
1819	return
1820
1821	@action(_('Cancel'), validator=NullValidator)
1822	def cancel(self, **data):
1823	self.redirect(self.url(self.context))
1824
1825	class OnlinePaymentDisplayFormPage(KofaDisplayFormPage):
1826	""" Page to view an online payment ticket
1827	"""
1828	grok.context(IStudentOnlinePayment)
1829	grok.name('index')
1830	grok.require('waeup.viewStudent')
1831	form_fields = grok.AutoFields(IStudentOnlinePayment).omit('p_item')
1832	form_fields[
1833	'creation_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
1834	form_fields[
1835	'payment_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
1836	pnav = 4
1837
1838	@property
1839	def label(self):
1840	return _('${a}: Online Payment Ticket ${b}', mapping = {
1841	'a':self.context.student.display_fullname,
1842	'b':self.context.p_id})
1843
1844	class OnlinePaymentApproveView(UtilityView, grok.View):
1845	""" Callback view
1846	"""
1847	grok.context(IStudentOnlinePayment)
1848	grok.name('approve')
1849	grok.require('waeup.managePortal')
1850
1851	def update(self):
1852	flashtype, msg, log = self.context.approveStudentPayment()
1853	if log is not None:
1854	# Add log message to students.log
1855	self.context.writeLogMessage(self,log)
1856	# Add log message to payments.log
1857	self.context.logger.info(
1858	'%s,%s,%s,%s,%s,,,,,,' % (
1859	self.context.student.student_id,
1860	self.context.p_id, self.context.p_category,
1861	self.context.amount_auth, self.context.r_code))
1862	self.flash(msg, type=flashtype)
1863	return
1864
1865	def render(self):
1866	self.redirect(self.url(self.context, '@@index'))
1867	return
1868
1869	class OnlinePaymentFakeApproveView(OnlinePaymentApproveView):
1870	""" Approval view for students.
1871
1872	This view is used for browser tests only and
1873	must be neutralized in custom pages!
1874	"""
1875	grok.name('fake_approve')
1876	grok.require('waeup.payStudent')
1877
1878	class ExportPDFPaymentSlip(UtilityView, grok.View):
1879	"""Deliver a PDF slip of the context.
1880	"""
1881	grok.context(IStudentOnlinePayment)
1882	grok.name('payment_slip.pdf')
1883	grok.require('waeup.viewStudent')
1884	form_fields = grok.AutoFields(IStudentOnlinePayment).omit('p_item')
1885	form_fields['creation_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
1886	form_fields['payment_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
1887	prefix = 'form'
1888	note = None
1889	omit_fields = (
1890	'password', 'suspended', 'phone', 'date_of_birth',
1891	'adm_code', 'sex', 'suspended_comment', 'current_level')
1892
1893	@property
1894	def title(self):
1895	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
1896	return translate(_('Payment Data'), 'waeup.kofa',
1897	target_language=portal_language)
1898
1899	@property
1900	def label(self):
1901	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
1902	return translate(_('Online Payment Slip'),
1903	'waeup.kofa', target_language=portal_language) \
1904	+ ' %s' % self.context.p_id
1905
1906	def render(self):
1907	#if self.context.p_state != 'paid':
1908	# self.flash('Ticket not yet paid.')
1909	# self.redirect(self.url(self.context))
1910	# return
1911	studentview = StudentBasePDFFormPage(self.context.student,
1912	self.request, self.omit_fields)
1913	students_utils = getUtility(IStudentsUtils)
1914	return students_utils.renderPDF(self, 'payment_slip.pdf',
1915	self.context.student, studentview, note=self.note,
1916	omit_fields=self.omit_fields)
1917
1918
1919	class AccommodationManageFormPage(KofaEditFormPage):
1920	""" Page to manage bed tickets.
1921
1922	This manage form page is for both students and students officers.
1923	"""
1924	grok.context(IStudentAccommodation)
1925	grok.name('index')
1926	grok.require('waeup.handleAccommodation')
1927	form_fields = grok.AutoFields(IStudentAccommodation)
1928	grok.template('accommodationmanagepage')
1929	pnav = 4
1930	with_hostel_selection = True
1931
1932	@property
1933	def actionsgroup1(self):
1934	if not self.with_hostel_selection:
1935	return []
1936	students_utils = getUtility(IStudentsUtils)
1937	acc_details = students_utils.getAccommodationDetails(self.context.student)
1938	error_message = students_utils.checkAccommodationRequirements(
1939	self.context.student, acc_details)
1940	if error_message:
1941	return []
1942	return [_('Save')]
1943
1944	@property
1945	def actionsgroup2(self):
1946	if getattr(self.request.principal, 'user_type', None) == 'student':
1947	return [_('Book accommodation')]
1948	return [_('Book accommodation'), _('Remove selected')]
1949
1950	@property
1951	def label(self):
1952	return _('${a}: Accommodation',
1953	mapping = {'a':self.context.__parent__.display_fullname})
1954
1955	@property
1956	def desired_hostel(self):
1957	if self.context.desired_hostel:
1958	hostel = grok.getSite()['hostels'].get(self.context.desired_hostel)
1959	if hostel is not None:
1960	return hostel.hostel_name
1961	return
1962
1963	def getHostels(self):
1964	"""Get a list of all stored hostels.
1965	"""
1966	yield(dict(name=None, title='--', selected=''))
1967	for val in grok.getSite()['hostels'].values():
1968	selected = ''
1969	if val.hostel_id == self.context.desired_hostel:
1970	selected = 'selected'
1971	yield(dict(name=val.hostel_id, title=val.hostel_name,
1972	selected=selected))
1973
1974	@action(_('Save'), style='primary')
1975	def save(self):
1976	hostel = self.request.form.get('hostel', None)
1977	self.context.desired_hostel = hostel
1978	self.flash(_('Your selection has been saved.'))
1979	return
1980
1981	@action(_('Book accommodation'), style='primary')
1982	def bookAccommodation(self, **data):
1983	self.redirect(self.url(self.context, 'add'))
1984	return
1985
1986	@jsaction(_('Remove selected'))
1987	def delBedTickets(self, **data):
1988	if getattr(self.request.principal, 'user_type', None) == 'student':
1989	self.flash(_('You are not allowed to remove bed tickets.'),
1990	type="warning")
1991	self.redirect(self.url(self.context))
1992	return
1993	form = self.request.form
1994	if 'val_id' in form:
1995	child_id = form['val_id']
1996	else:
1997	self.flash(_('No bed ticket selected.'), type="warning")
1998	self.redirect(self.url(self.context))
1999	return
2000	if not isinstance(child_id, list):
2001	child_id = [child_id]
2002	deleted = []
2003	for id in child_id:
2004	del self.context[id]
2005	deleted.append(id)
2006	if len(deleted):
2007	self.flash(_('Successfully removed: ${a}',
2008	mapping = {'a':', '.join(deleted)}))
2009	self.context.writeLogMessage(
2010	self,'removed: % s' % ', '.join(deleted))
2011	self.redirect(self.url(self.context))
2012	return
2013
2014	class BedTicketAddPage(KofaPage):
2015	""" Page to add an online payment ticket
2016	"""
2017	grok.context(IStudentAccommodation)
2018	grok.name('add')
2019	grok.require('waeup.handleAccommodation')
2020	grok.template('enterpin')
2021	ac_prefix = 'HOS'
2022	label = _('Add bed ticket')
2023	pnav = 4
2024	buttonname = _('Create bed ticket')
2025	notice = ''
2026	with_ac = True
2027
2028	def update(self, SUBMIT=None):
2029	student = self.context.student
2030	students_utils = getUtility(IStudentsUtils)
2031	acc_details = students_utils.getAccommodationDetails(student)
2032	error_message = students_utils.checkAccommodationRequirements(
2033	student, acc_details)
2034	if error_message:
2035	self.flash(error_message, type="warning")
2036	self.redirect(self.url(self.context))
2037	return
2038	if self.with_ac:
2039	self.ac_series = self.request.form.get('ac_series', None)
2040	self.ac_number = self.request.form.get('ac_number', None)
2041	if SUBMIT is None:
2042	return
2043	if self.with_ac:
2044	pin = '%s-%s-%s' % (self.ac_prefix, self.ac_series, self.ac_number)
2045	code = get_access_code(pin)
2046	if not code:
2047	self.flash(_('Activation code is invalid.'), type="warning")
2048	return
2049	# Search and book bed
2050	cat = queryUtility(ICatalog, name='beds_catalog', default=None)
2051	entries = cat.searchResults(
2052	owner=(student.student_id,student.student_id))
2053	if len(entries):
2054	# If bed space has been manually allocated use this bed
2055	manual = True
2056	bed = [entry for entry in entries][0]
2057	# Safety belt for paranoids: Does this bed really exist on portal?
2058	# XXX: Can be remove if nobody complains.
2059	if bed.__parent__.__parent__ is None:
2060	self.flash(_('System error: Please contact the adminsitrator.'),
2061	type="danger")
2062	self.context.writeLogMessage(
2063	self, 'fatal error: %s' % bed.bed_id)
2064	return
2065	else:
2066	# else search for other available beds
2067	manual = False
2068	entries = cat.searchResults(
2069	bed_type=(acc_details['bt'],acc_details['bt']))
2070	available_beds = [
2071	entry for entry in entries if entry.owner == NOT_OCCUPIED]
2072	if available_beds:
2073	students_utils = getUtility(IStudentsUtils)
2074	bed = students_utils.selectBed(
2075	available_beds, self.context.desired_hostel)
2076	if bed is None:
2077	self.flash(_(
2078	'There is no free bed in your desired hostel. '
2079	'Please try another hostel.'),
2080	type="warning")
2081	self.redirect(self.url(self.context))
2082	return
2083	# Safety belt for paranoids: Does this bed really exist
2084	# in portal?
2085	# XXX: Can be remove if nobody complains.
2086	if bed.__parent__.__parent__ is None:
2087	self.flash(_(
2088	'System error: Please contact the administrator.'),
2089	type="warning")
2090	self.context.writeLogMessage(
2091	self, 'fatal error: %s' % bed.bed_id)
2092	return
2093	bed.bookBed(student.student_id)
2094	else:
2095	self.flash(_('There is no free bed in your category ${a}.',
2096	mapping = {'a':acc_details['bt']}), type="warning")
2097	self.redirect(self.url(self.context))
2098	return
2099	if self.with_ac:
2100	# Mark pin as used (this also fires a pin related transition)
2101	if code.state == USED:
2102	self.flash(_('Activation code has already been used.'),
2103	type="warning")
2104	if not manual:
2105	# Release the previously booked bed
2106	bed.owner = NOT_OCCUPIED
2107	# Catalog must be informed
2108	notify(grok.ObjectModifiedEvent(bed))
2109	return
2110	else:
2111	comment = _(u'invalidated')
2112	# Here we know that the ac is in state initialized so we do not
2113	# expect an exception, but the owner might be different
2114	success = invalidate_accesscode(
2115	pin, comment, self.context.student.student_id)
2116	if not success:
2117	self.flash(_('You are not the owner of this access code.'),
2118	type="warning")
2119	if not manual:
2120	# Release the previously booked bed
2121	bed.owner = NOT_OCCUPIED
2122	# Catalog must be informed
2123	notify(grok.ObjectModifiedEvent(bed))
2124	return
2125	# Create bed ticket
2126	bedticket = createObject(u'waeup.BedTicket')
2127	if self.with_ac:
2128	bedticket.booking_code = pin
2129	bedticket.booking_session = acc_details['booking_session']
2130	bedticket.bed_type = acc_details['bt']
2131	bedticket.bed = bed
2132	hall_title = bed.__parent__.hostel_name
2133	coordinates = bed.coordinates[1:]
2134	block, room_nr, bed_nr = coordinates
2135	bc = _('${a}, Block ${b}, Room ${c}, Bed ${d} (${e})', mapping = {
2136	'a':hall_title, 'b':block,
2137	'c':room_nr, 'd':bed_nr,
2138	'e':bed.bed_type})
2139	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
2140	bedticket.bed_coordinates = translate(
2141	bc, 'waeup.kofa',target_language=portal_language)
2142	self.context.addBedTicket(bedticket)
2143	self.context.writeLogMessage(self, 'booked: %s' % bed.bed_id)
2144	self.flash(_('Bed ticket created and bed booked: ${a}',
2145	mapping = {'a':bedticket.display_coordinates}))
2146	self.redirect(self.url(self.context))
2147	return
2148
2149	class BedTicketDisplayFormPage(KofaDisplayFormPage):
2150	""" Page to display bed tickets
2151	"""
2152	grok.context(IBedTicket)
2153	grok.name('index')
2154	grok.require('waeup.handleAccommodation')
2155	form_fields = grok.AutoFields(IBedTicket).omit('bed_coordinates')
2156	form_fields['booking_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
2157	pnav = 4
2158
2159	@property
2160	def label(self):
2161	return _('Bed Ticket for Session ${a}',
2162	mapping = {'a':self.context.getSessionString()})
2163
2164	class ExportPDFBedTicketSlip(UtilityView, grok.View):
2165	"""Deliver a PDF slip of the context.
2166	"""
2167	grok.context(IBedTicket)
2168	grok.name('bed_allocation_slip.pdf')
2169	grok.require('waeup.handleAccommodation')
2170	form_fields = grok.AutoFields(IBedTicket).omit('bed_coordinates')
2171	form_fields['booking_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
2172	prefix = 'form'
2173	omit_fields = (
2174	'password', 'suspended', 'phone', 'adm_code',
2175	'suspended_comment', 'date_of_birth', 'current_level')
2176
2177	@property
2178	def title(self):
2179	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
2180	return translate(_('Bed Allocation Data'), 'waeup.kofa',
2181	target_language=portal_language)
2182
2183	@property
2184	def label(self):
2185	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
2186	#return translate(_('Bed Allocation: '),
2187	# 'waeup.kofa', target_language=portal_language) \
2188	# + ' %s' % self.context.bed_coordinates
2189	return translate(_('Bed Allocation Slip'),
2190	'waeup.kofa', target_language=portal_language) \
2191	+ ' %s' % self.context.getSessionString()
2192
2193	def render(self):
2194	studentview = StudentBasePDFFormPage(self.context.student,
2195	self.request, self.omit_fields)
2196	students_utils = getUtility(IStudentsUtils)
2197	return students_utils.renderPDF(
2198	self, 'bed_allocation_slip.pdf',
2199	self.context.student, studentview,
2200	omit_fields=self.omit_fields)
2201
2202	class BedTicketRelocationView(UtilityView, grok.View):
2203	""" Callback view
2204	"""
2205	grok.context(IBedTicket)
2206	grok.name('relocate')
2207	grok.require('waeup.manageHostels')
2208
2209	# Relocate student if student parameters have changed or the bed_type
2210	# of the bed has changed
2211	def update(self):
2212	success, msg = self.context.relocateStudent()
2213	if not success:
2214	self.flash(msg, type="warning")
2215	else:
2216	self.flash(msg)
2217	self.redirect(self.url(self.context))
2218	return
2219
2220	def render(self):
2221	return
2222
2223	class StudentHistoryPage(KofaPage):
2224	""" Page to display student history
2225	"""
2226	grok.context(IStudent)
2227	grok.name('history')
2228	grok.require('waeup.viewStudent')
2229	grok.template('studenthistory')
2230	pnav = 4
2231
2232	@property
2233	def label(self):
2234	return _('${a}: History', mapping = {'a':self.context.display_fullname})
2235
2236	# Pages for students only
2237
2238	class StudentBaseEditFormPage(KofaEditFormPage):
2239	""" View to edit student base data
2240	"""
2241	grok.context(IStudent)
2242	grok.name('edit_base')
2243	grok.require('waeup.handleStudent')
2244	form_fields = grok.AutoFields(IStudentBase).select(
2245	'email', 'phone')
2246	label = _('Edit base data')
2247	pnav = 4
2248
2249	@action(_('Save'), style='primary')
2250	def save(self, **data):
2251	msave(self, **data)
2252	return
2253
2254	class StudentChangePasswordPage(KofaEditFormPage):
2255	""" View to edit student passwords
2256	"""
2257	grok.context(IStudent)
2258	grok.name('change_password')
2259	grok.require('waeup.handleStudent')
2260	grok.template('change_password')
2261	label = _('Change password')
2262	pnav = 4
2263
2264	@action(_('Save'), style='primary')
2265	def save(self, **data):
2266	form = self.request.form
2267	password = form.get('change_password', None)
2268	password_ctl = form.get('change_password_repeat', None)
2269	if password:
2270	validator = getUtility(IPasswordValidator)
2271	errors = validator.validate_password(password, password_ctl)
2272	if not errors:
2273	IUserAccount(self.context).setPassword(password)
2274	# Unset temporary password
2275	self.context.temp_password = None
2276	self.context.writeLogMessage(self, 'saved: password')
2277	self.flash(_('Password changed.'))
2278	else:
2279	self.flash( ' '.join(errors), type="warning")
2280	return
2281
2282	class StudentFilesUploadPage(KofaPage):
2283	""" View to upload files by student
2284	"""
2285	grok.context(IStudent)
2286	grok.name('change_portrait')
2287	grok.require('waeup.uploadStudentFile')
2288	grok.template('filesuploadpage')
2289	label = _('Upload portrait')
2290	pnav = 4
2291
2292	def update(self):
2293	PORTRAIT_CHANGE_STATES = getUtility(IStudentsUtils).PORTRAIT_CHANGE_STATES
2294	if self.context.student.state not in PORTRAIT_CHANGE_STATES:
2295	emit_lock_message(self)
2296	return
2297	super(StudentFilesUploadPage, self).update()
2298	return
2299
2300	class StartClearancePage(KofaPage):
2301	grok.context(IStudent)
2302	grok.name('start_clearance')
2303	grok.require('waeup.handleStudent')
2304	grok.template('enterpin')
2305	label = _('Start clearance')
2306	ac_prefix = 'CLR'
2307	notice = ''
2308	pnav = 4
2309	buttonname = _('Start clearance now')
2310	with_ac = True
2311
2312	@property
2313	def all_required_fields_filled(self):
2314	if not self.context.email:
2315	return _("Email address is missing."), 'edit_base'
2316	if not self.context.phone:
2317	return _("Phone number is missing."), 'edit_base'
2318	return
2319
2320	@property
2321	def portrait_uploaded(self):
2322	store = getUtility(IExtFileStore)
2323	if store.getFileByContext(self.context, attr=u'passport.jpg'):
2324	return True
2325	return False
2326
2327	def update(self, SUBMIT=None):
2328	if not self.context.state == ADMITTED:
2329	self.flash(_("Wrong state"), type="warning")
2330	self.redirect(self.url(self.context))
2331	return
2332	if not self.portrait_uploaded:
2333	self.flash(_("No portrait uploaded."), type="warning")
2334	self.redirect(self.url(self.context, 'change_portrait'))
2335	return
2336	if self.all_required_fields_filled:
2337	arf_warning = self.all_required_fields_filled[0]
2338	arf_redirect = self.all_required_fields_filled[1]
2339	self.flash(arf_warning, type="warning")
2340	self.redirect(self.url(self.context, arf_redirect))
2341	return
2342	if self.with_ac:
2343	self.ac_series = self.request.form.get('ac_series', None)
2344	self.ac_number = self.request.form.get('ac_number', None)
2345	if SUBMIT is None:
2346	return
2347	if self.with_ac:
2348	pin = '%s-%s-%s' % (self.ac_prefix, self.ac_series, self.ac_number)
2349	code = get_access_code(pin)
2350	if not code:
2351	self.flash(_('Activation code is invalid.'), type="warning")
2352	return
2353	if code.state == USED:
2354	self.flash(_('Activation code has already been used.'),
2355	type="warning")
2356	return
2357	# Mark pin as used (this also fires a pin related transition)
2358	# and fire transition start_clearance
2359	comment = _(u"invalidated")
2360	# Here we know that the ac is in state initialized so we do not
2361	# expect an exception, but the owner might be different
2362	if not invalidate_accesscode(pin, comment, self.context.student_id):
2363	self.flash(_('You are not the owner of this access code.'),
2364	type="warning")
2365	return
2366	self.context.clr_code = pin
2367	IWorkflowInfo(self.context).fireTransition('start_clearance')
2368	self.flash(_('Clearance process has been started.'))
2369	self.redirect(self.url(self.context,'cedit'))
2370	return
2371
2372	class StudentClearanceEditFormPage(StudentClearanceManageFormPage):
2373	""" View to edit student clearance data by student
2374	"""
2375	grok.context(IStudent)
2376	grok.name('cedit')
2377	grok.require('waeup.handleStudent')
2378	label = _('Edit clearance data')
2379
2380	@property
2381	def form_fields(self):
2382	if self.context.is_postgrad:
2383	form_fields = grok.AutoFields(IPGStudentClearance).omit(
2384	'clr_code', 'officer_comment')
2385	else:
2386	form_fields = grok.AutoFields(IUGStudentClearance).omit(
2387	'clr_code', 'officer_comment')
2388	return form_fields
2389
2390	def update(self):
2391	if self.context.clearance_locked:
2392	emit_lock_message(self)
2393	return
2394	return super(StudentClearanceEditFormPage, self).update()
2395
2396	@action(_('Save'), style='primary')
2397	def save(self, **data):
2398	self.applyData(self.context, **data)
2399	self.flash(_('Clearance form has been saved.'))
2400	return
2401
2402	def dataNotComplete(self):
2403	"""To be implemented in the customization package.
2404	"""
2405	return False
2406
2407	@action(_('Save and request clearance'), style='primary')
2408	def requestClearance(self, **data):
2409	self.applyData(self.context, **data)
2410	if self.dataNotComplete():
2411	self.flash(self.dataNotComplete(), type="warning")
2412	return
2413	self.flash(_('Clearance form has been saved.'))
2414	if self.context.clr_code:
2415	self.redirect(self.url(self.context, 'request_clearance'))
2416	else:
2417	# We bypass the request_clearance page if student
2418	# has been imported in state 'clearance started' and
2419	# no clr_code was entered before.
2420	state = IWorkflowState(self.context).getState()
2421	if state != CLEARANCE:
2422	# This shouldn't happen, but the application officer
2423	# might have forgotten to lock the form after changing the state
2424	self.flash(_('This form cannot be submitted. Wrong state!'),
2425	type="danger")
2426	return
2427	IWorkflowInfo(self.context).fireTransition('request_clearance')
2428	self.flash(_('Clearance has been requested.'))
2429	self.redirect(self.url(self.context))
2430	return
2431
2432	class RequestClearancePage(KofaPage):
2433	grok.context(IStudent)
2434	grok.name('request_clearance')
2435	grok.require('waeup.handleStudent')
2436	grok.template('enterpin')
2437	label = _('Request clearance')
2438	notice = _('Enter the CLR access code used for starting clearance.')
2439	ac_prefix = 'CLR'
2440	pnav = 4
2441	buttonname = _('Request clearance now')
2442	with_ac = True
2443
2444	def update(self, SUBMIT=None):
2445	if self.with_ac:
2446	self.ac_series = self.request.form.get('ac_series', None)
2447	self.ac_number = self.request.form.get('ac_number', None)
2448	if SUBMIT is None:
2449	return
2450	if self.with_ac:
2451	pin = '%s-%s-%s' % (self.ac_prefix, self.ac_series, self.ac_number)
2452	if self.context.clr_code and self.context.clr_code != pin:
2453	self.flash(_("This isn't your CLR access code."), type="danger")
2454	return
2455	state = IWorkflowState(self.context).getState()
2456	if state != CLEARANCE:
2457	# This shouldn't happen, but the application officer
2458	# might have forgotten to lock the form after changing the state
2459	self.flash(_('This form cannot be submitted. Wrong state!'),
2460	type="danger")
2461	return
2462	IWorkflowInfo(self.context).fireTransition('request_clearance')
2463	self.flash(_('Clearance has been requested.'))
2464	self.redirect(self.url(self.context))
2465	return
2466
2467	class StartSessionPage(KofaPage):
2468	grok.context(IStudentStudyCourse)
2469	grok.name('start_session')
2470	grok.require('waeup.handleStudent')
2471	grok.template('enterpin')
2472	label = _('Start session')
2473	ac_prefix = 'SFE'
2474	notice = ''
2475	pnav = 4
2476	buttonname = _('Start now')
2477	with_ac = True
2478
2479	def update(self, SUBMIT=None):
2480	if not self.context.is_current:
2481	emit_lock_message(self)
2482	return
2483	super(StartSessionPage, self).update()
2484	if not self.context.next_session_allowed:
2485	self.flash(_("You are not entitled to start session."),
2486	type="warning")
2487	self.redirect(self.url(self.context))
2488	return
2489	if self.with_ac:
2490	self.ac_series = self.request.form.get('ac_series', None)
2491	self.ac_number = self.request.form.get('ac_number', None)
2492	if SUBMIT is None:
2493	return
2494	if self.with_ac:
2495	pin = '%s-%s-%s' % (self.ac_prefix, self.ac_series, self.ac_number)
2496	code = get_access_code(pin)
2497	if not code:
2498	self.flash(_('Activation code is invalid.'), type="warning")
2499	return
2500	# Mark pin as used (this also fires a pin related transition)
2501	if code.state == USED:
2502	self.flash(_('Activation code has already been used.'),
2503	type="warning")
2504	return
2505	else:
2506	comment = _(u"invalidated")
2507	# Here we know that the ac is in state initialized so we do not
2508	# expect an error, but the owner might be different
2509	if not invalidate_accesscode(
2510	pin,comment,self.context.student.student_id):
2511	self.flash(_('You are not the owner of this access code.'),
2512	type="warning")
2513	return
2514	try:
2515	if self.context.student.state == CLEARED:
2516	IWorkflowInfo(self.context.student).fireTransition(
2517	'pay_first_school_fee')
2518	elif self.context.student.state == RETURNING:
2519	IWorkflowInfo(self.context.student).fireTransition(
2520	'pay_school_fee')
2521	elif self.context.student.state == PAID:
2522	IWorkflowInfo(self.context.student).fireTransition(
2523	'pay_pg_fee')
2524	except ConstraintNotSatisfied:
2525	self.flash(_('An error occurred, please contact the system administrator.'),
2526	type="danger")
2527	return
2528	self.flash(_('Session started.'))
2529	self.redirect(self.url(self.context))
2530	return
2531
2532	class AddStudyLevelFormPage(KofaEditFormPage):
2533	""" Page for students to add current study levels
2534	"""
2535	grok.context(IStudentStudyCourse)
2536	grok.name('add')
2537	grok.require('waeup.handleStudent')
2538	grok.template('studyleveladdpage')
2539	form_fields = grok.AutoFields(IStudentStudyCourse)
2540	pnav = 4
2541
2542	@property
2543	def label(self):
2544	studylevelsource = StudyLevelSource().factory
2545	code = self.context.current_level
2546	title = studylevelsource.getTitle(self.context, code)
2547	return _('Add current level ${a}', mapping = {'a':title})
2548
2549	def update(self):
2550	if not self.context.is_current:
2551	emit_lock_message(self)
2552	return
2553	if self.context.student.state != PAID:
2554	emit_lock_message(self)
2555	return
2556	code = self.context.current_level
2557	if code is None:
2558	self.flash(_('Your data are incomplete'), type="danger")
2559	self.redirect(self.url(self.context))
2560	return
2561	super(AddStudyLevelFormPage, self).update()
2562	return
2563
2564	@action(_('Create course list now'), style='primary')
2565	def addStudyLevel(self, **data):
2566	studylevel = createObject(u'waeup.StudentStudyLevel')
2567	studylevel.level = self.context.current_level
2568	studylevel.level_session = self.context.current_session
2569	try:
2570	self.context.addStudentStudyLevel(
2571	self.context.certificate,studylevel)
2572	except KeyError:
2573	self.flash(_('This level exists.'), type="warning")
2574	except RequiredMissing:
2575	self.flash(_('Your data are incomplete'), type="danger")
2576	self.redirect(self.url(self.context))
2577	return
2578
2579	class StudyLevelEditFormPage(KofaEditFormPage):
2580	""" Page to edit the student study level data by students
2581	"""
2582	grok.context(IStudentStudyLevel)
2583	grok.name('edit')
2584	grok.require('waeup.editStudyLevel')
2585	grok.template('studyleveleditpage')
2586	pnav = 4
2587	placeholder = _('Enter valid course code')
2588
2589	def update(self, ADD=None, course=None):
2590	if not self.context.__parent__.is_current:
2591	emit_lock_message(self)
2592	return
2593	if self.context.student.state != PAID or \
2594	not self.context.is_current_level:
2595	emit_lock_message(self)
2596	return
2597	super(StudyLevelEditFormPage, self).update()
2598	if ADD is not None:
2599	if not course:
2600	self.flash(_('No valid course code entered.'), type="warning")
2601	return
2602	cat = queryUtility(ICatalog, name='courses_catalog')
2603	result = cat.searchResults(code=(course, course))
2604	if len(result) != 1:
2605	self.flash(_('Course not found.'), type="warning")
2606	return
2607	course = list(result)[0]
2608	addCourseTicket(self, course)
2609	return
2610
2611	@property
2612	def label(self):
2613	# Here we know that the cookie has been set
2614	lang = self.request.cookies.get('kofa.language')
2615	level_title = translate(self.context.level_title, 'waeup.kofa',
2616	target_language=lang)
2617	return _('Edit course list of ${a}',
2618	mapping = {'a':level_title})
2619
2620	@property
2621	def translated_values(self):
2622	return translated_values(self)
2623
2624	def _delCourseTicket(self, **data):
2625	form = self.request.form
2626	if 'val_id' in form:
2627	child_id = form['val_id']
2628	else:
2629	self.flash(_('No ticket selected.'), type="warning")
2630	self.redirect(self.url(self.context, '@@edit'))
2631	return
2632	if not isinstance(child_id, list):
2633	child_id = [child_id]
2634	deleted = []
2635	for id in child_id:
2636	# Students are not allowed to remove core tickets
2637	if id in self.context and \
2638	self.context[id].removable_by_student:
2639	del self.context[id]
2640	deleted.append(id)
2641	if len(deleted):
2642	self.flash(_('Successfully removed: ${a}',
2643	mapping = {'a':', '.join(deleted)}))
2644	self.context.writeLogMessage(
2645	self,'removed: %s at %s' %
2646	(', '.join(deleted), self.context.level))
2647	self.redirect(self.url(self.context, u'@@edit'))
2648	return
2649
2650	@jsaction(_('Remove selected tickets'))
2651	def delCourseTicket(self, **data):
2652	self._delCourseTicket(**data)
2653	return
2654
2655	def _registerCourses(self, **data):
2656	if self.context.student.is_postgrad and \
2657	not self.context.student.is_special_postgrad:
2658	self.flash(_(
2659	"You are a postgraduate student, "
2660	"your course list can't bee registered."), type="warning")
2661	self.redirect(self.url(self.context))
2662	return
2663	students_utils = getUtility(IStudentsUtils)
2664	max_credits = students_utils.maxCredits(self.context)
2665	if max_credits and self.context.total_credits > max_credits:
2666	self.flash(_('Maximum credits of ${a} exceeded.',
2667	mapping = {'a':max_credits}), type="warning")
2668	return
2669	if not self.context.course_registration_allowed:
2670	self.flash(_(
2671	"Course registration has ended. "
2672	"Please pay the late registration fee."), type="warning")
2673	#self.redirect(self.url(self.context))
2674	return
2675	IWorkflowInfo(self.context.student).fireTransition(
2676	'register_courses')
2677	self.flash(_('Course list has been registered.'))
2678	self.redirect(self.url(self.context))
2679	return
2680
2681	@action(_('Register course list'), style='primary',
2682	warning=_('You can not edit your course list after registration.'
2683	' You really want to register?'))
2684	def registerCourses(self, **data):
2685	self._registerCourses(**data)
2686	return
2687
2688	class CourseTicketAddFormPage2(CourseTicketAddFormPage):
2689	"""Add a course ticket by student.
2690	"""
2691	grok.name('ctadd')
2692	grok.require('waeup.handleStudent')
2693	form_fields = grok.AutoFields(ICourseTicketAdd)
2694
2695	def update(self):
2696	if self.context.student.state != PAID or \
2697	not self.context.is_current_level:
2698	emit_lock_message(self)
2699	return
2700	super(CourseTicketAddFormPage2, self).update()
2701	return
2702
2703	@action(_('Add course ticket'))
2704	def addCourseTicket(self, **data):
2705	# Safety belt
2706	if self.context.student.state != PAID:
2707	return
2708	course = data['course']
2709	success = addCourseTicket(self, course)
2710	if success:
2711	self.redirect(self.url(self.context, u'@@edit'))
2712	return
2713
2714	class SetPasswordPage(KofaPage):
2715	grok.context(IKofaObject)
2716	grok.name('setpassword')
2717	grok.require('waeup.Anonymous')
2718	grok.template('setpassword')
2719	label = _('Set password for first-time login')
2720	ac_prefix = 'PWD'
2721	pnav = 0
2722	set_button = _('Set')
2723
2724	def update(self, SUBMIT=None):
2725	self.reg_number = self.request.form.get('reg_number', None)
2726	self.ac_series = self.request.form.get('ac_series', None)
2727	self.ac_number = self.request.form.get('ac_number', None)
2728
2729	if SUBMIT is None:
2730	return
2731	hitlist = search(query=self.reg_number,
2732	searchtype='reg_number', view=self)
2733	if not hitlist:
2734	self.flash(_('No student found.'), type="warning")
2735	return
2736	if len(hitlist) != 1: # Cannot happen but anyway
2737	self.flash(_('More than one student found.'), type="warning")
2738	return
2739	student = hitlist[0].context
2740	self.student_id = student.student_id
2741	student_pw = student.password
2742	pin = '%s-%s-%s' % (self.ac_prefix, self.ac_series, self.ac_number)
2743	code = get_access_code(pin)
2744	if not code:
2745	self.flash(_('Access code is invalid.'), type="warning")
2746	return
2747	if student_pw and pin == student.adm_code:
2748	self.flash(_(
2749	'Password has already been set. Your Student Id is ${a}',
2750	mapping = {'a':self.student_id}))
2751	return
2752	elif student_pw:
2753	self.flash(
2754	_('Password has already been set. You are using the ' +
2755	'wrong Access Code.'), type="warning")
2756	return
2757	# Mark pin as used (this also fires a pin related transition)
2758	# and set student password
2759	if code.state == USED:
2760	self.flash(_('Access code has already been used.'), type="warning")
2761	return
2762	else:
2763	comment = _(u"invalidated")
2764	# Here we know that the ac is in state initialized so we do not
2765	# expect an exception
2766	invalidate_accesscode(pin,comment)
2767	IUserAccount(student).setPassword(self.ac_number)
2768	student.adm_code = pin
2769	self.flash(_('Password has been set. Your Student Id is ${a}',
2770	mapping = {'a':self.student_id}))
2771	return
2772
2773	class StudentRequestPasswordPage(KofaAddFormPage):
2774	"""Captcha'd request password page for students.
2775	"""
2776	grok.name('requestpw')
2777	grok.require('waeup.Anonymous')
2778	grok.template('requestpw')
2779	form_fields = grok.AutoFields(IStudentRequestPW).select(
2780	'lastname','number','email')
2781	label = _('Request password for first-time login')
2782
2783	def update(self):
2784	blocker = grok.getSite()['configuration'].maintmode_enabled_by
2785	if blocker:
2786	self.flash(_('The portal is in maintenance mode. '
2787	'Password request forms are temporarily disabled.'),
2788	type='warning')
2789	self.redirect(self.url(self.context))
2790	return
2791	# Handle captcha
2792	self.captcha = getUtility(ICaptchaManager).getCaptcha()
2793	self.captcha_result = self.captcha.verify(self.request)
2794	self.captcha_code = self.captcha.display(self.captcha_result.error_code)
2795	return
2796
2797	def _redirect(self, email, password, student_id):
2798	# Forward only email to landing page in base package.
2799	self.redirect(self.url(self.context, 'requestpw_complete',
2800	data = dict(email=email)))
2801	return
2802
2803	def _pw_used(self):
2804	# XXX: False if password has not been used. We need an extra
2805	# attribute which remembers if student logged in.
2806	return True
2807
2808	@action(_('Send login credentials to email address'), style='primary')
2809	def get_credentials(self, **data):
2810	if not self.captcha_result.is_valid:
2811	# Captcha will display error messages automatically.
2812	# No need to flash something.
2813	return
2814	number = data.get('number','')
2815	lastname = data.get('lastname','')
2816	cat = getUtility(ICatalog, name='students_catalog')
2817	results = list(
2818	cat.searchResults(reg_number=(number, number)))
2819	if not results:
2820	results = list(
2821	cat.searchResults(matric_number=(number, number)))
2822	if results:
2823	student = results[0]
2824	if getattr(student,'lastname',None) is None:
2825	self.flash(_('An error occurred.'), type="danger")
2826	return
2827	elif student.lastname.lower() != lastname.lower():
2828	# Don't tell the truth here. Anonymous must not
2829	# know that a record was found and only the lastname
2830	# verification failed.
2831	self.flash(_('No student record found.'), type="warning")
2832	return
2833	elif student.password is not None and self._pw_used:
2834	self.flash(_('Your password has already been set and used. '
2835	'Please proceed to the login page.'),
2836	type="warning")
2837	return
2838	# Store email address but nothing else.
2839	student.email = data['email']
2840	notify(grok.ObjectModifiedEvent(student))
2841	else:
2842	# No record found, this is the truth.
2843	self.flash(_('No student record found.'), type="warning")
2844	return
2845
2846	kofa_utils = getUtility(IKofaUtils)
2847	password = kofa_utils.genPassword()
2848	mandate = PasswordMandate()
2849	mandate.params['password'] = password
2850	mandate.params['user'] = student
2851	site = grok.getSite()
2852	site['mandates'].addMandate(mandate)
2853	# Send email with credentials
2854	args = {'mandate_id':mandate.mandate_id}
2855	mandate_url = self.url(site) + '/mandate?%s' % urlencode(args)
2856	url_info = u'Confirmation link: %s' % mandate_url
2857	msg = _('You have successfully requested a password for the')
2858	if kofa_utils.sendCredentials(IUserAccount(student),
2859	password, url_info, msg):
2860	email_sent = student.email
2861	else:
2862	email_sent = None
2863	self._redirect(email=email_sent, password=password,
2864	student_id=student.student_id)
2865	ob_class = self.__implemented__.__name__.replace('waeup.kofa.','')
2866	self.context.logger.info(
2867	'%s - %s (%s) - %s' % (ob_class, number, student.student_id, email_sent))
2868	return
2869
2870	class StudentRequestPasswordEmailSent(KofaPage):
2871	"""Landing page after successful password request.
2872
2873	"""
2874	grok.name('requestpw_complete')
2875	grok.require('waeup.Public')
2876	grok.template('requestpwmailsent')
2877	label = _('Your password request was successful.')
2878
2879	def update(self, email=None, student_id=None, password=None):
2880	self.email = email
2881	self.password = password
2882	self.student_id = student_id
2883	return
2884
2885	class FilterStudentsInDepartmentPage(KofaPage):
2886	"""Page that filters and lists students.
2887	"""
2888	grok.context(IDepartment)
2889	grok.require('waeup.showStudents')
2890	grok.name('students')
2891	grok.template('filterstudentspage')
2892	pnav = 1
2893	session_label = _('Current Session')
2894	level_label = _('Current Level')
2895
2896	def label(self):
2897	return 'Students in %s' % self.context.longtitle
2898
2899	def _set_session_values(self):
2900	vocab_terms = academic_sessions_vocab.by_value.values()
2901	self.sessions = sorted(
2902	[(x.title, x.token) for x in vocab_terms], reverse=True)
2903	self.sessions += [('All Sessions', 'all')]
2904	return
2905
2906	def _set_level_values(self):
2907	vocab_terms = course_levels.by_value.values()
2908	self.levels = sorted(
2909	[(x.title, x.token) for x in vocab_terms])
2910	self.levels += [('All Levels', 'all')]
2911	return
2912
2913	def _searchCatalog(self, session, level):
2914	if level not in (10, 999, None):
2915	start_level = 100 * (level // 100)
2916	end_level = start_level + 90
2917	else:
2918	start_level = end_level = level
2919	cat = queryUtility(ICatalog, name='students_catalog')
2920	students = cat.searchResults(
2921	current_session=(session, session),
2922	current_level=(start_level, end_level),
2923	depcode=(self.context.code, self.context.code)
2924	)
2925	hitlist = []
2926	for student in students:
2927	hitlist.append(StudentQueryResultItem(student, view=self))
2928	return hitlist
2929
2930	def update(self, SHOW=None, session=None, level=None):
2931	self.parent_url = self.url(self.context.__parent__)
2932	self._set_session_values()
2933	self._set_level_values()
2934	self.hitlist = []
2935	self.session_default = session
2936	self.level_default = level
2937	if SHOW is not None:
2938	if session != 'all':
2939	self.session = int(session)
2940	self.session_string = '%s %s/%s' % (
2941	self.session_label, self.session, self.session+1)
2942	else:
2943	self.session = None
2944	self.session_string = _('in any session')
2945	if level != 'all':
2946	self.level = int(level)
2947	self.level_string = '%s %s' % (self.level_label, self.level)
2948	else:
2949	self.level = None
2950	self.level_string = _('at any level')
2951	self.hitlist = self._searchCatalog(self.session, self.level)
2952	if not self.hitlist:
2953	self.flash(_('No student found.'), type="warning")
2954	return
2955
2956	class FilterStudentsInCertificatePage(FilterStudentsInDepartmentPage):
2957	"""Page that filters and lists students.
2958	"""
2959	grok.context(ICertificate)
2960
2961	def label(self):
2962	return 'Students studying %s' % self.context.longtitle
2963
2964	def _searchCatalog(self, session, level):
2965	if level not in (10, 999, None):
2966	start_level = 100 * (level // 100)
2967	end_level = start_level + 90
2968	else:
2969	start_level = end_level = level
2970	cat = queryUtility(ICatalog, name='students_catalog')
2971	students = cat.searchResults(
2972	current_session=(session, session),
2973	current_level=(start_level, end_level),
2974	certcode=(self.context.code, self.context.code)
2975	)
2976	hitlist = []
2977	for student in students:
2978	hitlist.append(StudentQueryResultItem(student, view=self))
2979	return hitlist
2980
2981	class FilterStudentsInCoursePage(FilterStudentsInDepartmentPage):
2982	"""Page that filters and lists students.
2983	"""
2984	grok.context(ICourse)
2985
2986	session_label = _('Session')
2987	level_label = _('Level')
2988
2989	def label(self):
2990	return 'Students registered for %s' % self.context.longtitle
2991
2992	def _searchCatalog(self, session, level):
2993	if level not in (10, 999, None):
2994	start_level = 100 * (level // 100)
2995	end_level = start_level + 90
2996	else:
2997	start_level = end_level = level
2998	cat = queryUtility(ICatalog, name='coursetickets_catalog')
2999	coursetickets = cat.searchResults(
3000	session=(session, session),
3001	level=(start_level, end_level),
3002	code=(self.context.code, self.context.code)
3003	)
3004	hitlist = []
3005	for ticket in coursetickets:
3006	hitlist.append(StudentQueryResultItem(ticket.student, view=self))
3007	return list(set(hitlist))
3008
3009	class ClearAllStudentsInDepartmentView(UtilityView, grok.View):
3010	""" Clear all students of a department in state 'clearance requested'.
3011	"""
3012	grok.context(IDepartment)
3013	grok.name('clearallstudents')
3014	grok.require('waeup.clearAllStudents')
3015
3016	def update(self):
3017	cat = queryUtility(ICatalog, name='students_catalog')
3018	students = cat.searchResults(
3019	depcode=(self.context.code, self.context.code),
3020	state=(REQUESTED, REQUESTED)
3021	)
3022	num = 0
3023	for student in students:
3024	if getUtility(IStudentsUtils).clearance_disabled_message(student):
3025	continue
3026	IWorkflowInfo(student).fireTransition('clear')
3027	num += 1
3028	self.flash(_('%d students have been cleared.' % num))
3029	self.redirect(self.url(self.context))
3030	return
3031
3032	def render(self):
3033	return
3034
3035
3036	class EditScoresPage(KofaPage):
3037	"""Page that filters and lists students.
3038	"""
3039	grok.context(ICourse)
3040	grok.require('waeup.editScores')
3041	grok.name('edit_scores')
3042	grok.template('editscorespage')
3043	pnav = 1
3044
3045	def label(self):
3046	session = academic_sessions_vocab.getTerm(
3047	self.current_academic_session).title
3048	return '%s tickets in academic session %s' % (
3049	self.context.code, session)
3050
3051	def _searchCatalog(self, session):
3052	cat = queryUtility(ICatalog, name='coursetickets_catalog')
3053	coursetickets = cat.searchResults(
3054	session=(session, session),
3055	code=(self.context.code, self.context.code)
3056	)
3057	return list(coursetickets)
3058
3059	def update(self, args, *kw):
3060	form = self.request.form
3061	ob_class = self.__implemented__.__name__.replace('waeup.kofa.','')
3062	self.current_academic_session = grok.getSite()[
3063	'configuration'].current_academic_session
3064	if self.context.__parent__.__parent__.score_editing_disabled:
3065	self.flash(_('Score editing disabled.'), type="warning")
3066	self.redirect(self.url(self.context))
3067	return
3068	if not self.current_academic_session:
3069	self.flash(_('Current academic session not set.'), type="warning")
3070	self.redirect(self.url(self.context))
3071	return
3072	self.tickets = self._searchCatalog(self.current_academic_session)
3073	editable_tickets = [
3074	ticket for ticket in self.tickets if ticket.editable_by_lecturer]
3075	if not self.tickets:
3076	self.flash(_('No student found.'), type="warning")
3077	self.redirect(self.url(self.context))
3078	return
3079	if 'UPDATE' in form:
3080	tno = 0
3081	error = ''
3082	if not editable_tickets:
3083	return
3084	scores = form['scores']
3085	if isinstance(scores, basestring):
3086	scores = [scores]
3087	for ticket in editable_tickets:
3088	score = ticket.score
3089	if scores[tno] == '':
3090	score = None
3091	else:
3092	try:
3093	score = int(scores[tno])
3094	except ValueError:
3095	error += '%s, ' % ticket.student.display_fullname
3096	if ticket.score != score:
3097	ticket.score = score
3098	ticket.student.__parent__.logger.info(
3099	'%s - %s %s/%s score updated (%s)' %
3100	(ob_class, ticket.student.student_id,
3101	ticket.level, ticket.code, score))
3102	#notify(grok.ObjectModifiedEvent(ticket))
3103	tno += 1
3104	if error:
3105	self.flash(_('Error: Score(s) of %s have not be updated. '
3106	'Only integers are allowed.' % error.strip(', ')),
3107	type="danger")
3108	return
3109
3110	class ExportJobContainerOverview(KofaPage):
3111	"""Page that lists active student data export jobs and provides links
3112	to discard or download CSV files.
3113
3114	"""
3115	grok.context(VirtualExportJobContainer)
3116	grok.require('waeup.showStudents')
3117	grok.name('index.html')
3118	grok.template('exportjobsindex')
3119	label = _('Student Data Exports')
3120	pnav = 1
3121	doclink = DOCLINK + '/datacenter/export.html#student-data-exporters'
3122
3123	def update(self, CREATE=None, DISCARD=None, job_id=None):
3124	if CREATE:
3125	self.redirect(self.url('@@exportconfig'))
3126	return
3127	if DISCARD and job_id:
3128	entry = self.context.entry_from_job_id(job_id)
3129	self.context.delete_export_entry(entry)
3130	ob_class = self.__implemented__.__name__.replace('waeup.kofa.','')
3131	self.context.logger.info(
3132	'%s - discarded: job_id=%s' % (ob_class, job_id))
3133	self.flash(_('Discarded export') + ' %s' % job_id)
3134	self.entries = doll_up(self, user=self.request.principal.id)
3135	return
3136
3137	class ExportJobContainerJobConfig(KofaPage):
3138	"""Page that configures a students export job.
3139
3140	This is a baseclass.
3141	"""
3142	grok.baseclass()
3143	grok.name('exportconfig')
3144	grok.require('waeup.showStudents')
3145	grok.template('exportconfig')
3146	label = _('Configure student data export')
3147	pnav = 1
3148	redirect_target = ''
3149	doclink = DOCLINK + '/datacenter/export.html#student-data-exporters'
3150
3151	def _set_session_values(self):
3152	vocab_terms = academic_sessions_vocab.by_value.values()
3153	self.sessions = sorted(
3154	[(x.title, x.token) for x in vocab_terms], reverse=True)
3155	self.sessions += [(_('All Sessions'), 'all')]
3156	return
3157
3158	def _set_level_values(self):
3159	vocab_terms = course_levels.by_value.values()
3160	self.levels = sorted(
3161	[(x.title, x.token) for x in vocab_terms])
3162	self.levels += [(_('All Levels'), 'all')]
3163	return
3164
3165	def _set_mode_values(self):
3166	utils = getUtility(IKofaUtils)
3167	self.modes = sorted([(value, key) for key, value in
3168	utils.STUDY_MODES_DICT.items()])
3169	self.modes +=[(_('All Modes'), 'all')]
3170	return
3171
3172	def _set_exporter_values(self):
3173	# We provide all student exporters, nothing else, yet.
3174	# Bursary or Department Officers don't have the general exportData
3175	# permission and are only allowed to export bursary or payments
3176	# overview data respectively. This is the only place where
3177	# waeup.exportBursaryData and waeup.exportPaymentsOverview
3178	# are used.
3179	exporters = []
3180	if not checkPermission('waeup.exportData', self.context):
3181	if checkPermission('waeup.exportBursaryData', self.context):
3182	exporters += [('Bursary Data', 'bursary')]
3183	if checkPermission('waeup.exportPaymentsOverview', self.context):
3184	exporters += [('Student Payments Overview', 'paymentsoverview')]
3185	self.exporters = exporters
3186	return
3187	STUDENT_EXPORTER_NAMES = getUtility(
3188	IStudentsUtils).STUDENT_EXPORTER_NAMES
3189	for name in STUDENT_EXPORTER_NAMES:
3190	util = getUtility(ICSVExporter, name=name)
3191	exporters.append((util.title, name),)
3192	self.exporters = exporters
3193	return
3194
3195	@property
3196	def faccode(self):
3197	return None
3198
3199	@property
3200	def depcode(self):
3201	return None
3202
3203	@property
3204	def certcode(self):
3205	return None
3206
3207	def update(self, START=None, session=None, level=None, mode=None,
3208	payments_start=None, payments_end=None,
3209	exporter=None):
3210	self._set_session_values()
3211	self._set_level_values()
3212	self._set_mode_values()
3213	self._set_exporter_values()
3214	if START is None:
3215	return
3216	ena = exports_not_allowed(self)
3217	if ena:
3218	self.flash(ena, type='danger')
3219	return
3220	if payments_start or payments_end:
3221	date_format = '%d/%m/%Y'
3222	try:
3223	dummy = datetime.strptime(payments_start, date_format)
3224	dummy = datetime.strptime(payments_end, date_format)
3225	except ValueError:
3226	self.flash(_('Payment dates do not match format d/m/Y.'),
3227	type="danger")
3228	return
3229	if session == 'all':
3230	session=None
3231	if level == 'all':
3232	level = None
3233	if mode == 'all':
3234	mode = None
3235	if payments_start == '':
3236	payments_start = None
3237	if payments_end == '':
3238	payments_end = None
3239	if (mode,
3240	level,
3241	session,
3242	self.faccode,
3243	self.depcode,
3244	self.certcode) == (None, None, None, None, None, None):
3245	# Export all students including those without certificate
3246	if payments_start:
3247	job_id = self.context.start_export_job(exporter,
3248	self.request.principal.id,
3249	payments_start = payments_start,
3250	payments_end = payments_end)
3251	else:
3252	job_id = self.context.start_export_job(exporter,
3253	self.request.principal.id)
3254	else:
3255	if payments_start:
3256	job_id = self.context.start_export_job(exporter,
3257	self.request.principal.id,
3258	current_session=session,
3259	current_level=level,
3260	current_mode=mode,
3261	faccode=self.faccode,
3262	depcode=self.depcode,
3263	certcode=self.certcode,
3264	payments_start = payments_start,
3265	payments_end = payments_end)
3266	else:
3267	job_id = self.context.start_export_job(exporter,
3268	self.request.principal.id,
3269	current_session=session,
3270	current_level=level,
3271	current_mode=mode,
3272	faccode=self.faccode,
3273	depcode=self.depcode,
3274	certcode=self.certcode)
3275	ob_class = self.__implemented__.__name__.replace('waeup.kofa.','')
3276	self.context.logger.info(
3277	'%s - exported: %s (%s, %s, %s, %s, %s, %s, %s, %s), job_id=%s'
3278	% (ob_class, exporter, session, level, mode, self.faccode,
3279	self.depcode, self.certcode, payments_start, payments_end, job_id))
3280	self.flash(_('Export started for students with') +
3281	' current_session=%s, current_level=%s, study_mode=%s' % (
3282	session, level, mode))
3283	self.redirect(self.url(self.redirect_target))
3284	return
3285
3286	class ExportJobContainerDownload(ExportCSVView):
3287	"""Page that downloads a students export csv file.
3288
3289	"""
3290	grok.context(VirtualExportJobContainer)
3291	grok.require('waeup.showStudents')
3292
3293	class DatacenterExportJobContainerJobConfig(ExportJobContainerJobConfig):
3294	"""Page that configures a students export job in datacenter.
3295
3296	"""
3297	grok.context(IDataCenter)
3298	redirect_target = '@@export'
3299
3300	class DatacenterExportJobContainerSelectStudents(ExportJobContainerJobConfig):
3301	"""Page that configures a students export job in datacenter.
3302
3303	"""
3304	grok.name('exportselected')
3305	grok.context(IDataCenter)
3306	redirect_target = '@@export'
3307	grok.template('exportselected')
3308	label = _('Configure student data export')
3309
3310	def update(self, START=None, students=None, exporter=None):
3311	self._set_exporter_values()
3312	if START is None:
3313	return
3314	ena = exports_not_allowed(self)
3315	if ena:
3316	self.flash(ena, type='danger')
3317	return
3318	try:
3319	ids = students.replace(',', ' ').split()
3320	except:
3321	self.flash(sys.exc_info()[1])
3322	self.redirect(self.url(self.redirect_target))
3323	return
3324	job_id = self.context.start_export_job(
3325	exporter, self.request.principal.id, selected=ids)
3326	ob_class = self.__implemented__.__name__.replace('waeup.kofa.','')
3327	self.context.logger.info(
3328	'%s - selected students exported: %s, job_id=%s' %
3329	(ob_class, exporter, job_id))
3330	self.flash(_('Export of selected students started.'))
3331	self.redirect(self.url(self.redirect_target))
3332	return
3333
3334	class FacultiesExportJobContainerJobConfig(ExportJobContainerJobConfig):
3335	"""Page that configures a students export job in facultiescontainer.
3336
3337	"""
3338	grok.context(VirtualFacultiesExportJobContainer)
3339
3340
3341	class FacultyExportJobContainerJobConfig(ExportJobContainerJobConfig):
3342	"""Page that configures a students export job in faculties.
3343
3344	"""
3345	grok.context(VirtualFacultyExportJobContainer)
3346
3347	@property
3348	def faccode(self):
3349	return self.context.__parent__.code
3350
3351	class DepartmentExportJobContainerJobConfig(ExportJobContainerJobConfig):
3352	"""Page that configures a students export job in departments.
3353
3354	"""
3355	grok.context(VirtualDepartmentExportJobContainer)
3356
3357	@property
3358	def depcode(self):
3359	return self.context.__parent__.code
3360
3361	class CertificateExportJobContainerJobConfig(ExportJobContainerJobConfig):
3362	"""Page that configures a students export job for certificates.
3363
3364	"""
3365	grok.context(VirtualCertificateExportJobContainer)
3366	grok.template('exportconfig_certificate')
3367
3368	@property
3369	def certcode(self):
3370	return self.context.__parent__.code
3371
3372	class CourseExportJobContainerJobConfig(ExportJobContainerJobConfig):
3373	"""Page that configures a students export job for courses.
3374
3375	In contrast to department or certificate student data exports the
3376	coursetickets_catalog is searched here. Therefore the update
3377	method from the base class is customized.
3378	"""
3379	grok.context(VirtualCourseExportJobContainer)
3380	grok.template('exportconfig_course')
3381
3382	def _set_exporter_values(self):
3383	# We provide only two exporters.
3384	exporters = []
3385	for name in ('students', 'coursetickets'):
3386	util = getUtility(ICSVExporter, name=name)
3387	exporters.append((util.title, name),)
3388	self.exporters = exporters
3389
3390	def update(self, START=None, session=None, level=None, mode=None,
3391	exporter=None):
3392	self._set_session_values()
3393	self._set_level_values()
3394	self._set_mode_values()
3395	self._set_exporter_values()
3396	if START is None:
3397	return
3398	ena = exports_not_allowed(self)
3399	if ena:
3400	self.flash(ena, type='danger')
3401	return
3402	if session == 'all':
3403	session = None
3404	if level == 'all':
3405	level = None
3406	job_id = self.context.start_export_job(exporter,
3407	self.request.principal.id,
3408	# Use a different catalog and
3409	# pass different keywords than
3410	# for the (default) students_catalog
3411	catalog='coursetickets',
3412	session=session,
3413	level=level,
3414	code=self.context.__parent__.code)
3415	ob_class = self.__implemented__.__name__.replace('waeup.kofa.','')
3416	self.context.logger.info(
3417	'%s - exported: %s (%s, %s, %s), job_id=%s'
3418	% (ob_class, exporter, session, level,
3419	self.context.__parent__.code, job_id))
3420	self.flash(_('Export started for course tickets with') +
3421	' level_session=%s, level=%s' % (
3422	session, level))
3423	self.redirect(self.url(self.redirect_target))
3424	return

Note: See TracBrowser for help on using the repository browser.

Download in other formats: