Context navigation

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

Last change on this file since 12953 was 12910, checked in by Henrik Bettermann, 10 years ago

Add doclinks.

Add warning to Certificates section.

Property svn:keywords set to Id

File size: 128.0 KB

Line
1	## $Id: browser.py 12910 2015-05-07 04:31:34Z 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	KofaForm, NullValidator,
39	jsaction, action, UtilityView)
40	from waeup.kofa.browser.breadcrumbs import Breadcrumb
41	from waeup.kofa.browser.pages import ContactAdminForm, ExportCSVView, doll_up
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 student section')
292	search_button = _('Find student(s)')
293	remove_button = _('Remove selected')
294
295	def update(self, args, *kw):
296	form = self.request.form
297	self.hitlist = []
298	if form.get('searchtype', None) == 'suspended':
299	self.searchtype = form['searchtype']
300	self.searchterm = None
301	elif 'searchterm' in form and form['searchterm']:
302	self.searchterm = form['searchterm']
303	self.searchtype = form['searchtype']
304	elif 'old_searchterm' in form:
305	self.searchterm = form['old_searchterm']
306	self.searchtype = form['old_searchtype']
307	else:
308	if 'search' in form:
309	self.flash(_('Empty search string'), type="warning")
310	return
311	if self.searchtype == 'current_session':
312	try:
313	self.searchterm = int(self.searchterm)
314	except ValueError:
315	self.flash(_('Only year dates allowed (e.g. 2011).'),
316	type="danger")
317	return
318	if not 'entries' in form:
319	self.hitlist = search(query=self.searchterm,
320	searchtype=self.searchtype, view=self)
321	if not self.hitlist:
322	self.flash(_('No student found.'), type="warning")
323	if 'remove' in form:
324	self.flash(_('No item selected.'), type="warning")
325	return
326	entries = form['entries']
327	if isinstance(entries, basestring):
328	entries = [entries]
329	deleted = []
330	for entry in entries:
331	if 'remove' in form:
332	del self.context[entry]
333	deleted.append(entry)
334	self.hitlist = search(query=self.searchterm,
335	searchtype=self.searchtype, view=self)
336	if len(deleted):
337	self.flash(_('Successfully removed: ${a}',
338	mapping = {'a':', '.join(deleted)}))
339	return
340
341	class StudentAddFormPage(KofaAddFormPage):
342	"""Add-form to add a student.
343	"""
344	grok.context(IStudentsContainer)
345	grok.require('waeup.manageStudent')
346	grok.name('addstudent')
347	form_fields = grok.AutoFields(IStudent).select(
348	'firstname', 'middlename', 'lastname', 'reg_number')
349	label = _('Add student')
350	pnav = 4
351
352	@action(_('Create student record'), style='primary')
353	def addStudent(self, **data):
354	student = createObject(u'waeup.Student')
355	self.applyData(student, **data)
356	self.context.addStudent(student)
357	self.flash(_('Student record created.'))
358	self.redirect(self.url(self.context[student.student_id], 'index'))
359	return
360
361	class LoginAsStudentStep1(KofaEditFormPage):
362	""" View to temporarily set a student password.
363	"""
364	grok.context(IStudent)
365	grok.name('loginasstep1')
366	grok.require('waeup.loginAsStudent')
367	grok.template('loginasstep1')
368	pnav = 4
369
370	def label(self):
371	return _(u'Set temporary password for ${a}',
372	mapping = {'a':self.context.display_fullname})
373
374	@action('Set password now', style='primary')
375	def setPassword(self, args, *data):
376	kofa_utils = getUtility(IKofaUtils)
377	password = kofa_utils.genPassword()
378	self.context.setTempPassword(self.request.principal.id, password)
379	self.context.writeLogMessage(
380	self, 'temp_password generated: %s' % password)
381	args = {'password':password}
382	self.redirect(self.url(self.context) +
383	'/loginasstep2?%s' % urlencode(args))
384	return
385
386	class LoginAsStudentStep2(KofaPage):
387	""" View to temporarily login as student with a temporary password.
388	"""
389	grok.context(IStudent)
390	grok.name('loginasstep2')
391	grok.require('waeup.Public')
392	grok.template('loginasstep2')
393	login_button = _('Login now')
394	pnav = 4
395
396	def label(self):
397	return _(u'Login as ${a}',
398	mapping = {'a':self.context.student_id})
399
400	def update(self, SUBMIT=None, password=None):
401	self.password = password
402	if SUBMIT is not None:
403	self.flash(_('You successfully logged in as student.'))
404	self.redirect(self.url(self.context))
405	return
406
407	class StudentBaseDisplayFormPage(KofaDisplayFormPage):
408	""" Page to display student base data
409	"""
410	grok.context(IStudent)
411	grok.name('index')
412	grok.require('waeup.viewStudent')
413	grok.template('basepage')
414	form_fields = grok.AutoFields(IStudentBase).omit(
415	'password', 'suspended', 'suspended_comment')
416	pnav = 4
417
418	@property
419	def label(self):
420	if self.context.suspended:
421	return _('${a}: Base Data (account deactivated)',
422	mapping = {'a':self.context.display_fullname})
423	return _('${a}: Base Data',
424	mapping = {'a':self.context.display_fullname})
425
426	@property
427	def hasPassword(self):
428	if self.context.password:
429	return _('set')
430	return _('unset')
431
432	class StudentBasePDFFormPage(KofaDisplayFormPage):
433	""" Page to display student base data in pdf files.
434	"""
435
436	def __init__(self, context, request, omit_fields=()):
437	self.omit_fields = omit_fields
438	super(StudentBasePDFFormPage, self).__init__(context, request)
439
440	@property
441	def form_fields(self):
442	form_fields = grok.AutoFields(IStudentBase)
443	for field in self.omit_fields:
444	form_fields = form_fields.omit(field)
445	return form_fields
446
447	class ContactStudentForm(ContactAdminForm):
448	grok.context(IStudent)
449	grok.name('contactstudent')
450	grok.require('waeup.viewStudent')
451	pnav = 4
452	form_fields = grok.AutoFields(IContactForm).select('subject', 'body')
453
454	def update(self, subject=u'', body=u''):
455	super(ContactStudentForm, self).update()
456	self.form_fields.get('subject').field.default = subject
457	self.form_fields.get('body').field.default = body
458	return
459
460	def label(self):
461	return _(u'Send message to ${a}',
462	mapping = {'a':self.context.display_fullname})
463
464	@action('Send message now', style='primary')
465	def send(self, args, *data):
466	try:
467	email = self.request.principal.email
468	except AttributeError:
469	email = self.config.email_admin
470	usertype = getattr(self.request.principal,
471	'user_type', 'system').title()
472	kofa_utils = getUtility(IKofaUtils)
473	success = kofa_utils.sendContactForm(
474	self.request.principal.title,email,
475	self.context.display_fullname,self.context.email,
476	self.request.principal.id,usertype,
477	self.config.name,
478	data['body'],data['subject'])
479	if success:
480	self.flash(_('Your message has been sent.'))
481	else:
482	self.flash(_('An smtp server error occurred.'), type="danger")
483	return
484
485	class ExportPDFAdmissionSlipPage(UtilityView, grok.View):
486	"""Deliver a PDF Admission slip.
487	"""
488	grok.context(IStudent)
489	grok.name('admission_slip.pdf')
490	grok.require('waeup.viewStudent')
491	prefix = 'form'
492
493	omit_fields = ('date_of_birth', 'current_level')
494
495	form_fields = grok.AutoFields(IStudentBase).select('student_id', 'reg_number')
496
497	@property
498	def label(self):
499	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
500	return translate(_('Admission Letter of'),
501	'waeup.kofa', target_language=portal_language) \
502	+ ' %s' % self.context.display_fullname
503
504	def render(self):
505	students_utils = getUtility(IStudentsUtils)
506	return students_utils.renderPDFAdmissionLetter(self,
507	self.context.student, omit_fields=self.omit_fields)
508
509	class StudentBaseManageFormPage(KofaEditFormPage):
510	""" View to manage student base data
511	"""
512	grok.context(IStudent)
513	grok.name('manage_base')
514	grok.require('waeup.manageStudent')
515	form_fields = grok.AutoFields(IStudentBase).omit(
516	'student_id', 'adm_code', 'suspended')
517	grok.template('basemanagepage')
518	label = _('Manage base data')
519	pnav = 4
520
521	def update(self):
522	super(StudentBaseManageFormPage, self).update()
523	self.wf_info = IWorkflowInfo(self.context)
524	return
525
526	@action(_('Save'), style='primary')
527	def save(self, **data):
528	form = self.request.form
529	password = form.get('password', None)
530	password_ctl = form.get('control_password', None)
531	if password:
532	validator = getUtility(IPasswordValidator)
533	errors = validator.validate_password(password, password_ctl)
534	if errors:
535	self.flash( ' '.join(errors), type="danger")
536	return
537	changed_fields = self.applyData(self.context, **data)
538	# Turn list of lists into single list
539	if changed_fields:
540	changed_fields = reduce(lambda x,y: x+y, changed_fields.values())
541	else:
542	changed_fields = []
543	if password:
544	# Now we know that the form has no errors and can set password
545	IUserAccount(self.context).setPassword(password)
546	changed_fields.append('password')
547	fields_string = ' + '.join(changed_fields)
548	self.flash(_('Form has been saved.'))
549	if fields_string:
550	self.context.writeLogMessage(self, 'saved: % s' % fields_string)
551	return
552
553	class StudentTriggerTransitionFormPage(KofaEditFormPage):
554	""" View to trigger student workflow transitions
555	"""
556	grok.context(IStudent)
557	grok.name('trigtrans')
558	grok.require('waeup.triggerTransition')
559	grok.template('trigtrans')
560	label = _('Trigger registration transition')
561	pnav = 4
562
563	def getTransitions(self):
564	"""Return a list of dicts of allowed transition ids and titles.
565
566	Each list entry provides keys ``name`` and ``title`` for
567	internal name and (human readable) title of a single
568	transition.
569	"""
570	wf_info = IWorkflowInfo(self.context)
571	allowed_transitions = [t for t in wf_info.getManualTransitions()
572	if not t[0].startswith('pay')]
573	if self.context.is_postgrad and not self.context.is_special_postgrad:
574	allowed_transitions = [t for t in allowed_transitions
575	if not t[0] in FORBIDDEN_POSTGRAD_TRANS]
576	return [dict(name='', title=_('No transition'))] +[
577	dict(name=x, title=y) for x, y in allowed_transitions]
578
579	@action(_('Save'), style='primary')
580	def save(self, **data):
581	form = self.request.form
582	if 'transition' in form and form['transition']:
583	transition_id = form['transition']
584	wf_info = IWorkflowInfo(self.context)
585	wf_info.fireTransition(transition_id)
586	return
587
588	class StudentActivatePage(UtilityView, grok.View):
589	""" Activate student account
590	"""
591	grok.context(IStudent)
592	grok.name('activate')
593	grok.require('waeup.manageStudent')
594
595	def update(self):
596	self.context.suspended = False
597	self.context.writeLogMessage(self, 'account activated')
598	history = IObjectHistory(self.context)
599	history.addMessage('Student account activated')
600	self.flash(_('Student account has been activated.'))
601	self.redirect(self.url(self.context))
602	return
603
604	def render(self):
605	return
606
607	class StudentDeactivatePage(UtilityView, grok.View):
608	""" Deactivate student account
609	"""
610	grok.context(IStudent)
611	grok.name('deactivate')
612	grok.require('waeup.manageStudent')
613
614	def update(self):
615	self.context.suspended = True
616	self.context.writeLogMessage(self, 'account deactivated')
617	history = IObjectHistory(self.context)
618	history.addMessage('Student account deactivated')
619	self.flash(_('Student account has been deactivated.'))
620	self.redirect(self.url(self.context))
621	return
622
623	def render(self):
624	return
625
626	class StudentClearanceDisplayFormPage(KofaDisplayFormPage):
627	""" Page to display student clearance data
628	"""
629	grok.context(IStudent)
630	grok.name('view_clearance')
631	grok.require('waeup.viewStudent')
632	pnav = 4
633
634	@property
635	def separators(self):
636	return getUtility(IStudentsUtils).SEPARATORS_DICT
637
638	@property
639	def form_fields(self):
640	if self.context.is_postgrad:
641	form_fields = grok.AutoFields(
642	IPGStudentClearance).omit('clearance_locked')
643	else:
644	form_fields = grok.AutoFields(
645	IUGStudentClearance).omit('clearance_locked')
646	if not getattr(self.context, 'officer_comment'):
647	form_fields = form_fields.omit('officer_comment')
648	else:
649	form_fields['officer_comment'].custom_widget = BytesDisplayWidget
650	return form_fields
651
652	@property
653	def label(self):
654	return _('${a}: Clearance Data',
655	mapping = {'a':self.context.display_fullname})
656
657	class ExportPDFClearanceSlipPage(grok.View):
658	"""Deliver a PDF slip of the context.
659	"""
660	grok.context(IStudent)
661	grok.name('clearance_slip.pdf')
662	grok.require('waeup.viewStudent')
663	prefix = 'form'
664	omit_fields = (
665	'suspended', 'phone',
666	'adm_code', 'suspended_comment',
667	'date_of_birth', 'current_level')
668
669	@property
670	def form_fields(self):
671	if self.context.is_postgrad:
672	form_fields = grok.AutoFields(
673	IPGStudentClearance).omit('clearance_locked')
674	else:
675	form_fields = grok.AutoFields(
676	IUGStudentClearance).omit('clearance_locked')
677	if not getattr(self.context, 'officer_comment'):
678	form_fields = form_fields.omit('officer_comment')
679	return form_fields
680
681	@property
682	def title(self):
683	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
684	return translate(_('Clearance Data'), 'waeup.kofa',
685	target_language=portal_language)
686
687	@property
688	def label(self):
689	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
690	return translate(_('Clearance Slip of'),
691	'waeup.kofa', target_language=portal_language) \
692	+ ' %s' % self.context.display_fullname
693
694	# XXX: not used in waeup.kofa and thus not tested
695	def _signatures(self):
696	isStudent = getattr(
697	self.request.principal, 'user_type', None) == 'student'
698	if not isStudent and self.context.state in (CLEARED, ):
699	return ([_('Student Signature')],
700	[_('Clearance Officer Signature')])
701	return
702
703	def _sigsInFooter(self):
704	isStudent = getattr(
705	self.request.principal, 'user_type', None) == 'student'
706	if not isStudent and self.context.state in (CLEARED, ):
707	return (_('Date, Student Signature'),
708	_('Date, Clearance Officer Signature'),
709	)
710	return ()
711
712	def render(self):
713	studentview = StudentBasePDFFormPage(self.context.student,
714	self.request, self.omit_fields)
715	students_utils = getUtility(IStudentsUtils)
716	return students_utils.renderPDF(
717	self, 'clearance_slip.pdf',
718	self.context.student, studentview, signatures=self._signatures(),
719	sigs_in_footer=self._sigsInFooter(),
720	omit_fields=self.omit_fields)
721
722	class StudentClearanceManageFormPage(KofaEditFormPage):
723	""" Page to manage student clearance data
724	"""
725	grok.context(IStudent)
726	grok.name('manage_clearance')
727	grok.require('waeup.manageStudent')
728	grok.template('clearanceeditpage')
729	label = _('Manage clearance data')
730	deletion_warning = _('Are you sure?')
731	pnav = 4
732
733	@property
734	def separators(self):
735	return getUtility(IStudentsUtils).SEPARATORS_DICT
736
737	@property
738	def form_fields(self):
739	if self.context.is_postgrad:
740	form_fields = grok.AutoFields(IPGStudentClearance).omit('clr_code')
741	else:
742	form_fields = grok.AutoFields(IUGStudentClearance).omit('clr_code')
743	return form_fields
744
745	@action(_('Save'), style='primary')
746	def save(self, **data):
747	msave(self, **data)
748	return
749
750	class StudentClearPage(UtilityView, grok.View):
751	""" Clear student by clearance officer
752	"""
753	grok.context(IStudent)
754	grok.name('clear')
755	grok.require('waeup.clearStudent')
756
757	def update(self):
758	cdm = getUtility(IStudentsUtils).clearance_disabled_message(self.context)
759	if cdm:
760	self.flash(cdm)
761	self.redirect(self.url(self.context,'view_clearance'))
762	return
763	if self.context.state == REQUESTED:
764	IWorkflowInfo(self.context).fireTransition('clear')
765	self.flash(_('Student has been cleared.'))
766	else:
767	self.flash(_('Student is in wrong state.'), type="warning")
768	self.redirect(self.url(self.context,'view_clearance'))
769	return
770
771	def render(self):
772	return
773
774	class StudentRejectClearancePage(KofaEditFormPage):
775	""" Reject clearance by clearance officers
776	"""
777	grok.context(IStudent)
778	grok.name('reject_clearance')
779	label = _('Reject clearance')
780	grok.require('waeup.clearStudent')
781	form_fields = grok.AutoFields(
782	IUGStudentClearance).select('officer_comment')
783
784	def update(self):
785	cdm = getUtility(IStudentsUtils).clearance_disabled_message(self.context)
786	if cdm:
787	self.flash(cdm, type="warning")
788	self.redirect(self.url(self.context,'view_clearance'))
789	return
790	return super(StudentRejectClearancePage, self).update()
791
792	@action(_('Save comment and reject clearance now'), style='primary')
793	def reject(self, **data):
794	if self.context.state == CLEARED:
795	IWorkflowInfo(self.context).fireTransition('reset4')
796	message = _('Clearance has been annulled.')
797	self.flash(message, type="warning")
798	elif self.context.state == REQUESTED:
799	IWorkflowInfo(self.context).fireTransition('reset3')
800	message = _('Clearance request has been rejected.')
801	self.flash(message, type="warning")
802	else:
803	self.flash(_('Student is in wrong state.'), type="warning")
804	self.redirect(self.url(self.context,'view_clearance'))
805	return
806	self.applyData(self.context, **data)
807	comment = data['officer_comment']
808	if comment:
809	self.context.writeLogMessage(
810	self, 'comment: %s' % comment.replace('\n', '<br>'))
811	args = {'subject':message, 'body':comment}
812	else:
813	args = {'subject':message,}
814	self.redirect(self.url(self.context) +
815	'/contactstudent?%s' % urlencode(args))
816	return
817
818
819	class StudentPersonalDisplayFormPage(KofaDisplayFormPage):
820	""" Page to display student personal data
821	"""
822	grok.context(IStudent)
823	grok.name('view_personal')
824	grok.require('waeup.viewStudent')
825	form_fields = grok.AutoFields(IStudentPersonal)
826	form_fields['perm_address'].custom_widget = BytesDisplayWidget
827	form_fields[
828	'personal_updated'].custom_widget = FriendlyDatetimeDisplayWidget('le')
829	pnav = 4
830
831	@property
832	def label(self):
833	return _('${a}: Personal Data',
834	mapping = {'a':self.context.display_fullname})
835
836	class StudentPersonalManageFormPage(KofaEditFormPage):
837	""" Page to manage personal data
838	"""
839	grok.context(IStudent)
840	grok.name('manage_personal')
841	grok.require('waeup.manageStudent')
842	form_fields = grok.AutoFields(IStudentPersonal)
843	form_fields['personal_updated'].for_display = True
844	form_fields[
845	'personal_updated'].custom_widget = FriendlyDatetimeDisplayWidget('le')
846	label = _('Manage personal data')
847	pnav = 4
848
849	@action(_('Save'), style='primary')
850	def save(self, **data):
851	msave(self, **data)
852	return
853
854	class StudentPersonalEditFormPage(KofaEditFormPage):
855	""" Page to edit personal data
856	"""
857	grok.context(IStudent)
858	grok.name('edit_personal')
859	grok.require('waeup.handleStudent')
860	form_fields = grok.AutoFields(IStudentPersonalEdit).omit('personal_updated')
861	label = _('Edit personal data')
862	pnav = 4
863
864	@action(_('Save/Confirm'), style='primary')
865	def save(self, **data):
866	msave(self, **data)
867	self.context.personal_updated = datetime.utcnow()
868	return
869
870	class StudyCourseDisplayFormPage(KofaDisplayFormPage):
871	""" Page to display the student study course data
872	"""
873	grok.context(IStudentStudyCourse)
874	grok.name('index')
875	grok.require('waeup.viewStudent')
876	grok.template('studycoursepage')
877	pnav = 4
878
879	@property
880	def form_fields(self):
881	if self.context.is_postgrad:
882	form_fields = grok.AutoFields(IStudentStudyCourse).omit(
883	'previous_verdict')
884	else:
885	form_fields = grok.AutoFields(IStudentStudyCourse)
886	return form_fields
887
888	@property
889	def label(self):
890	if self.context.is_current:
891	return _('${a}: Study Course',
892	mapping = {'a':self.context.__parent__.display_fullname})
893	else:
894	return _('${a}: Previous Study Course',
895	mapping = {'a':self.context.__parent__.display_fullname})
896
897	@property
898	def current_mode(self):
899	if self.context.certificate is not None:
900	studymodes_dict = getUtility(IKofaUtils).STUDY_MODES_DICT
901	return studymodes_dict[self.context.certificate.study_mode]
902	return
903
904	@property
905	def department(self):
906	if self.context.certificate is not None:
907	return self.context.certificate.__parent__.__parent__
908	return
909
910	@property
911	def faculty(self):
912	if self.context.certificate is not None:
913	return self.context.certificate.__parent__.__parent__.__parent__
914	return
915
916	@property
917	def prev_studycourses(self):
918	if self.context.is_current:
919	if self.context.__parent__.get('studycourse_2', None) is not None:
920	return (
921	{'href':self.url(self.context.student) + '/studycourse_1',
922	'title':_('First Study Course, ')},
923	{'href':self.url(self.context.student) + '/studycourse_2',
924	'title':_('Second Study Course')}
925	)
926	if self.context.__parent__.get('studycourse_1', None) is not None:
927	return (
928	{'href':self.url(self.context.student) + '/studycourse_1',
929	'title':_('First Study Course')},
930	)
931	return
932
933	class StudyCourseManageFormPage(KofaEditFormPage):
934	""" Page to edit the student study course data
935	"""
936	grok.context(IStudentStudyCourse)
937	grok.name('manage')
938	grok.require('waeup.manageStudent')
939	grok.template('studycoursemanagepage')
940	label = _('Manage study course')
941	pnav = 4
942	taboneactions = [_('Save'),_('Cancel')]
943	tabtwoactions = [_('Remove selected levels'),_('Cancel')]
944	tabthreeactions = [_('Add study level')]
945
946	@property
947	def form_fields(self):
948	if self.context.is_postgrad:
949	form_fields = grok.AutoFields(IStudentStudyCourse).omit(
950	'previous_verdict')
951	else:
952	form_fields = grok.AutoFields(IStudentStudyCourse)
953	return form_fields
954
955	def update(self):
956	if not self.context.is_current:
957	emit_lock_message(self)
958	return
959	super(StudyCourseManageFormPage, self).update()
960	return
961
962	@action(_('Save'), style='primary')
963	def save(self, **data):
964	try:
965	msave(self, **data)
966	except ConstraintNotSatisfied:
967	# The selected level might not exist in certificate
968	self.flash(_('Current level not available for certificate.'),
969	type="warning")
970	return
971	notify(grok.ObjectModifiedEvent(self.context.__parent__))
972	return
973
974	@property
975	def level_dicts(self):
976	studylevelsource = StudyLevelSource().factory
977	for code in studylevelsource.getValues(self.context):
978	title = studylevelsource.getTitle(self.context, code)
979	yield(dict(code=code, title=title))
980
981	@property
982	def session_dicts(self):
983	yield(dict(code='', title='--'))
984	for item in academic_sessions():
985	code = item[1]
986	title = item[0]
987	yield(dict(code=code, title=title))
988
989	@action(_('Add study level'), style='primary')
990	def addStudyLevel(self, **data):
991	level_code = self.request.form.get('addlevel', None)
992	level_session = self.request.form.get('level_session', None)
993	if not level_session:
994	self.flash(_('You must select a session for the level.'),
995	type="warning")
996	self.redirect(self.url(self.context, u'@@manage')+'#tab2')
997	return
998	studylevel = createObject(u'waeup.StudentStudyLevel')
999	studylevel.level = int(level_code)
1000	studylevel.level_session = int(level_session)
1001	try:
1002	self.context.addStudentStudyLevel(
1003	self.context.certificate,studylevel)
1004	self.flash(_('Study level has been added.'))
1005	except KeyError:
1006	self.flash(_('This level exists.'), type="warning")
1007	self.redirect(self.url(self.context, u'@@manage')+'#tab2')
1008	return
1009
1010	@jsaction(_('Remove selected levels'))
1011	def delStudyLevels(self, **data):
1012	form = self.request.form
1013	if 'val_id' in form:
1014	child_id = form['val_id']
1015	else:
1016	self.flash(_('No study level selected.'), type="warning")
1017	self.redirect(self.url(self.context, '@@manage')+'#tab2')
1018	return
1019	if not isinstance(child_id, list):
1020	child_id = [child_id]
1021	deleted = []
1022	for id in child_id:
1023	del self.context[id]
1024	deleted.append(id)
1025	if len(deleted):
1026	self.flash(_('Successfully removed: ${a}',
1027	mapping = {'a':', '.join(deleted)}))
1028	self.context.writeLogMessage(
1029	self,'removed: %s' % ', '.join(deleted))
1030	self.redirect(self.url(self.context, u'@@manage')+'#tab2')
1031	return
1032
1033	class StudentTranscriptRequestPage(KofaPage):
1034	""" Page to transcript by student
1035	"""
1036	grok.context(IStudent)
1037	grok.name('request_transcript')
1038	grok.require('waeup.handleStudent')
1039	grok.template('transcriptrequest')
1040	label = _('Request transcript')
1041	ac_prefix = 'TSC'
1042	notice = ''
1043	pnav = 4
1044	buttonname = _('Submit')
1045	with_ac = True
1046
1047	def update(self, SUBMIT=None):
1048	super(StudentTranscriptRequestPage, self).update()
1049	if not self.context.state == GRADUATED:
1050	self.flash(_("Wrong state"), type="danger")
1051	self.redirect(self.url(self.context))
1052	return
1053	if self.with_ac:
1054	self.ac_series = self.request.form.get('ac_series', None)
1055	self.ac_number = self.request.form.get('ac_number', None)
1056	if self.context.transcript_comment is not None:
1057	self.correspondence = self.context.transcript_comment.replace(
1058	'\n', '<br>')
1059	else:
1060	self.correspondence = ''
1061	if SUBMIT is None:
1062	return
1063	if self.with_ac:
1064	pin = '%s-%s-%s' % (self.ac_prefix, self.ac_series, self.ac_number)
1065	code = get_access_code(pin)
1066	if not code:
1067	self.flash(_('Activation code is invalid.'), type="warning")
1068	return
1069	if code.state == USED:
1070	self.flash(_('Activation code has already been used.'),
1071	type="warning")
1072	return
1073	# Mark pin as used (this also fires a pin related transition)
1074	# and fire transition start_clearance
1075	comment = _(u"invalidated")
1076	# Here we know that the ac is in state initialized so we do not
1077	# expect an exception, but the owner might be different
1078	if not invalidate_accesscode(pin, comment, self.context.student_id):
1079	self.flash(_('You are not the owner of this access code.'),
1080	type="warning")
1081	return
1082	self.context.clr_code = pin
1083	IWorkflowInfo(self.context).fireTransition('request_transcript')
1084	comment = self.request.form.get('comment', '').replace('\r', '')
1085	address = self.request.form.get('address', '').replace('\r', '')
1086	tz = getattr(queryUtility(IKofaUtils), 'tzinfo', pytz.utc)
1087	today = now(tz).strftime('%d/%m/%Y %H:%M:%S %Z')
1088	old_transcript_comment = self.context.transcript_comment
1089	if old_transcript_comment == None:
1090	old_transcript_comment = ''
1091	self.context.transcript_comment = '''On %s %s wrote:
1092
1093	%s
1094
1095	Dispatch Address:
1096	%s
1097
1098	%s''' % (today, self.request.principal.id, comment, address,
1099	old_transcript_comment)
1100	self.context.writeLogMessage(
1101	self, 'comment: %s' % comment.replace('\n', '<br>'))
1102	self.flash(_('Transcript processing has been started.'))
1103	self.redirect(self.url(self.context))
1104	return
1105
1106	class StudentTranscriptRequestProcessFormPage(KofaEditFormPage):
1107	""" Page to process transcript requests
1108	"""
1109	grok.context(IStudent)
1110	grok.name('process_transcript_request')
1111	grok.require('waeup.viewTranscript')
1112	grok.template('transcriptprocess')
1113	form_fields = grok.AutoFields(IStudentTranscript)
1114	label = _('Process transcript request')
1115	buttonname = _('Save comment and mark as processed')
1116	pnav = 4
1117
1118	def update(self, SUBMIT=None):
1119	super(StudentTranscriptRequestProcessFormPage, self).update()
1120	if self.context.state != TRANSCRIPT:
1121	self.flash(_('Student is in wrong state.'), type="warning")
1122	self.redirect(self.url(self.context))
1123	return
1124	if self.context.transcript_comment is not None:
1125	self.correspondence = self.context.transcript_comment.replace(
1126	'\n', '<br>')
1127	else:
1128	self.correspondence = ''
1129	if SUBMIT is None:
1130	return
1131	IWorkflowInfo(self.context).fireTransition('process_transcript')
1132	self.flash(_('Transcript request processed.'))
1133	comment = self.request.form.get('comment', '').replace('\r', '')
1134	tz = getattr(queryUtility(IKofaUtils), 'tzinfo', pytz.utc)
1135	today = now(tz).strftime('%d/%m/%Y %H:%M:%S %Z')
1136	old_transcript_comment = self.context.transcript_comment
1137	if old_transcript_comment == None:
1138	old_transcript_comment = ''
1139	self.context.transcript_comment = '''On %s %s wrote:
1140
1141	%s
1142
1143	%s''' % (today, self.request.principal.id, comment,
1144	old_transcript_comment)
1145	self.context.writeLogMessage(
1146	self, 'comment: %s' % comment.replace('\n', '<br>'))
1147	subject = _('Transcript processed')
1148	args = {'subject':subject, 'body':comment}
1149	self.redirect(self.url(self.context) +
1150	'/contactstudent?%s' % urlencode(args))
1151	return
1152
1153	class StudentTranscriptRequestManageFormPage(KofaEditFormPage):
1154	""" Page to edit personal data by student
1155	"""
1156	grok.context(IStudent)
1157	grok.name('manage_transcript_request')
1158	grok.require('waeup.manageStudent')
1159	form_fields = grok.AutoFields(IStudentTranscript)
1160	label = _('Manage transcript request')
1161	pnav = 4
1162
1163	@action(_('Save'), style='primary')
1164	def save(self, **data):
1165	msave(self, **data)
1166	return
1167
1168	class StudyCourseTranscriptPage(KofaDisplayFormPage):
1169	""" Page to display the student's transcript.
1170	"""
1171	grok.context(IStudentStudyCourseTranscript)
1172	grok.name('transcript')
1173	grok.require('waeup.viewTranscript')
1174	grok.template('transcript')
1175	pnav = 4
1176
1177	def update(self):
1178	if not self.context.student.transcript_enabled:
1179	self.flash(_('You are not allowed to view the transcript.'),
1180	type="warning")
1181	self.redirect(self.url(self.context))
1182	return
1183	super(StudyCourseTranscriptPage, self).update()
1184	self.semester_dict = getUtility(IKofaUtils).SEMESTER_DICT
1185	self.level_dict = level_dict(self.context)
1186	self.session_dict = dict(
1187	[(item[1], item[0]) for item in academic_sessions()])
1188	self.studymode_dict = getUtility(IKofaUtils).STUDY_MODES_DICT
1189	return
1190
1191	@property
1192	def label(self):
1193	# Here we know that the cookie has been set
1194	lang = self.request.cookies.get('kofa.language')
1195	return _('${a}: Transcript Data', mapping = {
1196	'a':self.context.student.display_fullname})
1197
1198	class ExportPDFTranscriptPage(UtilityView, grok.View):
1199	"""Deliver a PDF slip of the context.
1200	"""
1201	grok.context(IStudentStudyCourse)
1202	grok.name('transcript.pdf')
1203	grok.require('waeup.viewTranscript')
1204	form_fields = grok.AutoFields(IStudentStudyCourseTranscript)
1205	prefix = 'form'
1206	omit_fields = (
1207	'department', 'faculty', 'current_mode', 'entry_session', 'certificate',
1208	'password', 'suspended', 'phone', 'email',
1209	'adm_code', 'suspended_comment', 'current_level')
1210
1211	def update(self):
1212	if not self.context.student.transcript_enabled:
1213	self.flash(_('You are not allowed to download the transcript.'),
1214	type="warning")
1215	self.redirect(self.url(self.context))
1216	return
1217	super(ExportPDFTranscriptPage, self).update()
1218	self.semester_dict = getUtility(IKofaUtils).SEMESTER_DICT
1219	self.level_dict = level_dict(self.context)
1220	self.session_dict = dict(
1221	[(item[1], item[0]) for item in academic_sessions()])
1222	self.studymode_dict = getUtility(IKofaUtils).STUDY_MODES_DICT
1223	return
1224
1225	@property
1226	def label(self):
1227	# Here we know that the cookie has been set
1228	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
1229	return translate(_('Academic Transcript'),
1230	'waeup.kofa', target_language=portal_language)
1231
1232	def _sigsInFooter(self):
1233	return (_('CERTIFIED TRUE COPY'),)
1234
1235	def _signatures(self):
1236	return None
1237
1238	def render(self):
1239	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
1240	Term = translate(_('Term'), 'waeup.kofa', target_language=portal_language)
1241	Code = translate(_('Code'), 'waeup.kofa', target_language=portal_language)
1242	Title = translate(_('Title'), 'waeup.kofa', target_language=portal_language)
1243	Cred = translate(_('Credits'), 'waeup.kofa', target_language=portal_language)
1244	Score = translate(_('Score'), 'waeup.kofa', target_language=portal_language)
1245	Grade = translate(_('Grade'), 'waeup.kofa', target_language=portal_language)
1246	studentview = StudentBasePDFFormPage(self.context.student,
1247	self.request, self.omit_fields)
1248	students_utils = getUtility(IStudentsUtils)
1249
1250	tableheader = [(Code,'code', 2.5),
1251	(Title,'title', 7),
1252	(Term, 'semester', 1.5),
1253	(Cred, 'credits', 1.5),
1254	(Score, 'score', 1.5),
1255	(Grade, 'grade', 1.5),
1256	]
1257
1258	return students_utils.renderPDFTranscript(
1259	self, 'transcript.pdf',
1260	self.context.student, studentview,
1261	omit_fields=self.omit_fields,
1262	tableheader=tableheader,
1263	signatures=self._signatures(),
1264	sigs_in_footer=self._sigsInFooter(),
1265	)
1266
1267	class StudentTransferFormPage(KofaAddFormPage):
1268	"""Page to transfer the student.
1269	"""
1270	grok.context(IStudent)
1271	grok.name('transfer')
1272	grok.require('waeup.manageStudent')
1273	label = _('Transfer student')
1274	form_fields = grok.AutoFields(IStudentStudyCourseTransfer).omit(
1275	'entry_mode', 'entry_session')
1276	pnav = 4
1277
1278	@jsaction(_('Transfer'))
1279	def transferStudent(self, **data):
1280	error = self.context.transfer(**data)
1281	if error == -1:
1282	self.flash(_('Current level does not match certificate levels.'),
1283	type="warning")
1284	elif error == -2:
1285	self.flash(_('Former study course record incomplete.'),
1286	type="warning")
1287	elif error == -3:
1288	self.flash(_('Maximum number of transfers exceeded.'),
1289	type="warning")
1290	else:
1291	self.flash(_('Successfully transferred.'))
1292	return
1293
1294	class RevertTransferFormPage(KofaEditFormPage):
1295	"""View that reverts the previous transfer.
1296	"""
1297	grok.context(IStudent)
1298	grok.name('revert_transfer')
1299	grok.require('waeup.manageStudent')
1300	grok.template('reverttransfer')
1301	label = _('Revert previous transfer')
1302
1303	def update(self):
1304	if not self.context.has_key('studycourse_1'):
1305	self.flash(_('No previous transfer.'), type="warning")
1306	self.redirect(self.url(self.context))
1307	return
1308	return
1309
1310	@jsaction(_('Revert now'))
1311	def transferStudent(self, **data):
1312	self.context.revert_transfer()
1313	self.flash(_('Previous transfer reverted.'))
1314	self.redirect(self.url(self.context, 'studycourse'))
1315	return
1316
1317	class StudyLevelDisplayFormPage(KofaDisplayFormPage):
1318	""" Page to display student study levels
1319	"""
1320	grok.context(IStudentStudyLevel)
1321	grok.name('index')
1322	grok.require('waeup.viewStudent')
1323	form_fields = grok.AutoFields(IStudentStudyLevel).omit('level')
1324	form_fields[
1325	'validation_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
1326	grok.template('studylevelpage')
1327	pnav = 4
1328
1329	def update(self):
1330	super(StudyLevelDisplayFormPage, self).update()
1331	return
1332
1333	@property
1334	def translated_values(self):
1335	return translated_values(self)
1336
1337	@property
1338	def label(self):
1339	# Here we know that the cookie has been set
1340	lang = self.request.cookies.get('kofa.language')
1341	level_title = translate(self.context.level_title, 'waeup.kofa',
1342	target_language=lang)
1343	return _('${a}: Study Level ${b}', mapping = {
1344	'a':self.context.student.display_fullname,
1345	'b':level_title})
1346
1347	class ExportPDFCourseRegistrationSlipPage(UtilityView, grok.View):
1348	"""Deliver a PDF slip of the context.
1349	"""
1350	grok.context(IStudentStudyLevel)
1351	grok.name('course_registration_slip.pdf')
1352	grok.require('waeup.viewStudent')
1353	form_fields = grok.AutoFields(IStudentStudyLevel).omit('level')
1354	form_fields[
1355	'validation_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
1356	prefix = 'form'
1357	omit_fields = (
1358	'password', 'suspended', 'phone', 'date_of_birth',
1359	'adm_code', 'sex', 'suspended_comment', 'current_level')
1360
1361	@property
1362	def title(self):
1363	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
1364	return translate(_('Level Data'), 'waeup.kofa',
1365	target_language=portal_language)
1366
1367	@property
1368	def label(self):
1369	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
1370	lang = self.request.cookies.get('kofa.language', portal_language)
1371	level_title = translate(self.context.level_title, 'waeup.kofa',
1372	target_language=lang)
1373	return translate(_('Course Registration Slip'),
1374	'waeup.kofa', target_language=portal_language) \
1375	+ ' %s' % level_title
1376
1377	@property
1378	def tabletitle(self):
1379	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
1380	tabletitle = []
1381	tabletitle.append(translate(_('1st Semester Courses'), 'waeup.kofa',
1382	target_language=portal_language))
1383	tabletitle.append(translate(_('2nd Semester Courses'), 'waeup.kofa',
1384	target_language=portal_language))
1385	tabletitle.append(translate(_('Level Courses'), 'waeup.kofa',
1386	target_language=portal_language))
1387	return tabletitle
1388
1389	def render(self):
1390	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
1391	Term = translate(_('Term'), 'waeup.kofa', target_language=portal_language)
1392	Code = translate(_('Code'), 'waeup.kofa', target_language=portal_language)
1393	Title = translate(_('Title'), 'waeup.kofa', target_language=portal_language)
1394	Dept = translate(_('Dept.'), 'waeup.kofa', target_language=portal_language)
1395	Faculty = translate(_('Faculty'), 'waeup.kofa', target_language=portal_language)
1396	Cred = translate(_('Cred.'), 'waeup.kofa', target_language=portal_language)
1397	#Mand = translate(_('Requ.'), 'waeup.kofa', target_language=portal_language)
1398	Score = translate(_('Score'), 'waeup.kofa', target_language=portal_language)
1399	Grade = translate(_('Grade'), 'waeup.kofa', target_language=portal_language)
1400	studentview = StudentBasePDFFormPage(self.context.student,
1401	self.request, self.omit_fields)
1402	students_utils = getUtility(IStudentsUtils)
1403
1404	tabledata = []
1405	tableheader = []
1406	contenttitle = []
1407	for i in range(1,7):
1408	tabledata.append(sorted(
1409	[value for value in self.context.values() if value.semester == i],
1410	key=lambda value: str(value.semester) + value.code))
1411	tableheader.append([(Code,'code', 2.5),
1412	(Title,'title', 5),
1413	(Dept,'dcode', 1.5), (Faculty,'fcode', 1.5),
1414	(Cred, 'credits', 1.5),
1415	#(Mand, 'mandatory', 1.5),
1416	(Score, 'score', 1.5),
1417	(Grade, 'grade', 1.5),
1418	#('Auto', 'automatic', 1.5)
1419	])
1420	return students_utils.renderPDF(
1421	self, 'course_registration_slip.pdf',
1422	self.context.student, studentview,
1423	tableheader=tableheader,
1424	tabledata=tabledata,
1425	omit_fields=self.omit_fields
1426	)
1427
1428	class StudyLevelManageFormPage(KofaEditFormPage):
1429	""" Page to edit the student study level data
1430	"""
1431	grok.context(IStudentStudyLevel)
1432	grok.name('manage')
1433	grok.require('waeup.manageStudent')
1434	grok.template('studylevelmanagepage')
1435	form_fields = grok.AutoFields(IStudentStudyLevel).omit(
1436	'validation_date', 'validated_by', 'total_credits', 'gpa', 'level')
1437	pnav = 4
1438	taboneactions = [_('Save'),_('Cancel')]
1439	tabtwoactions = [_('Add course ticket'),
1440	_('Remove selected tickets'),_('Cancel')]
1441	placeholder = _('Enter valid course code')
1442
1443	def update(self, ADD=None, course=None):
1444	if not self.context.__parent__.is_current:
1445	emit_lock_message(self)
1446	return
1447	super(StudyLevelManageFormPage, self).update()
1448	if ADD is not None:
1449	if not course:
1450	self.flash(_('No valid course code entered.'), type="warning")
1451	self.redirect(self.url(self.context, u'@@manage')+'#tab2')
1452	return
1453	cat = queryUtility(ICatalog, name='courses_catalog')
1454	result = cat.searchResults(code=(course, course))
1455	if len(result) != 1:
1456	self.flash(_('Course not found.'), type="warning")
1457	else:
1458	course = list(result)[0]
1459	addCourseTicket(self, course)
1460	self.redirect(self.url(self.context, u'@@manage')+'#tab2')
1461	return
1462
1463	@property
1464	def translated_values(self):
1465	return translated_values(self)
1466
1467	@property
1468	def label(self):
1469	# Here we know that the cookie has been set
1470	lang = self.request.cookies.get('kofa.language')
1471	level_title = translate(self.context.level_title, 'waeup.kofa',
1472	target_language=lang)
1473	return _('Manage study level ${a}',
1474	mapping = {'a':level_title})
1475
1476	@action(_('Save'), style='primary')
1477	def save(self, **data):
1478	msave(self, **data)
1479	return
1480
1481	@jsaction(_('Remove selected tickets'))
1482	def delCourseTicket(self, **data):
1483	form = self.request.form
1484	if 'val_id' in form:
1485	child_id = form['val_id']
1486	else:
1487	self.flash(_('No ticket selected.'), type="warning")
1488	self.redirect(self.url(self.context, '@@manage')+'#tab2')
1489	return
1490	if not isinstance(child_id, list):
1491	child_id = [child_id]
1492	deleted = []
1493	for id in child_id:
1494	del self.context[id]
1495	deleted.append(id)
1496	if len(deleted):
1497	self.flash(_('Successfully removed: ${a}',
1498	mapping = {'a':', '.join(deleted)}))
1499	self.context.writeLogMessage(
1500	self,'removed: %s at %s' %
1501	(', '.join(deleted), self.context.level))
1502	self.redirect(self.url(self.context, u'@@manage')+'#tab2')
1503	return
1504
1505	class ValidateCoursesPage(UtilityView, grok.View):
1506	""" Validate course list by course adviser
1507	"""
1508	grok.context(IStudentStudyLevel)
1509	grok.name('validate_courses')
1510	grok.require('waeup.validateStudent')
1511
1512	def update(self):
1513	if not self.context.__parent__.is_current:
1514	emit_lock_message(self)
1515	return
1516	if str(self.context.__parent__.current_level) != self.context.__name__:
1517	self.flash(_('This level does not correspond current level.'),
1518	type="danger")
1519	elif self.context.student.state == REGISTERED:
1520	IWorkflowInfo(self.context.student).fireTransition(
1521	'validate_courses')
1522	self.flash(_('Course list has been validated.'))
1523	else:
1524	self.flash(_('Student is in the wrong state.'), type="warning")
1525	self.redirect(self.url(self.context))
1526	return
1527
1528	def render(self):
1529	return
1530
1531	class RejectCoursesPage(UtilityView, grok.View):
1532	""" Reject course list by course adviser
1533	"""
1534	grok.context(IStudentStudyLevel)
1535	grok.name('reject_courses')
1536	grok.require('waeup.validateStudent')
1537
1538	def update(self):
1539	if not self.context.__parent__.is_current:
1540	emit_lock_message(self)
1541	return
1542	if str(self.context.__parent__.current_level) != self.context.__name__:
1543	self.flash(_('This level does not correspond current level.'),
1544	type="danger")
1545	self.redirect(self.url(self.context))
1546	return
1547	elif self.context.student.state == VALIDATED:
1548	IWorkflowInfo(self.context.student).fireTransition('reset8')
1549	message = _('Course list request has been annulled.')
1550	self.flash(message)
1551	elif self.context.student.state == REGISTERED:
1552	IWorkflowInfo(self.context.student).fireTransition('reset7')
1553	message = _('Course list request has been rejected:')
1554	self.flash(message)
1555	else:
1556	self.flash(_('Student is in the wrong state.'), type="warning")
1557	self.redirect(self.url(self.context))
1558	return
1559	args = {'subject':message}
1560	self.redirect(self.url(self.context.student) +
1561	'/contactstudent?%s' % urlencode(args))
1562	return
1563
1564	def render(self):
1565	return
1566
1567	class CourseTicketAddFormPage(KofaAddFormPage):
1568	"""Add a course ticket.
1569	"""
1570	grok.context(IStudentStudyLevel)
1571	grok.name('add')
1572	grok.require('waeup.manageStudent')
1573	label = _('Add course ticket')
1574	form_fields = grok.AutoFields(ICourseTicketAdd)
1575	pnav = 4
1576
1577	def update(self):
1578	if not self.context.__parent__.is_current:
1579	emit_lock_message(self)
1580	return
1581	super(CourseTicketAddFormPage, self).update()
1582	return
1583
1584	@action(_('Add course ticket'), style='primary')
1585	def addCourseTicket(self, **data):
1586	course = data['course']
1587	success = addCourseTicket(self, course)
1588	if success:
1589	self.redirect(self.url(self.context, u'@@manage')+'#tab2')
1590	return
1591
1592	@action(_('Cancel'), validator=NullValidator)
1593	def cancel(self, **data):
1594	self.redirect(self.url(self.context))
1595
1596	class CourseTicketDisplayFormPage(KofaDisplayFormPage):
1597	""" Page to display course tickets
1598	"""
1599	grok.context(ICourseTicket)
1600	grok.name('index')
1601	grok.require('waeup.viewStudent')
1602	form_fields = grok.AutoFields(ICourseTicket)
1603	grok.template('courseticketpage')
1604	pnav = 4
1605
1606	@property
1607	def label(self):
1608	return _('${a}: Course Ticket ${b}', mapping = {
1609	'a':self.context.student.display_fullname,
1610	'b':self.context.code})
1611
1612	class CourseTicketManageFormPage(KofaEditFormPage):
1613	""" Page to manage course tickets
1614	"""
1615	grok.context(ICourseTicket)
1616	grok.name('manage')
1617	grok.require('waeup.manageStudent')
1618	form_fields = grok.AutoFields(ICourseTicket)
1619	form_fields['title'].for_display = True
1620	form_fields['fcode'].for_display = True
1621	form_fields['dcode'].for_display = True
1622	form_fields['semester'].for_display = True
1623	form_fields['passmark'].for_display = True
1624	form_fields['credits'].for_display = True
1625	form_fields['mandatory'].for_display = False
1626	form_fields['automatic'].for_display = True
1627	form_fields['carry_over'].for_display = True
1628	pnav = 4
1629	grok.template('courseticketmanagepage')
1630
1631	@property
1632	def label(self):
1633	return _('Manage course ticket ${a}', mapping = {'a':self.context.code})
1634
1635	@action('Save', style='primary')
1636	def save(self, **data):
1637	msave(self, **data)
1638	return
1639
1640	class PaymentsManageFormPage(KofaEditFormPage):
1641	""" Page to manage the student payments
1642
1643	This manage form page is for both students and students officers.
1644	"""
1645	grok.context(IStudentPaymentsContainer)
1646	grok.name('index')
1647	grok.require('waeup.viewStudent')
1648	form_fields = grok.AutoFields(IStudentPaymentsContainer)
1649	grok.template('paymentsmanagepage')
1650	pnav = 4
1651
1652	@property
1653	def manage_payments_allowed(self):
1654	return checkPermission('waeup.payStudent', self.context)
1655
1656	def unremovable(self, ticket):
1657	usertype = getattr(self.request.principal, 'user_type', None)
1658	if not usertype:
1659	return False
1660	if not self.manage_payments_allowed:
1661	return True
1662	return (self.request.principal.user_type == 'student' and ticket.r_code)
1663
1664	@property
1665	def label(self):
1666	return _('${a}: Payments',
1667	mapping = {'a':self.context.__parent__.display_fullname})
1668
1669	@jsaction(_('Remove selected tickets'))
1670	def delPaymentTicket(self, **data):
1671	form = self.request.form
1672	if 'val_id' in form:
1673	child_id = form['val_id']
1674	else:
1675	self.flash(_('No payment selected.'), type="warning")
1676	self.redirect(self.url(self.context))
1677	return
1678	if not isinstance(child_id, list):
1679	child_id = [child_id]
1680	deleted = []
1681	for id in child_id:
1682	# Students are not allowed to remove used payment tickets
1683	ticket = self.context.get(id, None)
1684	if ticket is not None and not self.unremovable(ticket):
1685	del self.context[id]
1686	deleted.append(id)
1687	if len(deleted):
1688	self.flash(_('Successfully removed: ${a}',
1689	mapping = {'a': ', '.join(deleted)}))
1690	self.context.writeLogMessage(
1691	self,'removed: %s' % ', '.join(deleted))
1692	self.redirect(self.url(self.context))
1693	return
1694
1695	#@action(_('Add online payment ticket'))
1696	#def addPaymentTicket(self, **data):
1697	# self.redirect(self.url(self.context, '@@addop'))
1698
1699	class OnlinePaymentAddFormPage(KofaAddFormPage):
1700	""" Page to add an online payment ticket
1701	"""
1702	grok.context(IStudentPaymentsContainer)
1703	grok.name('addop')
1704	grok.template('onlinepaymentaddform')
1705	grok.require('waeup.payStudent')
1706	form_fields = grok.AutoFields(IStudentOnlinePayment).select(
1707	'p_category')
1708	label = _('Add online payment')
1709	pnav = 4
1710
1711	@property
1712	def selectable_categories(self):
1713	categories = getUtility(IKofaUtils).SELECTABLE_PAYMENT_CATEGORIES
1714	return sorted(categories.items())
1715
1716	@action(_('Create ticket'), style='primary')
1717	def createTicket(self, **data):
1718	p_category = data['p_category']
1719	previous_session = data.get('p_session', None)
1720	previous_level = data.get('p_level', None)
1721	student = self.context.__parent__
1722	# The hostel_application payment category is temporarily used
1723	# by Uniben.
1724	if p_category in ('bed_allocation', 'hostel_application') and student[
1725	'studycourse'].current_session != grok.getSite()[
1726	'hostels'].accommodation_session:
1727	self.flash(
1728	_('Your current session does not match ' + \
1729	'accommodation session.'), type="danger")
1730	return
1731	if 'maintenance' in p_category:
1732	current_session = str(student['studycourse'].current_session)
1733	if not current_session in student['accommodation']:
1734	self.flash(_('You have not yet booked accommodation.'),
1735	type="warning")
1736	return
1737	students_utils = getUtility(IStudentsUtils)
1738	error, payment = students_utils.setPaymentDetails(
1739	p_category, student, previous_session, previous_level)
1740	if error is not None:
1741	self.flash(error, type="danger")
1742	return
1743	self.context[payment.p_id] = payment
1744	self.flash(_('Payment ticket created.'))
1745	self.context.writeLogMessage(self,'added: %s' % payment.p_id)
1746	self.redirect(self.url(self.context))
1747	return
1748
1749	@action(_('Cancel'), validator=NullValidator)
1750	def cancel(self, **data):
1751	self.redirect(self.url(self.context))
1752
1753	class PreviousPaymentAddFormPage(KofaAddFormPage):
1754	""" Page to add an online payment ticket for previous sessions
1755	"""
1756	grok.context(IStudentPaymentsContainer)
1757	grok.name('addpp')
1758	grok.require('waeup.payStudent')
1759	form_fields = grok.AutoFields(IStudentPreviousPayment)
1760	label = _('Add previous session online payment')
1761	pnav = 4
1762
1763	def update(self):
1764	if self.context.student.before_payment:
1765	self.flash(_("No previous payment to be made."), type="warning")
1766	self.redirect(self.url(self.context))
1767	super(PreviousPaymentAddFormPage, self).update()
1768	return
1769
1770	@action(_('Create ticket'), style='primary')
1771	def createTicket(self, **data):
1772	p_category = data['p_category']
1773	previous_session = data.get('p_session', None)
1774	previous_level = data.get('p_level', None)
1775	student = self.context.__parent__
1776	students_utils = getUtility(IStudentsUtils)
1777	error, payment = students_utils.setPaymentDetails(
1778	p_category, student, previous_session, previous_level)
1779	if error is not None:
1780	self.flash(error, type="danger")
1781	return
1782	self.context[payment.p_id] = payment
1783	self.flash(_('Payment ticket created.'))
1784	self.redirect(self.url(self.context))
1785	return
1786
1787	@action(_('Cancel'), validator=NullValidator)
1788	def cancel(self, **data):
1789	self.redirect(self.url(self.context))
1790
1791	class BalancePaymentAddFormPage(KofaAddFormPage):
1792	""" Page to add an online payment ticket for balance sessions
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 OnlinePaymentApprovePage(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 OnlinePaymentFakeApprovePage(OnlinePaymentApprovePage):
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
1876	grok.name('fake_approve')
1877	grok.require('waeup.payStudent')
1878
1879	class ExportPDFPaymentSlipPage(UtilityView, grok.View):
1880	"""Deliver a PDF slip of the context.
1881	"""
1882	grok.context(IStudentOnlinePayment)
1883	grok.name('payment_slip.pdf')
1884	grok.require('waeup.viewStudent')
1885	form_fields = grok.AutoFields(IStudentOnlinePayment).omit('p_item')
1886	form_fields['creation_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
1887	form_fields['payment_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
1888	prefix = 'form'
1889	note = None
1890	omit_fields = (
1891	'password', 'suspended', 'phone', 'date_of_birth',
1892	'adm_code', 'sex', 'suspended_comment', 'current_level')
1893
1894	@property
1895	def title(self):
1896	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
1897	return translate(_('Payment Data'), 'waeup.kofa',
1898	target_language=portal_language)
1899
1900	@property
1901	def label(self):
1902	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
1903	return translate(_('Online Payment Slip'),
1904	'waeup.kofa', target_language=portal_language) \
1905	+ ' %s' % self.context.p_id
1906
1907	def render(self):
1908	#if self.context.p_state != 'paid':
1909	# self.flash('Ticket not yet paid.')
1910	# self.redirect(self.url(self.context))
1911	# return
1912	studentview = StudentBasePDFFormPage(self.context.student,
1913	self.request, self.omit_fields)
1914	students_utils = getUtility(IStudentsUtils)
1915	return students_utils.renderPDF(self, 'payment_slip.pdf',
1916	self.context.student, studentview, note=self.note,
1917	omit_fields=self.omit_fields)
1918
1919
1920	class AccommodationManageFormPage(KofaEditFormPage):
1921	""" Page to manage bed tickets.
1922
1923	This manage form page is for both students and students officers.
1924	"""
1925	grok.context(IStudentAccommodation)
1926	grok.name('index')
1927	grok.require('waeup.handleAccommodation')
1928	form_fields = grok.AutoFields(IStudentAccommodation)
1929	grok.template('accommodationmanagepage')
1930	pnav = 4
1931	officers_only_actions = [_('Remove selected')]
1932
1933	@property
1934	def label(self):
1935	return _('${a}: Accommodation',
1936	mapping = {'a':self.context.__parent__.display_fullname})
1937
1938	@jsaction(_('Remove selected'))
1939	def delBedTickets(self, **data):
1940	if getattr(self.request.principal, 'user_type', None) == 'student':
1941	self.flash(_('You are not allowed to remove bed tickets.'),
1942	type="warning")
1943	self.redirect(self.url(self.context))
1944	return
1945	form = self.request.form
1946	if 'val_id' in form:
1947	child_id = form['val_id']
1948	else:
1949	self.flash(_('No bed ticket selected.'), type="warning")
1950	self.redirect(self.url(self.context))
1951	return
1952	if not isinstance(child_id, list):
1953	child_id = [child_id]
1954	deleted = []
1955	for id in child_id:
1956	del self.context[id]
1957	deleted.append(id)
1958	if len(deleted):
1959	self.flash(_('Successfully removed: ${a}',
1960	mapping = {'a':', '.join(deleted)}))
1961	self.context.writeLogMessage(
1962	self,'removed: % s' % ', '.join(deleted))
1963	self.redirect(self.url(self.context))
1964	return
1965
1966	@property
1967	def selected_actions(self):
1968	if getattr(self.request.principal, 'user_type', None) == 'student':
1969	return [action for action in self.actions
1970	if not action.label in self.officers_only_actions]
1971	return self.actions
1972
1973	class BedTicketAddPage(KofaPage):
1974	""" Page to add an online payment ticket
1975	"""
1976	grok.context(IStudentAccommodation)
1977	grok.name('add')
1978	grok.require('waeup.handleAccommodation')
1979	grok.template('enterpin')
1980	ac_prefix = 'HOS'
1981	label = _('Add bed ticket')
1982	pnav = 4
1983	buttonname = _('Create bed ticket')
1984	notice = ''
1985	with_ac = True
1986
1987	def update(self, SUBMIT=None):
1988	student = self.context.student
1989	students_utils = getUtility(IStudentsUtils)
1990	acc_details = students_utils.getAccommodationDetails(student)
1991	if acc_details.get('expired', False):
1992	startdate = acc_details.get('startdate')
1993	enddate = acc_details.get('enddate')
1994	if startdate and enddate:
1995	tz = getUtility(IKofaUtils).tzinfo
1996	startdate = to_timezone(
1997	startdate, tz).strftime("%d/%m/%Y %H:%M:%S")
1998	enddate = to_timezone(
1999	enddate, tz).strftime("%d/%m/%Y %H:%M:%S")
2000	self.flash(_("Outside booking period: ${a} - ${b}",
2001	mapping = {'a': startdate, 'b': enddate}), type="warning")
2002	else:
2003	self.flash(_("Outside booking period."), type="warning")
2004	self.redirect(self.url(self.context))
2005	return
2006	if not acc_details:
2007	self.flash(_("Your data are incomplete."), type="warning")
2008	self.redirect(self.url(self.context))
2009	return
2010	if not student.state in acc_details['allowed_states']:
2011	self.flash(_("You are in the wrong registration state."),
2012	type="warning")
2013	self.redirect(self.url(self.context))
2014	return
2015	if student['studycourse'].current_session != acc_details[
2016	'booking_session']:
2017	self.flash(
2018	_('Your current session does not match accommodation session.'),
2019	type="warning")
2020	self.redirect(self.url(self.context))
2021	return
2022	if str(acc_details['booking_session']) in self.context.keys():
2023	self.flash(
2024	_('You already booked a bed space in current ' \
2025	+ 'accommodation session.'), type="warning")
2026	self.redirect(self.url(self.context))
2027	return
2028	if self.with_ac:
2029	self.ac_series = self.request.form.get('ac_series', None)
2030	self.ac_number = self.request.form.get('ac_number', None)
2031	if SUBMIT is None:
2032	return
2033	if self.with_ac:
2034	pin = '%s-%s-%s' % (self.ac_prefix, self.ac_series, self.ac_number)
2035	code = get_access_code(pin)
2036	if not code:
2037	self.flash(_('Activation code is invalid.'), type="warning")
2038	return
2039	# Search and book bed
2040	cat = queryUtility(ICatalog, name='beds_catalog', default=None)
2041	entries = cat.searchResults(
2042	owner=(student.student_id,student.student_id))
2043	if len(entries):
2044	# If bed space has been manually allocated use this bed
2045	bed = [entry for entry in entries][0]
2046	# Safety belt for paranoids: Does this bed really exist on portal?
2047	# XXX: Can be remove if nobody complains.
2048	if bed.__parent__.__parent__ is None:
2049	self.flash(_('System error: Please contact the adminsitrator.'),
2050	type="danger")
2051	self.context.writeLogMessage(self, 'fatal error: %s' % bed.bed_id)
2052	return
2053	else:
2054	# else search for other available beds
2055	entries = cat.searchResults(
2056	bed_type=(acc_details['bt'],acc_details['bt']))
2057	available_beds = [
2058	entry for entry in entries if entry.owner == NOT_OCCUPIED]
2059	if available_beds:
2060	students_utils = getUtility(IStudentsUtils)
2061	bed = students_utils.selectBed(available_beds)
2062	# Safety belt for paranoids: Does this bed really exist in portal?
2063	# XXX: Can be remove if nobody complains.
2064	if bed.__parent__.__parent__ is None:
2065	self.flash(_('System error: Please contact the adminsitrator.'),
2066	type="warning")
2067	self.context.writeLogMessage(self, 'fatal error: %s' % bed.bed_id)
2068	return
2069	bed.bookBed(student.student_id)
2070	else:
2071	self.flash(_('There is no free bed in your category ${a}.',
2072	mapping = {'a':acc_details['bt']}), type="warning")
2073	return
2074	if self.with_ac:
2075	# Mark pin as used (this also fires a pin related transition)
2076	if code.state == USED:
2077	self.flash(_('Activation code has already been used.'),
2078	type="warning")
2079	return
2080	else:
2081	comment = _(u'invalidated')
2082	# Here we know that the ac is in state initialized so we do not
2083	# expect an exception, but the owner might be different
2084	if not invalidate_accesscode(
2085	pin,comment,self.context.student.student_id):
2086	self.flash(_('You are not the owner of this access code.'),
2087	type="warning")
2088	return
2089	# Create bed ticket
2090	bedticket = createObject(u'waeup.BedTicket')
2091	if self.with_ac:
2092	bedticket.booking_code = pin
2093	bedticket.booking_session = acc_details['booking_session']
2094	bedticket.bed_type = acc_details['bt']
2095	bedticket.bed = bed
2096	hall_title = bed.__parent__.hostel_name
2097	coordinates = bed.coordinates[1:]
2098	block, room_nr, bed_nr = coordinates
2099	bc = _('${a}, Block ${b}, Room ${c}, Bed ${d} (${e})', mapping = {
2100	'a':hall_title, 'b':block,
2101	'c':room_nr, 'd':bed_nr,
2102	'e':bed.bed_type})
2103	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
2104	bedticket.bed_coordinates = translate(
2105	bc, 'waeup.kofa',target_language=portal_language)
2106	self.context.addBedTicket(bedticket)
2107	self.context.writeLogMessage(self, 'booked: %s' % bed.bed_id)
2108	self.flash(_('Bed ticket created and bed booked: ${a}',
2109	mapping = {'a':bedticket.display_coordinates}))
2110	self.redirect(self.url(self.context))
2111	return
2112
2113	class BedTicketDisplayFormPage(KofaDisplayFormPage):
2114	""" Page to display bed tickets
2115	"""
2116	grok.context(IBedTicket)
2117	grok.name('index')
2118	grok.require('waeup.handleAccommodation')
2119	form_fields = grok.AutoFields(IBedTicket).omit('bed_coordinates')
2120	form_fields['booking_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
2121	pnav = 4
2122
2123	@property
2124	def label(self):
2125	return _('Bed Ticket for Session ${a}',
2126	mapping = {'a':self.context.getSessionString()})
2127
2128	class ExportPDFBedTicketSlipPage(UtilityView, grok.View):
2129	"""Deliver a PDF slip of the context.
2130	"""
2131	grok.context(IBedTicket)
2132	grok.name('bed_allocation_slip.pdf')
2133	grok.require('waeup.handleAccommodation')
2134	form_fields = grok.AutoFields(IBedTicket).omit('bed_coordinates')
2135	form_fields['booking_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
2136	prefix = 'form'
2137	omit_fields = (
2138	'password', 'suspended', 'phone', 'adm_code',
2139	'suspended_comment', 'date_of_birth', 'current_level')
2140
2141	@property
2142	def title(self):
2143	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
2144	return translate(_('Bed Allocation Data'), 'waeup.kofa',
2145	target_language=portal_language)
2146
2147	@property
2148	def label(self):
2149	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
2150	#return translate(_('Bed Allocation: '),
2151	# 'waeup.kofa', target_language=portal_language) \
2152	# + ' %s' % self.context.bed_coordinates
2153	return translate(_('Bed Allocation Slip'),
2154	'waeup.kofa', target_language=portal_language) \
2155	+ ' %s' % self.context.getSessionString()
2156
2157	def render(self):
2158	studentview = StudentBasePDFFormPage(self.context.student,
2159	self.request, self.omit_fields)
2160	students_utils = getUtility(IStudentsUtils)
2161	return students_utils.renderPDF(
2162	self, 'bed_allocation_slip.pdf',
2163	self.context.student, studentview,
2164	omit_fields=self.omit_fields)
2165
2166	class BedTicketRelocationPage(UtilityView, grok.View):
2167	""" Callback view
2168	"""
2169	grok.context(IBedTicket)
2170	grok.name('relocate')
2171	grok.require('waeup.manageHostels')
2172
2173	# Relocate student if student parameters have changed or the bed_type
2174	# of the bed has changed
2175	def update(self):
2176	student = self.context.student
2177	students_utils = getUtility(IStudentsUtils)
2178	acc_details = students_utils.getAccommodationDetails(student)
2179	if self.context.bed != None and \
2180	'reserved' in self.context.bed.bed_type:
2181	self.flash(_("Students in reserved beds can't be relocated."),
2182	type="warning")
2183	self.redirect(self.url(self.context))
2184	return
2185	if acc_details['bt'] == self.context.bed_type and \
2186	self.context.bed != None and \
2187	self.context.bed.bed_type == self.context.bed_type:
2188	self.flash(_("Student can't be relocated."), type="warning")
2189	self.redirect(self.url(self.context))
2190	return
2191	# Search a bed
2192	cat = queryUtility(ICatalog, name='beds_catalog', default=None)
2193	entries = cat.searchResults(
2194	owner=(student.student_id,student.student_id))
2195	if len(entries) and self.context.bed == None:
2196	# If booking has been cancelled but other bed space has been
2197	# manually allocated after cancellation use this bed
2198	new_bed = [entry for entry in entries][0]
2199	else:
2200	# Search for other available beds
2201	entries = cat.searchResults(
2202	bed_type=(acc_details['bt'],acc_details['bt']))
2203	available_beds = [
2204	entry for entry in entries if entry.owner == NOT_OCCUPIED]
2205	if available_beds:
2206	students_utils = getUtility(IStudentsUtils)
2207	new_bed = students_utils.selectBed(available_beds)
2208	new_bed.bookBed(student.student_id)
2209	else:
2210	self.flash(_('There is no free bed in your category ${a}.',
2211	mapping = {'a':acc_details['bt']}), type="warning")
2212	self.redirect(self.url(self.context))
2213	return
2214	# Release old bed if exists
2215	if self.context.bed != None:
2216	self.context.bed.owner = NOT_OCCUPIED
2217	notify(grok.ObjectModifiedEvent(self.context.bed))
2218	# Alocate new bed
2219	self.context.bed_type = acc_details['bt']
2220	self.context.bed = new_bed
2221	hall_title = new_bed.__parent__.hostel_name
2222	coordinates = new_bed.coordinates[1:]
2223	block, room_nr, bed_nr = coordinates
2224	bc = _('${a}, Block ${b}, Room ${c}, Bed ${d} (${e})', mapping = {
2225	'a':hall_title, 'b':block,
2226	'c':room_nr, 'd':bed_nr,
2227	'e':new_bed.bed_type})
2228	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
2229	self.context.bed_coordinates = translate(
2230	bc, 'waeup.kofa',target_language=portal_language)
2231	self.context.writeLogMessage(self, 'relocated: %s' % new_bed.bed_id)
2232	self.flash(_('Student relocated: ${a}',
2233	mapping = {'a':self.context.display_coordinates}))
2234	self.redirect(self.url(self.context))
2235	return
2236
2237	def render(self):
2238	return
2239
2240	class StudentHistoryPage(KofaPage):
2241	""" Page to display student history
2242	"""
2243	grok.context(IStudent)
2244	grok.name('history')
2245	grok.require('waeup.viewStudent')
2246	grok.template('studenthistory')
2247	pnav = 4
2248
2249	@property
2250	def label(self):
2251	return _('${a}: History', mapping = {'a':self.context.display_fullname})
2252
2253	# Pages for students only
2254
2255	class StudentBaseEditFormPage(KofaEditFormPage):
2256	""" View to edit student base data
2257	"""
2258	grok.context(IStudent)
2259	grok.name('edit_base')
2260	grok.require('waeup.handleStudent')
2261	form_fields = grok.AutoFields(IStudentBase).select(
2262	'email', 'phone')
2263	label = _('Edit base data')
2264	pnav = 4
2265
2266	@action(_('Save'), style='primary')
2267	def save(self, **data):
2268	msave(self, **data)
2269	return
2270
2271	class StudentChangePasswordPage(KofaEditFormPage):
2272	""" View to edit student passwords
2273	"""
2274	grok.context(IStudent)
2275	grok.name('change_password')
2276	grok.require('waeup.handleStudent')
2277	grok.template('change_password')
2278	label = _('Change password')
2279	pnav = 4
2280
2281	@action(_('Save'), style='primary')
2282	def save(self, **data):
2283	form = self.request.form
2284	password = form.get('change_password', None)
2285	password_ctl = form.get('change_password_repeat', None)
2286	if password:
2287	validator = getUtility(IPasswordValidator)
2288	errors = validator.validate_password(password, password_ctl)
2289	if not errors:
2290	IUserAccount(self.context).setPassword(password)
2291	# Unset temporary password
2292	self.context.temp_password = None
2293	self.context.writeLogMessage(self, 'saved: password')
2294	self.flash(_('Password changed.'))
2295	else:
2296	self.flash( ' '.join(errors), type="warning")
2297	return
2298
2299	class StudentFilesUploadPage(KofaPage):
2300	""" View to upload files by student
2301	"""
2302	grok.context(IStudent)
2303	grok.name('change_portrait')
2304	grok.require('waeup.uploadStudentFile')
2305	grok.template('filesuploadpage')
2306	label = _('Upload portrait')
2307	pnav = 4
2308
2309	def update(self):
2310	PWCHANGE_STATES = getUtility(IStudentsUtils).PWCHANGE_STATES
2311	if self.context.student.state not in PWCHANGE_STATES:
2312	emit_lock_message(self)
2313	return
2314	super(StudentFilesUploadPage, self).update()
2315	return
2316
2317	class StartClearancePage(KofaPage):
2318	grok.context(IStudent)
2319	grok.name('start_clearance')
2320	grok.require('waeup.handleStudent')
2321	grok.template('enterpin')
2322	label = _('Start clearance')
2323	ac_prefix = 'CLR'
2324	notice = ''
2325	pnav = 4
2326	buttonname = _('Start clearance now')
2327	with_ac = True
2328
2329	@property
2330	def all_required_fields_filled(self):
2331	if self.context.email and self.context.phone:
2332	return True
2333	return False
2334
2335	@property
2336	def portrait_uploaded(self):
2337	store = getUtility(IExtFileStore)
2338	if store.getFileByContext(self.context, attr=u'passport.jpg'):
2339	return True
2340	return False
2341
2342	def update(self, SUBMIT=None):
2343	if not self.context.state == ADMITTED:
2344	self.flash(_("Wrong state"), type="warning")
2345	self.redirect(self.url(self.context))
2346	return
2347	if not self.portrait_uploaded:
2348	self.flash(_("No portrait uploaded."), type="warning")
2349	self.redirect(self.url(self.context, 'change_portrait'))
2350	return
2351	if not self.all_required_fields_filled:
2352	self.flash(_("Not all required fields filled."), type="warning")
2353	self.redirect(self.url(self.context, 'edit_base'))
2354	return
2355	if self.with_ac:
2356	self.ac_series = self.request.form.get('ac_series', None)
2357	self.ac_number = self.request.form.get('ac_number', None)
2358	if SUBMIT is None:
2359	return
2360	if self.with_ac:
2361	pin = '%s-%s-%s' % (self.ac_prefix, self.ac_series, self.ac_number)
2362	code = get_access_code(pin)
2363	if not code:
2364	self.flash(_('Activation code is invalid.'), type="warning")
2365	return
2366	if code.state == USED:
2367	self.flash(_('Activation code has already been used.'),
2368	type="warning")
2369	return
2370	# Mark pin as used (this also fires a pin related transition)
2371	# and fire transition start_clearance
2372	comment = _(u"invalidated")
2373	# Here we know that the ac is in state initialized so we do not
2374	# expect an exception, but the owner might be different
2375	if not invalidate_accesscode(pin, comment, self.context.student_id):
2376	self.flash(_('You are not the owner of this access code.'),
2377	type="warning")
2378	return
2379	self.context.clr_code = pin
2380	IWorkflowInfo(self.context).fireTransition('start_clearance')
2381	self.flash(_('Clearance process has been started.'))
2382	self.redirect(self.url(self.context,'cedit'))
2383	return
2384
2385	class StudentClearanceEditFormPage(StudentClearanceManageFormPage):
2386	""" View to edit student clearance data by student
2387	"""
2388	grok.context(IStudent)
2389	grok.name('cedit')
2390	grok.require('waeup.handleStudent')
2391	label = _('Edit clearance data')
2392
2393	@property
2394	def form_fields(self):
2395	if self.context.is_postgrad:
2396	form_fields = grok.AutoFields(IPGStudentClearance).omit(
2397	'clearance_locked', 'clr_code', 'officer_comment')
2398	else:
2399	form_fields = grok.AutoFields(IUGStudentClearance).omit(
2400	'clearance_locked', 'clr_code', 'officer_comment')
2401	return form_fields
2402
2403	def update(self):
2404	if self.context.clearance_locked:
2405	emit_lock_message(self)
2406	return
2407	return super(StudentClearanceEditFormPage, self).update()
2408
2409	@action(_('Save'), style='primary')
2410	def save(self, **data):
2411	self.applyData(self.context, **data)
2412	self.flash(_('Clearance form has been saved.'))
2413	return
2414
2415	def dataNotComplete(self):
2416	"""To be implemented in the customization package.
2417	"""
2418	return False
2419
2420	@action(_('Save and request clearance'), style='primary')
2421	def requestClearance(self, **data):
2422	self.applyData(self.context, **data)
2423	if self.dataNotComplete():
2424	self.flash(self.dataNotComplete(), type="warning")
2425	return
2426	self.flash(_('Clearance form has been saved.'))
2427	if self.context.clr_code:
2428	self.redirect(self.url(self.context, 'request_clearance'))
2429	else:
2430	# We bypass the request_clearance page if student
2431	# has been imported in state 'clearance started' and
2432	# no clr_code was entered before.
2433	state = IWorkflowState(self.context).getState()
2434	if state != CLEARANCE:
2435	# This shouldn't happen, but the application officer
2436	# might have forgotten to lock the form after changing the state
2437	self.flash(_('This form cannot be submitted. Wrong state!'),
2438	type="danger")
2439	return
2440	IWorkflowInfo(self.context).fireTransition('request_clearance')
2441	self.flash(_('Clearance has been requested.'))
2442	self.redirect(self.url(self.context))
2443	return
2444
2445	class RequestClearancePage(KofaPage):
2446	grok.context(IStudent)
2447	grok.name('request_clearance')
2448	grok.require('waeup.handleStudent')
2449	grok.template('enterpin')
2450	label = _('Request clearance')
2451	notice = _('Enter the CLR access code used for starting clearance.')
2452	ac_prefix = 'CLR'
2453	pnav = 4
2454	buttonname = _('Request clearance now')
2455	with_ac = True
2456
2457	def update(self, SUBMIT=None):
2458	if self.with_ac:
2459	self.ac_series = self.request.form.get('ac_series', None)
2460	self.ac_number = self.request.form.get('ac_number', None)
2461	if SUBMIT is None:
2462	return
2463	if self.with_ac:
2464	pin = '%s-%s-%s' % (self.ac_prefix, self.ac_series, self.ac_number)
2465	if self.context.clr_code and self.context.clr_code != pin:
2466	self.flash(_("This isn't your CLR access code."), type="danger")
2467	return
2468	state = IWorkflowState(self.context).getState()
2469	if state != CLEARANCE:
2470	# This shouldn't happen, but the application officer
2471	# might have forgotten to lock the form after changing the state
2472	self.flash(_('This form cannot be submitted. Wrong state!'),
2473	type="danger")
2474	return
2475	IWorkflowInfo(self.context).fireTransition('request_clearance')
2476	self.flash(_('Clearance has been requested.'))
2477	self.redirect(self.url(self.context))
2478	return
2479
2480	class StartSessionPage(KofaPage):
2481	grok.context(IStudentStudyCourse)
2482	grok.name('start_session')
2483	grok.require('waeup.handleStudent')
2484	grok.template('enterpin')
2485	label = _('Start session')
2486	ac_prefix = 'SFE'
2487	notice = ''
2488	pnav = 4
2489	buttonname = _('Start now')
2490	with_ac = True
2491
2492	def update(self, SUBMIT=None):
2493	if not self.context.is_current:
2494	emit_lock_message(self)
2495	return
2496	super(StartSessionPage, self).update()
2497	if not self.context.next_session_allowed:
2498	self.flash(_("You are not entitled to start session."),
2499	type="warning")
2500	self.redirect(self.url(self.context))
2501	return
2502	if self.with_ac:
2503	self.ac_series = self.request.form.get('ac_series', None)
2504	self.ac_number = self.request.form.get('ac_number', None)
2505	if SUBMIT is None:
2506	return
2507	if self.with_ac:
2508	pin = '%s-%s-%s' % (self.ac_prefix, self.ac_series, self.ac_number)
2509	code = get_access_code(pin)
2510	if not code:
2511	self.flash(_('Activation code is invalid.'), type="warning")
2512	return
2513	# Mark pin as used (this also fires a pin related transition)
2514	if code.state == USED:
2515	self.flash(_('Activation code has already been used.'),
2516	type="warning")
2517	return
2518	else:
2519	comment = _(u"invalidated")
2520	# Here we know that the ac is in state initialized so we do not
2521	# expect an error, but the owner might be different
2522	if not invalidate_accesscode(
2523	pin,comment,self.context.student.student_id):
2524	self.flash(_('You are not the owner of this access code.'),
2525	type="warning")
2526	return
2527	try:
2528	if self.context.student.state == CLEARED:
2529	IWorkflowInfo(self.context.student).fireTransition(
2530	'pay_first_school_fee')
2531	elif self.context.student.state == RETURNING:
2532	IWorkflowInfo(self.context.student).fireTransition(
2533	'pay_school_fee')
2534	elif self.context.student.state == PAID:
2535	IWorkflowInfo(self.context.student).fireTransition(
2536	'pay_pg_fee')
2537	except ConstraintNotSatisfied:
2538	self.flash(_('An error occurred, please contact the system administrator.'),
2539	type="danger")
2540	return
2541	self.flash(_('Session started.'))
2542	self.redirect(self.url(self.context))
2543	return
2544
2545	class AddStudyLevelFormPage(KofaEditFormPage):
2546	""" Page for students to add current study levels
2547	"""
2548	grok.context(IStudentStudyCourse)
2549	grok.name('add')
2550	grok.require('waeup.handleStudent')
2551	grok.template('studyleveladdpage')
2552	form_fields = grok.AutoFields(IStudentStudyCourse)
2553	pnav = 4
2554
2555	@property
2556	def label(self):
2557	studylevelsource = StudyLevelSource().factory
2558	code = self.context.current_level
2559	title = studylevelsource.getTitle(self.context, code)
2560	return _('Add current level ${a}', mapping = {'a':title})
2561
2562	def update(self):
2563	if not self.context.is_current:
2564	emit_lock_message(self)
2565	return
2566	if self.context.student.state != PAID:
2567	emit_lock_message(self)
2568	return
2569	code = self.context.current_level
2570	if code is None:
2571	self.flash(_('Your data are incomplete'), type="danger")
2572	self.redirect(self.url(self.context))
2573	return
2574	super(AddStudyLevelFormPage, self).update()
2575	return
2576
2577	@action(_('Create course list now'), style='primary')
2578	def addStudyLevel(self, **data):
2579	studylevel = createObject(u'waeup.StudentStudyLevel')
2580	studylevel.level = self.context.current_level
2581	studylevel.level_session = self.context.current_session
2582	try:
2583	self.context.addStudentStudyLevel(
2584	self.context.certificate,studylevel)
2585	except KeyError:
2586	self.flash(_('This level exists.'), type="warning")
2587	except RequiredMissing:
2588	self.flash(_('Your data are incomplete'), type="danger")
2589	self.redirect(self.url(self.context))
2590	return
2591
2592	class StudyLevelEditFormPage(KofaEditFormPage):
2593	""" Page to edit the student study level data by students
2594	"""
2595	grok.context(IStudentStudyLevel)
2596	grok.name('edit')
2597	grok.require('waeup.editStudyLevel')
2598	grok.template('studyleveleditpage')
2599	pnav = 4
2600	placeholder = _('Enter valid course code')
2601
2602	def update(self, ADD=None, course=None):
2603	if not self.context.__parent__.is_current:
2604	emit_lock_message(self)
2605	return
2606	if self.context.student.state != PAID or \
2607	not self.context.is_current_level:
2608	emit_lock_message(self)
2609	return
2610	super(StudyLevelEditFormPage, self).update()
2611	if ADD is not None:
2612	if not course:
2613	self.flash(_('No valid course code entered.'), type="warning")
2614	return
2615	cat = queryUtility(ICatalog, name='courses_catalog')
2616	result = cat.searchResults(code=(course, course))
2617	if len(result) != 1:
2618	self.flash(_('Course not found.'), type="warning")
2619	return
2620	course = list(result)[0]
2621	addCourseTicket(self, course)
2622	return
2623
2624	@property
2625	def label(self):
2626	# Here we know that the cookie has been set
2627	lang = self.request.cookies.get('kofa.language')
2628	level_title = translate(self.context.level_title, 'waeup.kofa',
2629	target_language=lang)
2630	return _('Edit course list of ${a}',
2631	mapping = {'a':level_title})
2632
2633	@property
2634	def translated_values(self):
2635	return translated_values(self)
2636
2637	def _delCourseTicket(self, **data):
2638	form = self.request.form
2639	if 'val_id' in form:
2640	child_id = form['val_id']
2641	else:
2642	self.flash(_('No ticket selected.'), type="warning")
2643	self.redirect(self.url(self.context, '@@edit'))
2644	return
2645	if not isinstance(child_id, list):
2646	child_id = [child_id]
2647	deleted = []
2648	for id in child_id:
2649	# Students are not allowed to remove core tickets
2650	if id in self.context and \
2651	self.context[id].removable_by_student:
2652	del self.context[id]
2653	deleted.append(id)
2654	if len(deleted):
2655	self.flash(_('Successfully removed: ${a}',
2656	mapping = {'a':', '.join(deleted)}))
2657	self.context.writeLogMessage(
2658	self,'removed: %s at %s' %
2659	(', '.join(deleted), self.context.level))
2660	self.redirect(self.url(self.context, u'@@edit'))
2661	return
2662
2663	@jsaction(_('Remove selected tickets'))
2664	def delCourseTicket(self, **data):
2665	self._delCourseTicket(**data)
2666	return
2667
2668	def _registerCourses(self, **data):
2669	if self.context.student.is_postgrad and \
2670	not self.context.student.is_special_postgrad:
2671	self.flash(_(
2672	"You are a postgraduate student, "
2673	"your course list can't bee registered."), type="warning")
2674	self.redirect(self.url(self.context))
2675	return
2676	students_utils = getUtility(IStudentsUtils)
2677	max_credits = students_utils.maxCredits(self.context)
2678	if max_credits and self.context.total_credits > max_credits:
2679	self.flash(_('Maximum credits of ${a} exceeded.',
2680	mapping = {'a':max_credits}), type="warning")
2681	return
2682	IWorkflowInfo(self.context.student).fireTransition(
2683	'register_courses')
2684	self.flash(_('Course list has been registered.'))
2685	self.redirect(self.url(self.context))
2686	return
2687
2688	@action(_('Register course list'), style='primary',
2689	warning=_('You can not edit your course list after registration.'
2690	' You really want to register?'))
2691	def registerCourses(self, **data):
2692	self._registerCourses(**data)
2693	return
2694
2695	class CourseTicketAddFormPage2(CourseTicketAddFormPage):
2696	"""Add a course ticket by student.
2697	"""
2698	grok.name('ctadd')
2699	grok.require('waeup.handleStudent')
2700	form_fields = grok.AutoFields(ICourseTicketAdd)
2701
2702	def update(self):
2703	if self.context.student.state != PAID or \
2704	not self.context.is_current_level:
2705	emit_lock_message(self)
2706	return
2707	super(CourseTicketAddFormPage2, self).update()
2708	return
2709
2710	@action(_('Add course ticket'))
2711	def addCourseTicket(self, **data):
2712	# Safety belt
2713	if self.context.student.state != PAID:
2714	return
2715	course = data['course']
2716	success = addCourseTicket(self, course)
2717	if success:
2718	self.redirect(self.url(self.context, u'@@edit'))
2719	return
2720
2721	class SetPasswordPage(KofaPage):
2722	grok.context(IKofaObject)
2723	grok.name('setpassword')
2724	grok.require('waeup.Anonymous')
2725	grok.template('setpassword')
2726	label = _('Set password for first-time login')
2727	ac_prefix = 'PWD'
2728	pnav = 0
2729	set_button = _('Set')
2730
2731	def update(self, SUBMIT=None):
2732	self.reg_number = self.request.form.get('reg_number', None)
2733	self.ac_series = self.request.form.get('ac_series', None)
2734	self.ac_number = self.request.form.get('ac_number', None)
2735
2736	if SUBMIT is None:
2737	return
2738	hitlist = search(query=self.reg_number,
2739	searchtype='reg_number', view=self)
2740	if not hitlist:
2741	self.flash(_('No student found.'), type="warning")
2742	return
2743	if len(hitlist) != 1: # Cannot happen but anyway
2744	self.flash(_('More than one student found.'), type="warning")
2745	return
2746	student = hitlist[0].context
2747	self.student_id = student.student_id
2748	student_pw = student.password
2749	pin = '%s-%s-%s' % (self.ac_prefix, self.ac_series, self.ac_number)
2750	code = get_access_code(pin)
2751	if not code:
2752	self.flash(_('Access code is invalid.'), type="warning")
2753	return
2754	if student_pw and pin == student.adm_code:
2755	self.flash(_(
2756	'Password has already been set. Your Student Id is ${a}',
2757	mapping = {'a':self.student_id}))
2758	return
2759	elif student_pw:
2760	self.flash(
2761	_('Password has already been set. You are using the ' +
2762	'wrong Access Code.'), type="warning")
2763	return
2764	# Mark pin as used (this also fires a pin related transition)
2765	# and set student password
2766	if code.state == USED:
2767	self.flash(_('Access code has already been used.'), type="warning")
2768	return
2769	else:
2770	comment = _(u"invalidated")
2771	# Here we know that the ac is in state initialized so we do not
2772	# expect an exception
2773	invalidate_accesscode(pin,comment)
2774	IUserAccount(student).setPassword(self.ac_number)
2775	student.adm_code = pin
2776	self.flash(_('Password has been set. Your Student Id is ${a}',
2777	mapping = {'a':self.student_id}))
2778	return
2779
2780	class StudentRequestPasswordPage(KofaAddFormPage):
2781	"""Captcha'd registration page for applicants.
2782	"""
2783	grok.name('requestpw')
2784	grok.require('waeup.Anonymous')
2785	grok.template('requestpw')
2786	form_fields = grok.AutoFields(IStudentRequestPW).select(
2787	'firstname','number','email')
2788	label = _('Request password for first-time login')
2789
2790	def update(self):
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	firstname = data.get('firstname','')
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,'firstname',None) is None:
2825	self.flash(_('An error occurred.'), type="danger")
2826	return
2827	elif student.firstname.lower() != firstname.lower():
2828	# Don't tell the truth here. Anonymous must not
2829	# know that a record was found and only the firstname
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 ClearAllStudentsInDepartmentPage(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	utils = queryUtility(IKofaUtils)
3217	if not utils.expensive_actions_allowed():
3218	self.flash(_(
3219	"Currently, exporters cannot be started due to high "
3220	"system load. Please try again later."), type='danger')
3221	return
3222	if payments_start or payments_end:
3223	date_format = '%d/%m/%Y'
3224	try:
3225	dummy = datetime.strptime(payments_start, date_format)
3226	dummy = datetime.strptime(payments_end, date_format)
3227	except ValueError:
3228	self.flash(_('Payment dates do not match format d/m/Y.'),
3229	type="danger")
3230	return
3231	if session == 'all':
3232	session=None
3233	if level == 'all':
3234	level = None
3235	if mode == 'all':
3236	mode = None
3237	if payments_start == '':
3238	payments_start = None
3239	if payments_end == '':
3240	payments_end = None
3241	if (mode,
3242	level,
3243	session,
3244	self.faccode,
3245	self.depcode,
3246	self.certcode) == (None, None, None, None, None, None):
3247	# Export all students including those without certificate
3248	if payments_start:
3249	job_id = self.context.start_export_job(exporter,
3250	self.request.principal.id,
3251	payments_start = payments_start,
3252	payments_end = payments_end)
3253	else:
3254	job_id = self.context.start_export_job(exporter,
3255	self.request.principal.id)
3256	else:
3257	if payments_start:
3258	job_id = self.context.start_export_job(exporter,
3259	self.request.principal.id,
3260	current_session=session,
3261	current_level=level,
3262	current_mode=mode,
3263	faccode=self.faccode,
3264	depcode=self.depcode,
3265	certcode=self.certcode,
3266	payments_start = payments_start,
3267	payments_end = payments_end)
3268	else:
3269	job_id = self.context.start_export_job(exporter,
3270	self.request.principal.id,
3271	current_session=session,
3272	current_level=level,
3273	current_mode=mode,
3274	faccode=self.faccode,
3275	depcode=self.depcode,
3276	certcode=self.certcode)
3277	ob_class = self.__implemented__.__name__.replace('waeup.kofa.','')
3278	self.context.logger.info(
3279	'%s - exported: %s (%s, %s, %s, %s, %s, %s, %s, %s), job_id=%s'
3280	% (ob_class, exporter, session, level, mode, self.faccode,
3281	self.depcode, self.certcode, payments_start, payments_end, job_id))
3282	self.flash(_('Export started for students with') +
3283	' current_session=%s, current_level=%s, study_mode=%s' % (
3284	session, level, mode))
3285	self.redirect(self.url(self.redirect_target))
3286	return
3287
3288	class ExportJobContainerDownload(ExportCSVView):
3289	"""Page that downloads a students export csv file.
3290
3291	"""
3292	grok.context(VirtualExportJobContainer)
3293	grok.require('waeup.showStudents')
3294
3295	class DatacenterExportJobContainerJobConfig(ExportJobContainerJobConfig):
3296	"""Page that configures a students export job in datacenter.
3297
3298	"""
3299	grok.context(IDataCenter)
3300	redirect_target = '@@export'
3301
3302	class DatacenterExportJobContainerSelectStudents(ExportJobContainerJobConfig):
3303	"""Page that configures a students export job in datacenter.
3304
3305	"""
3306	grok.name('exportselected')
3307	grok.context(IDataCenter)
3308	redirect_target = '@@export'
3309	grok.template('exportselected')
3310	label = _('Configure student data export')
3311
3312	def update(self, START=None, students=None, exporter=None):
3313	self._set_exporter_values()
3314	if START is None:
3315	return
3316	utils = queryUtility(IKofaUtils)
3317	if not utils.expensive_actions_allowed():
3318	self.flash(_(
3319	"Currently, exporters cannot be started due to high "
3320	"system load. Please try again later."), type='danger')
3321	return
3322	try:
3323	ids = students.replace(',', ' ').split()
3324	except:
3325	self.flash(sys.exc_info()[1])
3326	self.redirect(self.url(self.redirect_target))
3327	return
3328	job_id = self.context.start_export_job(
3329	exporter, self.request.principal.id, selected=ids)
3330	ob_class = self.__implemented__.__name__.replace('waeup.kofa.','')
3331	self.context.logger.info(
3332	'%s - selected students exported: %s, job_id=%s' %
3333	(ob_class, exporter, job_id))
3334	self.flash(_('Export of selected students started.'))
3335	self.redirect(self.url(self.redirect_target))
3336	return
3337
3338	class FacultiesExportJobContainerJobConfig(ExportJobContainerJobConfig):
3339	"""Page that configures a students export job in facultiescontainer.
3340
3341	"""
3342	grok.context(VirtualFacultiesExportJobContainer)
3343
3344
3345	class FacultyExportJobContainerJobConfig(ExportJobContainerJobConfig):
3346	"""Page that configures a students export job in faculties.
3347
3348	"""
3349	grok.context(VirtualFacultyExportJobContainer)
3350
3351	@property
3352	def faccode(self):
3353	return self.context.__parent__.code
3354
3355	class DepartmentExportJobContainerJobConfig(ExportJobContainerJobConfig):
3356	"""Page that configures a students export job in departments.
3357
3358	"""
3359	grok.context(VirtualDepartmentExportJobContainer)
3360
3361	@property
3362	def depcode(self):
3363	return self.context.__parent__.code
3364
3365	class CertificateExportJobContainerJobConfig(ExportJobContainerJobConfig):
3366	"""Page that configures a students export job for certificates.
3367
3368	"""
3369	grok.context(VirtualCertificateExportJobContainer)
3370	grok.template('exportconfig_certificate')
3371
3372	@property
3373	def certcode(self):
3374	return self.context.__parent__.code
3375
3376	class CourseExportJobContainerJobConfig(ExportJobContainerJobConfig):
3377	"""Page that configures a students export job for courses.
3378
3379	In contrast to department or certificate student data exports the
3380	coursetickets_catalog is searched here. Therefore the update
3381	method from the base class is customized.
3382	"""
3383	grok.context(VirtualCourseExportJobContainer)
3384	grok.template('exportconfig_course')
3385
3386	def _set_exporter_values(self):
3387	# We provide only two exporters.
3388	exporters = []
3389	for name in ('students', 'coursetickets'):
3390	util = getUtility(ICSVExporter, name=name)
3391	exporters.append((util.title, name),)
3392	self.exporters = exporters
3393
3394	def update(self, START=None, session=None, level=None, mode=None,
3395	exporter=None):
3396	self._set_session_values()
3397	self._set_level_values()
3398	self._set_mode_values()
3399	self._set_exporter_values()
3400	if START is None:
3401	return
3402	utils = queryUtility(IKofaUtils)
3403	if not utils.expensive_actions_allowed():
3404	self.flash(_(
3405	"Currently, exporters cannot be started due to high "
3406	"system load. Please try again later."), type='danger')
3407	return
3408	if session == 'all':
3409	session = None
3410	if level == 'all':
3411	level = None
3412	job_id = self.context.start_export_job(exporter,
3413	self.request.principal.id,
3414	# Use a different catalog and
3415	# pass different keywords than
3416	# for the (default) students_catalog
3417	catalog='coursetickets',
3418	session=session,
3419	level=level,
3420	code=self.context.__parent__.code)
3421	ob_class = self.__implemented__.__name__.replace('waeup.kofa.','')
3422	self.context.logger.info(
3423	'%s - exported: %s (%s, %s, %s), job_id=%s'
3424	% (ob_class, exporter, session, level,
3425	self.context.__parent__.code, job_id))
3426	self.flash(_('Export started for course tickets with') +
3427	' level_session=%s, level=%s' % (
3428	session, level))
3429	self.redirect(self.url(self.redirect_target))
3430	return

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

Download in other formats: